标题: 【Arduino】168种传感器模块系列实验（158）---QMC5883L三轴罗盘 [打印本页]
作者: eagler8    时间: 2021-1-22 21:35
标题: 【Arduino】168种传感器模块系列实验（158）---QMC5883L三轴罗盘
37款传感器与模块的提法，在网络上广泛流传，其实Arduino能够兼容的传感器模块肯定是不止37种的。鉴于本人手头积累了一些传感器和执行器模块，依照实践出真知（一定要动手做）的理念，以学习和交流为目的，这里准备逐一动手试试做实验，不管成功与否，都会记录下来---小小的进步或是搞不定的问题，希望能够抛砖引玉。

【Arduino】168种传感器模块系列实验（资料代码+图形编程+仿真编程）
实验一百五十八：QMC5883L电子指南针罗盘模块 三轴磁场传感器GY-271








作者: eagler8    时间: 2021-1-22 21:40


QMC5883L
源于Honeywell的HMC5883L，是一款表面贴装的集成了信号处理电路的三轴磁性传感器，应用场景主要包括罗盘、导航、无人机、机器人和手持设备等一些高精度的场合。HMC5883是霍尼韦尔公司生产的一款地磁场检测芯片，其国产替代产品为QMC5883。这两种芯片基本相似，QMC 5883也是号称得到了霍尼韦尔公司的授权。

作者: eagler8    时间: 2021-1-23 08:57
QMC5883L特征
（1）霍尼韦尔（中国）QMC5883L是一款表面贴装多芯片模块，设计用于具有数字接口的低场磁感应，适用于低成本指南针和磁力计等应用
（2）结合低噪声AMR传感器的12位ADC在±8高斯场中实现5毫高斯场分辨率
（3）低电压运行，低功耗； 支持内置的自检
（4）内置式皮带驱动电路，I2C数字接口，宽磁场范围（+/- 8 oe）
（5）工作电压：3.3v-5v； PCB尺寸：1.3 x 2.3厘米（QMC5883L尺寸：3.0 x 3.0 x 0.9毫米），带有16引脚无铅芯片载体（LCC）




作者: eagler8    时间: 2021-1-23 09:39
QMC5883L内部原理图




作者: eagler8    时间: 2021-1-23 09:57
QMC5883L是一款多芯片三轴磁传感器。 这个表面贴装的小尺寸芯片集成了磁传感器信号条件ASIC，面向高精度应用，例如无人机，机器人，移动设备中的指南针，导航和游戏个人手持设备。

QMC5883L基于最新的高分辨率，霍尼韦尔AMR技术授权的磁阻技术。结合定制设计的16位ADC ASIC，它具有以下优势：
低噪声，高精度，低功耗，偏移消除和温度补偿。 QMC5883L启用1°至2°指南针航向精度。 I2C串行总线可简化接口。QMC5883L位于3x3x0.9mm3中表面贴装16针焊盘栅格阵列（LGA）封装。

功能
1、3x3x0.9 mm3中的3轴磁阻传感器陆地栅格阵列封装（LGA），保证在扩展的温度范围内工作-40°C至+85°C。
2、具有低噪声AMR传感器的16位ADC实现2毫高斯场分辨率。
3、宽磁场范围（±8高斯）。
4、温度补偿数据输出和温度输出。
5、具有标准模式和快速模式的I2C接口。
6、宽范围工作电压（2.16V至3.6V）和低功耗（75uA)。
7、无铅封装构造。
8、提供软件和算法支持。

优点
1、体积小，适用于高度集成的产品。 信号有已数字化和校准。
2、启用1°至2°度的罗盘航向精度，允许导航和LBS应用。
3、最大化传感器的完整动态范围和分辨率。
4、在宽广的范围内自动保持传感器的灵敏度工作温度范围。
5、用于快速数据通信的高速接口，最大200Hz数据输出速率。
6、兼容电池供电的应用。
7、符合RoHS标准。
8、罗盘航向，硬铁，软铁和自动可用校准库。




作者: eagler8    时间: 2021-1-23 10:23
QMC5883L封装3-D视图
箭头指示在正常测量中产生正输出读数的磁场方向组态。




作者: eagler8    时间: 2021-1-23 10:51

作者: eagler8    时间: 2021-1-23 10:55




作者: eagler8    时间: 2021-1-23 11:08
外部连接
双电源连接



作者: eagler8    时间: 2021-1-23 11:10

单电源连接



作者: eagler8    时间: 2021-1-23 11:22
QMC5883L性能




作者: eagler8    时间: 2021-1-23 11:25

作者: eagler8    时间: 2021-1-23 11:27

作者: eagler8    时间: 2021-1-23 11:28

作者: eagler8    时间: 2021-1-23 11:30

作者: eagler8    时间: 2021-1-23 11:32



作者: eagler8    时间: 2021-1-23 11:56
GY-271 QMC5883L模块 电子指南针罗盘模块 三轴磁场传感器

采用高品质沉金pcb，机器焊接工艺，保证品质
名称：QMC5883L模块(三轴磁场模块)
型号：GY-271使用芯片：QMC5883L
供电电源：3-5v
通信方式：IIC通信协议
测量范围：±1.3-8 高斯



作者: eagler8    时间: 2021-1-23 12:01
该模块包括一个最新的高分辨率QMC5883X系列磁阻传感器，一个包含放大功能的ASIC，自动消磁带驱动器，失调消除以及一个12位ADC，可实现1°至2°的罗盘 航向精度。 I2C串行总线可简化接口。电原理图如下。





作者: eagler8    时间: 2021-1-23 12:08


引脚功能
VCC + 5V-电源引脚，给它3.3v-5VDC。 对于Arduino，建议5v
GND-接地引脚
SDA和SCL-这些是I2C数据和时钟引脚，用于从模块向微控制器发送和接收数据。 这些引脚上有1万上拉至3.3v引脚。 您可以将这些引脚连接到5V I2C线路，板上有电平转换器，可将引脚安全降低到3V
DRDY-这是“数据就绪”引脚输出。 如果要高速流传输数据（每秒超过100次），则可以在准备好读取数据时收听此引脚。 有关使用DRDY引脚的更多详细信息，请参见数据表，我们不使用它，因为我们读得不快！

Build the circuit
QMC5883L--------------- Uno/Mega2560
VCC------------------- 5V
GND------------------- GND
SCL------------------- A5/ pin21 mega2560
SDA------------------- A4/pin20 mega2560
DRDY------------------ N/C

作者: eagler8    时间: 2021-1-23 13:37

QMC5883L模块的几个定义：

AMR Bridge：三轴磁性传感器

MUX：多路复用通道

PGA：可编程控制的传感器信号增益放大器

Signal Conditioning：进行磁场信号校正及补偿的数字模块

ADC：16位的模数转换器

I2C：总线形式

NVM：用于校正的非易失性存储器

SET/RST Driver：用于初始化磁性传感器的内部驱动

Reference：用于内部偏移的电压/电流基准

Clock Gen.：内部振荡器，用于内部操作

POR：上电复位

Temperature Sensor：用于内部精度/偏移的温度传感器，也可以用于测量温度并输出

QMC5883L有两种工作模式：连续测量模式和待命模式。




作者: eagler8    时间: 2021-1-23 13:42
QMC5883L模块实验接线示意图




作者: eagler8    时间: 2021-1-23 14:14
安装QMC5883库，在网上搜到不少相关的库：
keepworking /Mecha_QMC5883L
https://github.com/keepworking/mecha_qmc5883l


mprograms /QMC5883LCompass
https://github.com/mprograms/QMC5883LCompass


dthain /QMC5883L
https://github.com/dthain/QMC5883L


liyupengsGit /QMC5883LCompass
https://github.com/liyupengsGit/QMC5883LCompassv





作者: eagler8    时间: 2021-1-24 19:05
项目一：简易测量方位角度的实验开源代码



  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. */

  15. #include <QMC5883LCompass.h>

  17. QMC5883LCompass compass;

  19. void setup() {
  20.   Serial.begin(9600);
  21.   compass.init();

  23. }

  25. void loop() {
  26.   int a;

  28.   // 读取罗盘值
  29.   compass.read();

  31.   // 返回方位角读数
  32.   a = compass.getAzimuth();

  34.   Serial.print("A: ");
  35.   Serial.print(a);
  36.   Serial.println();

  38.   delay(500);
  39. }
复制代码




作者: eagler8    时间: 2021-1-24 19:12
实验串口返回情况






作者: eagler8    时间: 2021-1-24 19:25
实验场景图




作者: eagler8    时间: 2021-1-24 20:14
项目二：简易测量方位角度的实验开源代码（数值在0-11之间，每个数值间隔30度）


  1. /*
  2.   【Arduino】168种传感器模块系列实验（资料代码+图形编程+仿真编程）
  3.    实验一百五十八：QMC5883L电子指南针罗盘模块 三轴磁场传感器GY-271
  4.   1、安装库：IDE--工具--管理库--搜索“QMC5883L”--安装QMC5883LCompass
  5.   2、项目二：简易测量方位角度（数值在0-11之间，每个数值间隔30度）
  6.   3、实验接线：
  7.   QMC5883L-------------- UNO
  8.   VCC------------------- 5V
  9.   GND------------------- GND
  10.   SCL ------------------- A5
  11.   SDA------------------- A4
  12.   DRDY------------------ N/C
  13. */

  15. #include <QMC5883LCompass.h>

  17. QMC5883LCompass compass;

  19. void setup() {
  20.   Serial.begin(9600);
  21.   compass.init();
  22. }

  24. void loop() {
  25.   compass.read();

  27.   byte a = compass.getAzimuth();
  28.   // 根据方位/方位角的方向，此处的输出将是介于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. }
复制代码



作者: eagler8    时间: 2021-1-24 20:26
实验串口返回情况




作者: eagler8    时间: 2021-1-24 20:46

知识点：方位角

又称地平经度(Azimuth angle，缩写为Az)，是在平面上量度物体之间的角度差的方法之一。是从某点的指北方向线起，依顺时针方向到目标方向线之间的水平夹角，用“度”和“密位”表示。常用于判定方位、指示目标和保持行进方向。


从真子午线起算的为真方位角，通常在精密测量中使用，从磁子午线起算的方磁方位角，在航空、航海、炮兵射击、军队行进时广泛使用，从地形图的坐标纵线起算的为坐标方位角，炮兵使用较多。磁方位角与真方位角的关系式为：磁方位角=真方位角-(±磁偏角)。坐标方位角与磁方位角的关系式为：坐标方位角=磁方位角+ (±磁坐偏角)。


从标准方向的北端起,顺时针方向到直线的水平角称为该直线的方位角。以北点为起算点，由北点开始按顺时针方向计量。方位角的取值范围为0~360度，北点为0°，东点为90°，南点为180°，西点为270°。





作者: eagler8    时间: 2021-1-24 21:05
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读数。
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. */



  43. #include "Arduino.h"
  44. #include "QMC5883LCompass.h"
  45. #include <Wire.h>

  47. QMC5883LCompass::QMC5883LCompass() {
  48. }


  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. }


  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. }




  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. }


  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. }


  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. }

  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. }

  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;

  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. }



  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);

  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. }

  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;

  194.         int avg_delta = (x_avg_delta + y_avg_delta + z_avg_delta) / 3;

  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;

  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. }


  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. }


  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. }


  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. }


  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. }

  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];

  307.         return _vRaw[i];
  308. }



  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. }


  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. }


  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. }
复制代码




作者: eagler8    时间: 2021-1-24 21:07
QMC5883LCompass.h 库文件

  1. #ifndef QMC5883L_Compass
  2. #define QMC5883L_Compass

  4. #include "Arduino.h"
  5. #include "Wire.h"


  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. };

  66. #endif
复制代码




作者: eagler8    时间: 2021-1-25 10:12
实验开源代码，
项目三：通过串口实时绘制电子罗盘方位角的波形



  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. */

  15. #include <QMC5883LCompass.h>

  17. QMC5883LCompass compass;

  19. void setup() {
  20.   Serial.begin(9600);
  21.   compass.init();

  23. }

  25. void loop() {
  26.   int a;

  28.   // 读取罗盘值
  29.   compass.read();

  31.   // 返回方位角读数
  32.   a = compass.getAzimuth();

  34.   Serial.print("电子罗盘方位角: ");
  35.   Serial.print(a);
  36.   Serial.println();

  38.   delay(800);
  39. }
复制代码







作者: eagler8    时间: 2021-1-25 10:15
用手转动QMC5883L模块，串口输出的实时波形，数值在0--359°之间波动，简单又直观。






作者: eagler8    时间: 2021-1-25 10:17
串口输出的实时数值





作者: eagler8    时间: 2021-1-25 11:07
QMC5883L Compass库函数的几个使用要点

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（）函数中添加：

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

3、获取X，Y或Z轴的数值
要获取X，Y或Z传感器的读数，只需调用所需的功能。

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

作者: eagler8    时间: 2021-1-25 11:11
4、获取方位角的数值
要获取计算出的方位角（罗盘度）值，只需调用getAzimuth();。
void loop(){
   int a = compass.getAzimuth();
}
5、获取方向/方位
QMC5883L指南针库可计算传感器指向的方向范围和方向。您可以调用两个函数。
要获取传感器面向的方向的12点值，可以调用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);。这将产生一个char数组[3]，其中的字母代表每个方向。由于我们无法返回数组，因此需要通过引用传递值。
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();
}

作者: eagler8    时间: 2021-1-25 11:35
6、更改I2C地址
要在调用compass.setADDR(BYTE_VALUE);之前更改I2C地址呼叫，compass.init();如下所示：


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


7、更改模式，数据速率，比例，采样率
您还可以更改QMC5583L芯片的模式，灵敏度，采样率和输出率。等等，只需在调用compass.setMode(MODE, ODR, RNG, OSR);后调用即可compass.init()。请注意，每个值必须是一个字节。设置每个模式的值在预设中，并取自QST QMC5583L数据表。





作者: eagler8    时间: 2021-1-25 11:55
8、精细QMC5583L传感器输出
在传感器读数似乎反弹的情况下，平滑可以提供帮助。QMC5883L指南针库使用滚动平均值功能来存储（N）个传感器读数并返回每个轴的平均值。该平均还对方位角和方向输出进行平滑处理。


如果启用，该功能的第二部分将采用内部滚动逐步通过的当前替代和替代，将其从总体上中删除。这可以帮助消除在错误的读数中可能发生的替代的高点和低点。


应该注意的是，内置的平滑功能将导致额外的处理时间。


compass.setSmoothing(STEPS, ADVANCED);




在循环之前启用平滑调用。


步骤：int，使结果平滑的步骤数。1到10的有效值。更高的步长等于更平滑，但处理时间缩短。


*：启用此功能将使平滑效果更好，但处理时间缩短。*


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



作者: eagler8    时间: 2021-1-25 11:59
9、校准QMC5583L传感器
QMC5883LCompass库包含校准功能和实用程序大纲，可帮助您校准QMC5883L芯片。校准是一个两步过程。


步骤1：运行校准程序
a、确保已连接QMC5883L芯片。
b、在示例> QMC5883LCOMPASS>校准下找到随附的校准草图。
c、将校准草图上传到您的arduino，然后打开串行监视器。
d、校准过程开始时，通过移动传感器来伴随屏幕上的指示。
c、收集完所有校准数据后，复制副本的代码


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




可能需要保存它以备将来参考。


步骤2：使用校正资料
a、项目的程序，将然后复制的代码行直接插入到compass.init()调用下方。
b、照常使用QMC5883LCompass库。

建议您使用提供的校准草图来生成传感器的预设和替代，但也可以使用该


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




函数添加自己的预设和替代。


作者: eagler8    时间: 2021-1-25 13:16
实验开源代码
项目四：通过串口实时绘制电子罗盘方位（12等分）的波形
说明：实时数值 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、说明：实时数值 0 = N，3 = E，6 = S，9 =W
  14. */

  16. #include <QMC5883LCompass.h>

  18. QMC5883LCompass compass;

  20. void setup() {
  21.   Serial.begin(9600);
  22.   compass.init();
  23. }

  25. void loop() {
  26.   compass.read();

  28.   byte a = compass.getAzimuth();
  29.   // 根据方位/方位角的方向，此处的输出将是介于0到11之间的值。
  30.   byte b = compass.getBearing(a);
  31.   
  32.   Serial.print("指南针方位: ");
  33.   Serial.print(b);
  34.   Serial.println();
  35.   
  36.   delay(800);
  37. }
复制代码




作者: eagler8    时间: 2021-1-25 14:08
用手转动QMC5883L模块，串口输出的指南针方位数值变动实时波形




作者: eagler8    时间: 2021-1-25 14:11
串口输出的指南针方位数值






作者: 春阴酿寒    时间: 2021-3-18 16:18
准确度怎么样
作者: bynaruto    时间: 2021-6-14 18:13
very professionnel, thank you it's really useful




欢迎光临 (http://www.51hei.com/bbs/) Powered by Discuz! X3.1