From fc50c745f5587058f61860cc5e7c6d57384e2ba9 Mon Sep 17 00:00:00 2001 From: Roman Date: Wed, 9 Nov 2022 01:05:18 +0300 Subject: [PATCH] =?UTF-8?q?=D0=BC=D0=BD=D0=BE=D0=B3=D0=BE=20=D0=BF=D1=80?= =?UTF-8?q?=D0=B0=D0=B2=D0=BE=D0=BA?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 1 + .../MT6701_set_get_ZeroDegreePosition.ino | 93 +++++ examples/MT6701_test/MT6701_test.ino | 43 ++- keywords.txt | 10 +- library.properties | 2 +- src/MT6701_I2C.cpp | 344 +++++++++--------- src/MT6701_I2C.h | 118 +++--- 7 files changed, 355 insertions(+), 256 deletions(-) create mode 100644 examples/MT6701_set_get_ZeroDegreePosition/MT6701_set_get_ZeroDegreePosition.ino diff --git a/README.md b/README.md index 602b096..1750b09 100644 --- a/README.md +++ b/README.md @@ -14,6 +14,7 @@ uint8_t MT_RequestSingleRegister(uint8_t _reg_addr); // Запись нового содержимого в регистр void MT_WriteOneByte(uint8_t _reg_addr, uint8_t _payload); ``` +* Использовать методы описанные выше седует через наследование класса MT6701I2C * Все доступные методы, константы, типы данных можно посмотреть [тут](https://github.com/S-LABc/MT6701-Arduino-Library/blob/main/src/MT6701_I2C.h) ## Ссылки diff --git a/examples/MT6701_set_get_ZeroDegreePosition/MT6701_set_get_ZeroDegreePosition.ino b/examples/MT6701_set_get_ZeroDegreePosition/MT6701_set_get_ZeroDegreePosition.ino new file mode 100644 index 0000000..49e9bdf --- /dev/null +++ b/examples/MT6701_set_get_ZeroDegreePosition/MT6701_set_get_ZeroDegreePosition.ino @@ -0,0 +1,93 @@ +/* + * 1. Open Serial Monitor at 9600 and there is no line ending + * 2. Send the character "s" to the Serial Monitor + * + * CORRECT SERIAL MONITOR LOGS + + Sensor Found! + + Reading Current Value... + Zero Degree Position (HEX): 0 [0 - default, but may be different] + + Changing Value... Value Changed + + Saving New Values... + + Reading New Value... + Zero Degree Position After Saving (HEX): 8 + + Program Complete! + * + */ + +#include + +MT6701I2C SensorI2C(&Wire); + +void setup() { + Serial.begin(9600); + + SensorI2C.begin(); + SensorI2C.setClock(); + + while(1) { // Waiting for the input of the character "s" + byte c; + if(Serial.available()) + c = Serial.read(); + if(c == 's') { + break; + } + delay(100); + } + + while(!SensorI2C.isConnected()) { + Serial.println("Sensor not Connected!"); + delay(500); + } + Serial.println("Sensor Found!"); + Serial.println(); + + delay(300); // The delay is not important. so it's easier to see in the SM + + Serial.println("Reading Current Value..."); + word zdp; + zdp = SensorI2C.getZeroDegreePositionData(); + Serial.print("Zero Degree Position (HEX): "); + Serial.println(zdp, HEX); + Serial.println(); + + delay(300); // The delay is not important. so it's easier to see in the SM + + Serial.print("Changing Value... "); + word zdp_new = 0x0008; // New value + if(SensorI2C.setZeroDegreePositionDataVerify(zdp_new)) { + Serial.println("Value Changed"); + } else { + Serial.println("Value Change Error"); + } + Serial.println(); + + delay(300); // The delay is not important. so it's easier to see in the SM + + Serial.println("Saving New Values..."); + Serial.println(); + // It's important to save the new values after the change. + // Called once even after setting multiple values + // else values return to default after power off + SensorI2C.saveNewValues(); + + delay(700); // >600ms + + Serial.println("Reading New Value..."); + word zdp_after; + zdp_after = SensorI2C.getZeroDegreePositionData(); + Serial.print("Zero Degree Position After Saving (HEX): "); + Serial.println(zdp_after, HEX); + Serial.println(); + + Serial.println("Program Complete!"); +} + +void loop() { + // nop +} diff --git a/examples/MT6701_test/MT6701_test.ino b/examples/MT6701_test/MT6701_test.ino index 7a1fb6e..54f6de3 100644 --- a/examples/MT6701_test/MT6701_test.ino +++ b/examples/MT6701_test/MT6701_test.ino @@ -13,37 +13,42 @@ ** GitHub - https://github.com/S-LABc ** Gmail - romansklyar15@gmail.com * - * Copyright (C) 2022. v1.0 / Скляр Роман S-LAB + * Copyright (C) 2022. v1.1 / Скляр Роман S-LAB */ #include -// раскомментировать для заупска функции сохранения значений +// Раскомментировать для заупска функции сохранения значений //#define SAVE_VALUES -/* - * STM32_MT6701_MODE_PIN PC13 - * ESP32_MT6701_MODE_PIN 2 - * ARDUINO_MT6701_MODE_PIN 3 - * или любой другой - * - * MT6701I2C_MODE_I2C_SSI - притягивает контакт MODE к VCC - * MT6701I2C_MODE_UVW_ABZ - притягивает контакт MODE к GND - */ MT6701I2C SensorI2C(&Wire); -//MT6701I2C SensorI2C(&Wire, ARDUINO_MT6701_MODE_PIN, MT6701I2C_MODE_I2C_SSI); void setup() { Serial.begin(115200); + // Запускаем соединение SensorI2C.begin(); + // Настраиваем шину I2C на 400кГц + SensorI2C.setClock(); + //Можно на друие частоты, но работает не на всех микроконтроллерах + //SensorI2C.setClock(MT6701_I2C_CLOCK_100KHZ); // 100кГц + //SensorI2C.setClock(MT6701_I2C_CLOCK_1MHZ); // 1МГц + //SensorI2C.setClock(725000); // Пользовательское значение 725кГц + + /* + * Если нужно управлять режимами датчика + * STM32_MT6701_MODE_PIN PC13 + * ESP8266_MT6701_MODE_PIN 2 + * ESP32_MT6701_MODE_PIN 4 + * ARDUINO_MT6701_MODE_PIN 3 + * или любой другой GPIO + */ + //SensorI2C.attachModePin(ARDUINO_MT6701_MODE_PIN); // SensorI2C.detachModePin(); + //SensorI2C.enableI2CorSSI(); // Включить интерфейс I2C/SSI + //SensorI2C.enableUVWorABZ(); // Включить интерфейс UVW/ABZ + - //SensorI2C.setClock100kHz(); - SensorI2C.setClock400kHz(); - //SensorI2C.setClock1MHz(); - //SensorI2C.setClock(200000); // другое значение частоты - - while(!Serial) {} + while(!Serial); while(!SensorI2C.isConnected()) { Serial.println("Датчик не обнаружен"); @@ -133,5 +138,5 @@ void saveNewSettings() { delay(700); // >600мс Serial.println("Saved Successfully. Reconnect Power"); - while(1) {} + while(1); } diff --git a/keywords.txt b/keywords.txt index 55068b7..c929805 100644 --- a/keywords.txt +++ b/keywords.txt @@ -15,20 +15,17 @@ SensorI2C KEYWORD1 MT6701I2C KEYWORD2 -MT_RequestSingleRegister KEYWORD2 -MT_WriteOneByte KEYWORD2 - begin KEYWORD2 setClock KEYWORD2 -setClock100kHz KEYWORD2 -setClock400kHz KEYWORD2 -setClock1MHz KEYWORD2 end KEYWORD2 saveNewValues KEYWORD2 isConnected KEYWORD2 +attachModePin KEYWORD2 +detachModePin KEYWORD2 + enableI2CorSSI KEYWORD2 enableUVWorABZ KEYWORD2 @@ -110,6 +107,7 @@ MT6701_I2C_CLOCK_1MHZ LITERAL1 MT6701_I2C_ADDRESS LITERAL1 STM32_MT6701_MODE_PIN LITERAL1 +ESP8266_MT6701_MODE_PIN LITERAL1 ESP32_MT6701_MODE_PIN LITERAL1 ARDUINO_MT6701_MODE_PIN LITERAL1 diff --git a/library.properties b/library.properties index 6dbc398..72b45b9 100644 --- a/library.properties +++ b/library.properties @@ -1,5 +1,5 @@ name=MT6701 -version=1.0 +version=1.1 author=Roman Sklyar S-LAB maintainer=Roman Sklyar sentence=API for a 14-Bit Hall Based Angle Position Encoder Sensor diff --git a/src/MT6701_I2C.cpp b/src/MT6701_I2C.cpp index bb5ef40..2c63aa7 100644 --- a/src/MT6701_I2C.cpp +++ b/src/MT6701_I2C.cpp @@ -11,7 +11,7 @@ ** GitHub - https://github.com/S-LABc ** Gmail - romansklyar15@gmail.com * - * Copyright (C) 2022. v1.0 / License MIT / Скляр Роман S-LAB + * Copyright (C) 2022. v1.1 / License MIT / Скляр Роман S-LAB */ #include "MT6701_I2C.h" @@ -19,23 +19,11 @@ // ########## CONSTRUCTOR ########## /* * @brief: использовать только интерфейс I2C - * @param *twi: доступ к методам объекта Wire + * @param _twi: доступ к методам объекта Wire */ -MT6701I2C::MT6701I2C(TwoWire *twi) : _wire(twi ? twi : &Wire) { +MT6701I2C::MT6701I2C(TwoWire* _twi) : _wire_(_twi ? _twi : &Wire) { // Ничего } -/* - * @brief: использовать интерфейс I2C, вывод МК для контакта MODE датчика, режима интерфейса I2C/SSI или UVW/ABZ - * @param *twi: доступ к методам объекта Wire - * @param pinmode: вывод микроконтроллер к которому подключен контакт MODE датчика - * @param state: состояние вывода - */ -MT6701I2C::MT6701I2C(TwoWire *twi, int8_t pinmode, bool state) : _wire(twi ? twi : &Wire) { - _pin_mode = pinmode; - // Для включения интерфейса I2C - pinMode(_pin_mode, OUTPUT); - digitalWrite(_pin_mode, state); -} /* * @brief: запросить один байт данных из буфера * @param _reg_addr: 1 байт адреса регистра @@ -45,21 +33,21 @@ MT6701I2C::MT6701I2C(TwoWire *twi, int8_t pinmode, bool state) : _wire(twi ? twi uint8_t MT6701I2C::MT_RequestSingleRegister(uint8_t _reg_addr) { uint8_t single_byte = 0; - // Начать передачу по адресу 0x06 - _wire->beginTransmission(MT6701_I2C_ADDRESS); + // Начать передачу по адресу + _wire_->beginTransmission(MT6701_I2C_ADDRESS); // Отправить байт регистра - _wire->write(_reg_addr); + _wire_->write(_reg_addr); // Завершить соединение - _wire->endTransmission(); + _wire_->endTransmission(); - // Запросить байт данных по адресу 0x06 - _wire->requestFrom(MT6701_I2C_ADDRESS, 1); + // Запросить байт данных по адресу + _wire_->requestFrom(MT6701_I2C_ADDRESS, (uint8_t)1); // Прочитать данные из буфера - if (_wire->available() >= 1 ) { - single_byte = _wire->read(); + if (_wire_->available() >= 1 ) { + single_byte = _wire_->read(); } // Завершить соединение - _wire->endTransmission(); + _wire_->endTransmission(); return single_byte; } @@ -69,12 +57,12 @@ uint8_t MT6701I2C::MT_RequestSingleRegister(uint8_t _reg_addr) { * @param _payload: 1 байт полезных данных */ void MT6701I2C::MT_WriteOneByte(uint8_t _reg_addr, uint8_t _payload) { - // Начать передачу по адресу 0x06 для прередачи байта данных в регистр - _wire->beginTransmission(MT6701_I2C_ADDRESS); - _wire->write(_reg_addr); - _wire->write(_payload); + // Начать передачу по адресу для прередачи байта данных в регистр + _wire_->beginTransmission(MT6701_I2C_ADDRESS); + _wire_->write(_reg_addr); + _wire_->write(_payload); // Завершить соединение - _wire->endTransmission(); + _wire_->endTransmission(); } // ########## PUBLIC ########## @@ -83,65 +71,58 @@ void MT6701I2C::MT_WriteOneByte(uint8_t _reg_addr, uint8_t _payload) { * @note: использовать, если действие не было выполнено ранее */ void MT6701I2C::begin(void) { - _wire->begin(); -} -/* - * @brief: настройка произвольной частоты - * @note: использовать, если частота шины меняется из-за разных устройств - */ -void MT6701I2C::setClock(uint32_t _clock) { - _wire->setClock(_clock); -} -/* - * @brief: настройка частоты шины I2C на 100кГц - * @note: использовать, если частота шины меняется из-за разных устройств - */ -void MT6701I2C::setClock100kHz(void) { - _wire->setClock(MT6701_I2C_CLOCK_100KHZ); + _wire_->begin(); } /* - * @brief: настройка частоты шины I2C на 400кГц - * @note: использовать, если частота шины меняется из-за разных устройств + * @brief: вызов метода Wire.begin(SDA, SCL) с указанием выводов + * @param _sda_pin: пользовательский контакт SDA + * @param _scl_pin: пользовательский контакт SCL + * @note: использовать, если действие не было выполнено ранее. + * Применимо для платформ на базе ESP8266 и ESP32 */ -void MT6701I2C::setClock400kHz(void) { - _wire->setClock(MT6701_I2C_CLOCK_400KHZ); +#if defined(ESP8266) || defined(ESP32) +void MT6701I2C::begin(int8_t _sda_pin, int8_t _scl_pin) { + _wire_->begin(_sda_pin, _scl_pin); } +#endif /* - * @brief: настройка частоты шины I2C на 1МГц + * @brief: настройка произвольной частоты шины I2C (по умолчанию 400кГц) * @note: использовать, если частота шины меняется из-за разных устройств */ -void MT6701I2C::setClock1MHz(void) { - _wire->setClock(MT6701_I2C_CLOCK_1MHZ); +void MT6701I2C::setClock(uint32_t _clock) { + _wire_->setClock(_clock); } /* * @brief: отключение шины I2C */ +#if !defined(ESP8266) void MT6701I2C::end(void) { - _wire->end(); + _wire_->end(); } +#endif /* * @brief: сохраняет данные в EEPROM памяти датчика * @note: назначение каждой команды не описано в документации, порядок команд описан в 7.2 EEPROM Programming * рекомендуется выполнять эту операцию при напряжении питания от 4.5В до 5.5В */ void MT6701I2C::saveNewValues(void) { - // Начать передачу по адресу 0x06 - _wire->beginTransmission(MT6701_I2C_ADDRESS); + // Начать передачу по адресу + _wire_->beginTransmission(MT6701_I2C_ADDRESS); // Отправить 0x09 - _wire->write(MT6701_I2C_EEPROM_PROG_KEY_REG); + _wire_->write(MT6701_I2C_EEPROM_PROG_KEY_REG); // Отправить 0xB3 - _wire->write(MT6701_I2C_EEPROM_PROG_KEY_VALUE); + _wire_->write(MT6701_I2C_EEPROM_PROG_KEY_VALUE); // Завершить соединение - _wire->endTransmission(); + _wire_->endTransmission(); - // Начать передачу по адресу 0x06 - _wire->beginTransmission(MT6701_I2C_ADDRESS); + // Начать передачу по адресу + _wire_->beginTransmission(MT6701_I2C_ADDRESS); // Отправить 0x0A - _wire->write(MT6701_I2C_EEPROM_PROG_CMD_REG); + _wire_->write(MT6701_I2C_EEPROM_PROG_CMD_REG); // Отправить 0x05 - _wire->write(MT6701_I2C_EEPROM_PROG_CMD_VALUE); + _wire_->write(MT6701_I2C_EEPROM_PROG_CMD_VALUE); // Завершить соединение - _wire->endTransmission(); + _wire_->endTransmission(); } /* * @brief: узнать подкючен ли датчик к линии I2C @@ -151,21 +132,36 @@ void MT6701I2C::saveNewValues(void) { * MT6701I2C_DEFAULT_REPORT_OK - подключен */ bool MT6701I2C::isConnected(void) { - // Начать передачу по адресу 0x06 - _wire->beginTransmission(MT6701_I2C_ADDRESS); - return (!_wire->endTransmission(MT6701_I2C_ADDRESS)) ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR; + // Начать передачу по адресу + _wire_->beginTransmission(MT6701_I2C_ADDRESS); + return (!_wire_->endTransmission(MT6701_I2C_ADDRESS)) ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR; +} +/* + * @brief: назначить контакт микроконтроллера для управления режимом интерфейса + * @param _pin_mode: контакт микроконтроллера к которому подключен контакт MODE датчика + */ +void MT6701I2C::attachModePin(byte _pin_mode) { + _pin_mode_ = _pin_mode; + pinMode(_pin_mode_, OUTPUT); +} +/* + * @brief: освоободить назначенный контакт микроконтроллера для управления режимом интерфейса + */ +void MT6701I2C::detachModePin(void) { + pinMode(_pin_mode_, INPUT); + _pin_mode_ = -1; } /* * @brief: включить интерфейс I2C/SSI */ void MT6701I2C::enableI2CorSSI(void) { - digitalWrite(_pin_mode, MT6701I2C_MODE_I2C_SSI); + digitalWrite(_pin_mode_, MT6701I2C_MODE_I2C_SSI); } /* * @brief: включить интерфейс UVW/ABZ */ void MT6701I2C::enableUVWorABZ(void) { - digitalWrite(_pin_mode, MT6701I2C_MODE_UVW_ABZ); + digitalWrite(_pin_mode_, MT6701I2C_MODE_UVW_ABZ); } /* * @brief: получить чистое значение угла из Angle Data Register(13:0) @@ -173,8 +169,8 @@ void MT6701I2C::enableUVWorABZ(void) { * 0 - 16383 */ word MT6701I2C::getRawAngle(void) { - uint8_t high_byte = MT6701I2C::MT_RequestSingleRegister(MT6701_I2C_ANGLE_DATA_REG_H); - uint8_t low_byte = MT6701I2C::MT_RequestSingleRegister(MT6701_I2C_ANGLE_DATA_REG_L); + uint8_t high_byte = MT_RequestSingleRegister(MT6701_I2C_ANGLE_DATA_REG_H); + uint8_t low_byte = MT_RequestSingleRegister(MT6701_I2C_ANGLE_DATA_REG_L); return (word)(high_byte << 6) | (low_byte >> 2); } /* @@ -183,7 +179,7 @@ word MT6701I2C::getRawAngle(void) { * 0.00 - 359.98 */ float MT6701I2C::getDegreesAngle(void) { - return ((float)MT6701I2C::getRawAngle() * 360) / 16384; + return ((float)getRawAngle() * 360) / 16384; } /* * @brief: получить значение угла в радианах @@ -191,7 +187,7 @@ float MT6701I2C::getDegreesAngle(void) { * 0.00 - 6.28319 */ float MT6701I2C::getRadiansAngle(void) { - return (MT6701I2C::getDegreesAngle() * M_PI) / 180; + return (getDegreesAngle() * M_PI) / 180; } /* * @brief: получить тип конфигурации выходного интерфейса @@ -201,16 +197,16 @@ float MT6701I2C::getRadiansAngle(void) { * MT6701I2_OUTPUT_TYPE_UVW */ MT6701I2CConfigurationOutputType MT6701I2C::getConfigurationOutputType(void) { - return (MT6701I2CConfigurationOutputType)((MT6701I2C::MT_RequestSingleRegister(MT6701_I2C_EEPROM_UVW_MUX_REG) >> MT6701_I2C_EEPROM_UVW_MUX_BIT) & 0x01); + return (MT6701I2CConfigurationOutputType)((MT_RequestSingleRegister(MT6701_I2C_EEPROM_UVW_MUX_REG) >> MT6701_I2C_EEPROM_UVW_MUX_BIT) & 0x01); } /* * @brief: установить тип конфигурации выходного интерфейса -A-B-Z * @note: только для корпуса QFN */ void MT6701I2C::setConfigurationOutputTypeABZ(void) { - uint8_t bkup = MT6701I2C::MT_RequestSingleRegister(MT6701_I2C_EEPROM_UVW_MUX_REG); + uint8_t bkup = MT_RequestSingleRegister(MT6701_I2C_EEPROM_UVW_MUX_REG); bkup &= ~(1 << MT6701_I2C_EEPROM_UVW_MUX_BIT); - MT6701I2C::MT_WriteOneByte(MT6701_I2C_EEPROM_UVW_MUX_REG, bkup); + MT_WriteOneByte(MT6701_I2C_EEPROM_UVW_MUX_REG, bkup); } /* * @brief: установить тип конфигурации выходного интерфейса -A-B-Z с проверкой @@ -220,17 +216,17 @@ void MT6701I2C::setConfigurationOutputTypeABZ(void) { * MT6701I2C_DEFAULT_REPORT_OK - установлено */ bool MT6701I2C::setConfigurationOutputTypeABZVerify(void) { - MT6701I2C::setConfigurationOutputTypeABZ(); - return MT6701I2C::getConfigurationOutputType() ? MT6701I2C_DEFAULT_REPORT_ERROR : MT6701I2C_DEFAULT_REPORT_OK; + setConfigurationOutputTypeABZ(); + return getConfigurationOutputType() ? MT6701I2C_DEFAULT_REPORT_ERROR : MT6701I2C_DEFAULT_REPORT_OK; } /* * @brief: установить тип конфигурации выходного интерфейса UVW * @note: только для корпуса QFN */ void MT6701I2C::setConfigurationOutputTypeUVW(void) { - uint8_t bkup = MT6701I2C::MT_RequestSingleRegister(MT6701_I2C_EEPROM_UVW_MUX_REG); + uint8_t bkup = MT_RequestSingleRegister(MT6701_I2C_EEPROM_UVW_MUX_REG); bkup |= 1 << MT6701_I2C_EEPROM_UVW_MUX_BIT; - MT6701I2C::MT_WriteOneByte(MT6701_I2C_EEPROM_UVW_MUX_REG, bkup); + MT_WriteOneByte(MT6701_I2C_EEPROM_UVW_MUX_REG, bkup); } /* * @brief: установить тип конфигурации выходного интерфейса UVW с проверкой @@ -240,8 +236,8 @@ void MT6701I2C::setConfigurationOutputTypeUVW(void) { * MT6701I2C_DEFAULT_REPORT_OK - установлено */ bool MT6701I2C::setConfigurationOutputTypeUVWVerify(void) { - MT6701I2C::setConfigurationOutputTypeUVW(); - return MT6701I2C::getConfigurationOutputType() ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR; + setConfigurationOutputTypeUVW(); + return getConfigurationOutputType() ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR; } /* * @brief: получить значение типа выходного интерфейса @@ -250,15 +246,15 @@ bool MT6701I2C::setConfigurationOutputTypeUVWVerify(void) { * MT6701I2_OUTPUT_TYPE_UVW */ MT6701I2COutputType MT6701I2C::getOutputType(void) { - return (MT6701I2COutputType)((MT6701I2C::MT_RequestSingleRegister(MT6701_I2C_EEPROM_ABZ_MUX_REG) >> MT6701_I2C_EEPROM_ABZ_MUX_BIT) & 0x01); + return (MT6701I2COutputType)((MT_RequestSingleRegister(MT6701_I2C_EEPROM_ABZ_MUX_REG) >> MT6701_I2C_EEPROM_ABZ_MUX_BIT) & 0x01); } /* * @brief: установить тип выходного интерфейса ABZ */ void MT6701I2C::setOutputTypeABZ(void) { - uint8_t bkup = MT6701I2C::MT_RequestSingleRegister(MT6701_I2C_EEPROM_ABZ_MUX_REG); + uint8_t bkup = MT_RequestSingleRegister(MT6701_I2C_EEPROM_ABZ_MUX_REG); bkup &= ~(1 << MT6701_I2C_EEPROM_ABZ_MUX_BIT); - MT6701I2C::MT_WriteOneByte(MT6701_I2C_EEPROM_ABZ_MUX_REG, bkup); + MT_WriteOneByte(MT6701_I2C_EEPROM_ABZ_MUX_REG, bkup); } /* * @brief: установить тип выходного интерфейса ABZ с проверкой @@ -267,16 +263,16 @@ void MT6701I2C::setOutputTypeABZ(void) { * MT6701I2C_DEFAULT_REPORT_OK - установлено */ bool MT6701I2C::setOutputTypeABZVerify(void) { - MT6701I2C::setOutputTypeABZ(); - return MT6701I2C::getOutputType() ? MT6701I2C_DEFAULT_REPORT_ERROR : MT6701I2C_DEFAULT_REPORT_OK; + setOutputTypeABZ(); + return getOutputType() ? MT6701I2C_DEFAULT_REPORT_ERROR : MT6701I2C_DEFAULT_REPORT_OK; } /* * @brief: установить тип выходного интерфейса UVW */ void MT6701I2C::setOutputTypeUVW(void) { - uint8_t bkup = MT6701I2C::MT_RequestSingleRegister(MT6701_I2C_EEPROM_ABZ_MUX_REG); + uint8_t bkup = MT_RequestSingleRegister(MT6701_I2C_EEPROM_ABZ_MUX_REG); bkup |= 1 << MT6701_I2C_EEPROM_ABZ_MUX_BIT; - MT6701I2C::MT_WriteOneByte(MT6701_I2C_EEPROM_ABZ_MUX_REG, bkup); + MT_WriteOneByte(MT6701_I2C_EEPROM_ABZ_MUX_REG, bkup); } /* * @brief: установить тип выходного интерфейса UVW с проверкой @@ -285,8 +281,8 @@ void MT6701I2C::setOutputTypeUVW(void) { * MT6701I2C_DEFAULT_REPORT_OK - установлено */ bool MT6701I2C::setOutputTypeUVWVerify(void) { - MT6701I2C::setOutputTypeUVW(); - return MT6701I2C::getOutputType() ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR; + setOutputTypeUVW(); + return getOutputType() ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR; } /* * @brief: получить значение положительного направления вращения @@ -295,15 +291,15 @@ bool MT6701I2C::setOutputTypeUVWVerify(void) { * MT6701I2_DIRECTION_CLOCKWISE */ MT6701I2CDirection MT6701I2C::getOutputRotationDirection(void) { - return (MT6701I2CDirection)((MT6701I2C::MT_RequestSingleRegister(MT6701_I2C_EEPROM_DIR_REG) >> MT6701_I2C_EEPROM_DIR_BIT) & 0x01); + return (MT6701I2CDirection)((MT_RequestSingleRegister(MT6701_I2C_EEPROM_DIR_REG) >> MT6701_I2C_EEPROM_DIR_BIT) & 0x01); } /* * @brief: установить положительное направление вращения против часовой стрелки */ void MT6701I2C::setOutputRotationDirectionCounterclockwise(void) { - uint8_t bkup = MT6701I2C::MT_RequestSingleRegister(MT6701_I2C_EEPROM_DIR_REG); + uint8_t bkup = MT_RequestSingleRegister(MT6701_I2C_EEPROM_DIR_REG); bkup &= ~(1 << MT6701_I2C_EEPROM_DIR_BIT); - MT6701I2C::MT_WriteOneByte(MT6701_I2C_EEPROM_DIR_REG, bkup); + MT_WriteOneByte(MT6701_I2C_EEPROM_DIR_REG, bkup); } /* * @brief: установить положительное направление вращения против часовой стрелки с проверкой @@ -312,16 +308,16 @@ void MT6701I2C::setOutputRotationDirectionCounterclockwise(void) { * MT6701I2C_DEFAULT_REPORT_OK - установлено */ bool MT6701I2C::setOutputRotationDirectionCounterclockwiseVerify(void) { - MT6701I2C::setOutputRotationDirectionCounterclockwise(); - return MT6701I2C::getOutputRotationDirection() ? MT6701I2C_DEFAULT_REPORT_ERROR : MT6701I2C_DEFAULT_REPORT_OK; + setOutputRotationDirectionCounterclockwise(); + return getOutputRotationDirection() ? MT6701I2C_DEFAULT_REPORT_ERROR : MT6701I2C_DEFAULT_REPORT_OK; } /* * @brief: установить положительное направление вращения по часовой стрелке */ void MT6701I2C::setOutputRotationDirectionClockwise(void) { - uint8_t bkup = MT6701I2C::MT_RequestSingleRegister(MT6701_I2C_EEPROM_DIR_REG); + uint8_t bkup =MT_RequestSingleRegister(MT6701_I2C_EEPROM_DIR_REG); bkup |= 1 << MT6701_I2C_EEPROM_DIR_BIT; - MT6701I2C::MT_WriteOneByte(MT6701_I2C_EEPROM_DIR_REG, bkup); + MT_WriteOneByte(MT6701_I2C_EEPROM_DIR_REG, bkup); } /* * @brief: установить положительное направление вращения по часовой стрелке с проверкой @@ -330,8 +326,8 @@ void MT6701I2C::setOutputRotationDirectionClockwise(void) { * MT6701I2C_DEFAULT_REPORT_OK - установлено */ bool MT6701I2C::setOutputRotationDirectionClockwiseVerify(void) { - MT6701I2C::setOutputRotationDirectionClockwise(); - return MT6701I2C::getOutputRotationDirection() ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR; + setOutputRotationDirectionClockwise(); + return getOutputRotationDirection() ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR; } /* * @brief: получить значение выходного разрешения в режиме UVW @@ -339,7 +335,7 @@ bool MT6701I2C::setOutputRotationDirectionClockwiseVerify(void) { * 1 - 16 */ byte MT6701I2C::getOutputResolutionUVW(void) { - return ((MT6701I2C::MT_RequestSingleRegister(MT6701_I2C_EEPROM_UVW_RES_REG) >> MT6701_I2C_EEPROM_UVW_MUX_BIT_S) & 0x0F) + 1; // 0x0F = 0b00001111, +1 для смещения в диапазон 1-16 + return ((MT_RequestSingleRegister(MT6701_I2C_EEPROM_UVW_RES_REG) >> MT6701_I2C_EEPROM_UVW_MUX_BIT_S) & 0x0F) + 1; // 0x0F = 0b00001111, +1 для смещения в диапазон 1-16 } /* * @brief: установить значение выходного разрешения в режиме UVW @@ -347,9 +343,9 @@ byte MT6701I2C::getOutputResolutionUVW(void) { * 1 - 16 */ void MT6701I2C::setOutputResolutionUVW(byte _resolution) { - uint8_t bkup = MT6701I2C::MT_RequestSingleRegister(MT6701_I2C_EEPROM_UVW_RES_REG); + uint8_t bkup = MT_RequestSingleRegister(MT6701_I2C_EEPROM_UVW_RES_REG); bkup |= (_resolution - 1) << MT6701_I2C_EEPROM_UVW_MUX_BIT_S; // -1 для смещения в диапазон 0-15 - MT6701I2C::MT_WriteOneByte(MT6701_I2C_EEPROM_UVW_RES_REG, bkup); + MT_WriteOneByte(MT6701_I2C_EEPROM_UVW_RES_REG, bkup); } /* * @brief: установить значение выходного разрешения в режиме UVW с проверкой @@ -360,8 +356,8 @@ void MT6701I2C::setOutputResolutionUVW(byte _resolution) { * MT6701I2C_DEFAULT_REPORT_OK - установлено */ bool MT6701I2C::setOutputResolutionUVWVerify(byte _resolution) { - MT6701I2C::setOutputResolutionUVW(_resolution); - return MT6701I2C::getOutputResolutionUVW() == _resolution ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR; + setOutputResolutionUVW(_resolution); + return getOutputResolutionUVW() == _resolution ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR; } /* * @brief: получить значение выходного разрешения в режиме ABZ @@ -369,8 +365,8 @@ bool MT6701I2C::setOutputResolutionUVWVerify(byte _resolution) { * 1 - 1024 */ word MT6701I2C::getOutputResolutionABZ(void) { - uint8_t reg_h = MT6701I2C::MT_RequestSingleRegister(MT6701_I2C_EEPROM_ABZ_RES_REG_H) & 0x03; // 0x03 = 0b00000011 - return (word)((reg_h << 8) | MT6701I2C::MT_RequestSingleRegister(MT6701_I2C_EEPROM_ABZ_RES_REG_L)) + 1; // +1 для смещения в диапазон 1-1024 + uint8_t reg_h = MT_RequestSingleRegister(MT6701_I2C_EEPROM_ABZ_RES_REG_H) & 0x03; // 0x03 = 0b00000011 + return (word)((reg_h << 8) | MT_RequestSingleRegister(MT6701_I2C_EEPROM_ABZ_RES_REG_L)) + 1; // +1 для смещения в диапазон 1-1024 } /* * @brief: установить значение выходного разрешения в режиме ABZ @@ -379,10 +375,10 @@ word MT6701I2C::getOutputResolutionABZ(void) { */ void MT6701I2C::setOutputResolutionABZ(word _resolution) { uint8_t reg_l = (_resolution - 1) & 0xFF; - uint8_t reg_h = MT6701I2C::MT_RequestSingleRegister(MT6701_I2C_EEPROM_ABZ_RES_REG_H); + uint8_t reg_h = MT_RequestSingleRegister(MT6701_I2C_EEPROM_ABZ_RES_REG_H); reg_h |= ((_resolution - 1) >> 8) & 0x03; - MT6701I2C::MT_WriteOneByte(MT6701_I2C_EEPROM_ABZ_RES_REG_H, reg_h); - MT6701I2C::MT_WriteOneByte(MT6701_I2C_EEPROM_ABZ_RES_REG_L, reg_l); + MT_WriteOneByte(MT6701_I2C_EEPROM_ABZ_RES_REG_H, reg_h); + MT_WriteOneByte(MT6701_I2C_EEPROM_ABZ_RES_REG_L, reg_l); } /* * @brief: установить значение выходного разрешения в режиме ABZ с проверкой @@ -393,8 +389,8 @@ void MT6701I2C::setOutputResolutionABZ(word _resolution) { * MT6701I2C_DEFAULT_REPORT_OK - установлено */ bool MT6701I2C::setOutputResolutionABZVerify(word _resolution) { - MT6701I2C::setOutputResolutionABZ(_resolution); - return MT6701I2C::getOutputResolutionABZ() == _resolution ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR; + setOutputResolutionABZ(_resolution); + return getOutputResolutionABZ() == _resolution ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR; } @@ -411,15 +407,15 @@ bool MT6701I2C::setOutputResolutionABZVerify(word _resolution) { * MT6701I2_Z_PULSE_WIDTH_1LSB_2 */ MT6701I2CZPulseWidth MT6701I2C::getZPulseWidth(void) { - return (MT6701I2CZPulseWidth)((MT6701I2C::MT_RequestSingleRegister(MT6701_I2C_EEPROM_Z_PULSE_WIDTH_REG) >> MT6701_I2C_EEPROM_Z_PULSE_WIDTH_BIT_S) & 0x07); // 0x07 = 0b00000111 + return (MT6701I2CZPulseWidth)((MT_RequestSingleRegister(MT6701_I2C_EEPROM_Z_PULSE_WIDTH_REG) >> MT6701_I2C_EEPROM_Z_PULSE_WIDTH_BIT_S) & 0x07); // 0x07 = 0b00000111 } /* * @brief: установить ширину импульса Z 1LSB */ void MT6701I2C::setZPulseWidth1LSB(void) { - uint8_t bkup = MT6701I2C::MT_RequestSingleRegister(MT6701_I2C_EEPROM_Z_PULSE_WIDTH_REG); + uint8_t bkup = MT_RequestSingleRegister(MT6701_I2C_EEPROM_Z_PULSE_WIDTH_REG); bkup |= MT6701I2_Z_PULSE_WIDTH_1LSB << MT6701_I2C_EEPROM_Z_PULSE_WIDTH_BIT_S; - MT6701I2C::MT_WriteOneByte(MT6701_I2C_EEPROM_Z_PULSE_WIDTH_REG, bkup); + MT_WriteOneByte(MT6701_I2C_EEPROM_Z_PULSE_WIDTH_REG, bkup); } /* * @brief: установить ширину импульса Z 1LSB с проверкой @@ -428,16 +424,16 @@ void MT6701I2C::setZPulseWidth1LSB(void) { * MT6701I2C_DEFAULT_REPORT_OK - установлено */ bool MT6701I2C::setZPulseWidth1LSBVerify(void) { - MT6701I2C::setZPulseWidth1LSB(); - return MT6701I2C::getZPulseWidth() == MT6701I2_Z_PULSE_WIDTH_1LSB ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR; + setZPulseWidth1LSB(); + return getZPulseWidth() == MT6701I2_Z_PULSE_WIDTH_1LSB ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR; } /* * @brief: установить ширину импульса Z 2LSB */ void MT6701I2C::setZPulseWidth2LSB(void) { - uint8_t bkup = MT6701I2C::MT_RequestSingleRegister(MT6701_I2C_EEPROM_Z_PULSE_WIDTH_REG); + uint8_t bkup = MT_RequestSingleRegister(MT6701_I2C_EEPROM_Z_PULSE_WIDTH_REG); bkup |= MT6701I2_Z_PULSE_WIDTH_2LSB << MT6701_I2C_EEPROM_Z_PULSE_WIDTH_BIT_S; - MT6701I2C::MT_WriteOneByte(MT6701_I2C_EEPROM_Z_PULSE_WIDTH_REG, bkup); + MT_WriteOneByte(MT6701_I2C_EEPROM_Z_PULSE_WIDTH_REG, bkup); } /* * @brief: установить ширину импульса Z 2LSB с проверкой @@ -446,16 +442,16 @@ void MT6701I2C::setZPulseWidth2LSB(void) { * MT6701I2C_DEFAULT_REPORT_OK - установлено */ bool MT6701I2C::setZPulseWidth2LSBVerify(void) { - MT6701I2C::setZPulseWidth2LSB(); - return MT6701I2C::getZPulseWidth() == MT6701I2_Z_PULSE_WIDTH_2LSB ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR; + setZPulseWidth2LSB(); + return getZPulseWidth() == MT6701I2_Z_PULSE_WIDTH_2LSB ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR; } /* * @brief: установить ширину импульса Z 4LSB */ void MT6701I2C::setZPulseWidth4LSB(void) { - uint8_t bkup = MT6701I2C::MT_RequestSingleRegister(MT6701_I2C_EEPROM_Z_PULSE_WIDTH_REG); + uint8_t bkup = MT_RequestSingleRegister(MT6701_I2C_EEPROM_Z_PULSE_WIDTH_REG); bkup |= MT6701I2_Z_PULSE_WIDTH_4LSB << MT6701_I2C_EEPROM_Z_PULSE_WIDTH_BIT_S; - MT6701I2C::MT_WriteOneByte(MT6701_I2C_EEPROM_Z_PULSE_WIDTH_REG, bkup); + MT_WriteOneByte(MT6701_I2C_EEPROM_Z_PULSE_WIDTH_REG, bkup); } /* * @brief: установить ширину импульса Z 4LSB с проверкой @@ -464,16 +460,16 @@ void MT6701I2C::setZPulseWidth4LSB(void) { * MT6701I2C_DEFAULT_REPORT_OK - установлено */ bool MT6701I2C::setZPulseWidth4LSBVerify(void) { - MT6701I2C::setZPulseWidth1LSB(); - return MT6701I2C::getZPulseWidth() == MT6701I2_Z_PULSE_WIDTH_4LSB ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR; + setZPulseWidth1LSB(); + return getZPulseWidth() == MT6701I2_Z_PULSE_WIDTH_4LSB ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR; } /* * @brief: установить ширину импульса Z 8LSB */ void MT6701I2C::setZPulseWidth8LSB(void) { - uint8_t bkup = MT6701I2C::MT_RequestSingleRegister(MT6701_I2C_EEPROM_Z_PULSE_WIDTH_REG); + uint8_t bkup = MT_RequestSingleRegister(MT6701_I2C_EEPROM_Z_PULSE_WIDTH_REG); bkup |= MT6701I2_Z_PULSE_WIDTH_8LSB << MT6701_I2C_EEPROM_Z_PULSE_WIDTH_BIT_S; - MT6701I2C::MT_WriteOneByte(MT6701_I2C_EEPROM_Z_PULSE_WIDTH_REG, bkup); + MT_WriteOneByte(MT6701_I2C_EEPROM_Z_PULSE_WIDTH_REG, bkup); } /* * @brief: установить ширину импульса Z 8LSB с проверкой @@ -482,16 +478,16 @@ void MT6701I2C::setZPulseWidth8LSB(void) { * MT6701I2C_DEFAULT_REPORT_OK - установлено */ bool MT6701I2C::setZPulseWidth8LSBVerify(void) { - MT6701I2C::setZPulseWidth8LSB(); - return MT6701I2C::getZPulseWidth() == MT6701I2_Z_PULSE_WIDTH_8LSB ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR; + setZPulseWidth8LSB(); + return getZPulseWidth() == MT6701I2_Z_PULSE_WIDTH_8LSB ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR; } /* * @brief: установить ширину импульса Z 12LSB */ void MT6701I2C::setZPulseWidth12LSB(void) { - uint8_t bkup = MT6701I2C::MT_RequestSingleRegister(MT6701_I2C_EEPROM_Z_PULSE_WIDTH_REG); + uint8_t bkup = MT_RequestSingleRegister(MT6701_I2C_EEPROM_Z_PULSE_WIDTH_REG); bkup |= MT6701I2_Z_PULSE_WIDTH_12LSB << MT6701_I2C_EEPROM_Z_PULSE_WIDTH_BIT_S; - MT6701I2C::MT_WriteOneByte(MT6701_I2C_EEPROM_Z_PULSE_WIDTH_REG, bkup); + MT_WriteOneByte(MT6701_I2C_EEPROM_Z_PULSE_WIDTH_REG, bkup); } /* * @brief: установить ширину импульса Z 12LSB с проверкой @@ -500,16 +496,16 @@ void MT6701I2C::setZPulseWidth12LSB(void) { * MT6701I2C_DEFAULT_REPORT_OK - установлено */ bool MT6701I2C::setZPulseWidth12LSBVerify(void) { - MT6701I2C::setZPulseWidth12LSB(); - return MT6701I2C::getZPulseWidth() == MT6701I2_Z_PULSE_WIDTH_12LSB ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR; + setZPulseWidth12LSB(); + return getZPulseWidth() == MT6701I2_Z_PULSE_WIDTH_12LSB ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR; } /* * @brief: установить ширину импульса Z 16LSB */ void MT6701I2C::setZPulseWidth16LSB(void) { - uint8_t bkup = MT6701I2C::MT_RequestSingleRegister(MT6701_I2C_EEPROM_Z_PULSE_WIDTH_REG); + uint8_t bkup = MT_RequestSingleRegister(MT6701_I2C_EEPROM_Z_PULSE_WIDTH_REG); bkup |= MT6701I2_Z_PULSE_WIDTH_16LSB << MT6701_I2C_EEPROM_Z_PULSE_WIDTH_BIT_S; - MT6701I2C::MT_WriteOneByte(MT6701_I2C_EEPROM_Z_PULSE_WIDTH_REG, bkup); + MT_WriteOneByte(MT6701_I2C_EEPROM_Z_PULSE_WIDTH_REG, bkup); } /* * @brief: установить ширину импульса Z 16LSB с проверкой @@ -518,16 +514,16 @@ void MT6701I2C::setZPulseWidth16LSB(void) { * MT6701I2C_DEFAULT_REPORT_OK - установлено */ bool MT6701I2C::setZPulseWidth16LSBVerify(void) { - MT6701I2C::setZPulseWidth16LSB(); - return MT6701I2C::getZPulseWidth() == MT6701I2_Z_PULSE_WIDTH_16LSB ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR; + setZPulseWidth16LSB(); + return getZPulseWidth() == MT6701I2_Z_PULSE_WIDTH_16LSB ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR; } /* * @brief: установить ширину импульса Z 180 градусов */ void MT6701I2C::setZPulseWidth180DEG(void) { - uint8_t bkup = MT6701I2C::MT_RequestSingleRegister(MT6701_I2C_EEPROM_Z_PULSE_WIDTH_REG); + uint8_t bkup = MT_RequestSingleRegister(MT6701_I2C_EEPROM_Z_PULSE_WIDTH_REG); bkup |= MT6701I2_Z_PULSE_WIDTH_180DEG << MT6701_I2C_EEPROM_Z_PULSE_WIDTH_BIT_S; - MT6701I2C::MT_WriteOneByte(MT6701_I2C_EEPROM_Z_PULSE_WIDTH_REG, bkup); + MT_WriteOneByte(MT6701_I2C_EEPROM_Z_PULSE_WIDTH_REG, bkup); } /* * @brief: установить ширину импульса Z 180 градусов с проверкой @@ -536,8 +532,8 @@ void MT6701I2C::setZPulseWidth180DEG(void) { * MT6701I2C_DEFAULT_REPORT_OK - установлено */ bool MT6701I2C::setZPulseWidth180DEGVerify(void) { - MT6701I2C::setZPulseWidth180DEG(); - return MT6701I2C::getZPulseWidth() == MT6701I2_Z_PULSE_WIDTH_180DEG ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR; + setZPulseWidth180DEG(); + return getZPulseWidth() == MT6701I2_Z_PULSE_WIDTH_180DEG ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR; } /* * @brief: получить значение нулевого положения @@ -546,8 +542,8 @@ bool MT6701I2C::setZPulseWidth180DEGVerify(void) { * 0 - 4095 */ word MT6701I2C::getZeroDegreePositionData(void) { - uint8_t reg_h = MT6701I2C::MT_RequestSingleRegister(MT6701_I2C_EEPROM_ZERO_REG_H) & 0x0F; // 0x0F = 0b00001111 - return (word)((reg_h << 8) | MT6701I2C::MT_RequestSingleRegister(MT6701_I2C_EEPROM_ZERO_REG_L)); + uint8_t reg_h = MT_RequestSingleRegister(MT6701_I2C_EEPROM_ZERO_REG_H) & 0x0F; // 0x0F = 0b00001111 + return (word)((reg_h << 8) | MT_RequestSingleRegister(MT6701_I2C_EEPROM_ZERO_REG_L)); } /* * @brief: установить значение нулевого положения @@ -556,11 +552,11 @@ word MT6701I2C::getZeroDegreePositionData(void) { * 0 - 4095 */ void MT6701I2C::setZeroDegreePositionData(word _zero_position_data) { - uint8_t bkup = MT6701I2C::MT_RequestSingleRegister(MT6701_I2C_EEPROM_ZERO_REG_H); + uint8_t bkup = MT_RequestSingleRegister(MT6701_I2C_EEPROM_ZERO_REG_H) & 0xF0; // 0xF0 = 0b11110000 uint8_t reg_l = _zero_position_data & 0xFF; bkup |= _zero_position_data >> 8; - MT6701I2C::MT_WriteOneByte(MT6701_I2C_EEPROM_ZERO_REG_H, bkup); - MT6701I2C::MT_WriteOneByte(MT6701_I2C_EEPROM_ZERO_REG_L, reg_l); + MT_WriteOneByte(MT6701_I2C_EEPROM_ZERO_REG_H, bkup); + MT_WriteOneByte(MT6701_I2C_EEPROM_ZERO_REG_L, reg_l); } /* * @brief: установить значение нулевого положения с проверкой @@ -572,8 +568,8 @@ void MT6701I2C::setZeroDegreePositionData(word _zero_position_data) { * MT6701I2C_DEFAULT_REPORT_OK - установлено */ bool MT6701I2C::setZeroDegreePositionDataVerify(word _zero_position_data) { - MT6701I2C::setZeroDegreePositionData(_zero_position_data); - return MT6701I2C::getZeroDegreePositionData() == _zero_position_data ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR; + setZeroDegreePositionData(_zero_position_data); + return getZeroDegreePositionData() == _zero_position_data ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR; } /* * @brief: получить значение частоты ШИМ @@ -582,15 +578,15 @@ bool MT6701I2C::setZeroDegreePositionDataVerify(word _zero_position_data) { * MT6701I2_PWM_FREQUENCY_4972 */ MT6701I2CFrequencyPWM MT6701I2C::getFrequencyPWM(void) { - return (MT6701I2CFrequencyPWM)((MT6701I2C::MT_RequestSingleRegister(MT6701_I2C_EEPROM_PWM_FREQ_REG) >> MT6701_I2C_EEPROM_PWM_FREQ_BIT) & 0x01); + return (MT6701I2CFrequencyPWM)((MT_RequestSingleRegister(MT6701_I2C_EEPROM_PWM_FREQ_REG) >> MT6701_I2C_EEPROM_PWM_FREQ_BIT) & 0x01); } /* * @brief: установить значение частоты ШИМ 994.4Гц */ void MT6701I2C::setFrequencyPWM9944(void) { - uint8_t bkup = MT6701I2C::MT_RequestSingleRegister(MT6701_I2C_EEPROM_PWM_FREQ_REG); + uint8_t bkup = MT_RequestSingleRegister(MT6701_I2C_EEPROM_PWM_FREQ_REG); bkup &= ~(1 << MT6701_I2C_EEPROM_PWM_FREQ_BIT); - MT6701I2C::MT_WriteOneByte(MT6701_I2C_EEPROM_PWM_FREQ_REG, bkup); + MT_WriteOneByte(MT6701_I2C_EEPROM_PWM_FREQ_REG, bkup); } /* * @brief: установить значение частоты ШИМ 994.4Гц с проверкой @@ -599,16 +595,16 @@ void MT6701I2C::setFrequencyPWM9944(void) { * MT6701I2C_DEFAULT_REPORT_OK - установлено */ bool MT6701I2C::setFrequencyPWM9944Verify(void) { - MT6701I2C::setFrequencyPWM9944(); - return MT6701I2C::getFrequencyPWM() == MT6701I2_PWM_FREQUENCY_9944 ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR; + setFrequencyPWM9944(); + return getFrequencyPWM() == MT6701I2_PWM_FREQUENCY_9944 ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR; } /* * @brief: установить значение частоты ШИМ 497.2Гц */ void MT6701I2C::setFrequencyPWM4972(void) { - uint8_t bkup = MT6701I2C::MT_RequestSingleRegister(MT6701_I2C_EEPROM_PWM_FREQ_REG); + uint8_t bkup = MT_RequestSingleRegister(MT6701_I2C_EEPROM_PWM_FREQ_REG); bkup |= 1 << MT6701_I2C_EEPROM_PWM_FREQ_BIT; - MT6701I2C::MT_WriteOneByte(MT6701_I2C_EEPROM_PWM_FREQ_REG, bkup); + MT_WriteOneByte(MT6701_I2C_EEPROM_PWM_FREQ_REG, bkup); } /* * @brief: установить значение частоты ШИМ 497.2Гц с проверкой @@ -617,8 +613,8 @@ void MT6701I2C::setFrequencyPWM4972(void) { * MT6701I2C_DEFAULT_REPORT_OK - установлено */ bool MT6701I2C::setFrequencyPWM4972Verify(void) { - MT6701I2C::setFrequencyPWM4972(); - return MT6701I2C::getFrequencyPWM() == MT6701I2_PWM_FREQUENCY_4972 ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR; + setFrequencyPWM4972(); + return getFrequencyPWM() == MT6701I2_PWM_FREQUENCY_4972 ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR; } /* * @brief: получить значение полярности ШИМ @@ -627,15 +623,15 @@ bool MT6701I2C::setFrequencyPWM4972Verify(void) { * MT6701I2_PWM_POLARITY_LOW */ MT6701I2CPolarityPWM MT6701I2C::getPolarityPWM(void) { - return (MT6701I2CPolarityPWM)((MT6701I2C::MT_RequestSingleRegister(MT6701_I2C_EEPROM_PWM_POL_REG) >> MT6701_I2C_EEPROM_PWM_POL_BIT) & 0x01); + return (MT6701I2CPolarityPWM)((MT_RequestSingleRegister(MT6701_I2C_EEPROM_PWM_POL_REG) >> MT6701_I2C_EEPROM_PWM_POL_BIT) & 0x01); } /* * @brief: установить значение полярности ШИМ HIGH */ void MT6701I2C::setPolarityPWMHigh(void) { - uint8_t bkup = MT6701I2C::MT_RequestSingleRegister(MT6701_I2C_EEPROM_PWM_POL_REG); + uint8_t bkup = MT_RequestSingleRegister(MT6701_I2C_EEPROM_PWM_POL_REG); bkup &= ~(1 << MT6701_I2C_EEPROM_PWM_POL_BIT); - MT6701I2C::MT_WriteOneByte(MT6701_I2C_EEPROM_PWM_POL_REG, bkup); + MT_WriteOneByte(MT6701_I2C_EEPROM_PWM_POL_REG, bkup); } /* * @brief: установить значение полярности ШИМ HIGH с проверкой @@ -644,26 +640,26 @@ void MT6701I2C::setPolarityPWMHigh(void) { * MT6701I2C_DEFAULT_REPORT_OK - установлено */ bool MT6701I2C::setPolarityPWMHighVerify(void) { - MT6701I2C::setPolarityPWMHigh(); - return MT6701I2C::getPolarityPWM() == MT6701I2_PWM_POLARITY_HIGH ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR; + setPolarityPWMHigh(); + return getPolarityPWM() == MT6701I2_PWM_POLARITY_HIGH ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR; } /* * @brief: установить значение полярности ШИМ LOW */ void MT6701I2C::setPolarityPWMLow(void) { - uint8_t bkup = MT6701I2C::MT_RequestSingleRegister(MT6701_I2C_EEPROM_PWM_POL_REG); + uint8_t bkup = MT_RequestSingleRegister(MT6701_I2C_EEPROM_PWM_POL_REG); bkup |= 1 << MT6701_I2C_EEPROM_PWM_POL_BIT; - MT6701I2C::MT_WriteOneByte(MT6701_I2C_EEPROM_PWM_POL_REG, bkup); + MT_WriteOneByte(MT6701_I2C_EEPROM_PWM_POL_REG, bkup); } /* - * @brief: установить значение частоты ШИМ LOW с проверкой + * @brief: установить значение полярности ШИМ LOW с проверкой * @return: * MT6701I2C_DEFAULT_REPORT_ERROR - не установлено * MT6701I2C_DEFAULT_REPORT_OK - установлено */ bool MT6701I2C::setPolarityPWMLowVerify(void) { - MT6701I2C::setPolarityPWMLow(); - return MT6701I2C::getPolarityPWM() == MT6701I2_PWM_POLARITY_LOW ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR; + setPolarityPWMLow(); + return getPolarityPWM() == MT6701I2_PWM_POLARITY_LOW ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR; } /* @@ -673,15 +669,15 @@ bool MT6701I2C::setPolarityPWMLowVerify(void) { * MT6701I2_OUTPUT_MODE_PWM */ MT6701I2COutputMode MT6701I2C::getOutputMode(void) { - return (MT6701I2COutputMode)((MT6701I2C::MT_RequestSingleRegister(MT6701_I2C_EEPROM_OUT_MODE_REG) >> MT6701_I2C_EEPROM_OUT_MODE_BIT) & 0x01); + return (MT6701I2COutputMode)((MT_RequestSingleRegister(MT6701_I2C_EEPROM_OUT_MODE_REG) >> MT6701_I2C_EEPROM_OUT_MODE_BIT) & 0x01); } /* * @brief: установить режим выхода Аналог */ void MT6701I2C::setOutputModeAnalog(void) { - uint8_t bkup = MT6701I2C::MT_RequestSingleRegister(MT6701_I2C_EEPROM_OUT_MODE_REG); + uint8_t bkup = MT_RequestSingleRegister(MT6701_I2C_EEPROM_OUT_MODE_REG); bkup &= ~(1 << MT6701_I2C_EEPROM_OUT_MODE_BIT); - MT6701I2C::MT_WriteOneByte(MT6701_I2C_EEPROM_OUT_MODE_REG, bkup); + MT_WriteOneByte(MT6701_I2C_EEPROM_OUT_MODE_REG, bkup); } /* * @brief: установить режим выхода Аналог с проверкой @@ -690,16 +686,16 @@ void MT6701I2C::setOutputModeAnalog(void) { * MT6701I2C_DEFAULT_REPORT_OK - установлено */ bool MT6701I2C::setOutputModeAnalogVerify(void) { - MT6701I2C::setOutputModeAnalog(); - return MT6701I2C::getOutputMode() == MT6701I2_OUTPUT_MODE_ANALOG ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR; + setOutputModeAnalog(); + return getOutputMode() == MT6701I2_OUTPUT_MODE_ANALOG ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR; } /* * @brief: установить режим выхода ШИМ */ void MT6701I2C::setOutputModePWM(void) { - uint8_t bkup = MT6701I2C::MT_RequestSingleRegister(MT6701_I2C_EEPROM_OUT_MODE_REG); + uint8_t bkup = MT_RequestSingleRegister(MT6701_I2C_EEPROM_OUT_MODE_REG); bkup |= 1 << MT6701_I2C_EEPROM_OUT_MODE_BIT; - MT6701I2C::MT_WriteOneByte(MT6701_I2C_EEPROM_OUT_MODE_REG, bkup); + MT_WriteOneByte(MT6701_I2C_EEPROM_OUT_MODE_REG, bkup); } /* * @brief: установить режим выхода ШИМ с проверкой @@ -708,6 +704,6 @@ void MT6701I2C::setOutputModePWM(void) { * MT6701I2C_DEFAULT_REPORT_OK - установлено */ bool MT6701I2C::setOutputModePWMVerify(void) { - MT6701I2C::setOutputModePWM(); - return MT6701I2C::getOutputMode() == MT6701I2_OUTPUT_MODE_PWM ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR; + setOutputModePWM(); + return getOutputMode() == MT6701I2_OUTPUT_MODE_PWM ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR; } diff --git a/src/MT6701_I2C.h b/src/MT6701_I2C.h index 010439b..05f2956 100644 --- a/src/MT6701_I2C.h +++ b/src/MT6701_I2C.h @@ -11,7 +11,7 @@ ** GitHub - https://github.com/S-LABc ** Gmail - romansklyar15@gmail.com * - * Copyright (C) 2022. v1.0 / License MIT / Скляр Роман S-LAB + * Copyright (C) 2022. v1.1 / License MIT / Скляр Роман S-LAB */ #pragma once @@ -19,66 +19,67 @@ #include "Wire.h" /*=== Настройки шины I2C датчика ===*/ -#define MT6701_I2C_CLOCK_100KHZ 100000UL -#define MT6701_I2C_CLOCK_400KHZ 400000UL -#define MT6701_I2C_CLOCK_1MHZ 1000000UL -#define MT6701_I2C_ADDRESS 0x06 +const uint32_t MT6701_I2C_CLOCK_100KHZ = 100000; +const uint32_t MT6701_I2C_CLOCK_400KHZ = 400000; +const uint32_t MT6701_I2C_CLOCK_1MHZ = 1000000; +const uint8_t MT6701_I2C_ADDRESS = 0x06; /*=== Выводы MODE на разных платах (зависит от ядра) ===*/ #define STM32_MT6701_MODE_PIN PC13 -#define ESP32_MT6701_MODE_PIN 2 +#define ESP8266_MT6701_MODE_PIN 2 +#define ESP32_MT6701_MODE_PIN 4 #define ARDUINO_MT6701_MODE_PIN 3 /*=== Адреса регистров датчика ===*/ // Angle Data Register -#define MT6701_I2C_ANGLE_DATA_REG_H 0x03 -#define MT6701_I2C_ANGLE_DATA_REG_L 0x04 +const uint8_t MT6701_I2C_ANGLE_DATA_REG_H = 0x03; +const uint8_t MT6701_I2C_ANGLE_DATA_REG_L = 0x04; // UVW_MUX только для корпуса QFN -#define MT6701_I2C_EEPROM_UVW_MUX_REG 0x25 -#define MT6701_I2C_EEPROM_UVW_MUX_BIT 7 +const uint8_t MT6701_I2C_EEPROM_UVW_MUX_REG = 0x25; +const uint8_t MT6701_I2C_EEPROM_UVW_MUX_BIT = 7; // ABZ_MUX -#define MT6701_I2C_EEPROM_ABZ_MUX_REG 0x29 -#define MT6701_I2C_EEPROM_ABZ_MUX_BIT 6 +const uint8_t MT6701_I2C_EEPROM_ABZ_MUX_REG = 0x29; +const uint8_t MT6701_I2C_EEPROM_ABZ_MUX_BIT = 6; // DIR -#define MT6701_I2C_EEPROM_DIR_REG 0x29 -#define MT6701_I2C_EEPROM_DIR_BIT 1 +const uint8_t MT6701_I2C_EEPROM_DIR_REG = 0x29; +const uint8_t MT6701_I2C_EEPROM_DIR_BIT = 1; // UVW_RES -#define MT6701_I2C_EEPROM_UVW_RES_REG 0x30 -#define MT6701_I2C_EEPROM_UVW_MUX_BIT_S 4 +const uint8_t MT6701_I2C_EEPROM_UVW_RES_REG = 0x30; +const uint8_t MT6701_I2C_EEPROM_UVW_MUX_BIT_S = 4; // ABZ_RES -#define MT6701_I2C_EEPROM_ABZ_RES_REG_H 0x30 -#define MT6701_I2C_EEPROM_ABZ_RES_REG_L 0x31 -#define MT6701_I2C_EEPROM_ABZ_MUX_BIT_S 0 +const uint8_t MT6701_I2C_EEPROM_ABZ_RES_REG_H = 0x30; +const uint8_t MT6701_I2C_EEPROM_ABZ_RES_REG_L = 0x31; +const uint8_t MT6701_I2C_EEPROM_ABZ_MUX_BIT_S = 0; // HYST -#define MT6701_I2C_EEPROM_HYST_REG_H 0x32 -#define MT6701_I2C_EEPROM_HYST_REG_L 0x34 +const uint8_t MT6701_I2C_EEPROM_HYST_REG_H = 0x32; +const uint8_t MT6701_I2C_EEPROM_HYST_REG_L = 0x34; // Z_PULSE_WIDTH -#define MT6701_I2C_EEPROM_Z_PULSE_WIDTH_REG 0x32 -#define MT6701_I2C_EEPROM_Z_PULSE_WIDTH_BIT_S 4 +const uint8_t MT6701_I2C_EEPROM_Z_PULSE_WIDTH_REG = 0x32; +const uint8_t MT6701_I2C_EEPROM_Z_PULSE_WIDTH_BIT_S = 4; // ZERO -#define MT6701_I2C_EEPROM_ZERO_REG_H 0x32 -#define MT6701_I2C_EEPROM_ZERO_REG_L 0x33 +const uint8_t MT6701_I2C_EEPROM_ZERO_REG_H = 0x32; +const uint8_t MT6701_I2C_EEPROM_ZERO_REG_L = 0x33; // PWM_FREQ -#define MT6701_I2C_EEPROM_PWM_FREQ_REG 0x38 -#define MT6701_I2C_EEPROM_PWM_FREQ_BIT 7 +const uint8_t MT6701_I2C_EEPROM_PWM_FREQ_REG = 0x38; +const uint8_t MT6701_I2C_EEPROM_PWM_FREQ_BIT = 7; // PWM_POL -#define MT6701_I2C_EEPROM_PWM_POL_REG 0x38 -#define MT6701_I2C_EEPROM_PWM_POL_BIT 6 +const uint8_t MT6701_I2C_EEPROM_PWM_POL_REG = 0x38; +const uint8_t MT6701_I2C_EEPROM_PWM_POL_BIT = 6; // OUT_MODE -#define MT6701_I2C_EEPROM_OUT_MODE_REG 0x38 -#define MT6701_I2C_EEPROM_OUT_MODE_BIT 5 +const uint8_t MT6701_I2C_EEPROM_OUT_MODE_REG = 0x38; +const uint8_t MT6701_I2C_EEPROM_OUT_MODE_BIT = 5; // A_START -#define MT6701_I2C_EEPROM_A_START_REG_H 0x3E -#define MT6701_I2C_EEPROM_A_START_REG_L 0x3F +const uint8_t MT6701_I2C_EEPROM_A_START_REG_H = 0x3E; +const uint8_t MT6701_I2C_EEPROM_A_START_REG_L = 0x3F; // A_STOP -#define MT6701_I2C_EEPROM_A_STOP_REG_H 0x3E -#define MT6701_I2C_EEPROM_A_STOP_REG_L 0x40 -#define MT6701_I2C_EEPROM_A_STOP_BIT_S 4 +const uint8_t MT6701_I2C_EEPROM_A_STOP_REG_H = 0x3E; +const uint8_t MT6701_I2C_EEPROM_A_STOP_REG_L = 0x40; +const uint8_t MT6701_I2C_EEPROM_A_STOP_BIT_S = 4; // 7.2 EEPROM Programming -#define MT6701_I2C_EEPROM_PROG_KEY_REG 0x09 -#define MT6701_I2C_EEPROM_PROG_KEY_VALUE 0xB3 -#define MT6701_I2C_EEPROM_PROG_CMD_REG 0x0A -#define MT6701_I2C_EEPROM_PROG_CMD_VALUE 0x05 +const uint8_t MT6701_I2C_EEPROM_PROG_KEY_REG = 0x09; +const uint8_t MT6701_I2C_EEPROM_PROG_KEY_VALUE = 0xB3; +const uint8_t MT6701_I2C_EEPROM_PROG_CMD_REG = 0x0A; +const uint8_t MT6701_I2C_EEPROM_PROG_CMD_VALUE = 0x05; /*=== Вспомогательные значения ===*/ // Тип конфигурации выходного интерфейса (только для корпуса QFN) @@ -123,36 +124,41 @@ enum MT6701I2COutputMode { MT6701I2_OUTPUT_MODE_PWM, }; // Ответы стандартного вида успех/ошибка -#define MT6701I2C_DEFAULT_REPORT_ERROR false -#define MT6701I2C_DEFAULT_REPORT_OK true +const uint8_t MT6701I2C_DEFAULT_REPORT_ERROR = 0; +const uint8_t MT6701I2C_DEFAULT_REPORT_OK = 1; // Выбор интерфейсов датчика -#define MT6701I2C_MODE_I2C_SSI HIGH -#define MT6701I2C_MODE_UVW_ABZ LOW +const uint8_t MT6701I2C_MODE_I2C_SSI = 0; +const uint8_t MT6701I2C_MODE_UVW_ABZ = 1; class MT6701I2C { private: - TwoWire *_wire; // Объект для использования методов I2C - int8_t _pin_mode = -1; // Контакт микроконтроллера к которому подключен вывод MODE датчика - - public: - MT6701I2C(TwoWire *twi); // Конструктор с использованием только интерфейса I2C - MT6701I2C(TwoWire *twi, int8_t pinmode, bool state = MT6701I2C_MODE_I2C_SSI); // Конструктор с использованием интерфейса I2C, контакта MODE, режима интерфейса + TwoWire* _wire_; // Объект для использования методов I2C + int8_t _pin_mode_ = -1; // Контакт микроконтроллера к которому подключен вывод MODE датчика + protected: uint8_t MT_RequestSingleRegister(uint8_t _reg_addr); // Запрос значения регистра размером 1 байт void MT_WriteOneByte(uint8_t _reg_addr, uint8_t _payload); // Запись одного байта в однобайтовый регистр + public: + MT6701I2C(TwoWire* _twi); // Конструктор с использованием только интерфейса I2C + void begin(void); // Вызов Wire.begin() - void setClock(uint32_t _clock); // Настройка произвольной частоты - void setClock100kHz(void); // Настройка частоты на 100кГц - void setClock400kHz(void); // Настройка частоты на 400кГц - void setClock1MHz(void); // Настройка частоты на 1МГц +#if defined(ESP8266) || defined(ESP32) + void begin(int8_t _sda_pin, int8_t _scl_pin); // Вызов Wire.begin(SDA, SCL) с указанием выводов +#endif + void setClock(uint32_t _clock = MT6701_I2C_CLOCK_400KHZ); // Настройка частоты на 100кГц, 400кГц, 1МГц, или пользовательское значение (по умолчанию 400кГц) +#if !defined(ESP8266) void end(void); // Вызов Wire.end() +#endif - void saveNewValues(void); // Метод производителя для сохранения значений в памяти EEPROM. Напряжение питания от 4.5В до 5.5В + void saveNewValues(void); // Метод производителя для сохранения значений в памяти EEPROM. Рекомендуется выполнять при напряжение питания от 4.5В до 5.5В bool isConnected(void); // Проверка по стандартному алгоритму поиска устройств на линии I2C + void attachModePin(byte _pin_mode); // Назначить контакт микроконтроллера для управления режимом интерфейса + void detachModePin(void); // Освоободить назначенный контакт микроконтроллера для управления режимом интерфейса + void enableI2CorSSI(void); // Включить интерфейс I2C/SSI. MT6701I2C_MODE_I2C_SSI void enableUVWorABZ(void); // Включить интерфейс UVW/ABZ. MT6701I2C_MODE_UVW_ABZ @@ -203,7 +209,7 @@ class MT6701I2C { void setZPulseWidth180DEG(void); // Установить ширину импульса 180 градсуов bool setZPulseWidth180DEGVerify(void); // То же самое, но с подтверждением - word getZeroDegreePositionData(void); // Получить значение нулевого положения. Смотреть таблицу в документации + word getZeroDegreePositionData(void); // Получить значение нулевого положения. Смотреть таблицу в документации стр 28. 0x000 - 0xFFF void setZeroDegreePositionData(word _zero_position_data); // Установить значение нулевого положения. Смотреть таблицу в документации bool setZeroDegreePositionDataVerify(word _zero_position_data); // То же самое, но с подтверждением