very professionnel, thank you it's really useful

準確度怎么樣

實驗開源代碼
項目四：通過串口實時繪制電子羅盤方位（12等分）的波形
說明：實時數(shù)值 0 = N，3 = E，6 = S，9 =W

1. /*
   
2.   【Arduino】168種傳感器模塊系列實驗（資料代碼+圖形編程+仿真編程）
   
3.    實驗一百五十八：QMC5883L電子指南針羅盤模塊 三軸磁場傳感器GY-271
   
4.   1、安裝庫：IDE--工具--管理庫--搜索“QMC5883L”--安裝QMC5883LCompass
   
5.   2、項目四：通過串口實時繪制電子羅盤方位（12等分）的波形
   
6.   3、實驗接線：
   
7.   QMC5883L-------------- UNO
   
8.   VCC------------------- 5V
   
9.   GND------------------- GND
   
10.   SCL ------------------- A5
    
11.   SDA------------------- A4
    
12.   DRDY------------------ N/C
    
13.   4、說明：實時數(shù)值 0 = N，3 = E，6 = S，9 =W
    
14. */
    
15. 
    
16. #include <QMC5883LCompass.h>
    
17. 
    
18. QMC5883LCompass compass;
    
19. 
    
20. void setup() {
    
21.   Serial.begin(9600);
    
22.   compass.init();
    
23. }
    
24. 
    
25. void loop() {
    
26.   compass.read();
    
27. 
    
28.   byte a = compass.getAzimuth();
    
29.   // 根據(jù)方位/方位角的方向，此處的輸出將是介于0到11之間的值。
    
30.   byte b = compass.getBearing(a);
    
31.   
    
32.   Serial.print("指南針方位: ");
    
33.   Serial.print(b);
    
34.   Serial.println();
    
35.   
    
36.   delay(800);
    
37. }

復制代碼

9、校準QMC5583L傳感器
QMC5883LCompass庫包含校準功能和實用程序大綱，可幫助您校準QMC5883L芯片。校準是一個兩步過程。

步驟1：運行校準程序
a、確保已連接QMC5883L芯片。
b、在示例> QMC5883LCOMPASS>校準下找到隨附的校準草圖。
c、將校準草圖上傳到您的arduino，然后打開串行監(jiān)視器。
d、校準過程開始時，通過移動傳感器來伴隨屏幕上的指示。
c、收集完所有校準數(shù)據(jù)后，復制副本的代碼

compass.setCalibration(-1537, 1266, -1961, 958, -1342, 1492);

可能需要保存它以備將來參考。

步驟2：使用校正資料
a、項目的程序，將然后復制的代碼行直接插入到compass.init()調(diào)用下方。
b、照常使用QMC5883LCompass庫。

建議您使用提供的校準草圖來生成傳感器的預設和替代，但也可以使用該

compass.setCalibration(X_MIN, X_MAX, Y_MIN, Y_MAX, Z_MIN, Z_MAX);

函數(shù)添加自己的預設和替代。

8、精細QMC5583L傳感器輸出
在傳感器讀數(shù)似乎反彈的情況下，平滑可以提供幫助。QMC5883L指南針庫使用滾動平均值功能來存儲（N）個傳感器讀數(shù)并返回每個軸的平均值。該平均還對方位角和方向輸出進行平滑處理。

如果啟用，該功能的第二部分將采用內(nèi)部滾動逐步通過的當前替代和替代，將其從總體上中刪除。這可以幫助消除在錯誤的讀數(shù)中可能發(fā)生的替代的高點和低點。

應該注意的是，內(nèi)置的平滑功能將導致額外的處理時間。

compass.setSmoothing(STEPS, ADVANCED);

在循環(huán)之前啟用平滑調(diào)用。

步驟：int，使結果平滑的步驟數(shù)。1到10的有效值。更高的步長等于更平滑，但處理時間縮短。

*：啟用此功能將使平滑效果更好，但處理時間縮短。*

void setup(){
  compass.init();
  compass.setSmoothing(10, true);
}

4、獲取方位角的數(shù)值
要獲取計算出的方位角（羅盤度）值，只需調(diào)用getAzimuth();。
void loop(){
   int a = compass.getAzimuth();
}
5、獲取方向/方位
QMC5883L指南針庫可計算傳感器指向的方向范圍和方向。您可以調(diào)用兩個函數(shù)。
要獲取傳感器面向的方向的12點值，可以調(diào)用getBearing(azimuth)。這會將羅盤的360度范圍劃分為12個部分，并按順時針順序返回值0-12。在這種情況下，0 = N，4 = E，8 = S，12 =W。如果您希望滾動自己的方向輸出功能而不需要計算，則此功能很有用。
void loop(){
   azimuth = compass.getAzimuth();
   byte b = compass.getBearing(azimuth);
}
要獲取傳感器指向方向的12點文字表示，可以致電getDirection(azimuth);。這將產(chǎn)生一個char數(shù)組[3]，其中的字母代表每個方向。由于我們無法返回數(shù)組，因此需要通過引用傳遞值。
void loop(){
   azimuth = compass.getAzimuth();
   char myArray[3];
   getDirection(myArray, azimuth);
}
如果要打印這些值，可以這樣：
void loop(){
   azimuth = compass.getAzimuth();
   char myArray[3];
   
   getDirection(myArray, azimuth);
   
   Serial.print(myArray[0]);
   Serial.print(myArray[1]);
   Serial.print(myArray[2]);
   Serial.println();
}

QMC5883L Compass庫函數(shù)的幾個使用要點

1、QMC5883L與Arduino Uno / Nano的連接

VCC  O ---- O +5v
GND  O ---- O GND
SCL  O ---- O A5
SDA  O ---- O A4
DRDY O ---- X NOT CONNECTED

2、入門
首先，在程序頂部包括QMC5883L指南針庫。

#include <QMC5883LCompass.h>
QMC5883LCompass compass;

然后在setup（）函數(shù)中添加：

void setup(){
  compass.init();
}

3、獲取X，Y或Z軸的數(shù)值

要獲取X，Y或Z傳感器的讀數(shù)，只需調(diào)用所需的功能。

void loop(){
   int x = compass.getX();
   int y = compass.getY();
   int z = compass.getZ();
}

實驗開源代碼，

項目三：通過串口實時繪制電子羅盤方位角的波形

1. /*
   
2.   【Arduino】168種傳感器模塊系列實驗（資料代碼+圖形編程+仿真編程）
   
3.    實驗一百五十八：QMC5883L電子指南針羅盤模塊 三軸磁場傳感器GY-271
   
4.   1、安裝庫：IDE--工具--管理庫--搜索“QMC5883L”--安裝QMC5883LCompass
   
5.   2、項目三：通過串口實時繪制電子羅盤方位角的波形
   
6.   3、實驗接線：
   
7.   QMC5883L-------------- UNO
   
8.   VCC------------------- 5V
   
9.   GND------------------- GND
   
10.   SCL ------------------- A5
    
11.   SDA------------------- A4
    
12.   DRDY------------------ N/C
    
13. */
    
14. 
    
15. #include <QMC5883LCompass.h>
    
16. 
    
17. QMC5883LCompass compass;
    
18. 
    
19. void setup() {
    
20.   Serial.begin(9600);
    
21.   compass.init();
    
22. 
    
23. }
    
24. 
    
25. void loop() {
    
26.   int a;
    
27. 
    
28.   // 讀取羅盤值
    
29.   compass.read();
    
30. 
    
31.   // 返回方位角讀數(shù)
    
32.   a = compass.getAzimuth();
    
33. 
    
34.   Serial.print("電子羅盤方位角: ");
    
35.   Serial.print(a);
    
36.   Serial.println();
    
37. 
    
38.   delay(800);
    
39. }

復制代碼

QMC5883LCompass.h 庫文件

1. #ifndef QMC5883L_Compass
   
2. #define QMC5883L_Compass
   
3. 
   
4. #include "Arduino.h"
   
5. #include "Wire.h"
   
6. 
   
7. 
   
8. class QMC5883LCompass{
   
9.        
   
10.   public:
    
11.     QMC5883LCompass();
    
12.         void init();
    
13.     void setADDR(byte b);
    
14.     void setMode(byte mode, byte odr, byte rng, byte osr);
    
15.         void setSmoothing(byte steps, bool adv);
    
16.         void setCalibration(int x_min, int x_max, int y_min, int y_max, int z_min, int z_max);
    
17.     void setReset();
    
18.     void read();
    
19.         int getX();
    
20.         int getY();
    
21.         int getZ();
    
22.         int getAzimuth();
    
23.         byte getBearing(int azimuth);
    
24.         void getDirection(char* myArray, int azimuth);
    
25.        
    
26.   private:
    
27.     void _writeReg(byte reg,byte val);
    
28.         int _get(int index);
    
29.         bool _smoothUse = false;
    
30.         byte _smoothSteps = 5;
    
31.         bool _smoothAdvanced = false;
    
32.     byte _ADDR = 0x0D;
    
33.         int _vRaw[3] = {0,0,0};
    
34.         int _vHistory[10][3];
    
35.         int _vScan = 0;
    
36.         long _vTotals[3] = {0,0,0};
    
37.         int _vSmooth[3] = {0,0,0};
    
38.         void _smoothing();
    
39.         bool _calibrationUse = false;
    
40.         int _vCalibration[3][2];
    
41.         int _vCalibrated[3];
    
42.         void _applyCalibration();
    
43.         const char _bearings[16][3] =  {
    
44.                 {' ', ' ', 'N'},
    
45.                 {'N', 'N', 'E'},
    
46.                 {' ', 'N', 'E'},
    
47.                 {'E', 'N', 'E'},
    
48.                 {' ', ' ', 'E'},
    
49.                 {'E', 'S', 'E'},
    
50.                 {' ', 'S', 'E'},
    
51.                 {'S', 'S', 'E'},
    
52.                 {' ', ' ', 'S'},
    
53.                 {'S', 'S', 'W'},
    
54.                 {' ', 'S', 'W'},
    
55.                 {'W', 'S', 'W'},
    
56.                 {' ', ' ', 'W'},
    
57.                 {'W', 'N', 'W'},
    
58.                 {' ', 'N', 'W'},
    
59.                 {'N', 'N', 'W'},
    
60.         };
    
61.        
    
62.        
    
63.        
    
64. };
    
65. 
    
66. #endif

復制代碼

QMC5883L Compass是一個Arduino庫，用于將QMC5583L系列模塊使用指南針（電子羅盤）功能。支持：

1、獲取XYZ軸的值。
2、計算方位角。
3、獲得16點方位角軸承方向（0-15）。
4、獲取16點方位角軸承名稱（N，NNE，NE，ENE，E，ESE，SE，SSE，S，SSW，SW，WSW，W，WNW，NW，NNW）
5、通過滾動平均和最小/最大消除來平滑XYZ讀數(shù)。
6、任選的芯片組模式。

QMC5883LCompass.cpp 庫文件

1. /*
   
2. ===============================================================================================================
   
3. QMC5883LCompass.h
   
4. Library for using QMC5583L series chip boards as a compass.
   
5. Learn more at [https://github.com/mprograms/QMC5883LCompass]
   
6. Supports:
   
7. - Getting values of XYZ axis.
   
8. - Calculating Azimuth.
   
9. - Getting 16 point Azimuth bearing direction (0 - 15).
   
10. - Getting 16 point Azimuth bearing Names (N, NNE, NE, ENE, E, ESE, SE, SSE, S, SSW, SW, WSW, W, WNW, NW, NNW)
    
11. - Smoothing of XYZ readings via rolling averaging and min / max removal.
    
12. - Optional chipset modes (see below)
    
13. ===============================================================================================================
    
14. v1.0 - June 13, 2019
    
15. Written by MRPrograms
    
16. Github: [https://github.com/mprograms/]
    
17. Release under the GNU General Public License v3
    
18. [https://www.gnu.org/licenses/gpl-3.0.en.html]
    
19. ===============================================================================================================
    
20. FROM QST QMC5883L Datasheet [https://nettigo.pl/attachments/440]
    
21. -----------------------------------------------
    
22. MODE CONTROL (MODE)
    
23.         Standby                        0x00
    
24.         Continuous                0x01
    
25. OUTPUT DATA RATE (ODR)
    
26.         10Hz                0x00
    
27.         50Hz                0x04
    
28.         100Hz               0x08
    
29.         200Hz               0x0C
    
30. FULL SCALE (RNG)
    
31.         2G                  0x00
    
32.         8G                  0x10
    
33. OVER SAMPLE RATIO (OSR)
    
34.         512                 0x00
    
35.         256                 0x40
    
36.         128                 0x80
    
37.         64                  0xC0
    
38.   
    
39. */
    
40. 
    
41. 
    
42. 
    
43. #include "Arduino.h"
    
44. #include "QMC5883LCompass.h"
    
45. #include <Wire.h>
    
46. 
    
47. QMC5883LCompass::QMC5883LCompass() {
    
48. }
    
49. 
    
50. 
    
51. /**
    
52.         INIT
    
53.         Initialize Chip - This needs to be called in the sketch setup() function.
    
54.        
    
55.         @since v0.1;
    
56. **/
    
57. void QMC5883LCompass::init(){
    
58.         Wire.begin();
    
59.         _writeReg(0x0B,0x01);
    
60.         setMode(0x01,0x0C,0x10,0X00);
    
61. }
    
62. 
    
63. 
    
64. /**
    
65.         SET ADDRESS
    
66.         Set the I2C Address of the chip. This needs to be called in the sketch setup() function.
    
67.        
    
68.         @since v0.1;
    
69. **/
    
70. // Set I2C Address if different then default.
    
71. void QMC5883LCompass::setADDR(byte b){
    
72.         _ADDR = b;
    
73. }
    
74. 
    
75. 
    
76. 
    
77. 
    
78. /**
    
79.         REGISTER
    
80.         Write the register to the chip.
    
81.        
    
82.         @since v0.1;
    
83. **/
    
84. // Write register values to chip
    
85. void QMC5883LCompass::_writeReg(byte r, byte v){
    
86.         Wire.beginTransmission(_ADDR);
    
87.         Wire.write(r);
    
88.         Wire.write(v);
    
89.         Wire.endTransmission();
    
90. }
    
91. 
    
92. 
    
93. /**
    
94.         CHIP MODE
    
95.         Set the chip mode.
    
96.        
    
97.         @since v0.1;
    
98. **/
    
99. // Set chip mode
    
100. void QMC5883LCompass::setMode(byte mode, byte odr, byte rng, byte osr){
     
101.         _writeReg(0x09,mode|odr|rng|osr);
     
102. }
     
103. 
     
104. 
     
105. /**
     
106.         RESET
     
107.         Reset the chip.
     
108.        
     
109.         @since v0.1;
     
110. **/
     
111. // Reset the chip
     
112. void QMC5883LCompass::setReset(){
     
113.         _writeReg(0x0A,0x80);
     
114. }
     
115. 
     
116. // 1 = Basic 2 = Advanced
     
117. void QMC5883LCompass::setSmoothing(byte steps, bool adv){
     
118.         _smoothUse = true;
     
119.         _smoothSteps = ( steps > 10) ? 10 : steps;
     
120.         _smoothAdvanced = (adv == true) ? true : false;
     
121. }
     
122. 
     
123. /**
     
124.     SET CALIBRATION
     
125.         Set calibration values for more accurate readings
     
126.                
     
127.         @author Claus N&auml;veke - TheNitek [https://github.com/TheNitek]
     
128.        
     
129.         @since v1.1.0
     
130. **/
     
131. void QMC5883LCompass::setCalibration(int x_min, int x_max, int y_min, int y_max, int z_min, int z_max){
     
132.         _calibrationUse = true;
     
133. 
     
134.         _vCalibration[0][0] = x_min;
     
135.         _vCalibration[0][1] = x_max;
     
136.         _vCalibration[1][0] = y_min;
     
137.         _vCalibration[1][1] = y_max;
     
138.         _vCalibration[2][0] = z_min;
     
139.         _vCalibration[2][1] = z_max;
     
140. }
     
141. 
     
142. 
     
143. 
     
144. /**
     
145.         READ
     
146.         Read the XYZ axis and save the values in an array.
     
147.        
     
148.         @since v0.1;
     
149. **/
     
150. void QMC5883LCompass::read(){
     
151.         Wire.beginTransmission(_ADDR);
     
152.         Wire.write(0x00);
     
153.         int err = Wire.endTransmission();
     
154.         if (!err) {
     
155.                 Wire.requestFrom(_ADDR, (byte)6);
     
156.                 _vRaw[0] = (int)(int16_t)(Wire.read() | Wire.read() << 8);
     
157.                 _vRaw[1] = (int)(int16_t)(Wire.read() | Wire.read() << 8);
     
158.                 _vRaw[2] = (int)(int16_t)(Wire.read() | Wire.read() << 8);
     
159. 
     
160.                 if ( _calibrationUse ) {
     
161.                         _applyCalibration();
     
162.                 }
     
163.                
     
164.                 if ( _smoothUse ) {
     
165.                         _smoothing();
     
166.                 }
     
167.                
     
168.                 //byte overflow = Wire.read() & 0x02;
     
169.                 //return overflow << 2;
     
170.         }
     
171. }
     
172. 
     
173. /**
     
174.     APPLY CALIBRATION
     
175.         This function uses the calibration data provided via @see setCalibration() to calculate more
     
176.         accurate readings
     
177.        
     
178.         @author Claus N&auml;veke - TheNitek [https://github.com/TheNitek]
     
179.        
     
180.         Based on this awesome article:
     
181.         https://appelsiini.net/2018/calibrate-magnetometer/
     
182.        
     
183.         @since v1.1.0
     
184.        
     
185. **/
     
186. void QMC5883LCompass::_applyCalibration(){
     
187.         int x_offset = (_vCalibration[0][0] + _vCalibration[0][1])/2;
     
188.         int y_offset = (_vCalibration[1][0] + _vCalibration[1][1])/2;
     
189.         int z_offset = (_vCalibration[2][0] + _vCalibration[2][1])/2;
     
190.         int x_avg_delta = (_vCalibration[0][1] - _vCalibration[0][0])/2;
     
191.         int y_avg_delta = (_vCalibration[1][1] - _vCalibration[1][0])/2;
     
192.         int z_avg_delta = (_vCalibration[2][1] - _vCalibration[2][0])/2;
     
193. 
     
194.         int avg_delta = (x_avg_delta + y_avg_delta + z_avg_delta) / 3;
     
195. 
     
196.         float x_scale = (float)avg_delta / x_avg_delta;
     
197.         float y_scale = (float)avg_delta / y_avg_delta;
     
198.         float z_scale = (float)avg_delta / z_avg_delta;
     
199. 
     
200.         _vCalibrated[0] = (_vRaw[0] - x_offset) * x_scale;
     
201.         _vCalibrated[1] = (_vRaw[1] - y_offset) * y_scale;
     
202.         _vCalibrated[2] = (_vRaw[2] - z_offset) * z_scale;
     
203. }
     
204. 
     
205. 
     
206. /**
     
207.         SMOOTH OUTPUT
     
208.         This function smooths the output for the XYZ axis. Depending on the options set in
     
209.         @see setSmoothing(), we can run multiple methods of smoothing the sensor readings.
     
210.        
     
211.         First we store (n) samples of sensor readings for each axis and store them in a rolling array.
     
212.         As each new sensor reading comes in we replace it with a new reading. Then we average the total
     
213.         of all (n) readings.
     
214.        
     
215.         Advanced Smoothing
     
216.         If you turn advanced smoothing on, we will select the min and max values from our array
     
217.         of (n) samples. We then subtract both the min and max from the total and average the total of all
     
218.         (n - 2) readings.
     
219.        
     
220.         NOTE: This function does several calculations and can cause your sketch to run slower.
     
221.        
     
222.         @since v0.3;
     
223. **/
     
224. void QMC5883LCompass::_smoothing(){
     
225.         byte max = 0;
     
226.         byte min = 0;
     
227.        
     
228.         if ( _vScan > _smoothSteps - 1 ) { _vScan = 0; }
     
229.        
     
230.         for ( int i = 0; i < 3; i++ ) {
     
231.                 if ( _vTotals[i] != 0 ) {
     
232.                         _vTotals[i] = _vTotals[i] - _vHistory[_vScan][i];
     
233.                 }
     
234.                 _vHistory[_vScan][i] = ( _calibrationUse ) ? _vCalibrated[i] : _vRaw[i];
     
235.                 _vTotals[i] = _vTotals[i] + _vHistory[_vScan][i];
     
236.                
     
237.                 if ( _smoothAdvanced ) {
     
238.                         max = 0;
     
239.                         for (int j = 0; j < _smoothSteps - 1; j++) {
     
240.                                 max = ( _vHistory[j][i] > _vHistory[max][i] ) ? j : max;
     
241.                         }
     
242.                        
     
243.                         min = 0;
     
244.                         for (int k = 0; k < _smoothSteps - 1; k++) {
     
245.                                 min = ( _vHistory[k][i] < _vHistory[min][i] ) ? k : min;
     
246.                         }
     
247.                                        
     
248.                         _vSmooth[i] = ( _vTotals[i] - (_vHistory[max][i] + _vHistory[min][i]) ) / (_smoothSteps - 2);
     
249.                 } else {
     
250.                         _vSmooth[i] = _vTotals[i]  / _smoothSteps;
     
251.                 }
     
252.         }
     
253.        
     
254.         _vScan++;
     
255. }
     
256. 
     
257. 
     
258. /**
     
259.         GET X AXIS
     
260.         Read the X axis
     
261.        
     
262.         @since v0.1;
     
263.         @return int x axis
     
264. **/
     
265. int QMC5883LCompass::getX(){
     
266.         return _get(0);
     
267. }
     
268. 
     
269. 
     
270. /**
     
271.         GET Y AXIS
     
272.         Read the Y axis
     
273.        
     
274.         @since v0.1;
     
275.         @return int y axis
     
276. **/
     
277. int QMC5883LCompass::getY(){
     
278.         return _get(1);
     
279. }
     
280. 
     
281. 
     
282. /**
     
283.         GET Z AXIS
     
284.         Read the Z axis
     
285.        
     
286.         @since v0.1;
     
287.         @return int z axis
     
288. **/
     
289. int QMC5883LCompass::getZ(){
     
290.         return _get(2);
     
291. }
     
292. 
     
293. /**
     
294.         GET SENSOR AXIS READING
     
295.         Get the smoothed, calibration, or raw data from a given sensor axis
     
296.        
     
297.         @since v1.1.0
     
298.         @return int sensor axis value
     
299. **/
     
300. int QMC5883LCompass::_get(int i){
     
301.         if ( _smoothUse )
     
302.                 return _vSmooth[i];
     
303.        
     
304.         if ( _calibrationUse )
     
305.                 return _vCalibrated[i];
     
306. 
     
307.         return _vRaw[i];
     
308. }
     
309. 
     
310. 
     
311. 
     
312. /**
     
313.         GET AZIMUTH
     
314.         Calculate the azimuth (in degrees);
     
315.        
     
316.         @since v0.1;
     
317.         @return int azimuth
     
318. **/
     
319. int QMC5883LCompass::getAzimuth(){
     
320.         int a = atan2( getY(), getX() ) * 180.0 / PI;
     
321.         return a < 0 ? 360 + a : a;
     
322. }
     
323. 
     
324. 
     
325. /**
     
326.         GET BEARING
     
327.         Divide the 360 degree circle into 16 equal parts and then return the a value of 0-15
     
328.         based on where the azimuth is currently pointing.
     
329.        
     
330.         @since v1.0.1 - function now requires azimuth parameter.
     
331.         @since v0.2.0 - initial creation
     
332.        
     
333.         @return byte direction of bearing
     
334. */
     
335. byte QMC5883LCompass::getBearing(int azimuth){
     
336.         unsigned long a = azimuth / 22.5;
     
337.         unsigned long r = a - (int)a;
     
338.         byte sexdec = 0;       
     
339.         sexdec = ( r >= .5 ) ? ceil(a) : floor(a);
     
340.         return sexdec;
     
341. }
     
342. 
     
343. 
     
344. /**
     
345.         This will take the location of the azimuth as calculated in getBearing() and then
     
346.         produce an array of chars as a text representation of the direction.
     
347.        
     
348.         NOTE: This function does not return anything since it is not possible to return an array.
     
349.         Values must be passed by reference back to your sketch.
     
350.        
     
351.         Example:
     
352.        
     
353.         ( if direction is in 1 / NNE)
     
354.        
     
355.         char myArray[3];
     
356.         compass.getDirection(myArray, azimuth);
     
357.        
     
358.         Serial.print(myArray[0]); // N
     
359.         Serial.print(myArray[1]); // N
     
360.         Serial.print(myArray[2]); // E
     
361.        
     
362.        
     
363.         @see getBearing();
     
364.        
     
365.         @since v1.0.1 - function now requires azimuth parameter.
     
366.         @since v0.2.0 - initial creation
     
367. */
     
368. void QMC5883LCompass::getDirection(char* myArray, int azimuth){
     
369.         int d = getBearing(azimuth);
     
370.         myArray[0] = _bearings[d][0];
     
371.         myArray[1] = _bearings[d][1];
     
372.         myArray[2] = _bearings[d][2];
     
373. }

復制代碼

項目二：簡易測量方位角度的實驗開源代碼（數(shù)值在0-11之間，每個數(shù)值間隔30度）

1. /*
   
2.   【Arduino】168種傳感器模塊系列實驗（資料代碼+圖形編程+仿真編程）
   
3.    實驗一百五十八：QMC5883L電子指南針羅盤模塊 三軸磁場傳感器GY-271
   
4.   1、安裝庫：IDE--工具--管理庫--搜索“QMC5883L”--安裝QMC5883LCompass
   
5.   2、項目二：簡易測量方位角度（數(shù)值在0-11之間，每個數(shù)值間隔30度）
   
6.   3、實驗接線：
   
7.   QMC5883L-------------- UNO
   
8.   VCC------------------- 5V
   
9.   GND------------------- GND
   
10.   SCL ------------------- A5
    
11.   SDA------------------- A4
    
12.   DRDY------------------ N/C
    
13. */
    
14. 
    
15. #include <QMC5883LCompass.h>
    
16. 
    
17. QMC5883LCompass compass;
    
18. 
    
19. void setup() {
    
20.   Serial.begin(9600);
    
21.   compass.init();
    
22. }
    
23. 
    
24. void loop() {
    
25.   compass.read();
    
26. 
    
27.   byte a = compass.getAzimuth();
    
28.   // 根據(jù)方位/方位角的方向，此處的輸出將是介于0到11之間的值。
    
29.   byte b = compass.getBearing(a);
    
30.   
    
31.   Serial.print("B: ");
    
32.   Serial.print(b);
    
33.   Serial.println();
    
34.   
    
35.   delay(250);
    
36. }

復制代碼

項目一：簡易測量方位角度的實驗開源代碼

1. /*
   
2.   【Arduino】168種傳感器模塊系列實驗（資料代碼+圖形編程+仿真編程）
   
3.    實驗一百五十八：QMC5883L電子指南針羅盤模塊 三軸磁場傳感器GY-271
   
4.   1、安裝庫：IDE--工具--管理庫--搜索“QMC5883L”--安裝QMC5883LCompass
   
5.   2、項目一：簡易測量方位角度
   
6.   3、實驗接線：
   
7.   QMC5883L-------------- UNO
   
8.   VCC------------------- 5V
   
9.   GND------------------- GND
   
10.   SCL ------------------- A5
    
11.   SDA------------------- A4
    
12.   DRDY------------------ N/C
    
13. */
    
14. 
    
15. #include <QMC5883LCompass.h>
    
16. 
    
17. QMC5883LCompass compass;
    
18. 
    
19. void setup() {
    
20.   Serial.begin(9600);
    
21.   compass.init();
    
22. 
    
23. }
    
24. 
    
25. void loop() {
    
26.   int a;
    
27. 
    
28.   // 讀取羅盤值
    
29.   compass.read();
    
30. 
    
31.   // 返回方位角讀數(shù)
    
32.   a = compass.getAzimuth();
    
33. 
    
34.   Serial.print("A: ");
    
35.   Serial.print(a);
    
36.   Serial.println();
    
37. 
    
38.   delay(500);
    
39. }

復制代碼