IMU-3DOF Трехосевой акселерометр (Trema-модуль) - Datasheet - Описания, примеры, подключение к Arduino

Общие сведения:

Trema-модуль IMU-сенсор 3 DOF (трёхосевой акселерометр) - это модуль, позволяющий определять своё положение в пространстве по показаниям проекций кажущегося ускорения на оси X, Y и Z. Направление осей указано на плате модуля. Интегрированная в чип схема обработки сигнала (ASIC) позволяет распознавать движение, вибрацию и самостоятельно подсчитывать количество касаний и шагов.

Два программируемых выхода прерываний позволяют получать информацию о регистрации шага, обнаружении обычного или значительного движения, отсутствия движения, обнаружения указанного количества касаний, поднятия или опускания руки, обновления данных и переполнения буфера FIFO.

Видео:

Редактируется...

Спецификация:

Чип: QMA6100
Питание модуля: 3,3 В или 5 В (оба напряжения входят в диапазон допустимых значений).
Низкое энергопотребление: до 70 мкА (QMA6100=44мкА, TXS0102=15мкА).
Диапазоны измерений проекции кажущегося ускорения: ±2g, ±4g, ±8g, ±16g, ±32g.
где g - ускорение свободного падения = 9,81 м/c².
Входной уровень «0» на шине I2C: 0 ... 0,15 В.
Входной уровень «1» на шине I2C: Vcc-0,4 ... Vcc В.
Адрес на шине I2C: 0x12 (по умолчанию), 0x13 (можно установить перемычками).
Рабочая температура: -40 ... 85 °C.
Габариты модуля 30x30 мм.

Все модули линейки "Trema" выполнены в одном формате

Подключение:

Trema-модуль IMU 3 DOF подключается к аппаратной или программной шине I2C Arduino.

В комплекте имеется кабель для быстрого и удобного подключения модуля к колодке I2C на Trema Shield . Если на шине I2C уже имеется другое устройство, то для подключения модуля, предлагаем воспользоваться I2C Hub. К одной шине I2C можно подключить до двух модулей IMU 3 DOF (трёхосевой акселерометр), задав им разные адреса перемычками на тыльной стороне платы.

Модуль удобно подключать 4 способами, в зависимости от ситуации:

Способ - 1: Используя проводной шлейф и Piranha UNO

Используя провода «Папа — Мама», подключаем напрямую к контроллеру Piranha UNO.

Способ - 2: Используя Trema Set Shield

Модуль можно подключить к любому из I2C входов Trema Set Shield.

Способ - 3: Используя проводной шлейф и Shield

Используя 4-х проводной шлейф, к Trema Shield, Trema-Power Shield, Motor Shield, Trema Shield NANO и тд.

Способ - 4: Подключение к программной шине I2C

При использовании программной шины I2C, модуль можно подключить к любым выводам Arduino, но потребуется дополнительно установить библиотеку iarduino_I2C_Software.h, для создания программной шины I2C, указав номера выбранных вами выводов. О том как это сделать читайте ниже в разделе «Подключение библиотеки», а так же на странице Wiki - Расширенные возможности библиотек iarduino для шины I2C.

Подключение выводов INT:

Выводы INT1 и INT2 являются выходами прерываний и расположены на плате модуля по бокам от колодки шины I2C.

Оба вывода INT модуля являются программируемыми. Настройка выводов осуществляется по шине I2C. Выводам можно назначить активный логический уровень (0 или 1), а так же выбрать схему включения (двухтактную или с открытым стоком). Подключение выводов зависит от выбранной схемы и логического уровня.

Каждому выводу можно назначить те прерывания, состояния которых требуется выводить. Модуль позволяет сопоставить выводам такие прерывания как: обнаружение шага, движения, значительного движения, отсутствия движения, указанного количества касаний, поднятия или опускания руки, обновления данных и переполнения буфера FIFO.

Модуль потребляет малые токи, что позволяет интегрировать его в устройства с питанием от батареек, а выводы INT использовать для пробуждения внешних устройств, например, назначив выводу прерывание по тройному касанию.

Питание:

Входное напряжение питания 3,3 В, или 5 В постоянного тока, подаётся на выводы Vcc и GND модуля.

Подробнее о модуле:

Trema-модуль IMU 3 DOF (Inertial Measurement Unit 3 Degrees Of Freedom) - инерционное измерительное устройство на 3 степени свободы, построен на базе чипа QMA6100 (QST Module Accelerometer) - модуль акселерометра компании «QST». 3 степени свободы означает, что акселерометр трёхосевой и выдаёт показания по 3 осям (X,Y,Z). Питание чипа осуществляется через линейный понижающий стабилизатор с низким энергопотреблением и малым падением напряжения XC6206P332MR, что позволяет модулю работать при напряжениях выходящих за пределы заявленные в спецификации на 1,0 В в обе стороны. Для согласования логических уровней чипа QMA6100 с 5В логикой, на плате модуля предусмотрен двунаправленный преобразователь уровня и напряжения TXS0102.

Акселерометр это датчик измеряющий проекцию кажущегося ускорения, которая является геометрической разницей между истинным ускорением датчика (быстрота изменения скорости датчика) и ускорением силы гравитации (ускорение свободного падения). Показания датчика можно получать в м/c², или в g (количестве ускорений свободного падения). Предположим что датчик неподвижен, или движется равномерно (истинное ускорение датчика равно 0 м/c²), ось Z направлена вверх (детали на плате модуля смотрят вверх). В таком случае проекция вектора силы гравитации не оказывает влияния на оси XY, их показания равны 0 м/c², но оказывает влияние на ось Z и направлена в противоположную сторону (к земле), значит Z = a - -g = 9,81 м/c², где:
a: проекция истинного ускорения модуля на ось Z. Так как модуль неподвижен, то a = 0.
g: ускорение свободного падения взятое со знаком минус, так как его вектор противоположен направлению оси Z. Примечание: все значения (X,Y,Z,a,g) векторные.

Если модуль наклонить, то влияние ускорения свободного падения (g) на ось Z ослабнет, но увеличится на те оси в направлении которых был наклонён модуль. Таким образом, зная проекцию вектора ускорения свободного падения (g) на оси X, Y, Z, можно вычислить положение датчика относительно поверхности земли, но только если датчик неподвижен, или движется равномерно, так как только в этом случае истинное ускорение равно 0 м/с². Истинным ускорением можно пренебречь при определении положения устройств движущихся с незначительной скоростью, но на больших и часто меняющихся скоростях используются модули с 6 и более степенями свободы (IMU 6 DOF), в которых влияние истинного ускорения на модуль компенсируется показаниями гироскопа.

Специально для Trema-модуля IMU 3 DOF (трёхосевой акселерометр) нами разработана библиотека iarduino_Position_QMA6100, которая значительно упрощает процесс получения данных с модуля.

В библиотеке имеются функции аппаратного самотестирования и программной калибровки акселерометра, есть возможность выбора диапазонов и единиц измерений.

Подробнее про установку библиотеки читайте в нашей инструкции.

Примеры:

В примерах используется разработанная нами библиотека iarduino_Position_QMA6100.

Самотестирование акселерометра:

Самотестирование запускается функцией test(), которая проверяет наличие модуля на шине и корректность показаний акселерометра. В процессе самотестирования, модуль должен быть неподвижен, а его положение в пространстве не влияет на результат самотестирования. Функция сравнивает показания акселерометра в нормальном режиме работы с показаниями в момент приложения внутренних электростатических сил разного направления.

/* САМОТЕСТИРОВАНИЕ АКСЕЛЕРОМЕТРА */                         // 
                                                             //
#include <Wire.h>                                            // Подключаем библиотеку для работы с аппаратной шиной I2C, до подключения библиотеки iarduino_Position_QMA6100.
#include <iarduino_Position_QMA6100.h>                       // Подключаем библиотеку для работы с Trema-модулем IMU 3 DOF (трёхосевой акселерометр).
iarduino_Position_QMA6100 sensor(0x12);                      // Создаём объект sensor для работы с функциями и методами библиотеки iarduino_Position_QMA6100, указывая адрес модуля на шине I2C.
                                                             //
void setup(){                                                // 
     Serial.begin(9600);                                     // Инициируем передачу данных в монитор последовательного порта на скорости 9600 бит/сек.
     while(!Serial){}                                        // Ждём готовность Serial к передаче данных в монитор последовательного порта.
     sensor.begin(&Wire); // &Wire1, &Wire2 ...              // Инициируем работу с модулем, указав ссылку на объект для работы с шиной I2C.
     switch( sensor.test() ){                                // Выполняем самотестирование модуля.
       case QMA_ERR_ID: Serial.println("Not found"); break;  // Акселерометр не найден.
       case QMA_ERR_ST: Serial.println("Err test" ); break;  // Акселерометр не прошел самотестирование.
       default:         Serial.println("Test Ok!" ); break;  // Самотестирование успешно пройдено.
     }                                                       //
}                                                            //
                                                             //
void loop(){                                                 //
}                                                            //

В результате выполнения данного скетча на экране появится надпись:

"Not found" Если модуль не найден на шине I2C.
"Err test" Если модуль обнаружен, но самотестирование не пройдено.
"Test Ok!" Если модуль обнаружен и самотестирование успешно пройдено.

Компенсация смещения данных акселерометра:

Нормальное положение Trema-модуля IMU 3 DOF (трёхосевой акселерометр) в любом устройстве соответствует направлению оси Z вверх от земли (это положение при котором детали на плате модуля смотрят вверх от земли). Не всегда возможно точно расположить модуль, значит если мы захотим получить углы по трём осям относительно горизонта, то углы для осей X и Y будут отличаться от 0°, а угол для оси Z будет отличаться от 90°. При калибровке акселерометра, он скорректирует свои данные так, будто ось Z направлена строго вверх, а оси XY параллельны земле).

/* ВЫРАВНИВАНИЕ АКСЕЛЕРОМЕТРА            */                  //
/* Модуль должен находиться осью Z вверх */                  //
                                                             //
#include <Wire.h>                                            // Подключаем библиотеку для работы с аппаратной шиной I2C, до подключения библиотеки iarduino_Position_QMA6100.
#include <iarduino_Position_QMA6100.h>                       // Подключаем библиотеку для работы с Trema-модулем IMU 3 DOF (трёхосевой акселерометр).
iarduino_Position_QMA6100 sensor(0x12);                      // Создаём объект sensor для работы с функциями и методами библиотеки iarduino_Position_QMA6100, указывая адрес модуля на шине I2C.
                                                             //
void setup(){                                                // 
     Serial.begin(9600);                                     // Инициируем передачу данных в монитор последовательного порта на скорости 9600 бит/сек.
     while(!Serial){}                                        // Ждём готовность Serial к передаче данных в монитор последовательного порта.
     sensor.begin(&Wire); // &Wire1, &Wire2 ...              // Инициируем работу с модулем, указав ссылку на объект для работы с шиной I2C.
     sensor.calibrateOffsets();                              // Выполняем компенсацию смещения. Модуль должен находиться осью Z вверх.
}                                                            //
                                                             //
void loop(){                                                 //
//   Читаем показания акселерометра:                         //
     sensor.read(QMA_DEG);                                   // Получаем данные, указав, что хотим получить углы в градусах относительно горизонта (QMA_DEG).
     int8_t x = sensor.axisX;                                // Сохраняем угол оси X, как знаковое целое. Для большей точности можно сохранить как float.
     int8_t y = sensor.axisY;                                // Сохраняем угол оси Y, как знаковое целое. Для большей точности можно сохранить как float.
     int8_t z = sensor.axisZ;                                // Сохраняем угол оси Z, как знаковое целое. Для большей точности можно сохранить как float.
//   Выводим углы наклона осей относительно горизонта:       //
     Serial.println((String) "XYZ: "+x+"°, "+y+"°, "+z+"°"); //
     delay(1000);                                            //
}                                                            //

В коде setup() выполняется инициализация передачи данных в монитор последовательного порта и инициализация работы с модулем, после чего функцией calibrateOffsets() осуществляется компенсация смещения данных акселерометра. Функция записывает найденные значения для компенсации показаний в регистры чипа, которые сохраняются до перезагрузки или отключения питания. В коде loop() данные акселерометра читаются функцией read() в углах наклона осей относительно горизонта, в градусах.

После загрузки скетча, на экране будут появляться строки с текущими углами осей относительно горизонта в формате: XYZ: 0°, 0°, 90°. Если значения сильно отличаются от ожидаемых, то перед компенсацией смещения рекомендуется выполнить калибровку.

Получение данных с акселерометра:

Функция read() позволяет получать данные в м/c² (QMA_M_S), в количестве g (QMA_G), в углах наклона осей относительно горизонта в градусах (QMA_DEG), или в радианах (QMA_RAD), результат чтения доступен из переменных axisX, axisY, axisZ.

/* ЧТЕНИЕ ДАННЫХ АКСЕЛЕРОМЕТРА */                            // 
                                                             //
#include <Wire.h>                                            // Подключаем библиотеку для работы с аппаратной шиной I2C, до подключения библиотеки iarduino_Position_QMA6100.
#include <iarduino_Position_QMA6100.h>                       // Подключаем библиотеку для работы с Trema-модулем IMU 3 DOF (трёхосевой акселерометр).
iarduino_Position_QMA6100 sensor(0x12);                      // Создаём объект sensor для работы с функциями и методами библиотеки iarduino_Position_QMA6100, указывая адрес модуля на шине I2C.
                                                             //
void setup(){                                                // 
     Serial.begin(9600);                                     // Инициируем передачу данных в монитор последовательного порта на скорости 9600 бит/сек.
     while(!Serial){}                                        // Ждём готовность Serial к передаче данных в монитор последовательного порта.
     sensor.begin(&Wire); // &Wire1, &Wire2 ...              // Инициируем работу с модулем, указав ссылку на объект для работы с шиной I2C.
//   sensor.calibrateOffsets();                              // Выполняем компенсацию смещения. Модуль должен находиться осью Z вверх.
}                                                            //
                                                             //
void loop(){                                                 //
//   Читаем показания акселерометра:                         //
     sensor.read(QMA_M_S);                                   // Получаем данные, указав, что хотим получить ускорение в м/с² (QMA_M_S).
     float x = sensor.axisX;                                 // Сохраняем ускорение по оси X.
     float y = sensor.axisY;                                 // Сохраняем ускорение по оси Y.
     float z = sensor.axisZ;                                 // Сохраняем ускорение по оси Z.
//   Выводим ускорение каждой оси в м/с²:                    //
     Serial.println((String)"XYZ: "+x+", "+y+", "+z+" м/с²");//
     delay(1000);                                            //
}                                                            //

В предыдущем примере мы читали углы наклона осей в градусах относительно горизонта, а в этом примере на экран монитора будут выводится ускорения по трём осям XYZ в м/c², в формате: XYZ: 0.02, 0.05, 9.78 м/с². Если значения сильно отличаются от ожидаемых, то перед чтением данных рекомендуется выполнить калибровку.

Калибровка акселерометра:

В начале накапливаются данные акселерометра для каждой оси в двух положениях: ось направлена вверх, ось направлена вниз. Значения читаются функцией read() в количестве g (QMA_G) по 100 раз (чем больше значений, тем точнее среднее арифметическое). В мониторе будут отображаться подсказки, как расположить модуль: осью X вверх, осью Y вверх, осью Z вверх, осью X вниз, осью Y вниз, осью Z вниз. После того как все данные собраны, выполняется калибровка, обращением к функции calibrateAll(), которой в качестве параметра указывается массив собранных данных data.

/* КАЛИБРОВКА АКСЕЛЕРОМЕТРА */                               // 
                                                             //
#include <Wire.h>                                            // Подключаем библиотеку для работы с аппаратной шиной I2C, до подключения библиотеки iarduino_Position_QMA6100.
#include <iarduino_Position_QMA6100.h>                       // Подключаем библиотеку для работы с Trema-модулем IMU 3 DOF (трёхосевой акселерометр).
iarduino_Position_QMA6100 sensor(0x12);                      // Создаём объект sensor для работы с функциями и методами библиотеки iarduino_Position_QMA6100, указывая адрес модуля на шине I2C.
                                                             //
float data[6]={ 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f };        // Массив для накопления данных осей (X вверх, Y вверх, Z вверх, X вниз, Y вниз, Z вниз).
                                                             //
void setup(){                                                // 
     Serial.begin(9600);                                     // Инициируем передачу данных в монитор последовательного порта на скорости 9600 бит/сек.
     while(!Serial){}                                        // Ждём готовность Serial к передаче данных в монитор последовательного порта.
     sensor.begin(&Wire); // &Wire1, &Wire2 ...              // Инициируем работу с модулем, указав ссылку на объект для работы с шиной I2C.
//   Накапливаем данные для калибровки:                      //
     uint8_t i;                                              //
     Serial.println("Установите модуль осью X вверх, чтение данных начнётся через 5 секунд..."); delay(5000); Serial.println("Читаем данные..."); i=0; while(i<100){ sensor.read(QMA_G); data[0]+=sensor.axisX; i++; delay(1); } data[0]/=i;
     Serial.println("Установите модуль осью Y вверх, чтение данных начнётся через 5 секунд..."); delay(5000); Serial.println("Читаем данные..."); i=0; while(i<100){ sensor.read(QMA_G); data[1]+=sensor.axisY; i++; delay(1); } data[1]/=i;
     Serial.println("Установите модуль осью Z вверх, чтение данных начнётся через 5 секунд..."); delay(5000); Serial.println("Читаем данные..."); i=0; while(i<100){ sensor.read(QMA_G); data[2]+=sensor.axisZ; i++; delay(1); } data[2]/=i;
     Serial.println("Установите модуль осью X вниз , чтение данных начнётся через 5 секунд..."); delay(5000); Serial.println("Читаем данные..."); i=0; while(i<100){ sensor.read(QMA_G); data[3]+=sensor.axisX; i++; delay(1); } data[3]/=i;
     Serial.println("Установите модуль осью Y вниз , чтение данных начнётся через 5 секунд..."); delay(5000); Serial.println("Читаем данные..."); i=0; while(i<100){ sensor.read(QMA_G); data[4]+=sensor.axisY; i++; delay(1); } data[4]/=i;
     Serial.println("Установите модуль осью Z вниз , чтение данных начнётся через 5 секунд..."); delay(5000); Serial.println("Читаем данные..."); i=0; while(i<100){ sensor.read(QMA_G); data[5]+=sensor.axisZ; i++; delay(1); } data[5]/=i;
//   Выполняем калибровку:                                   //
     sensor.calibrateAll(data);                              // Выполняем калибровку отправляя массив с усреднёнными значениями осей.
}                                                            //
                                                             //
void loop(){                                                 //
//   Читаем показания акселерометра:                         //
     sensor.read(QMA_M_S);                                   // Получаем данные, указав, что хотим получить ускорение в м/с² (QMA_M_S).
     float x = sensor.axisX;                                 // Сохраняем ускорение по оси X.
     float y = sensor.axisY;                                 // Сохраняем ускорение по оси Y.
     float z = sensor.axisZ;                                 // Сохраняем ускорение по оси Z.
//   Выводим ускорение каждой оси в м/с²:                    //
     Serial.println((String)"XYZ: "+x+", "+y+", "+z+" м/с²");//
     delay(1000);                                            //
}                                                            //

Функция calibrateAll() рассчитывает усиление для необработанных сигналов и смещение выходных данных акселерометра. Рассчитанные значения функция отправляет в модуль, как при выполнении функций setGain() и setOffset().

Основная трудность калибровки заключается в сборе данных. Но эти данные можно собрать всего один раз, после чего сохранить значения массива data в скетче и использовать уже сохранённые данные в качестве параметра функции calibrateAll(), без необходимости вращать модуль и собирать показания при каждом старте скетча. Данные собранные с одного модуля не подойдут в качестве калибровочных для другого модуля.

Работа с прерываниями:

123

/* ПРЕРЫВАНИЯ ДВОЙНОГО И ТРОЙНОГО КАСАНИЯ */                 // 
                                                             //
#include <Wire.h>                                            // Подключаем библиотеку для работы с аппаратной шиной I2C, до подключения библиотеки iarduino_Position_QMA6100.
#include <iarduino_Position_QMA6100.h>                       // Подключаем библиотеку для работы с Trema-модулем IMU 3 DOF (трёхосевой акселерометр).
iarduino_Position_QMA6100 sensor(0x12);                      // Создаём объект sensor для работы с функциями и методами библиотеки iarduino_Position_QMA6100, указывая адрес модуля на шине I2C.
                                                             //
void setup(){                                                //

123

В библиотеке iarduino_Position_QMA6100 имеется больше примеров.

Описание основных функций библиотеки:

В данном разделе описаны основные функции библиотеки iarduino_Position_QMA6100 для работы с Trema-модулем IMU 3 DOF (трёхосевой акселерометр). Эти функции позволяют получать данные акселерометра (проекцию кажущегося ускорения на оси XYZ), выполнять сброс и тестирование акселерометра, а так же осуществлять настройки показаний акселерометра путем изменения усиления необработанных сигналов, смещения выходных данных и управления ФНЧ.

Библиотека iarduino_Position_QMA6100 может использовать как аппаратную, так и программную реализацию шины I2C. О том как выбрать тип шины I2C рассказано ниже в разделе «Подключение библиотеки», а так же на странице Wiki - расширенные возможности библиотек iarduino для шины I2C.

Подключение библиотеки:

Если используется аппаратная шина I2C:

#include <Wire.h>                        // Подключаем библиотеку для работы с аппаратной шиной I2C, до подключения библиотеки iarduino_Position_QMA6100.h
                                         //
#include <iarduino_Position_QMA6100.h>   // Подключаем библиотеку для работы с Trema-модулем IMU 3 DOF (трёхосевой акселерометр).
iarduino_Position_QMA6100 sensor(0x12);  // Создаём объект sensor для работы с функциями и методами библиотеки iarduino_Position_QMA6100, указывая адрес модуля на шине I2C.
                                         // Адрес можно не указывать: iarduino_Position_QMA6100 sensor; Будет использован адрес по умолчанию - 0x12.
void setup(){                            //
     ...                                 //
     sensor.begin(&Wire);                // Инициируем работу с модулем, указав ссылку на объект для работы с шиной I2C на которой находится модуль (по умолчанию &Wire).
     ...                                 // Доступны объекты: &Wire, &Wire1, &Wire2...
}                                        //

Если используется программная шина I2C:

#include <iarduino_I2C_Software.h>       // Подключаем библиотеку для работы с программной шиной I2C, до подключения библиотеки iarduino_Position_QMA6100.h
SoftTwoWire sWire(3,4);                  // Создаём объект программной шины I2C указав выводы которым будет назначена роль линий: SDA, SCL.
                                         //
#include <iarduino_Position_QMA6100.h>   // Подключаем библиотеку для работы с Trema-модулем IMU 3 DOF (трёхосевой акселерометр).
iarduino_Position_QMA6100 sensor(0x12);  // Создаём объект sensor для работы с функциями и методами библиотеки iarduino_Position_QMA6100, указывая адрес модуля на шине I2C.
                                         // Адрес можно не указывать: iarduino_Position_QMA6100 sensor; Будет использован адрес по умолчанию - 0x12.
void setup(){                            //
     ...                                 //
     sensor.begin(&sWire);               // Инициируем работу с модулем, указав ссылку на объект для работы с шиной I2C на которой находится модуль (по умолчанию &Wire).
     ...                                 //
}                                        //

В обоих примерах сначала подключается библиотека для работы с шиной I2C. Для аппаратной шины библиотека Wire.h (предустановлена в Arduino IDE), а для программной шины библиотека iarduino_I2C_Software.h, с созданием объекта которому указываются выбранные вами выводы шины, в примере выводы (3-SDA, 4-SCL).
Далее подключается библиотека и создаётся объект для работы с модулем.
В коде Setup(), при инициализации работы с модулем указывается ссылка на объект работы с выбранной шиной I2C begin(&ШИНА). Остальные строки кода одинаковы для любой шины I2C.

К одной шине I2C можно подключить до двух модулей IMU 3 DOF, задав им разные адреса (0x12 и 0x13). В следующем примере используются 4 шины I2C для подключения 8 модулей.

#include <Wire.h>                        // Подключаем библиотеку для работы с аппаратными шинами I2C, до подключения библиотеки iarduino_Position_QMA6100.h
#include <iarduino_I2C_Software.h>       // Подключаем библиотеку для работы с программными шинами I2C, до подключения библиотеки iarduino_Position_QMA6100.h
#include <iarduino_Position_QMA6100.h>   // Подключаем библиотеку для работы с Trema-модулями IMU 3 DOF.
                                         //
SoftTwoWire myWire1(3,4);                // Создаём программную шину I2C на выводах 3 (SDA), 4 (SCL).
SoftTwoWire myWire2(5,6);                // Создаём программную шину I2C на выводах 5 (SDA), 6 (SCL).
iarduino_Position_QMA6100 sensor1(0x12); // Объект 1 модуля с адресом 0x12 на шине I2C.
iarduino_Position_QMA6100 sensor2(0x13); // Объект 2 модуля с адресом 0x13 на шине I2C.
iarduino_Position_QMA6100 sensor3(0x12); // Объект 3 модуля с адресом 0x12 на шине I2C.
iarduino_Position_QMA6100 sensor4(0x13); // Объект 4 модуля с адресом 0x13 на шине I2C.
iarduino_Position_QMA6100 sensor5(0x12); // Объект 5 модуля с адресом 0x12 на шине I2C.
iarduino_Position_QMA6100 sensor6(0x13); // Объект 6 модуля с адресом 0x13 на шине I2C.
iarduino_Position_QMA6100 sensor7(0x12); // Объект 7 модуля с адресом 0x12 на шине I2C.
iarduino_Position_QMA6100 sensor8(0x13); // Объект 8 модуля с адресом 0x13 на шине I2C.
                                         //
void setup(){                            //
     ...                                 //
     sensor1.begin(&Wire);               // Инициируем работу с 1 модулем на шине Wire.
     sensor2.begin(&Wire);               // Инициируем работу с 2 модулем на шине Wire.
     sensor3.begin(&Wire1);              // Инициируем работу с 3 модулем на шине Wire1.
     sensor4.begin(&Wire1);              // Инициируем работу с 4 модулем на шине Wire1.
     sensor5.begin(&myWire1);            // Инициируем работу с 5 модулем на шине myWire1.
     sensor6.begin(&myWire1);            // Инициируем работу с 6 модулем на шине myWire1.
     sensor7.begin(&myWire2);            // Инициируем работу с 7 модулем на шине myWire2.
     sensor8.begin(&myWire2);            // Инициируем работу с 8 модулем на шине myWire2.
     ...                                 //
}                                        //

В начале подключаются библиотеки:

Wire.h - позволяет работать с аппаратными шинами I2C: Wire, Wire1, Wire2, ...
iarduino_I2C_Software.h - позволяет создавать программные шины I2C.
iarduino_Position_QMA6100 - позволяет работать с модулями IMU 3 DOF.

Далее создаются объекты:

Создаём 2 программные шины myWire1 и myWire2 на выводах 3, 4 и 5, 6.
Создаём 8 объектов sensor для работы с модулями, указав их адреса на шинах I2C.

Вместо 8 объектов можно создать один массив из 8 элементов с адресами:
iarduino_Position_QMA6100 sensor[8]={0x12,0x13,0x12,0x13,0x12,0x13,0x12,0x13};

В коде setup() указываем какой модуль на какой шине I2C находится.

Модули sensor1 и sensor2 находятся на аппаратной шине Wire.
Модули sensor3 и sensor4 находятся на аппаратной шине Wire1.
Модули sensor5 и sensor6 находятся на программной шине myWire1.
Модули sensor7 и sensor8 находятся на программной шине myWire2.

Таким образом на каждой шине I2C находятся по 2 модуля с разными адресами.

Функция begin();

Назначение: Инициализация работы с модулем.
Синтаксис: begin( [&ШИНА [, СМЕЩЕНИЕ]] );
Параметры:
- &ШИНА - Ссылка на объект для работы с шиной I2C на которой находится модуль.
- СМЕЩЕНИЕ - флаг указывающий выполнить компенсацию смещения акселерометра.
Возвращаемые значения: bool - результат инициализации датчика (true или false).
Примечание:
- Функцию необходимо вызывать до обращения к остальным функциям и методам объекта.
- Функцию достаточно вызвать 1 раз в коде setup.
- Оба параметра функции являются необязательными. Если функция вызвана без параметров, то будет использоваться аппаратная шина Wire, без компенсации смещения.
Пример:

sensor.begin(&Wire1, true); // Инициализация модуля на шине Wire1 с выполнением компенсации смещения.
sensor.begin(&Wire2);       // Инициализация модуля на шине Wire2 без компенсации смещения.
sensor.begin();             // Инициализация модуля на шине Wire без компенсации смещения.

Функция test();

Назначение: Выполнение аппаратного самотестирования акселерометра.
Синтаксис: test();
Параметры: нет.
Возвращаемые значения:
- 0 - аппаратное самотестирование акселерометра успешно пройдено.
- QMA_ERR_ID - акселерометр не найден.
- QMA_ERR_ST - акселерометр не прошел самотестирование.
Примечание:
- В процессе самотестирования акселерометра, модуль должен быть неподвижен.
- Положение модуля в пространстве не влияет на результат самотестирования.
- При тестировании проверяется не только работоспособность акселерометра, но и корректность выдаваемых им показаний, путем сравнения данных с приложением внутренних электростатических сил и без таковых.
- Выполнение функции занимает не менее 3 мс.
- В разделе «Примеры» настоящей статьи есть скетч использования этой функции.
Пример:

if( sensor.test() ){ Serial.print("Err"); } // Самотестирование с выводом ошибки.

Функция read();

Назначение: Выполнение чтения показаний акселерометра.
Синтаксис: read( [ЕДИНИЦЫ_ИЗМЕРЕНИЯ] );
Параметр:
- QMA_M_S - выводить проекцию кажущегося ускорения в м/с² (по умолчанию).
- QMA_G - выводить проекцию кажущегося ускорения в количестве ускорений свободного падения (g).
- QMA_DEG - выводить углы наклона осей относительно горизонта в градусах.
- QMA_RAD - выводить углы наклона осей относительно горизонта в радианах.
Возвращаемые значения: bool - успех чтения данных (true или false).
Примечание:
- Функция возвращает результат успешности чтения, а прочитанные данные сохраняются в переменные: axisX, axisY, axisZ.
- Проекция кажущегося ускорения на ось - это геометрическая разница между истинным ускорением модуля (быстрота изменения скорости модуля) и ускорением силы гравитации (ускорение свободного падения).
- Возвращаемые углы наклона осей относительно горизонта являются корректными при отсутствии истинного ускорения модуля, то есть, при условии неподвижности (малоподвижности) или равноускоренности модуля. В противном случае влияние истинного ускорения модуля необходимо компенсировать показаниями угловой скорости гироскопа.
- В разделе «Примеры» настоящей статьи есть скетч использования этой функции.
Пример:

sensor.read(QMA_DEG);   // Читаем наклоны всех осей модуля относительно горизонта.
float x = sensor.axisX; // Получаем наклон оси X относительно горизонта от 0 до ±90°.
float y = sensor.axisY; // Получаем наклон оси Y относительно горизонта от 0 до ±90°.
float z = sensor.axisZ; // Получаем наклон оси Z относительно горизонта от 0 до ±90°.

Функция reset();

Назначение: Перезагрузка акселерометра.
Синтаксис: reset();
Параметры: нет.
Возвращаемые значения: bool - успех выполнения перезагрузки (true или false).
Примечание:
- В процессе перезагрузки выполняется программный сброс всех регистров чипа.
- После перезагрузки функция самостоятельно восстанавливает диапазон измерений акселерометра, указанный ранее функцией setScale() - по умолчанию 32 g.
- Выполнение функции занимает не менее 10 мс.
Пример:

if( !sensor.reset() ){ Serial.print("Err"); } // Перезагрузка с выводом ошибки.

Функция resetDetector();

Назначение: Сброс детекторов акселерометра.
Синтаксис: resetDetector();
Параметры: нет.
Возвращаемые значения: bool - успех отправки сброса (true или false).
Примечание:
- Обращение к функции приведёт к сбросу состояния и настроек детекторов: любого движения, значительного движения, отсутствия движения и касания.
- Указанные детекторы являются частью интегрированной в чип схемы обработки сигнала (ASIC) позволяющей распознавать определённые события и вызывать прерывания.
Пример:

if( !sensor.resetDetector() ){ Serial.print("Err"); } // Сброс детекторов с выводом ошибки

Функция setScale();

Назначение: Установка диапазона измерений акселерометра.
Синтаксис: setScale( ДИАПАЗОН );
Параметр:
- QMA_2G - производить измерения в диапазоне ±2 g.
- QMA_4G - производить измерения в диапазоне ±4 g.
- QMA_8G - производить измерения в диапазоне ±8 g.
- QMA_16G - производить измерения в диапазоне ±16 g.
- QMA_32G - производить измерения в диапазоне ±32 g (по умолчанию).
Возвращаемые значения: bool - успех записи нового диапазона (true или false).
Примечание:
- Акселерометр не сможет измерять проекцию кажущегося ускорения если она превышает установленный диапазон измерений. Выходные данные будут ограничены установленным диапазоном.
- От указанного диапазона измерений зависит шаг данных, который рассчитывается по формуле: шаг данных = диапазон / (2¹³-1) = диапазон / 8191.
- Таким образом, для увеличения точности, рекомендуется указать минимальный диапазон измерений, при котором показания акселерометра не будут выходить за его пределы.
- Датчик использует диапазон по умолчанию ±2 g, а библиотека указывает ±32 g.
- Диапазон указанный данной функцией не сбрасывается функциями begin() и reset().
Пример:

sensor.setScale(QMA_16G); // Установить диапазон измерений от 0 до ±16g (±157 м/с²).

Функция getScale();

Назначение: Получение текущего диапазона измерений акселерометра.
Синтаксис: getScale();
Параметр: нет.
Возвращаемые значения: uint8_t - одно из значений:

QMA_2G / QMA_4G / QMA_8G / QMA_16G / QMA_32G.

Примечание: см. функцию setScale().
Пример:

uint8_t i = getScale(); // Получить используемый в настоящее время диапазон измерений.

Функция setGain();

Назначение: Установка усиления для необработанных сигналов акселерометра.
Синтаксис: setGain( gain_X, gain_Y, gain_Z );
Параметры:
- uint8_t gain_X - усиление необработанного сигнала по оси X, значение от 0 до 255.
- uint8_t gain_Y - усиление необработанного сигнала по оси Y, значение от 0 до 255.
- uint16_t gain_Z - усиление необработанного сигнала по оси Z, значение от 0 до 1023.
Возвращаемые значения: bool - успех записи указанных значений (true или false).
Примечание:
- Указанные значения сохраняются в регистры чипа: GAIN_X, GAIN_Y, GAIN_Z.
- Необработанные данные с датчиков каждой оси акселерометра поступают на усилители, коэффициент усиления которых можно задать программно:
- Приведённые формулы были получены опытным путём, в datasheet (13-52-20) на чип QMA6100 нет информации о зависимости коэффициента усиления от значений регистров: GAIN_X, GAIN_Y, GAIN_Z.
- Из приведённых формул и допустимых значений параметров следует:
- Коэффициенты усиления подбираются так, чтоб показания акселерометра после усилителя для оси направленной вверх (против гравитации) были на 2g больше чем показания акселерометра для той же оси направленной вниз (в направлении гравитации).
- После настройки усиления производится настройка смещения функцией setOffset() и/или setUserOffset(), так, чтоб показания акселерометра для осей направленных горизонтально были равны 0.
- При правильных настройках усиления и смещения, выходные данные любой оси для неподвижного акселерометра должны быть равны:
- Для автоматического расчёта настроек усиления и смещения предлагаем воспользоваться функцией calibrateAll().
Пример:

sensor.setGain(70, 70, 130); // Установить усиление осей по указанным значениям.

Функция getGain();

Назначение: Получение значений для коэффициентов усиления.
Синтаксис: getGain();
Параметр: нет.
Возвращаемые значения: bool - успех чтения данных (true или false).
Примечание:

Функция возвращает результат успешности чтения смещений, а прочитанные данные сохраняются в переменные: axisX, axisY, axisZ.
В переменные сохраняются не коэффициенты усиления усилителей, а значения регистров GAIN_X, GAIN_Y, GAIN_Z, то есть те значения, которые были заданы функцией setGain().

Пример:

sensor.getGain();          // Читаем   значения для коэффициентов усиления.
uint8_t  x = sensor.axisX; // Получаем значение для коэффициента усиления по оси X.
uint8_t  y = sensor.axisY; // Получаем значение для коэффициента усиления по оси Y.
uint16_t z = sensor.axisZ; // Получаем значение для коэффициента усиления по оси Z.

Функция setOffset();

Назначение: Установка смещений для данных акселерометра.
Синтаксис: setOffset( offset_X, offset_Y, offset_Z );
Параметры:
- int16_t offset_X - смещение данных для оси X, значение от -1024 до +1023.
- int16_t offset_Y - смещение данных для оси Y, значение от -1024 до +1023.
- uint8_t offset_Z - смещение данных для оси Z, значение от 0 до +255.
Возвращаемые значения: bool - успех записи указанных значений (true или false).
Примечание:
- Указанные значения сохраняются в регистры чипа: OFFSET_X, OFFSET_Y, OFFSET_Z.
- К данным осей акселерометра после усилителей прибавляются значения смещений, которые можно задать программно:
- Приведённые формулы были получены опытным путём, в datasheet (13-52-20) на чип QMA6100 нет информации о зависимости величины смещения от значений регистров: OFFSET_X, OFFSET_Y, OFFSET_Z.
- Из приведённых формул и допустимых значений параметров следует:
- Смещения подбираются так, чтоб выходные показания акселерометра, для осей направленных горизонтально, были равны 0.
- Перед тем как подбирать смещения данных по осям, необходимо убедиться, что корректно подобраны коэффициенты усиления функцией setGain()
- Кроме описанных смещений можно задать пользовательские смещения функцией setUserOffset(). К данным акселерометра применятся оба варианта смещения.
- При правильных настройках усиления и смещения, выходные данные любой оси для неподвижного акселерометра должны быть равны:
- Для автоматического расчёта смещения воспользуйтесь функцией calibrateOffsets().
- Для автоматического расчёта настроек усиления и смещения предлагаем воспользоваться функцией calibrateAll().
Пример:

sensor.setOffset(-100, 50, 100); // Установить смещение осей по указанным значениям.

Функция getOffset();

Назначение: Получение значений для смещения данных акселерометра.
Синтаксис: getOffset();
Параметр: нет.
Возвращаемые значения: bool - успех чтения данных (true или false).
Примечание:

Функция возвращает результат успешности чтения смещения, а прочитанные данные сохраняются в переменные: axisX, axisY, axisZ.
В переменные сохраняются не смещения, а значения регистров OFFSET_X, OFFSET_Y, OFFSET_Z, то есть те значения, которые были заданы функцией setOffset().

Пример:

sensor.getOffset();        // Читаем   значения для смещения данных акселерометра.
uint8_t  x = sensor.axisX; // Получаем значение для смещения данных по оси X.
uint8_t  y = sensor.axisY; // Получаем значение для смещения данных по оси Y.
uint16_t z = sensor.axisZ; // Получаем значение для смещения данных по оси Z.

Функция setUserOffset();

Назначение: Установка пользовательских смещений для данных акселерометра.
Синтаксис: setUserOffset( offset_X, offset_Y, offset_Z );
Параметры:
- int8_t offset_X - смещение данных для оси X, значение от -128 до +127.
- int8_t offset_Y - смещение данных для оси Y, значение от -128 до +127.
- int8_t offset_Z - смещение данных для оси Z, значение от -128 до +127.
Возвращаемые значения: bool - успех записи указанных значений (true или false).
Примечание:
- Указанные значения сохраняются в регистры чипа: OFFSET_CUSTOM.
- 1 шаг смещения равен 16 шагам данных.
- 1 шаг данных = диапазон измерений / (2¹³-1) = getScale() / 8191.
- Из равенств следует, что каждая единица пользовательского смещения равна:
- Кроме пользовательских смещений можно задать смещения функцией setOffset(). К выходным данным акселерометра применятся оба варианта смещения.
- Преимущества пользовательского смещения перед смещением setOffset():
- Недостатки пользовательского смещения по сравнению с setOffset():
- Пользовательское смещение подбираются так, чтоб выходные показания акселерометра, для осей направленных горизонтально, были равны 0.
Пример:

sensor.setUserOffset(70, 70, 130); // Установить смещение осей по указанным значениям.

Функция getUserOffset();

Назначение: Получение пользовательских смещений данных акселерометра.
Синтаксис: getUserOffset();
Параметр: нет.
Возвращаемые значения: bool - успех чтения данных (true или false).
Примечание:

Функция возвращает результат успешности чтения смещения, а прочитанные данные сохраняются в переменные: axisX, axisY, axisZ.
В переменные сохраняются не смещения, а значения регистров OFFSET_CUSTOM, то есть те значения, которые были заданы функцией setUserOffset().

Пример:

sensor.getUserOffset();  // Читаем   пользовательские смещения данных акселерометра.
int8_t x = sensor.axisX; // Получаем пользовательское смещение данных по оси X.
int8_t y = sensor.axisY; // Получаем пользовательское смещение данных по оси Y.
int8_t z = sensor.axisZ; // Получаем пользовательское смещение данных по оси Z.

Функция calibrateOffsets();

Назначение: Выполнение компенсации смещения данных акселерометра.
Синтаксис: calibrateOffsets();
Параметр: нет.
Возвращаемые значения: bool - успех записи рассчитанных значений (true или false).
Примечание:
- При обращении к функции, ось Z модуля должна быть направлена вверх.
- Не всегда возможно точно расположить модуль в устройствах. Компенсация смещения скорректирует выходные данные акселерометра так, будто ось Z направлена строго вверх, а оси XY параллельны земле. Для этого будут автоматически рассчитаны и применены смещения, как при обращении к функции setOffset().
- После обращения к данной функции, показание оси Z будет скорректировано до ускорения свободного падения 9,81 м/c², а значение осей XY будет скорректировано до 0,0 м/c², модуль как бы программно выровняется по горизонту.
- Рассчитанные и применённые значения смещений доступны функцией getOffset().
- Компенсацию смещения рекомендуется выполнить в начале скетча. Это можно сделать обратившись к функции calibrateOffsets() или установив в true второй параметр функции begin().
- В разделе «Примеры» настоящей статьи есть скетч использования этой функции.
- Корректная работа функции гарантируется только в том случае, если правильно заданы параметры усиления необработанных сигналов акселерометра (калибруются на заводе изготовителе). В противном случае нужно сначала указать усиление setGain(), а затем выполнить компенсацию смещения calibrateOffsets() или вместо этих функций выполнить полную калибровку функцией calibrateAll().
Примеры:

sensor.begin(&Wire, true); // Инициализация модуля на шине Wire с выполнением компенсации смещения.

sensor.calibrateOffsets(); // выполняем компенсацию смещения данных акселерометра.

Функция calibrateAll();

Назначение: Выполнение калибровки акселерометра (подбор усиления и смещения).
Синтаксис:

calibrateAll( Xup, Yup, Zup, Xdn, Ydn, Zdn );
calibrateAll( МАССИВ );

Параметры:

float Xup - проекция кажущегося ускорения на ось X, которая смотрит вверх.
float Yup - проекция кажущегося ускорения на ось Y, которая смотрит вверх.
float Zup - проекция кажущегося ускорения на ось Z, которая смотрит вверх.
float Xdn - проекция кажущегося ускорения на ось X, которая смотрит вниз.
float Ydn - проекция кажущегося ускорения на ось Y, которая смотрит вниз.
float Zdn - проекция кажущегося ускорения на ось Z, которая смотрит вниз.
Все значения указываются в количестве ускорений свободного падения (g).
float МАССИВ - состоящий из 6 элементов { Xup,Yup,Zup,Xdn,Ydn,Zdn }.

Возвращаемые значения: bool - успех записи рассчитанных значений (true или false).
Примечание:
- Перед обращением к функции calibrateAll() необходимо обратиться к функции reset(), для сброса пользовательских смещений, если они указывались.
- Далее необходимо получить 6 показаний для их ввода в качестве параметров функции calibrateAll( Xup, Yup, Zup, Xdn, Ydn, Zdn ). Например для получения значения первого параметра (Xup) необходимо установить модуль так, чтоб ось X была направлена строго вверх, после чего получить несколько (чем больше - тем лучше) значений оси X обращаясь к функции read(). Среднее арифметическое полученных данных и будет значением параметра (Xup). Для параметра (Xdn) нужно выполнить те же действия, но ось X должна быть направлена строго вниз. Аналогичным образом получаются данные для осей Y и Z.
- Функция calibrateAll(), по указанным параметрам, рассчитает и применит требуемые усиления для необработанных сигналов, и смещения для данных акселерометра, как при обращении к функциям setGain() и setOffset().
- После обращения к данной функции, показания вертикально расположенных осей будут равны ускорению свободного падения 9,81 м/c², со знаком указывающим направление, а показания горизонтально расположенных осей будут равны 0,0 м/c².
- Рассчитанные функцией значения доступны для чтения функциями getGain() и getOffset(). Эти значения можно сохранить для конкретного модуля и, в дальнейшем, записывать без калибровки функциями setGain() и setOffset().
Пример:

sensor.calibrateAll(0.51,0.83,0.59,-1.46,-1.14,-1.29); // выполняем калибровку (X↑=0.51, Y↑=0.83, Z↑=0.59, X↓=-1.46, Y↓=-1.14, Z↓=-1.29)

Функция setDataLPF();

Назначение: Разрешение работы ФНЧ для данных акселерометра.
Синтаксис: setDataLPF( ФЛАГ );
Параметры: bool - флаг разрешения работы ФНЧ (true или false).
Возвращаемые значения: bool - успех записи флага в модуль (true или false).
Примечание: ФНЧ (фильтр нижних частот) по умолчанию включен.
Пример:

sensor.setDataLPF(false); // Запретить работу ФНЧ для данных акселерометра.

Функция getDataLPF();

Назначение: Получение флага разрешения работы ФНЧ для данных акселерометра.
Синтаксис: getDataLPF();
Параметр: нет.
Возвращаемые значения: bool - флаг разрешения работы ФНЧ (true или false).
Примечание: ФНЧ (фильтр нижних частот) по умолчанию включен.
Пример:

bool f = sensor.getDataLPF();  // Получаем состояние ФНЧ для данных акселерометра.

Функция setDeteLPF();

Назначение: Разрешение работы ФНЧ для детекторов.
Синтаксис: setDeteLPF( ФЛАГ );
Параметры: bool - флаг разрешения работы ФНЧ (true или false).
Возвращаемые значения: bool - успех записи флага в модуль (true или false).
Примечание:

ФНЧ (фильтр нижних частот) по умолчанию включен.
Функция позволяет включать/отключать ФНЧ на входах следующих детекторов:

детектор шагов (и счетчик).
детектор поднятия и опускания руки.
детектор любого и значительного движения.
детектор касаний (и счётчик).

Пример:

sensor.setDeteLPF(false); // Запретить работу ФНЧ для детекторов.

Функция getDeteLPF();

Назначение: Получение флага разрешения работы ФНЧ для детекторов.
Синтаксис: getDeteLPF();
Параметр: нет.
Возвращаемые значения: bool - флаг разрешения работы ФНЧ (true или false).
Примечание:

ФНЧ (фильтр нижних частот) по умолчанию включен.
Функция позволяет узнать состояние работы ФНЧ на входах следующих детекторов:

детектор шагов (и счетчик).
детектор поднятия и опускания руки.
детектор любого и значительного движения.
детектор касаний (и счётчик).

Пример:

bool f = sensor.getDeteLPF();  // Получаем состояние ФНЧ для детекторов.

Переменные axisX, axisY, axisZ:

Тип: float
Данные: показания акселерометра, значение усиления или смещения для осей X, Y, Z.
Обновление данных: после вызова функций: read(), getGain(), getOffset(), getUserOffset().

Описание функции конфигурации прерываний:

В данном разделе описаны функции позволяющие разрешить работу прерываний и получать их статус, назначить прерывания выводам, и настроить режим их работы.

Функция setIntEnable();

Назначение: Разрешение работы прерываний.
Синтаксис: setIntEnable( ПРЕРЫВАНИЯ, [ФЛАГ] );
Параметры:
- uint16_t ПРЕРЫВАНИЯ - работу которых требуется разрешить/запретить:
- bool ФЛАГ - разрешения указанных прерываний (true или false).
Возвращаемые значения: bool - успех записи разрешений (true или false).
Примечание:
- В качестве первого параметра указывается прерывание (из перечисленных), работу которого требуется разрешить или запретить. Можно указать сразу несколько прерываний разделённых оператором | - побитовое или (см. пример).
- Второй оператор сообщает, разрешить или запретить работу прерываний указанных в первом параметре. Этот параметр не обязательный, значение по умолчанию - true.
- Функция не влияет на работу прерываний которые не указанны в первом параметре.
- Если разрешено прерывание значительного движения QMA_INT_SIG_MOT, то прерывания любого движения QMA_INT_ANY_MOT_N работать не будут, но разрешённые прерывания любого движения указывают по каким осям нужно фиксировать значительное движение.
- Прерывания шага будут работать если включён датчик шагов функцией setStepEn().
- Узнать какие прерывания разрешены можно функцией getIntEnable().
- Узнать статус разрешённых прерываний можно функцией getIntStatus().
Пример:

sensor.setIntEnable( QMA_INT_DATA | QMA_INT_TAP_2 | QMA_INT_TAP_3 , true ); // Разрешаем прерывания готовности данных, двойного и тройного касания.
sensor.setIntEnable( QMA_INT_HAND_UP | QMA_INT_HAND_DN , false ); // Запрещаем прерывания поднятия и опускания руки.

Функция getIntEnable();

Назначение: Получение списка разрешённых прерываний.
Синтаксис: getIntEnable();
Параметр: нет.
Возвращаемые значения: uint16_t - ПРЕРЫВАНИЯ работа которых разрешена.

Список возможных значений аналогичен списку параметра функции setIntEnable():

QMA_INT_DATA - прерывание готовности данных.
QMA_INT_TAP_1 - прерывание одиночного касания.
QMA_INT_TAP_2 - прерывание двойного касания.
QMA_INT_TAP_3 - прерывание тройного касания.
QMA_INT_TAP_4 - прерывание четверного касания.
QMA_INT_HAND_UP - прерывание поднятии руки.
QMA_INT_HAND_DN - прерывание опускании руки.
QMA_INT_STEP - прерывание обычного шага.
QMA_INT_SIG_STEP - прерывание значительного шага.
QMA_INT_SIG_MOT - прерывание значительного движения.
QMA_INT_ANY_MOT_X - прерывание любого движения по оси X.
QMA_INT_ANY_MOT_Y - прерывание любого движения по оси Y.
QMA_INT_ANY_MOT_Z - прерывание любого движения по оси Z.
QMA_INT_NO_MOT_X - прерывание отсутствия движения по оси X.
QMA_INT_NO_MOT_Y - прерывание отсутствия движения по оси Y.
QMA_INT_NO_MOT_Z - прерывание отсутствия движения по оси Z.

Примечание:

Функция возвращает прерывания которые были разрешены функцией setIntEnable().
Узнать статус разрешённых прерываний можно функцией getIntStatus().

Пример:

uint16_t i = sensor.getIntEnable(); // Читаем список разрешённых прерываний.
if( i & QMA_INT_DATA  ){ Serial.println("Разрешено прерывание готовности данных "); }
if( i & QMA_INT_TAP_1 ){ Serial.println("Разрешено прерывание одиночного касания"); }
if( i & QMA_INT_TAP_2 ){ Serial.println("Разрешено прерывание двойного   касания"); }
...

Функция getIntStatus();

Назначение: Получение статусов разрешённых прерываний.
Синтаксис: getIntStatus();
Параметр: нет.
Возвращаемые значения: uint16_t - ПРЕРЫВАНИЯ которые сработали.

QMA_INT_DATA - прерывание готовности данных.
QMA_INT_TAP_1 - прерывание одиночного касания.
QMA_INT_TAP_2 - прерывание двойного касания.
QMA_INT_TAP_3 - прерывание тройного касания.
QMA_INT_TAP_4 - прерывание четверного касания.
QMA_INT_HAND_UP - прерывание поднятии руки.
QMA_INT_HAND_DN - прерывание опускании руки.
QMA_INT_STEP - прерывание обычного шага.
QMA_INT_SIG_STEP - прерывание значительного шага.
QMA_INT_SIG_MOT - прерывание значительного движения.
QMA_INT_ANY_MOT_X - прерывание любого движения по оси X.
QMA_INT_ANY_MOT_Y - прерывание любого движения по оси Y.
QMA_INT_ANY_MOT_Z - прерывание любого движения по оси Z.
QMA_INT_NO_MOT - прерывание отсутствия движения.

Примечание:

Функция возвращает прерывания которые сработали (статусные флаги прерываний).
Статусные флаги прерываний устанавливаются в момент готовности данных, если соблюдается условие для прерывания соответствующего статусного флага.
После чтения функцией getIntStatus(), все статусные флаги прерываний в регистрах чипа сбрасываются, независимо от режима указанного функцией setIntLatched().
Поведение статусных флагов зависит от режима фиксации setIntLatched().
Прерывание QMA_INT_NO_MOT срабатывает по тем осям (XYZ) для которых были разрешены прерывания отсутствия движения функцией setIntEnable().

Пример:

uint16_t i = sensor.getIntStatus(); // Читаем список сработавших прерываний.
if( i & QMA_INT_DATA  ){ Serial.println("Сработало прерывание готовности данных "); }
if( i & QMA_INT_TAP_1 ){ Serial.println("Сработало прерывание одиночного касания"); }
if( i & QMA_INT_TAP_2 ){ Serial.println("Сработало прерывание двойного   касания"); }
...

Функция setIntLatched();

Назначение: Установка режима прерываний с фиксацией.
Синтаксис: setIntLatched( ФЛАГ );
Параметры: bool - флаг включения режима прерываний с фиксацией (true или false).
Возвращаемые значения: bool - успех записи режима в модуль (true или false).
Примечание:

Режим прерываний без фиксации:

Статусные флаги прерываний находятся в установленном состоянии пока выполняется условие прерывания, после чего автоматически сбрасываются.
Функция getIntStatus() вернёт прерывание если к ней обратились в тот момент пока статусный флаг прерывания установлен (соблюдается условие прерывания).

Режим прерываний с фиксацией:

Статусные флаги прерываний устанавливаются при возникновении условия прерывания и сохраняют своё состояние до чтения функцией getIntStatus().
Режим прерываний с фиксацией не распространяется на прерывание готовности данных, статусный флаг этого прерывания автоматически сбрасывается через 64*MCLK после установки.

Вне зависимости от режима прерываний, активные уровни на выводах INT, сопоставленные с прерываниями, повторяют состояния статусных флагов этих прерываний.
По умолчанию используется режим прерываний без фиксации.

Пример:

sensor.setIntLatched(true); // Включить фиксацию прерыаний.

Функция getIntLatched();

Назначение: Получение состояние режима прерываний с фиксацией.
Синтаксис: getIntLatched();
Параметр: нет.
Возвращаемые значения: bool - флаг режима прерываний с фиксацией (true или false).
Пример:

bool f = sensor.getIntLatched();  // Получаем true если установлен режим прерываний с фиксацией.

Функция setPinInts();

Назначение: Установка выводу сопоставленных прерываний.
Синтаксис: setPinInts( ВЫВОД, ПРЕРЫВАНИЯ, [ФЛАГ] );
Параметры:

uint8_t ВЫВОД - которому нужно сопоставить прерывания:

1 - вывод INT-1.
2 - вывод INT-2.

uint16_t ПРЕРЫВАНИЯ - которые нужно сопоставить с выводом:

QMA_INT_DATA - прерывание готовности данных.
QMA_INT_TAP_1 - прерывание одиночного касания.
QMA_INT_TAP_2 - прерывание двойного касания.
QMA_INT_TAP_3 - прерывание тройного касания.
QMA_INT_TAP_4 - прерывание четверного касания.
QMA_INT_HAND_UP - прерывание поднятии руки.
QMA_INT_HAND_DN - прерывание опускании руки.
QMA_INT_STEP - прерывание обычного шага.
QMA_INT_SIG_STEP - прерывание значительного шага.
QMA_INT_SIG_MOT - прерывание значительного движения.
QMA_INT_ANY_MOT - прерывание любого движения.
QMA_INT_NO_MOT - прерывание отсутствия движения.

bool ФЛАГ - сопоставления указанных прерываний с выводом (true или false).

Возвращаемые значения: bool - успех записи сопоставлений в модуль (true или false).
Примечание:

На выводе INT появится активный уровень, если установится статусный флаг любого из прерываний сопоставленных с выводом.
На выводе INT сбросится активный уровень, если сброшены все статусные флаги всех прерываний сопоставленных с выводом.
Поведение статусных флагов зависит от режима фиксации setIntLatched().
По умолчанию используется режим прерываний без фиксации.
Прерывание любого движения QMA_INT_ANY_MOT сопоставляется без указания осей. Вывод будет реагировать на те оси, прерывания которых были разрешены.
Прерывание отсутствия движения QMA_INT_NO_MOT сопоставляется без указания осей. Вывод будет реагировать на те оси, прерывания которых были разрешены.

Пример:

sensor.setPinInts(1, QMA_INT_DATA | QMA_INT_TAP_2 | QMA_INT_TAP_3, true); // Сопоставить выводу INT-1 прерывания готовности данных, двойного и тройного касания.
sensor.setPinInts(2, QMA_INT_HAND_UP | QMA_INT_HAND_DN, false); // Отключить сопоставление вывода INT-2 с прерываниями поднятия и опускания руки.

Функция getPinInts();

Назначение: Получение списка сопоставленных прерываний выводу.
Синтаксис: getPinInts( ВЫВОД );
Параметры:

uint8_t ВЫВОД - сопоставленные прерывания которого нужно получить:

1 - вывод INT-1.
2 - вывод INT-2.

Возвращаемые значения: uint16_t - ПРЕРЫВАНИЯ работа которых разрешена.

Список возможных значений аналогичен списку параметра функции setPinInts():

QMA_INT_DATA - прерывание готовности данных.
QMA_INT_TAP_1 - прерывание одиночного касания.
QMA_INT_TAP_2 - прерывание двойного касания.
QMA_INT_TAP_3 - прерывание тройного касания.
QMA_INT_TAP_4 - прерывание четверного касания.
QMA_INT_HAND_UP - прерывание поднятии руки.
QMA_INT_HAND_DN - прерывание опускании руки.
QMA_INT_STEP - прерывание обычного шага.
QMA_INT_SIG_STEP - прерывание значительного шага.
QMA_INT_SIG_MOT - прерывание значительного движения.
QMA_INT_ANY_MOT - прерывание любого движения.
QMA_INT_NO_MOT - прерывание отсутствия движения.

Примечание:

Возвращаются прерывания которые были сопоставлены функцией setPinInts().

Пример:

uint16_t i = sensor.getPinInts(); // Читаем список сопоставленных прерываний.
if( i & QMA_INT_DATA  ){ Serial.println("Сопоставлено прерывание готовности данных "); }
if( i & QMA_INT_TAP_1 ){ Serial.println("Сопоставлено прерывание одиночного касания"); }
if( i & QMA_INT_TAP_2 ){ Serial.println("Сопоставлено прерывание двойного   касания"); }
...

Функция setPinLevel();

Назначение: Назначение активного уровня вывода INT.
Синтаксис: setPinLevel( ВЫВОД , УРОВЕНЬ );
Параметры:

uint8_t ВЫВОД - для которого назначается активный уровень:

1 - вывод INT-1.
2 - вывод INT-2.

bool УРОВЕНЬ - который будет активным для вывода INT (0 или 1).

Возвращаемые значения: bool - успех записи активного уровня (true или false).
Примечание:

Активный уровень будет устанавливаться на выводе INT при срабатывании любого из прерываний сопоставленных выводу функцией setPinInts().

Пример:

sensor.setPinLevel(2, 0); // Сделать активным уровнем вывода INT-2 логический 0.

Функция getPinLevel();

Назначение: Получение активного уровня вывода INT.
Синтаксис: getPinLevel( ВЫВОД );
Параметры:

uint8_t ВЫВОД - активный уровень которого требуется получить:

1 - вывод INT-1.
2 - вывод INT-2.

Возвращаемые значения: bool - активный уровень указанного вывода (0 или 1).
Пример:

bool level = sensor.getPinLevel( 2 ); // Получаем активный уровень вывода INT-2.

Функция setPinScheme();

Назначение: Установка схемы выходного каскада вывода INT.
Синтаксис: setPinScheme( ВЫВОД , СХЕМА );
Параметры:

uint8_t ВЫВОД - для которого устанавливается схема выходного каскада:

1 - вывод INT-1.
2 - вывод INT-2.

bool СХЕМА - выходного каскада:

QMA_INT_SCHEME_PP - двухтактная схема (Push Pull).
QMA_INT_SCHEME_OD - схема с открытым стоком (Open Drain).

Возвращаемые значения: bool - успех записи схемы (true или false).
Примечание:

При двухтактной схеме, на выходе INT устанавливается, либо 0, либо 1.
При схеме с открытым стоком, на выводе INT устанавливается, либо активный логический уровень, либо состояние высокого импеданса (отключение).

Пример:

sensor.setPinScheme(1, QMA_INT_SCHEME_PP); // Указываем выводу INT-1 работать по двухтактной схеме.
sensor.setPinScheme(2, QMA_INT_SCHEME_OD); // Указываем выводу INT-2 работать по схеме с открытым стоком.

Функция getPinScheme();

Назначение: Получение схемы выходного каскада вывода INT.
Синтаксис: getPinScheme( ВЫВОД );
Параметры:

uint8_t ВЫВОД - активный уровень которого требуется получить:

1 - вывод INT-1.
2 - вывод INT-2.

Возвращаемые значения:

bool СХЕМА - выходного каскада:

QMA_INT_SCHEME_PP - двухтактная схема (Push Pull).
QMA_INT_SCHEME_OD - схема с открытым стоком (Open Drain).

Пример:

bool scheme = sensor.getPinScheme( 2 ); // Получаем схему выходного каскада вывода INT-2.

Описание функций настроек детекторов:

Интегрированная в чип схема обработки сигнала (ASIC) содержит несколько детекторов, которые позволяют определять шаги, движения, касания и вызывать прерывания. Каждый детектор можно настроить для работы в различных условиях.

Настройки детектора шага:

Разрешение работы счётчика шагов:

Синтаксис: setStepEn( [ФЛАГ] );
Параметр: bool ФЛАГ - разрешения работы счётчика шагов (true или false).
Примечание: Если работа счётчика запрещена, то шаги не будут определяться.

Получение количества шагов:

Синтаксис: getStepCnt();
Возвращает: uint32_t КОЛИЧЕСТВО подсчитанных шагов.
Примечание: После выполнения функции количество шагов будет сброшено.

Количество выборок для определения шага:

Синтаксис:

setStepSamples( СЕМПЛЫ ); // Указать.
getStepSamples(); // Получить.

Параметр: uint16_t СЕМПЛЫ - количество выборок от 8 до 1024 (значение кратное 8)
Примечание: По умолчанию, для определения 1 шага используется 160 выборок данных.

Порог для регистрации шага:

Синтаксис:

setStepPrecision( ПОРОГ ); // Указать.
getStepPrecision(); // Получить.

Параметр: uint8_t ПОРОГ - значение от 0 до 127.

Указанное значение переводится в количество ускорений свободного падения (g) по формуле: ПОРОГ * 16 LSB, где LSB это шаг данных = getScale() / 8191.

Примечание: Данные ниже порога не учитываются при регистрации шага.

Минимальное значение временного окна:

Синтаксис:

setStepTimeLow( ВРЕМЯ ); // Указать.
getStepTimeLow(); // Получить.

Параметр: uint8_t ВРЕМЯ - значение от 0 до 255.

Указанное значение переводится в секунды по формуле ВРЕМЯ * ODR, где ODR это скорость передачи выходных данных (output data rate).

Примечание: Все события вне временного окна не считаются шагом.

Максимальное значение временного окна:

Синтаксис:

setStepTimeUp( ВРЕМЯ ); // Указать.
getStepTimeUp(); // Получить.

Параметр: uint8_t ВРЕМЯ - значение от 0 до 255.

Указанное значение переводится в секунды по формуле ВРЕМЯ * 8 * ODR, где ODR это скорость передачи выходных данных (output data rate).

Примечание: Все события вне временного окна не считаются шагом.

Интервал для регистрации значительного шага:

Синтаксис:

setStepInterval( ИНТЕРВАЛ ); // Указать.
getStepInterval(); // Получить.

Параметр: uint8_t ИНТЕРВАЛ - значение от 0 до 127.
Примечание: Прерывание значительного шага генерируется, если счётчик шагов досчитал до значения кратного указанному интервалу.

Скользящее среднее шага:

Синтаксис:

setStepNLPF( NLPF ); // Указать.
getStepNLPF(); // Получить.

Параметр: uint8_t NLPF - одно из значений:

QMA_NLPF_1, QMA_NLPF_2, QMA_NLPF_4, QMA_NLPF_8.

Примечание: Значение по умолчанию QMA_NLPF_1.

Количество шагов до старта счётчика:

Синтаксис:

setStepStartCnt( КОЛИЧЕСТВО ); // Указать.
getStepStartCnt(); // Получить.

Параметр: uint8_t КОЛИЧЕСТВО - количество от 0 до 7.
Примечание: Указанное количество первых шагов игнорируется счётчиком.

Пиковое ускорение для обнаружения шагов:

Синтаксис:

setStepCntPeak( ПИК ); // Указать.
getStepCntPeak(); // Получить.

Параметр: uint8_t ПИК - одно из значений (от 0,05g до 0,40g с шагом 0,05g):

QMA_PEAK_0G05, QMA_PEAK_0G10, QMA_PEAK_0G15, QMA_PEAK_0G20
QMA_PEAK_0G25, QMA_PEAK_0G30, QMA_PEAK_0G35, QMA_PEAK_0G40

Примечание: Шаги определяются в пределах размаха ПИК-ПИК от пикового значения.

Размах от пикового ускорения для обнаружения шагов:

Синтаксис:

setStepCntP2P( ПИК-ПИК ); // Указать.
getStepCntP2P(); // Получить.

Параметр: uint8_t ПИК-ПИК - одно из значений (от 0.3g до 1.0g с шагом 0.1g):

QMA_P2P_0G3, QMA_P2P_0G4, QMA_P2P_0G5, QMA_P2P_0G6
QMA_P2P_0G7, QMA_P2P_0G8, QMA_P2P_0G9, QMA_P2P_1G0

Примечание: Шаги определяются в пределах размаха от пикового значения ПИК.

Оси, данные которых используются для обнаружения шагов:

Синтаксис:

setStepAxis( ОСИ ); // Указать.
getStepAxis(); // Получить.

Параметр: uint8_t ОСИ - одно из значений:

QMA_AXIS_XY, QMA_AXIS_XZ, QMA_AXIS_YZ, QMA_AXIS_XYZ.

Примечание: Выбор двух или трёх осей используемых при обнаружении шагов.

Настройки детектора движений:

Порог для регистрации любого движения:

Синтаксис:

setAnyMotTh( ПОРОГ ); // Указать.
getAnyMotTh(); // Получить.

Параметр: uint8_t ПОРОГ - значение от 0 до 255.

Указанное значение переводится в количество ускорений свободного падения (g) по формуле:

ПОРОГ * 16 LSB, если входными данными детектора движений является крутизна.
ПОРОГ * 32 LSB, если входными данными детектора движений является ускорение.
где LSB это шаг данных = getScale() / 8191.

Тип входных данных детектора движений выбирается функцией setAnyMotIn().

Примечание: Данные выше порога в течении указанного функцией setAnyMotDur() семплов, вызовут прерывание любого движения

Количество семплов для регистрации любого движения:

Синтаксис:

setAnyMotDur( КОЛИЧЕСТВО ); // Указать.
getAnyMotDur(); // Получить.

Параметр: uint8_t КОЛИЧЕСТВО семплов - значение от 1 до 4.
Примечание: Данные выше порога указанного функцией setAnyMotTh() в течении указанного количества семплов, вызовут прерывание любого движения.

Тип входных данных для детектора движений:

Синтаксис:

setAnyMotIn( ТИП ); // Указать.
getAnyMotIn(); // Получить.

Параметр: bool ТИП - одно из значений:

QMA_IN_SLOPE (крутизна) или QMA_IN_ACCEL (ускорение).

Примечание: Крутизна это разница двух последовательных данных ускорения.

Время ожидания после регистрации любого движения:

Синтаксис:

setSigMotWait( ВРЕМЯ ); // Указать.
getSigMotWait(); // Получить.

Параметр: uint8_t ВРЕМЯ - одно из значений (соответствует 1,5сек, 3,0сек, 6,0сек, 12сек ).

QMA_TIM_1S5, QMA_TIM_3S0, QMA_TIM_6S0, QMA_TIM_12S.

Примечание: Время после регистрацией любого движения до начала проверки наличия значительного движения.

Время для регистрации значительного движения:

Синтаксис:

setSigMotDur( ВРЕМЯ ); // Указать.
getSigMotDur(); // Получить.

Параметр: uint8_t ВРЕМЯ - одно из значений (соответствует 0,25сек, 0,5сек, 1сек, 2сек )

QMA_TIM_0S25, QMA_TIM_0S5, QMA_TIM_1S0, QMA_TIM_2S0.

Примечание: Если в течении указанного времени, после паузы заданной функцией setSigMotWait(), будет зафиксировано любое движение, то оно будет расценено как значительное движение.

Настройки детектора отсутствия движений:

Порог для регистрации отсутствия движения:

Синтаксис:

setNoMotTh(threshold); // Указать.
getNoMotTh(); // Получить.

Параметр: uint8_t ПОРОГ - значение от 0 до 255.

Указанное значение переводится в количество ускорений свободного падения (g) по формуле: ПОРОГ * 16 LSB, где LSB это шаг данных = getScale() / 8191.
Данными для сравнения является крутизна (разница двух последовательных данных).

Примечание: Данные ниже указанного порога в течении времени указанного функцией setNoMotDur(), вызовут прерывание по отсутствию движения.

Время для регистрации отсутствия движения:

Синтаксис:

setNoMotDur( ВРЕМЯ ); // Указать.
getNoMotDur(); // Получить.

Параметр: uint8_t ВРЕМЯ - значение от 1 до 250 секунд.

Время до 16 сек не округляется
Время до 100 сек округляется до 5
Время до 250 сек округляется до 10.

Примечание: Данные ниже порога заданного функцией setNoMotTh() в течении указанного времени, вызовут прерывание по отсутствию движения.

Настройки детектора касаний:

Порог для регистрации касаний:

Синтаксис:

setTapShockTh( ПОРОГ ); // Указать.
getTapShockTh(); // Получить.

Параметр: float ПОРОГ - значение ускорения от 0,03125 g до 2,0 g, с шагом 0,03125 g.
Примечание: Одиночным касанием считается следующая последовательность:

Данные выше порога setTapShockTh() в течении setTapShockDur() мс, а затем
Данные ниже порога setTapQuietTh() в течении setTapQuietDur() мс.
Данными для сравнения является крутизна (разница двух последовательных данных).

Время касания:

Синтаксис:

setTapShockDur( ВРЕМЯ ); // Указать.
getTapShockDur(); // Получить.

Параметр: bool ВРЕМЯ - одно из значений (соответствует 50мс, 70мс):

QMA_TIM_50MS, QMA_TIM_75MS.

Примечание: Одиночным касанием считается следующая последовательность:

Данные выше порога setTapShockTh() в течении setTapShockDur() мс, а затем
Данные ниже порога setTapQuietTh() в течении setTapQuietDur() мс.
Данными для сравнения является крутизна (разница двух последовательных данных).

Порог для регистрации тишины:

Синтаксис:

setTapQuietTh( ПОРОГ ); // Указать.
getTapQuietTh(); // Получить.

Параметр: float ПОРОГ - значение ускорения от 0,03125 g до 2,0 g, с шагом 0,03125 g.
Примечание: Одиночным касанием считается следующая последовательность:

Данные выше порога setTapShockTh() в течении setTapShockDur() мс, а затем
Данные ниже порога setTapQuietTh() в течении setTapQuietDur() мс.
Данными для сравнения является крутизна (разница двух последовательных данных).

Время тишины:

Синтаксис:

setTapQuietDur( ВРЕМЯ ); // Указать.
getTapQuietDur(); // Получить.

Параметр: bool ВРЕМЯ - одно из значений (соответствует 20мс, 30мс):

QMA_TIM_20MS, QMA_TIM_30MS:

Примечание: Одиночным касанием считается следующая последовательность:

Данные выше порога setTapShockTh() в течении setTapShockDur() мс, а затем
Данные ниже порога setTapQuietTh() в течении setTapQuietDur() мс.
Данными для сравнения является крутизна (разница двух последовательных данных).

Время между касаниями для их объединения:

Синтаксис:

setTapUniteDur( ВРЕМЯ ); // Указать.
getTapUniteDur(); // Получить.

Параметр: uint8_t ВРЕМЯ - одно из значений (100,150,200,250,300,400,500,700мс):

QMA_TIM_100MS, QMA_TIM_150MS, QMA_TIM_200MS, QMA_TIM_250MS
QMA_TIM_300MS, QMA_TIM_400MS, QMA_TIM_500MS, QMA_TIM_700MS

Примечание: Если пауза между двумя одиночными касаниями не превышает установленного времени, то такие касания объединяются в двойное, тройное, или четверное.

Оси, данные которых используются для обнаружения касаний:

Синтаксис:

setTapAxis( ОСИ ); // Указать.
getTapAxis(); // Получить.

Параметр: uint8_t ОСИ - одно из значений:

QMA_AXIS_X, QMA_AXIS_Y, QMA_AXIS_Z, QMA_AXIS_XYZ.

Примечание: Выбор одной или всех осей используемых при обнаружении касаний.

Поведение тройного касания:

Синтаксис:

setTapInt3( ФЛАГ ); // Указать.
getTapInt3(); // Получить.

Параметр: bool ФЛАГ ожидания четвёртого касания (true или false).
Примечание: Если флаг установлен, то прерывание тройного касания будет установлено не сразу, а только если не зарегистрировано четверное касание.

Учёт бита EarIn при разрешении прерываний касания:

Синтаксис:

setTapEarIn( ФЛАГ ); // Указать.
getTapEarIn(); // Получить.

Параметр: bool ФЛАГ учёта бита EarIn (true или false).
Примечание: Если флаг установлен, то будет учитываться состояние бита EarIn.

Настройки детектора поднятия/опускания руки:

Порог чувствительности поднятия/опускания руки:

Синтаксис:

setHandSumTh( ПОРОГ ); // Указать.
getHandSumTh(); // Получить.

Параметр: float ПОРОГ - значение от 0 до 31,5 м/c² (с шагом 0,5 м/c²).

Порог крутизны указывающий на завершение поднятия/опускания руки:

Синтаксис:

setHandDiffTh( КРУТИЗНА ); // Указать.
getHandDiffTh(); // Получить.

Параметр: uint8_t КРУТИЗНА - одно из значений (от 0,2 до 1,2м/c² с шагом 0,1 м/c²):

QMA_HAND_0MS2, QMA_HAND_0MS3, QMA_HAND_0MS4, QMA_HAND_0MS5
QMA_HAND_0MS6, QMA_HAND_0MS7, QMA_HAND_0MS8, QMA_HAND_0MS9
QMA_HAND_1MS0, QMA_HAND_1MS1, QMA_HAND_1MS2.

Примечание: Крутизна это разница двух последовательных данных. При завершении движения руки, крутизна уменьшается и как только она окажется ниже указанного порога, будет сгенерировано прерывание.

Период действия руки:

Синтаксис:

setHandPeriod( ПЕРИОД ); // Указать.
getHandPeriod(); // Получить.

Параметр: uint16_t ПЕРИОД - значение от 0 до 2047.

Указанное значение переводится в секунды по формуле: ПЕРИОД * период ODR.

Примечание: ODR это скорость передачи выходных данных (output data rate).

TimeOut действия руки:

Синтаксис:

setHandTimeOut( ВРЕМЯ ); // Указать.
getHandTimeOut(); // Получить.

Параметр: uint16_t ВРЕМЯ - значение от 0 до 4095.

Указанное значение переводится в секунды по формуле: ВРЕМЯ * период ODR.

Примечание: ODR это скорость передачи выходных данных (output data rate).

Порог чувствительности к силе опускания руки для оси X:

Синтаксис:

setHandDownThX( ПОРОГ ); // Указать.
getHandDownThX(); // Получить.

Параметр: uint8_t ПОРОГ - значение от 0 до 7 м/c² (с шагом 1 м/c²).

Порог чувствительности к силе опускания руки для оси Z:

Синтаксис:

setHandDownThZ( ПОРОГ ); // Указать.
getHandDownThZ(); // Получить.

Параметр: uint8_t ПОРОГ - значение от 0 до 7 м/c² (с шагом 1 м/c²).

Порог чувствительности к силе поднятия руки для оси X:

Синтаксис:

setHandRaiseThX( ПОРОГ ); // Указать.
getHandRaiseThX(); // Получить.

Параметр: float ПОРОГ - значение от 0 до 7,5 м/c² (с шагом 0,5 м/c²).

Порог чувствительности к силе поднятия руки для оси Y:

Синтаксис:

setHandRaiseThY( ПОРОГ ); // Указать.
getHandRaiseThY(); // Получить.

Параметр: int8_t ПОРОГ - значение от -16 до +15 м/c² (с шагом 1 м/c²).

Порог чувствительности к силе поднятия руки для оси Z:

Синтаксис:

setHandRaiseThZ( ПОРОГ ); // Указать.
getHandRaiseThZ(); // Получить.

Параметр: int8_t ПОРОГ - значение от -8 до +7 м/c² (с шагом 1 м/c²).

Порог чувствительности по осям YZ:

Синтаксис:

setHandSelThYZ( ПОРОГ ); // Указать.
getHandSelThYZ(); // Получить.

Параметр: float ПОРОГ - значение от +7 до 10,5 м/c² (с шагом 0,5 м/c²).

Выбор функции выполняемых по прерыванию:

Синтаксис:

setHandIntMode( ФУНКЦИЯ ); // Указать.
getHandIntMode(); // Получить.

Параметр: bool ФУНКЦИЯ - один из параметров:

QMA_FUNC_WAKE (проснуться) или QMA_FUNC_EARIN (EarIn).

Смена осей XYZ на указанные:

Синтаксис:

setHandAxis( ОСИ ); // Указать.
getHandAxis(); // Получить.

Параметр: uint8_t ОСИ - одно из значений:

QMA_AXIS_XYZ, QMA_AXIS_XZY, QMA_AXIS_YXZ
QMA_AXIS_YZX, QMA_AXIS_ZXY, QMA_AXIS_ZYX.

Применение:

Системы стабилизации, навигации, манипуляторы, роботостроение и игры;
Определение поворота экрана, подсчёта шагов, мониторинга сна.

IMU-3DOF Трехосевой акселерометр (Trema-модуль) - Datasheet