├── LICENSE
├── README.md
├── examples
    ├── MT6701_set_get_ZeroDegreePosition
    │   └── MT6701_set_get_ZeroDegreePosition.ino
    └── MT6701_test
    │   └── MT6701_test.ino
├── images
    └── mt6701_module.jpg
├── keywords.txt
├── library.properties
└── src
    ├── MT6701_I2C.cpp
    └── MT6701_I2C.h


/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2022 Roman Sklyar S-LAB
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # MT6701-Arduino-Library
 2 | <p align="center"><img src="/images/mt6701_module.jpg"></p>
 3 | 
 4 | ## Еще магнытные датчики
 5 | * [AS5600](https://github.com/S-LABc/AMS-AS5600-Arduino-Library)
 6 | * [AS5601](https://github.com/S-LABc/AMS-AS5601-Arduino-Library)
 7 | 
 8 | ## Предупреждение
 9 | * Библиотека не проверялась полностью. Возможны ошибки. Используя бибилиотеку вы берете все риски на себя
10 | * Реализованы не все возможности датчика. Для взаимодействия с регистрами датчика можно использовать эти методы:
11 | ```C++
12 | // Чтение содержимого регистра
13 | uint8_t MT_RequestSingleRegister(uint8_t _reg_addr);
14 | // Запись нового содержимого в регистр
15 | void MT_WriteOneByte(uint8_t _reg_addr, uint8_t _payload);
16 | ```
17 | * Использовать методы описанные выше седует через наследование класса MT6701I2C
18 | * Все доступные методы, константы, типы данных можно посмотреть [тут](https://github.com/S-LABc/MT6701-Arduino-Library/blob/main/src/MT6701_I2C.h)
19 | 
20 | ## Ссылки
21 | * [Даташит MT6701 rev.1.0](https://www.magntek.com.cn/upload/MT6701_Rev.1.0.pdf)
22 | * [Даташит MT6701 rev.1.5](http://www.magntek.com.cn/upload/MT6701_Rev.1.5.pdf)
23 | * [Даташит MT6701 rev.1.8](https://www.magntek.com.cn/upload/MT6701_Rev.1.8.pdf)
24 | * [Страница MT6701](http://www.magntek.com.cn/en/list/177/559.htm)
25 | * [Корпус для тестов](https://github.com/S-LABc/AMS-AS5600-Arduino-Library/tree/main/addons/AS5600-Case-STL)
26 | 


--------------------------------------------------------------------------------
/examples/MT6701_set_get_ZeroDegreePosition/MT6701_set_get_ZeroDegreePosition.ino:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * 1. Open Serial Monitor at 9600 and there is no line ending
 3 |  * 2. Send the character "s" to the Serial Monitor
 4 |  * 
 5 |  * CORRECT SERIAL MONITOR LOGS
 6 | 
 7 |    Sensor Found!
 8 | 
 9 |    Reading Current Value...
10 |    Zero Degree Position (HEX): 0 [0 - default, but may be different]
11 | 
12 |    Changing Value... Value Changed
13 | 
14 |    Saving New Values...
15 | 
16 |    Reading New Value...
17 |    Zero Degree Position After Saving (HEX): 8
18 | 
19 |    Program Complete!
20 |  *
21 |  */
22 | 
23 | #include <MT6701_I2C.h>
24 | 
25 | MT6701I2C SensorI2C(&Wire);
26 | 
27 | void setup() {
28 |   Serial.begin(9600);
29 |   
30 |   SensorI2C.begin();
31 |   SensorI2C.setClock();
32 |   
33 |   while(1) { // Waiting for the input of the character "s"
34 |     byte c;
35 |     if(Serial.available())
36 |       c = Serial.read();
37 |     if(c == 's') {
38 |       break;
39 |     }
40 |     delay(100);
41 |   }
42 | 
43 |   while(!SensorI2C.isConnected()) {
44 |     Serial.println("Sensor not Connected!");
45 |     delay(500);
46 |   }
47 |   Serial.println("Sensor Found!");
48 |   Serial.println();
49 | 
50 |   delay(300); // The delay is not important. so it's easier to see in the SM
51 | 
52 |   Serial.println("Reading Current Value...");
53 |   word zdp;
54 |   zdp = SensorI2C.getZeroDegreePositionData();
55 |   Serial.print("Zero Degree Position (HEX): ");
56 |   Serial.println(zdp, HEX);
57 |   Serial.println();
58 | 
59 |   delay(300); // The delay is not important. so it's easier to see in the SM
60 | 
61 |   Serial.print("Changing Value... ");
62 |   word zdp_new = 0x0008; // New value
63 |   if(SensorI2C.setZeroDegreePositionDataVerify(zdp_new)) {
64 |     Serial.println("Value Changed");
65 |   } else {
66 |     Serial.println("Value Change Error");
67 |   }
68 |   Serial.println();
69 | 
70 |   delay(300); // The delay is not important. so it's easier to see in the SM
71 | 
72 |   Serial.println("Saving New Values...");
73 |   Serial.println();
74 |   // It's important to save the new values after the change.
75 |   // Called once even after setting multiple values
76 |   // else values return to default after power off
77 |   SensorI2C.saveNewValues();
78 | 
79 |   delay(700); // >600ms
80 | 
81 |   Serial.println("Reading New Value...");
82 |   word zdp_after;
83 |   zdp_after = SensorI2C.getZeroDegreePositionData();
84 |   Serial.print("Zero Degree Position After Saving (HEX): ");
85 |   Serial.println(zdp_after, HEX);
86 |   Serial.println();
87 | 
88 |   Serial.println("Program Complete!");
89 | }
90 | 
91 | void loop() {
92 |   // nop
93 | }
94 | 


--------------------------------------------------------------------------------
/examples/MT6701_test/MT6701_test.ino:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * MT6701_test
  3 |  * 
  4 |  * Демонстрация некоторых возможнойстей библиотеки MT6701_I2C.h для датчика MT6701
  5 |  * 
  6 |  * Документация к датчику:
  7 |  * http://www.magntek.com.cn/upload/MT6701_Rev.1.5.pdf
  8 |  * 
  9 |  * Все методы можно посмотреть в файле MT6701_I2C.h или тут
 10 |  * https://github.com/S-LABc/MT6701-Arduino-Library/blob/main/src/MT6701_I2C.h
 11 |  * 
 12 |  * Контакты:
 13 |  ** GitHub - https://github.com/S-LABc
 14 |  ** Gmail - romansklyar15@gmail.com
 15 |  * 
 16 |  * Copyright (C) 2022. v1.1 / Скляр Роман S-LAB
 17 |  */
 18 |  
 19 | #include <MT6701_I2C.h>
 20 | 
 21 | // Раскомментировать для заупска функции сохранения значений
 22 | //#define SAVE_VALUES
 23 | 
 24 | MT6701I2C SensorI2C(&Wire);
 25 |  
 26 | void setup() {
 27 |   Serial.begin(115200);
 28 |   
 29 |   // Запускаем соединение
 30 |   SensorI2C.begin();
 31 |   // Настраиваем шину I2C на 400кГц
 32 |   SensorI2C.setClock();
 33 |   //Можно на друие частоты, но работает не на всех микроконтроллерах
 34 |   //SensorI2C.setClock(MT6701_I2C_CLOCK_100KHZ); // 100кГц
 35 |   //SensorI2C.setClock(MT6701_I2C_CLOCK_1MHZ); // 1МГц
 36 |   //SensorI2C.setClock(725000); // Пользовательское значение 725кГц
 37 | 
 38 |   /*
 39 |    * Если нужно управлять режимами датчика
 40 |    * STM32_MT6701_MODE_PIN   PC13
 41 |    * ESP8266_MT6701_MODE_PIN 2
 42 |    * ESP32_MT6701_MODE_PIN   4
 43 |    * ARDUINO_MT6701_MODE_PIN 3
 44 |    * или любой другой GPIO
 45 |    */
 46 |   //SensorI2C.attachModePin(ARDUINO_MT6701_MODE_PIN); // SensorI2C.detachModePin();
 47 |   //SensorI2C.enableI2CorSSI(); // Включить интерфейс I2C/SSI
 48 |   //SensorI2C.enableUVWorABZ(); // Включить интерфейс UVW/ABZ
 49 |    
 50 |   
 51 |   while(!Serial);
 52 | 
 53 |   while(!SensorI2C.isConnected()) {
 54 |     Serial.println("Датчик не обнаружен");
 55 |     delay(500);
 56 |   }
 57 | }
 58 |  
 59 |  
 60 | void loop() {
 61 | #ifdef SAVE_VALUES
 62 |   saveNewSettings();
 63 | #else
 64 |   readValues();
 65 | #endif
 66 | }
 67 | 
 68 | void readValues() {
 69 |   Serial.print("Raw: ");
 70 |   Serial.println(SensorI2C.getRawAngle());
 71 | 
 72 |   Serial.print("Degrees: ");
 73 |   Serial.println(SensorI2C.getDegreesAngle());
 74 | 
 75 |   Serial.print("Radians: ");
 76 |   Serial.println(SensorI2C.getRadiansAngle());
 77 | 
 78 |   Serial.print("Resolution UVW: ");
 79 |   Serial.println(SensorI2C.getOutputResolutionUVW()); // setOutputResolutionUVW()
 80 | 
 81 |   Serial.print("Resolution ABZ: ");
 82 |   Serial.println(SensorI2C.getOutputResolutionABZ()); // setOutputResolutionABZ()
 83 | 
 84 |   Serial.print("Output Type: ");
 85 |   MT6701I2COutputType output_type = SensorI2C.getOutputType();
 86 |   if(output_type == MT6701I2_OUTPUT_TYPE_ABZ) { // setOutputTypeABZ()
 87 |     Serial.println("ABZ");
 88 |   } else if(output_type == MT6701I2_OUTPUT_TYPE_UVW) { // setOutputTypeUVW()
 89 |     Serial.println("UVW");
 90 |   }
 91 | 
 92 |   Serial.print("Output Mode: ");
 93 |   MT6701I2COutputMode output_mode = SensorI2C.getOutputMode();
 94 |   if(output_mode == MT6701I2_OUTPUT_MODE_ANALOG) { // setOutputModeAnalog()
 95 |     Serial.println("ANALOG");
 96 |   } else if(output_mode == MT6701I2_OUTPUT_MODE_PWM) { // setOutputModePWM()
 97 |     Serial.println("PWM");
 98 |   }
 99 | 
100 |   Serial.print("Rotation Direction: ");
101 |   MT6701I2CDirection output_dir = SensorI2C.getOutputRotationDirection();
102 |   if(output_dir == MT6701I2_DIRECTION_CLOCKWISE) { // setOutputRotationDirectionClockwise()
103 |     Serial.println("CLOCKWISE");
104 |   } else if(output_dir == MT6701I2_DIRECTION_COUNTERCLOCKWISE) { // setOutputRotationDirectionCounterclockwise()
105 |     Serial.println("COUNTERCLOCKWISE");
106 |   }
107 |   
108 |   Serial.println();
109 | 
110 |   delay(200);
111 | }
112 | 
113 | void saveNewSettings() {
114 |   Serial.print("Write Resolution ABZ: ");
115 |   word new_res_abz = 732;
116 |   if(SensorI2C.setOutputResolutionABZVerify(new_res_abz)) {
117 |     Serial.println("OK");
118 |   } else {
119 |     Serial.println("ERROR");
120 |   }
121 | 
122 |   Serial.print("Write Output Mode PWM: ");
123 |   if(SensorI2C.setOutputModePWMVerify()) {
124 |     Serial.println("OK");
125 |   } else {
126 |     Serial.println("ERROR");
127 |   }
128 | 
129 |   Serial.print("Write Rotation Direction Clockwise: ");
130 |   if(SensorI2C.setOutputRotationDirectionClockwiseVerify()) {
131 |     Serial.println("OK");
132 |   } else {
133 |     Serial.println("ERROR");
134 |   }
135 | 
136 |   Serial.println("Saving New Values...");
137 |   SensorI2C.saveNewValues();
138 |   delay(700); // >600мс
139 |   Serial.println("Saved Successfully. Reconnect Power");
140 |   
141 |   while(1);
142 | }
143 | 


--------------------------------------------------------------------------------
/images/mt6701_module.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/S-LABc/MT6701-Arduino-Library/cb1b78f444c997c26c24278a4ba3a96aa3192881/images/mt6701_module.jpg


--------------------------------------------------------------------------------
/keywords.txt:
--------------------------------------------------------------------------------
  1 | #######################################
  2 | # Syntax Coloring Map For MT6701_I2C
  3 | #######################################
  4 | 
  5 | #######################################
  6 | # Datatypes (KEYWORD1)
  7 | #######################################
  8 | 
  9 | MT6701_I2C	KEYWORD1
 10 | SensorI2C	KEYWORD1
 11 | 
 12 | #######################################
 13 | # Methods and Functions (KEYWORD2)
 14 | #######################################
 15 | 
 16 | MT6701I2C	KEYWORD2
 17 | 
 18 | begin	KEYWORD2
 19 | setClock	KEYWORD2
 20 | end	KEYWORD2
 21 | 
 22 | saveNewValues	KEYWORD2
 23 | 
 24 | isConnected	KEYWORD2
 25 | 
 26 | attachModePin	KEYWORD2
 27 | detachModePin	KEYWORD2
 28 | 
 29 | enableI2CorSSI	KEYWORD2
 30 | enableUVWorABZ	KEYWORD2
 31 | 
 32 | getRawAngle	KEYWORD2
 33 | getDegreesAngle	KEYWORD2
 34 | getRadiansAngle	KEYWORD2
 35 | 
 36 | getConfigurationOutputType	KEYWORD2
 37 | setConfigurationOutputTypeABZ	KEYWORD2
 38 | setConfigurationOutputTypeABZVerify	KEYWORD2
 39 | setConfigurationOutputTypeUVW	KEYWORD2
 40 | setConfigurationOutputTypeUVWVerify	KEYWORD2
 41 | 
 42 | getOutputType	KEYWORD2
 43 | setOutputTypeABZ	KEYWORD2
 44 | setOutputTypeABZVerify	KEYWORD2
 45 | setOutputTypeUVW	KEYWORD2
 46 | setOutputTypeUVWVerify	KEYWORD2
 47 | 
 48 | getOutputRotationDirection	KEYWORD2
 49 | setOutputRotationDirectionCounterclockwise	KEYWORD2
 50 | setOutputRotationDirectionCounterclockwiseVerify	KEYWORD2
 51 | setOutputRotationDirectionClockwise	KEYWORD2
 52 | setOutputRotationDirectionClockwiseVerify	KEYWORD2
 53 | 
 54 | getOutputResolutionUVW	KEYWORD2
 55 | setOutputResolutionUVW	KEYWORD2
 56 | setOutputResolutionUVWVerify	KEYWORD2
 57 | 
 58 | getOutputResolutionABZ	KEYWORD2
 59 | setOutputResolutionABZ	KEYWORD2
 60 | setOutputResolutionABZVerify	KEYWORD2
 61 | 
 62 | getZPulseWidth	KEYWORD2
 63 | setZPulseWidth1LSB	KEYWORD2
 64 | setZPulseWidth1LSBVerify	KEYWORD2
 65 | setZPulseWidth2LSB	KEYWORD2
 66 | setZPulseWidth2LSBVerify	KEYWORD2
 67 | setZPulseWidth4LSB	KEYWORD2
 68 | setZPulseWidth4LSBVerify	KEYWORD2
 69 | setZPulseWidth8LSB	KEYWORD2
 70 | setZPulseWidth8LSBVerify	KEYWORD2
 71 | setZPulseWidth12LSB	KEYWORD2
 72 | setZPulseWidth12LSBVerify	KEYWORD2
 73 | setZPulseWidth16LSB	KEYWORD2
 74 | setZPulseWidth16LSBVerify	KEYWORD2
 75 | setZPulseWidth180DEG	KEYWORD2
 76 | setZPulseWidth180DEGVerify	KEYWORD2
 77 | 
 78 | getZeroDegreePositionData	KEYWORD2
 79 | setZeroDegreePositionData	KEYWORD2
 80 | setZeroDegreePositionDataVerify	KEYWORD2
 81 | 
 82 | getFrequencyPWM	KEYWORD2
 83 | setFrequencyPWM9944	KEYWORD2
 84 | setFrequencyPWM9944Verify	KEYWORD2
 85 | setFrequencyPWM4972	KEYWORD2
 86 | setFrequencyPWM4972Verify	KEYWORD2
 87 | 
 88 | getPolarityPWM	KEYWORD2
 89 | setPolarityPWMHigh	KEYWORD2
 90 | setPolarityPWMHighVerify	KEYWORD2
 91 | setPolarityPWMLow	KEYWORD2
 92 | setPolarityPWMLowVerify	KEYWORD2
 93 | 
 94 | getOutputMode	KEYWORD2
 95 | setOutputModeAnalog	KEYWORD2
 96 | setOutputModeAnalogVerify	KEYWORD2
 97 | setOutputModePWM	KEYWORD2
 98 | setOutputModePWMVerify	KEYWORD2
 99 | 
100 | #######################################
101 | # Constants (LITERAL1)
102 | #######################################
103 | 
104 | MT6701_I2C_CLOCK_100KHZ	LITERAL1
105 | MT6701_I2C_CLOCK_400KHZ	LITERAL1
106 | MT6701_I2C_CLOCK_1MHZ	LITERAL1
107 | MT6701_I2C_ADDRESS	LITERAL1
108 | 
109 | STM32_MT6701_MODE_PIN	LITERAL1
110 | ESP8266_MT6701_MODE_PIN	LITERAL1
111 | ESP32_MT6701_MODE_PIN	LITERAL1
112 | ARDUINO_MT6701_MODE_PIN	LITERAL1
113 | 
114 | MT6701_I2C_ANGLE_DATA_REG_H	LITERAL1
115 | MT6701_I2C_ANGLE_DATA_REG_L	LITERAL1
116 | 
117 | MT6701_I2C_EEPROM_UVW_MUX_REG	LITERAL1
118 | MT6701_I2C_EEPROM_UVW_MUX_BIT	LITERAL1
119 | 
120 | MT6701_I2C_EEPROM_ABZ_MUX_DIR_REG	LITERAL1
121 | MT6701_I2C_EEPROM_ABZ_MUX_BIT	LITERAL1
122 | 
123 | MT6701_I2C_EEPROM_DIR_REG	LITERAL1
124 | MT6701_I2C_EEPROM_DIR_BIT	LITERAL1
125 | 
126 | MT6701_I2C_EEPROM_UVW_RES_REG	LITERAL1
127 | MT6701_I2C_EEPROM_UVW_MUX_BIT_S	LITERAL1
128 | 
129 | MT6701_I2C_EEPROM_ABZ_RES_REG_H	LITERAL1
130 | MT6701_I2C_EEPROM_ABZ_RES_REG_L	LITERAL1
131 | MT6701_I2C_EEPROM_ABZ_MUX_BIT_S	LITERAL1
132 | 
133 | MT6701_I2C_EEPROM_HYST_REG_H	LITERAL1
134 | MT6701_I2C_EEPROM_HYST_REG_L	LITERAL1
135 | 
136 | MT6701_I2C_EEPROM_Z_PULSE_WIDTH_REG	LITERAL1
137 | MT6701_I2C_EEPROM_Z_PULSE_WIDTH_BIT_S	LITERAL1
138 | 
139 | MT6701_I2C_EEPROM_ZERO_REG_H	LITERAL1
140 | MT6701_I2C_EEPROM_ZERO_REG_L	LITERAL1
141 | 
142 | MT6701_I2C_EEPROM_PWM_FREQ_REG	LITERAL1
143 | MT6701_I2C_EEPROM_PWM_FREQ_BIT	LITERAL1
144 | 
145 | MT6701_I2C_EEPROM_PWM_POL_REG	LITERAL1
146 | MT6701_I2C_EEPROM_PWM_POL_BIT	LITERAL1
147 | 
148 | MT6701_I2C_EEPROM_OUT_MODE_REG	LITERAL1
149 | MT6701_I2C_EEPROM_OUT_MODE_BIT	LITERAL1
150 | 
151 | MT6701_I2C_EEPROM_A_START_REG_H	LITERAL1
152 | MT6701_I2C_EEPROM_A_START_REG_L	LITERAL1
153 | 
154 | MT6701_I2C_EEPROM_A_STOP_REG_H	LITERAL1
155 | MT6701_I2C_EEPROM_A_STOP_REG_L	LITERAL1
156 | MT6701_I2C_EEPROM_A_STOP_BIT_S	LITERAL1
157 | 
158 | MT6701_I2C_EEPROM_PROG_KEY_REG	LITERAL1
159 | MT6701_I2C_EEPROM_PROG_KEY_VALUE	LITERAL1
160 | MT6701_I2C_EEPROM_PROG_CMD_REG	LITERAL1
161 | MT6701_I2C_EEPROM_PROG_CMD_VALUE	LITERAL1
162 | 
163 | MT6701I2CConfigurationOutputType	LITERAL1
164 | MT6701I2_CONFIG_OUTPUT_TYPE_UVW	LITERAL1
165 | MT6701I2_CONFIG_OUTPUT_TYPE_A_B_Z	LITERAL1
166 | 
167 | MT6701I2COutputType	LITERAL1
168 | MT6701I2_OUTPUT_TYPE_ABZ	LITERAL1
169 | MT6701I2_OUTPUT_TYPE_UVW	LITERAL1
170 | 
171 | MT6701I2CDirection	LITERAL1
172 | MT6701I2_DIRECTION_COUNTERCLOCKWISE	LITERAL1
173 | MT6701I2_DIRECTION_CLOCKWISE	LITERAL1
174 | 
175 | MT6701I2CZPulseWidth	LITERAL1
176 | MT6701I2_Z_PULSE_WIDTH_1LSB	LITERAL1
177 | MT6701I2_Z_PULSE_WIDTH_2LSB	LITERAL1
178 | MT6701I2_Z_PULSE_WIDTH_4LSB	LITERAL1
179 | MT6701I2_Z_PULSE_WIDTH_8LSB	LITERAL1
180 | MT6701I2_Z_PULSE_WIDTH_12LSB	LITERAL1
181 | MT6701I2_Z_PULSE_WIDTH_16LSB	LITERAL1
182 | MT6701I2_Z_PULSE_WIDTH_180DEG	LITERAL1
183 | MT6701I2_Z_PULSE_WIDTH_1LSB_2	LITERAL1
184 | 
185 | MT6701I2CFrequencyPWM	LITERAL1
186 | MT6701I2_PWM_FREQUENCY_9944	LITERAL1
187 | MT6701I2_PWM_FREQUENCY_4972	LITERAL1
188 | 
189 | MT6701I2CPolarityPWM	LITERAL1
190 | MT6701I2_PWM_POLARITY_HIGH	LITERAL1
191 | MT6701I2_PWM_POLARITY_LOW	LITERAL1
192 | 
193 | MT6701I2COutputMode	LITERAL1
194 | MT6701I2_OUTPUT_MODE_ANALOG	LITERAL1
195 | MT6701I2_OUTPUT_MODE_PWM	LITERAL1
196 | 
197 | MT6701I2C_DEFAULT_REPORT_ERROR	LITERAL1
198 | MT6701I2C_DEFAULT_REPORT_OK	LITERAL1
199 | 
200 | MT6701I2C_MODE_I2C_SSI	LITERAL1
201 | MT6701I2C_MODE_UVW_ABZ	LITERAL1


--------------------------------------------------------------------------------
/library.properties:
--------------------------------------------------------------------------------
 1 | name=MT6701
 2 | version=1.3
 3 | author=Roman Sklyar S-LAB <romansklyar15@gmail.com>
 4 | maintainer=Roman Sklyar <romansklyar15@gmail.com>
 5 | sentence=API for a 14-Bit Hall Based Angle Position Encoder Sensor
 6 | paragraph=Implements I2C interface MagnTek MT6701
 7 | category=Sensors
 8 | url=https://github.com/S-LABc/MT6701-Arduino-Library
 9 | architectures=*
10 | includes=MT6701_I2C.h


--------------------------------------------------------------------------------
/src/MT6701_I2C.cpp:
--------------------------------------------------------------------------------
  1 | /* 
  2 |  * Класс для Arduino IDE реализующий множество методов
  3 |  * взаимодействия с бесконтактным датчиком положения
  4 |  * MT6701 от компании MagnTek http://www.magntek.com.cn/en/index.htm
  5 |  * 
  6 |  * Документация к датчику:
  7 |  ** http://www.magntek.com.cn/en/list/177/559.htm
  8 |  ** http://www.magntek.com.cn/upload/MT6701_Rev.1.5.pdf
  9 |  * 
 10 |  * Контакты:
 11 |  ** GitHub - https://github.com/S-LABc
 12 |  ** Gmail - romansklyar15@gmail.com
 13 |  * 
 14 |  * Copyright (C) 2022. v1.2 / License MIT / Скляр Роман S-LAB
 15 |  */
 16 | 
 17 | #include "MT6701_I2C.h"
 18 | 
 19 | // ########## CONSTRUCTOR ##########
 20 | /*
 21 |  * @brief: использовать только интерфейс I2C
 22 |  * @param _twi: доступ к методам объекта Wire
 23 |  */
 24 | MT6701I2C::MT6701I2C(TwoWire* _twi) : _wire_(_twi ? _twi : &Wire) {
 25 |   // Ничего
 26 | }
 27 | /* 
 28 |  * @brief: запросить один байт данных из буфера
 29 |  * @param _reg_addr: 1 байт адреса регистра
 30 |  * @return: значение байта из регистра, который был запрошен
 31 |  * @note: использовать для одиночного регистра, например 0x29
 32 |  */
 33 | uint8_t MT6701I2C::MT_RequestSingleRegister(uint8_t _reg_addr) {
 34 |   uint8_t single_byte = 0;
 35 | 
 36 |   // Начать передачу по адресу
 37 |   _wire_->beginTransmission(MT6701_I2C_ADDRESS);
 38 |   // Отправить байт регистра
 39 |   _wire_->write(_reg_addr);
 40 |   // Завершить соединение
 41 |   _wire_->endTransmission();
 42 |   
 43 |   // Запросить байт данных по адресу
 44 |   _wire_->requestFrom(MT6701_I2C_ADDRESS, (uint8_t)1);
 45 |   // Прочитать данные из буфера
 46 |   if (_wire_->available() >= 1 ) {
 47 |     single_byte = _wire_->read();
 48 |   }
 49 |   // Завершить соединение
 50 |   _wire_->endTransmission();
 51 | 
 52 |   return single_byte;
 53 | }
 54 | /*
 55 |  * @brief: записать значение размером 1 байт в произвольный регистр размером 1 байт
 56 |  * @param _reg_addr: 1 байт адреса регистра
 57 |  * @param _payload: 1 байт полезных данных
 58 |  */
 59 | void MT6701I2C::MT_WriteOneByte(uint8_t _reg_addr, uint8_t _payload) {
 60 |   // Начать передачу по адресу для прередачи байта данных в регистр
 61 |   _wire_->beginTransmission(MT6701_I2C_ADDRESS);
 62 |   _wire_->write(_reg_addr);
 63 |   _wire_->write(_payload);
 64 |   // Завершить соединение
 65 |   _wire_->endTransmission();
 66 | }
 67 | 
 68 | // ########## PUBLIC ##########
 69 | /* 
 70 |  * @brief: вызов метода Wire.begin()
 71 |  * @note: использовать, если действие не было выполнено ранее
 72 |  */
 73 | void MT6701I2C::begin(void) {
 74 |   _wire_->begin();
 75 | }
 76 | /* 
 77 |  * @brief: вызов метода Wire.begin(SDA, SCL) с указанием выводов
 78 |  * @param _sda_pin: пользовательский контакт SDA
 79 |  * @param _scl_pin: пользовательский контакт SCL
 80 |  * @note: использовать, если действие не было выполнено ранее.
 81 |  *   Применимо для платформ на базе ESP8266 и ESP32
 82 |  */
 83 | #if defined(ESP8266) || defined(ESP32)
 84 | void MT6701I2C::begin(int8_t _sda_pin, int8_t _scl_pin) {
 85 |   _wire_->begin(_sda_pin, _scl_pin);
 86 | }
 87 | #endif
 88 | 
 89 | #if defined(ARDUINO_ARCH_STM32)
 90 | void MT6701I2C::begin(int8_t _sda_pin, int8_t _scl_pin) {
 91 |   _wire_->setSDA(_sda_pin);
 92 |   _wire_->setSCL(_scl_pin);
 93 |   _wire_->begin();
 94 | }
 95 | #endif
 96 | /* 
 97 |  * @brief: настройка произвольной частоты шины I2C (по умолчанию 400кГц)
 98 |  * @note: использовать, если частота шины меняется из-за разных устройств
 99 |  */
100 | void MT6701I2C::setClock(uint32_t _clock) {
101 |   _wire_->setClock(_clock);
102 | }
103 | /*
104 |  * @brief: сохраняет данные в EEPROM памяти датчика
105 |  * @note: назначение каждой команды не описано в документации, порядок команд описан в 7.2 EEPROM Programming
106 |  *  рекомендуется выполнять эту операцию при напряжении питания от 4.5В до 5.5В
107 |  */
108 | void MT6701I2C::saveNewValues(void) {
109 |   // Начать передачу по адресу
110 |   _wire_->beginTransmission(MT6701_I2C_ADDRESS);
111 |   // Отправить 0x09
112 |   _wire_->write(MT6701_I2C_EEPROM_PROG_KEY_REG);
113 |   // Отправить 0xB3
114 |   _wire_->write(MT6701_I2C_EEPROM_PROG_KEY_VALUE);
115 |   // Завершить соединение
116 |   _wire_->endTransmission();
117 |   
118 |   // Начать передачу по адресу
119 |   _wire_->beginTransmission(MT6701_I2C_ADDRESS);
120 |   // Отправить 0x0A
121 |   _wire_->write(MT6701_I2C_EEPROM_PROG_CMD_REG);
122 |   // Отправить 0x05
123 |   _wire_->write(MT6701_I2C_EEPROM_PROG_CMD_VALUE);
124 |   // Завершить соединение
125 |   _wire_->endTransmission();
126 | }
127 | /*
128 |  * @brief: узнать подкючен ли датчик к линии I2C
129 |  * @note: используется алгоритм стандартного поиска устройств на шина I2C
130 |  * @return:
131 |  *  MT6701I2C_DEFAULT_REPORT_ERROR - не подключен
132 |  *  MT6701I2C_DEFAULT_REPORT_OK - подключен
133 |  */
134 | bool MT6701I2C::isConnected(void) {
135 |   // Начать передачу по адресу
136 |   _wire_->beginTransmission(MT6701_I2C_ADDRESS);
137 |   return (!_wire_->endTransmission(MT6701_I2C_ADDRESS)) ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR;
138 | }
139 | /*
140 |  * @brief: назначить контакт микроконтроллера для управления режимом интерфейса
141 |  * @param _pin_mode: контакт микроконтроллера к которому подключен контакт MODE датчика
142 |  */
143 | void MT6701I2C::attachModePin(byte _pin_mode) {
144 |   _pin_mode_ = _pin_mode;
145 |   pinMode(_pin_mode_, OUTPUT);
146 | }
147 | /*
148 |  * @brief: освоободить назначенный контакт микроконтроллера для управления режимом интерфейса
149 |  */
150 | void MT6701I2C::detachModePin(void) {
151 |   pinMode(_pin_mode_, INPUT);
152 |   _pin_mode_ = -1;
153 | }
154 | /* 
155 |  * @brief: включить интерфейс I2C/SSI
156 |  */
157 | void MT6701I2C::enableI2CorSSI(void) {
158 |   digitalWrite(_pin_mode_, MT6701I2C_MODE_I2C_SSI);
159 | }
160 | /* 
161 |  * @brief: включить интерфейс UVW/ABZ
162 |  */
163 | void MT6701I2C::enableUVWorABZ(void) {
164 |   digitalWrite(_pin_mode_, MT6701I2C_MODE_UVW_ABZ);
165 | }
166 | /* 
167 |  * @brief: получить чистое значение угла из Angle Data Register(13:0)
168 |  * @return:
169 |  *  0 - 16383
170 |  */
171 | word MT6701I2C::getRawAngle(void) {
172 |   uint8_t high_byte = MT_RequestSingleRegister(MT6701_I2C_ANGLE_DATA_REG_H);
173 |   uint8_t low_byte = MT_RequestSingleRegister(MT6701_I2C_ANGLE_DATA_REG_L);
174 |   return (word)(high_byte << 6) | (low_byte >> 2);
175 | }
176 | /* 
177 |  * @brief: получить значение угла в градусах
178 |  * @return:
179 |  *  0.00 - 359.98
180 |  */
181 | float MT6701I2C::getDegreesAngle(void) {
182 |   return ((float)getRawAngle() * 360) / 16384;
183 | }
184 | /* 
185 |  * @brief: получить значение угла в радианах
186 |  * @return:
187 |  *  0.00 - 6.28319
188 |  */
189 | float MT6701I2C::getRadiansAngle(void) {
190 |   return (getDegreesAngle() * M_PI) / 180;
191 | }
192 | /* 
193 |  * @brief: получить тип конфигурации выходного интерфейса
194 |  * @note: только для корпуса QFN
195 |  * @return:
196 |  *  MT6701I2_OUTPUT_TYPE_A_B_Z
197 |  *  MT6701I2_OUTPUT_TYPE_UVW
198 |  */
199 | MT6701I2CConfigurationOutputType MT6701I2C::getConfigurationOutputType(void) {
200 |   return (MT6701I2CConfigurationOutputType)((MT_RequestSingleRegister(MT6701_I2C_EEPROM_UVW_MUX_REG) >> MT6701_I2C_EEPROM_UVW_MUX_BIT) & 0x01);
201 | }
202 | /* 
203 |  * @brief: установить тип конфигурации выходного интерфейса -A-B-Z
204 |  * @note: только для корпуса QFN
205 |  */
206 | void MT6701I2C::setConfigurationOutputTypeABZ(void) {
207 |   uint8_t bkup = MT_RequestSingleRegister(MT6701_I2C_EEPROM_UVW_MUX_REG);
208 |   bkup &= ~(1 << MT6701_I2C_EEPROM_UVW_MUX_BIT);
209 |   MT_WriteOneByte(MT6701_I2C_EEPROM_UVW_MUX_REG, bkup);
210 | }
211 | /* 
212 |  * @brief: установить тип конфигурации выходного интерфейса -A-B-Z с проверкой
213 |  * @note: только для корпуса QFN
214 |  * @return:
215 |  *  MT6701I2C_DEFAULT_REPORT_ERROR - не установлено
216 |  *  MT6701I2C_DEFAULT_REPORT_OK - установлено
217 |  */
218 | bool MT6701I2C::setConfigurationOutputTypeABZVerify(void) {
219 |   setConfigurationOutputTypeABZ();
220 |   return getConfigurationOutputType() ? MT6701I2C_DEFAULT_REPORT_ERROR : MT6701I2C_DEFAULT_REPORT_OK;
221 | }
222 | /* 
223 |  * @brief: установить тип конфигурации выходного интерфейса UVW
224 |  * @note: только для корпуса QFN
225 |  */
226 | void MT6701I2C::setConfigurationOutputTypeUVW(void) {
227 |   uint8_t bkup = MT_RequestSingleRegister(MT6701_I2C_EEPROM_UVW_MUX_REG);
228 |   bkup |= 1 << MT6701_I2C_EEPROM_UVW_MUX_BIT;
229 |   MT_WriteOneByte(MT6701_I2C_EEPROM_UVW_MUX_REG, bkup);
230 | }
231 | /* 
232 |  * @brief: установить тип конфигурации выходного интерфейса UVW с проверкой
233 |  * @note: только для корпуса QFN
234 |  * @return:
235 |  *  MT6701I2C_DEFAULT_REPORT_ERROR - не установлено
236 |  *  MT6701I2C_DEFAULT_REPORT_OK - установлено
237 |  */
238 | bool MT6701I2C::setConfigurationOutputTypeUVWVerify(void) {
239 |   setConfigurationOutputTypeUVW();
240 |   return getConfigurationOutputType() ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR;
241 | }
242 | /* 
243 |  * @brief: получить значение типа выходного интерфейса
244 |  * @return:
245 |  *  MT6701I2_OUTPUT_TYPE_ABZ
246 |  *  MT6701I2_OUTPUT_TYPE_UVW
247 |  */
248 | MT6701I2COutputType MT6701I2C::getOutputType(void) {
249 |   return (MT6701I2COutputType)((MT_RequestSingleRegister(MT6701_I2C_EEPROM_ABZ_MUX_REG) >> MT6701_I2C_EEPROM_ABZ_MUX_BIT) & 0x01);
250 | }
251 | /* 
252 |  * @brief: установить тип выходного интерфейса ABZ
253 |  */
254 | void MT6701I2C::setOutputTypeABZ(void) {
255 |   uint8_t bkup = MT_RequestSingleRegister(MT6701_I2C_EEPROM_ABZ_MUX_REG);
256 |   bkup &= ~(1 << MT6701_I2C_EEPROM_ABZ_MUX_BIT);
257 |   MT_WriteOneByte(MT6701_I2C_EEPROM_ABZ_MUX_REG, bkup);
258 | }
259 | /* 
260 |  * @brief: установить тип выходного интерфейса ABZ с проверкой
261 |  * @return:
262 |  *  MT6701I2C_DEFAULT_REPORT_ERROR - не установлено
263 |  *  MT6701I2C_DEFAULT_REPORT_OK - установлено
264 |  */
265 | bool MT6701I2C::setOutputTypeABZVerify(void) {
266 |   setOutputTypeABZ();
267 |   return getOutputType() ? MT6701I2C_DEFAULT_REPORT_ERROR : MT6701I2C_DEFAULT_REPORT_OK;
268 | }
269 | /* 
270 |  * @brief: установить тип выходного интерфейса UVW
271 |  */
272 | void MT6701I2C::setOutputTypeUVW(void) {
273 |   uint8_t bkup = MT_RequestSingleRegister(MT6701_I2C_EEPROM_ABZ_MUX_REG);
274 |   bkup |= 1 << MT6701_I2C_EEPROM_ABZ_MUX_BIT;
275 |   MT_WriteOneByte(MT6701_I2C_EEPROM_ABZ_MUX_REG, bkup);
276 | }
277 | /* 
278 |  * @brief: установить тип выходного интерфейса UVW с проверкой
279 |  * @return:
280 |  *  MT6701I2C_DEFAULT_REPORT_ERROR - не установлено
281 |  *  MT6701I2C_DEFAULT_REPORT_OK - установлено
282 |  */
283 | bool MT6701I2C::setOutputTypeUVWVerify(void) {
284 |   setOutputTypeUVW();
285 |   return getOutputType() ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR;
286 | }
287 | /* 
288 |  * @brief: получить значение положительного направления вращения
289 |  * @return:
290 |  *  MT6701I2_DIRECTION_COUNTERCLOCKWISE
291 |  *  MT6701I2_DIRECTION_CLOCKWISE
292 |  */
293 | MT6701I2CDirection MT6701I2C::getOutputRotationDirection(void) {
294 |   return (MT6701I2CDirection)((MT_RequestSingleRegister(MT6701_I2C_EEPROM_DIR_REG) >> MT6701_I2C_EEPROM_DIR_BIT) & 0x01);
295 | }
296 | /* 
297 |  * @brief: установить положительное направление вращения против часовой стрелки
298 |  */
299 | void MT6701I2C::setOutputRotationDirectionCounterclockwise(void) {
300 |   uint8_t bkup = MT_RequestSingleRegister(MT6701_I2C_EEPROM_DIR_REG);
301 |   bkup &= ~(1 << MT6701_I2C_EEPROM_DIR_BIT);
302 |   MT_WriteOneByte(MT6701_I2C_EEPROM_DIR_REG, bkup);
303 | }
304 | /* 
305 |  * @brief: установить положительное направление вращения против часовой стрелки с проверкой
306 |  * @return:
307 |  *  MT6701I2C_DEFAULT_REPORT_ERROR - не установлено
308 |  *  MT6701I2C_DEFAULT_REPORT_OK - установлено
309 |  */
310 | bool MT6701I2C::setOutputRotationDirectionCounterclockwiseVerify(void) {
311 |   setOutputRotationDirectionCounterclockwise();
312 |   return getOutputRotationDirection() ? MT6701I2C_DEFAULT_REPORT_ERROR : MT6701I2C_DEFAULT_REPORT_OK;
313 | }
314 | /* 
315 |  * @brief: установить положительное направление вращения по часовой стрелке
316 |  */
317 | void MT6701I2C::setOutputRotationDirectionClockwise(void) {
318 |   uint8_t bkup =MT_RequestSingleRegister(MT6701_I2C_EEPROM_DIR_REG);
319 |   bkup |= 1 << MT6701_I2C_EEPROM_DIR_BIT;
320 |   MT_WriteOneByte(MT6701_I2C_EEPROM_DIR_REG, bkup);
321 | }
322 | /* 
323 |  * @brief: установить положительное направление вращения по часовой стрелке с проверкой
324 |  * @return:
325 |  *  MT6701I2C_DEFAULT_REPORT_ERROR - не установлено
326 |  *  MT6701I2C_DEFAULT_REPORT_OK - установлено
327 |  */
328 | bool MT6701I2C::setOutputRotationDirectionClockwiseVerify(void) {
329 |   setOutputRotationDirectionClockwise();
330 |   return getOutputRotationDirection() ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR;
331 | }
332 | /* 
333 |  * @brief: получить значение выходного разрешения в режиме UVW
334 |  * @return:
335 |  *  1 - 16
336 |  */
337 | byte MT6701I2C::getOutputResolutionUVW(void) {
338 |   return ((MT_RequestSingleRegister(MT6701_I2C_EEPROM_UVW_RES_REG) >> MT6701_I2C_EEPROM_UVW_MUX_BIT_S) & 0x0F) + 1; // 0x0F = 0b00001111, +1 для смещения в диапазон 1-16
339 | }
340 | /* 
341 |  * @brief: установить значение выходного разрешения в режиме UVW
342 |  * @param _resolution:
343 |  *  1 - 16
344 |  */
345 | void MT6701I2C::setOutputResolutionUVW(byte _resolution) {
346 |   uint8_t bkup = MT_RequestSingleRegister(MT6701_I2C_EEPROM_UVW_RES_REG);
347 |   bkup |= (_resolution - 1) << MT6701_I2C_EEPROM_UVW_MUX_BIT_S; // -1 для смещения в диапазон 0-15
348 |   MT_WriteOneByte(MT6701_I2C_EEPROM_UVW_RES_REG, bkup);
349 | }
350 | /* 
351 |  * @brief: установить значение выходного разрешения в режиме UVW с проверкой
352 |  * @param _resolution:
353 |  *  1 - 16
354 |  * @return:
355 |  *  MT6701I2C_DEFAULT_REPORT_ERROR - не установлено
356 |  *  MT6701I2C_DEFAULT_REPORT_OK - установлено
357 |  */
358 | bool MT6701I2C::setOutputResolutionUVWVerify(byte _resolution) {
359 |   setOutputResolutionUVW(_resolution);
360 |   return getOutputResolutionUVW() == _resolution ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR;
361 | }
362 | /* 
363 |  * @brief: получить значение выходного разрешения в режиме ABZ
364 |  * @return:
365 |  *  1 - 1024
366 |  */
367 | word MT6701I2C::getOutputResolutionABZ(void) {
368 |   uint8_t reg_h = MT_RequestSingleRegister(MT6701_I2C_EEPROM_ABZ_RES_REG_H) & 0x03; // 0x03 = 0b00000011
369 |   return (word)((reg_h << 8) | MT_RequestSingleRegister(MT6701_I2C_EEPROM_ABZ_RES_REG_L)) + 1; // +1 для смещения в диапазон 1-1024
370 | }
371 | /* 
372 |  * @brief: установить значение выходного разрешения в режиме ABZ
373 |  * @param _resolution:
374 |  *  1 - 1024
375 |  */
376 | void MT6701I2C::setOutputResolutionABZ(word _resolution) {
377 |   uint8_t reg_l = (_resolution - 1) & 0xFF;
378 |   uint8_t reg_h = MT_RequestSingleRegister(MT6701_I2C_EEPROM_ABZ_RES_REG_H);
379 |   reg_h &= ~0x03; // исправление от dRon
380 |   reg_h |= ((_resolution - 1) >> 8) & 0x03;
381 |   MT_WriteOneByte(MT6701_I2C_EEPROM_ABZ_RES_REG_H, reg_h);
382 |   MT_WriteOneByte(MT6701_I2C_EEPROM_ABZ_RES_REG_L, reg_l);
383 | }
384 | /* 
385 |  * @brief: установить значение выходного разрешения в режиме ABZ с проверкой
386 |  * @param _resolution:
387 |  *  1 - 1024
388 |  * @return:
389 |  *  MT6701I2C_DEFAULT_REPORT_ERROR - не установлено
390 |  *  MT6701I2C_DEFAULT_REPORT_OK - установлено
391 |  */
392 | bool MT6701I2C::setOutputResolutionABZVerify(word _resolution) {
393 |   setOutputResolutionABZ(_resolution);
394 |   return getOutputResolutionABZ() == _resolution ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR;
395 | }
396 | 
397 | 
398 | /* 
399 |  * @brief: получить значение ширины импульса Z в режиме ABZ
400 |  * @return:
401 |  *  MT6701I2_Z_PULSE_WIDTH_1LSB
402 |  *  MT6701I2_Z_PULSE_WIDTH_2LSB
403 |  *  MT6701I2_Z_PULSE_WIDTH_4LSB
404 |  *  MT6701I2_Z_PULSE_WIDTH_8LSB
405 |  *  MT6701I2_Z_PULSE_WIDTH_12LSB
406 |  *  MT6701I2_Z_PULSE_WIDTH_16LSB
407 |  *  MT6701I2_Z_PULSE_WIDTH_180DEG
408 |  *  MT6701I2_Z_PULSE_WIDTH_1LSB_2
409 |  */
410 | MT6701I2CZPulseWidth MT6701I2C::getZPulseWidth(void) {
411 |   return (MT6701I2CZPulseWidth)((MT_RequestSingleRegister(MT6701_I2C_EEPROM_Z_PULSE_WIDTH_REG) >> MT6701_I2C_EEPROM_Z_PULSE_WIDTH_BIT_S) & 0x07); // 0x07 = 0b00000111
412 | }
413 | /*
414 |  * @brief: установить ширину импульса Z 1LSB
415 |  */
416 | void MT6701I2C::setZPulseWidth1LSB(void) {
417 |   uint8_t bkup = MT_RequestSingleRegister(MT6701_I2C_EEPROM_Z_PULSE_WIDTH_REG);
418 |   bkup |= MT6701I2_Z_PULSE_WIDTH_1LSB << MT6701_I2C_EEPROM_Z_PULSE_WIDTH_BIT_S;
419 |   MT_WriteOneByte(MT6701_I2C_EEPROM_Z_PULSE_WIDTH_REG, bkup);
420 | }
421 | /*
422 |  * @brief: установить ширину импульса Z 1LSB с проверкой
423 |  * @return:
424 |  *  MT6701I2C_DEFAULT_REPORT_ERROR - не установлено
425 |  *  MT6701I2C_DEFAULT_REPORT_OK - установлено
426 |  */
427 | bool MT6701I2C::setZPulseWidth1LSBVerify(void) {
428 |   setZPulseWidth1LSB();
429 |   return getZPulseWidth() == MT6701I2_Z_PULSE_WIDTH_1LSB ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR;
430 | }
431 | /*
432 |  * @brief: установить ширину импульса Z 2LSB
433 |  */
434 | void MT6701I2C::setZPulseWidth2LSB(void) {
435 |   uint8_t bkup = MT_RequestSingleRegister(MT6701_I2C_EEPROM_Z_PULSE_WIDTH_REG);
436 |   bkup |= MT6701I2_Z_PULSE_WIDTH_2LSB << MT6701_I2C_EEPROM_Z_PULSE_WIDTH_BIT_S;
437 |   MT_WriteOneByte(MT6701_I2C_EEPROM_Z_PULSE_WIDTH_REG, bkup);
438 | }
439 | /*
440 |  * @brief: установить ширину импульса Z 2LSB с проверкой
441 |  * @return:
442 |  *  MT6701I2C_DEFAULT_REPORT_ERROR - не установлено
443 |  *  MT6701I2C_DEFAULT_REPORT_OK - установлено
444 |  */
445 | bool MT6701I2C::setZPulseWidth2LSBVerify(void) {
446 |   setZPulseWidth2LSB();
447 |   return getZPulseWidth() == MT6701I2_Z_PULSE_WIDTH_2LSB ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR;
448 | }
449 | /*
450 |  * @brief: установить ширину импульса Z 4LSB
451 |  */
452 | void MT6701I2C::setZPulseWidth4LSB(void) {
453 |   uint8_t bkup = MT_RequestSingleRegister(MT6701_I2C_EEPROM_Z_PULSE_WIDTH_REG);
454 |   bkup |= MT6701I2_Z_PULSE_WIDTH_4LSB << MT6701_I2C_EEPROM_Z_PULSE_WIDTH_BIT_S;
455 |   MT_WriteOneByte(MT6701_I2C_EEPROM_Z_PULSE_WIDTH_REG, bkup);
456 | }
457 | /*
458 |  * @brief: установить ширину импульса Z 4LSB с проверкой
459 |  * @return:
460 |  *  MT6701I2C_DEFAULT_REPORT_ERROR - не установлено
461 |  *  MT6701I2C_DEFAULT_REPORT_OK - установлено
462 |  */
463 | bool MT6701I2C::setZPulseWidth4LSBVerify(void) {
464 |   setZPulseWidth1LSB();
465 |   return getZPulseWidth() == MT6701I2_Z_PULSE_WIDTH_4LSB ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR;
466 | }
467 | /*
468 |  * @brief: установить ширину импульса Z 8LSB
469 |  */
470 | void MT6701I2C::setZPulseWidth8LSB(void) {
471 |   uint8_t bkup = MT_RequestSingleRegister(MT6701_I2C_EEPROM_Z_PULSE_WIDTH_REG);
472 |   bkup |= MT6701I2_Z_PULSE_WIDTH_8LSB << MT6701_I2C_EEPROM_Z_PULSE_WIDTH_BIT_S;
473 |   MT_WriteOneByte(MT6701_I2C_EEPROM_Z_PULSE_WIDTH_REG, bkup);
474 | }
475 | /*
476 |  * @brief: установить ширину импульса Z 8LSB с проверкой
477 |  * @return:
478 |  *  MT6701I2C_DEFAULT_REPORT_ERROR - не установлено
479 |  *  MT6701I2C_DEFAULT_REPORT_OK - установлено
480 |  */
481 | bool MT6701I2C::setZPulseWidth8LSBVerify(void) {
482 |   setZPulseWidth8LSB();
483 |   return getZPulseWidth() == MT6701I2_Z_PULSE_WIDTH_8LSB ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR;
484 | }
485 | /*
486 |  * @brief: установить ширину импульса Z 12LSB
487 |  */
488 | void MT6701I2C::setZPulseWidth12LSB(void) {
489 |   uint8_t bkup = MT_RequestSingleRegister(MT6701_I2C_EEPROM_Z_PULSE_WIDTH_REG);
490 |   bkup |= MT6701I2_Z_PULSE_WIDTH_12LSB << MT6701_I2C_EEPROM_Z_PULSE_WIDTH_BIT_S;
491 |   MT_WriteOneByte(MT6701_I2C_EEPROM_Z_PULSE_WIDTH_REG, bkup);
492 | }
493 | /*
494 |  * @brief: установить ширину импульса Z 12LSB с проверкой
495 |  * @return:
496 |  *  MT6701I2C_DEFAULT_REPORT_ERROR - не установлено
497 |  *  MT6701I2C_DEFAULT_REPORT_OK - установлено
498 |  */
499 | bool MT6701I2C::setZPulseWidth12LSBVerify(void) {
500 |   setZPulseWidth12LSB();
501 |   return getZPulseWidth() == MT6701I2_Z_PULSE_WIDTH_12LSB ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR;
502 | }
503 | /*
504 |  * @brief: установить ширину импульса Z 16LSB
505 |  */
506 | void MT6701I2C::setZPulseWidth16LSB(void) {
507 |   uint8_t bkup = MT_RequestSingleRegister(MT6701_I2C_EEPROM_Z_PULSE_WIDTH_REG);
508 |   bkup |= MT6701I2_Z_PULSE_WIDTH_16LSB << MT6701_I2C_EEPROM_Z_PULSE_WIDTH_BIT_S;
509 |   MT_WriteOneByte(MT6701_I2C_EEPROM_Z_PULSE_WIDTH_REG, bkup);
510 | }
511 | /*
512 |  * @brief: установить ширину импульса Z 16LSB с проверкой
513 |  * @return:
514 |  *  MT6701I2C_DEFAULT_REPORT_ERROR - не установлено
515 |  *  MT6701I2C_DEFAULT_REPORT_OK - установлено
516 |  */
517 | bool MT6701I2C::setZPulseWidth16LSBVerify(void) {
518 |   setZPulseWidth16LSB();
519 |   return getZPulseWidth() == MT6701I2_Z_PULSE_WIDTH_16LSB ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR;
520 | }
521 | /*
522 |  * @brief: установить ширину импульса Z 180 градусов
523 |  */
524 | void MT6701I2C::setZPulseWidth180DEG(void) {
525 |   uint8_t bkup = MT_RequestSingleRegister(MT6701_I2C_EEPROM_Z_PULSE_WIDTH_REG);
526 |   bkup |= MT6701I2_Z_PULSE_WIDTH_180DEG << MT6701_I2C_EEPROM_Z_PULSE_WIDTH_BIT_S;
527 |   MT_WriteOneByte(MT6701_I2C_EEPROM_Z_PULSE_WIDTH_REG, bkup);
528 | }
529 | /*
530 |  * @brief: установить ширину импульса Z 180 градусов с проверкой
531 |  * @return:
532 |  *  MT6701I2C_DEFAULT_REPORT_ERROR - не установлено
533 |  *  MT6701I2C_DEFAULT_REPORT_OK - установлено
534 |  */
535 | bool MT6701I2C::setZPulseWidth180DEGVerify(void) {
536 |   setZPulseWidth180DEG();
537 |   return getZPulseWidth() == MT6701I2_Z_PULSE_WIDTH_180DEG ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR;
538 | }
539 | /* 
540 |  * @brief: получить значение нулевого положения
541 |  * @note: СМОТРЕТЬ ТАБЛИЦУ В ДОКУМЕНТАЦИИ
542 |  * @return:
543 |  *  0 - 4095
544 |  */
545 | word MT6701I2C::getZeroDegreePositionData(void) {
546 |   uint8_t reg_h = MT_RequestSingleRegister(MT6701_I2C_EEPROM_ZERO_REG_H) & 0x0F; // 0x0F = 0b00001111
547 |   return (word)((reg_h << 8) | MT_RequestSingleRegister(MT6701_I2C_EEPROM_ZERO_REG_L));
548 | }
549 | /* 
550 |  * @brief: установить значение нулевого положения
551 |  * @note: СМОТРЕТЬ ТАБЛИЦУ В ДОКУМЕНТАЦИИ
552 |  * @param _zero_position_data:
553 |  *  0 - 4095
554 |  */
555 | void MT6701I2C::setZeroDegreePositionData(word _zero_position_data) {
556 |   uint8_t bkup = MT_RequestSingleRegister(MT6701_I2C_EEPROM_ZERO_REG_H) & 0xF0; // 0xF0 = 0b11110000
557 |   uint8_t reg_l = _zero_position_data & 0xFF;
558 |   bkup |= _zero_position_data >> 8;
559 |   MT_WriteOneByte(MT6701_I2C_EEPROM_ZERO_REG_H, bkup);
560 |   MT_WriteOneByte(MT6701_I2C_EEPROM_ZERO_REG_L, reg_l);
561 | }
562 | /* 
563 |  * @brief: установить значение нулевого положения с проверкой
564 |  * @note: СМОТРЕТЬ ТАБЛИЦУ В ДОКУМЕНТАЦИИ
565 |  * @param _zero_position_data:
566 |  *  0 - 4095
567 |  * @return:
568 |  *  MT6701I2C_DEFAULT_REPORT_ERROR - не установлено
569 |  *  MT6701I2C_DEFAULT_REPORT_OK - установлено
570 |  */
571 | bool MT6701I2C::setZeroDegreePositionDataVerify(word _zero_position_data) {
572 |   setZeroDegreePositionData(_zero_position_data);
573 |   return getZeroDegreePositionData() == _zero_position_data ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR;
574 | }
575 | /* 
576 |  * @brief: получить значение частоты ШИМ
577 |  * @return:
578 |  *  MT6701I2_PWM_FREQUENCY_9944
579 |  *  MT6701I2_PWM_FREQUENCY_4972
580 |  */
581 | MT6701I2CFrequencyPWM MT6701I2C::getFrequencyPWM(void) {
582 |   return (MT6701I2CFrequencyPWM)((MT_RequestSingleRegister(MT6701_I2C_EEPROM_PWM_FREQ_REG) >> MT6701_I2C_EEPROM_PWM_FREQ_BIT) & 0x01);
583 | }
584 | /* 
585 |  * @brief: установить значение частоты ШИМ 994.4Гц
586 |  */
587 | void MT6701I2C::setFrequencyPWM9944(void) {
588 |   uint8_t bkup = MT_RequestSingleRegister(MT6701_I2C_EEPROM_PWM_FREQ_REG);
589 |   bkup &= ~(1 << MT6701_I2C_EEPROM_PWM_FREQ_BIT);
590 |   MT_WriteOneByte(MT6701_I2C_EEPROM_PWM_FREQ_REG, bkup);
591 | }
592 | /* 
593 |  * @brief: установить значение частоты ШИМ 994.4Гц с проверкой
594 |  * @return:
595 |  *  MT6701I2C_DEFAULT_REPORT_ERROR - не установлено
596 |  *  MT6701I2C_DEFAULT_REPORT_OK - установлено
597 |  */
598 | bool MT6701I2C::setFrequencyPWM9944Verify(void) {
599 |   setFrequencyPWM9944();
600 |   return getFrequencyPWM() == MT6701I2_PWM_FREQUENCY_9944 ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR;
601 | }
602 | /* 
603 |  * @brief: установить значение частоты ШИМ 497.2Гц
604 |  */
605 | void MT6701I2C::setFrequencyPWM4972(void) {
606 |   uint8_t bkup = MT_RequestSingleRegister(MT6701_I2C_EEPROM_PWM_FREQ_REG);
607 |   bkup |= 1 << MT6701_I2C_EEPROM_PWM_FREQ_BIT;
608 |   MT_WriteOneByte(MT6701_I2C_EEPROM_PWM_FREQ_REG, bkup);
609 | }
610 | /* 
611 |  * @brief: установить значение частоты ШИМ 497.2Гц с проверкой
612 |  * @return:
613 |  *  MT6701I2C_DEFAULT_REPORT_ERROR - не установлено
614 |  *  MT6701I2C_DEFAULT_REPORT_OK - установлено
615 |  */
616 | bool MT6701I2C::setFrequencyPWM4972Verify(void) {
617 |   setFrequencyPWM4972();
618 |   return getFrequencyPWM() == MT6701I2_PWM_FREQUENCY_4972 ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR;
619 | }
620 | /* 
621 |  * @brief: получить значение полярности ШИМ
622 |  * @return:
623 |  *  MT6701I2_PWM_POLARITY_HIGH
624 |  *  MT6701I2_PWM_POLARITY_LOW
625 |  */
626 | MT6701I2CPolarityPWM MT6701I2C::getPolarityPWM(void) {
627 |   return (MT6701I2CPolarityPWM)((MT_RequestSingleRegister(MT6701_I2C_EEPROM_PWM_POL_REG) >> MT6701_I2C_EEPROM_PWM_POL_BIT) & 0x01);
628 | }
629 | /* 
630 |  * @brief: установить значение полярности ШИМ HIGH
631 |  */
632 | void MT6701I2C::setPolarityPWMHigh(void) {
633 |   uint8_t bkup = MT_RequestSingleRegister(MT6701_I2C_EEPROM_PWM_POL_REG);
634 |   bkup &= ~(1 << MT6701_I2C_EEPROM_PWM_POL_BIT);
635 |   MT_WriteOneByte(MT6701_I2C_EEPROM_PWM_POL_REG, bkup);
636 | }
637 | /* 
638 |  * @brief: установить значение полярности ШИМ HIGH с проверкой
639 |  * @return:
640 |  *  MT6701I2C_DEFAULT_REPORT_ERROR - не установлено
641 |  *  MT6701I2C_DEFAULT_REPORT_OK - установлено
642 |  */
643 | bool MT6701I2C::setPolarityPWMHighVerify(void) {
644 |   setPolarityPWMHigh();
645 |   return getPolarityPWM() == MT6701I2_PWM_POLARITY_HIGH ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR;
646 | }
647 | /* 
648 |  * @brief: установить значение полярности ШИМ LOW
649 |  */
650 | void MT6701I2C::setPolarityPWMLow(void) {
651 |   uint8_t bkup = MT_RequestSingleRegister(MT6701_I2C_EEPROM_PWM_POL_REG);
652 |   bkup |= 1 << MT6701_I2C_EEPROM_PWM_POL_BIT;
653 |   MT_WriteOneByte(MT6701_I2C_EEPROM_PWM_POL_REG, bkup);
654 | }
655 | /* 
656 |  * @brief: установить значение полярности ШИМ LOW с проверкой
657 |  * @return:
658 |  *  MT6701I2C_DEFAULT_REPORT_ERROR - не установлено
659 |  *  MT6701I2C_DEFAULT_REPORT_OK - установлено
660 |  */
661 | bool MT6701I2C::setPolarityPWMLowVerify(void) {
662 |   setPolarityPWMLow();
663 |   return getPolarityPWM() == MT6701I2_PWM_POLARITY_LOW ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR;
664 | }
665 | 
666 | /* 
667 |  * @brief: получить режима выхода
668 |  * @return:
669 |  *  MT6701I2_OUTPUT_MODE_ANALOG
670 |  *  MT6701I2_OUTPUT_MODE_PWM
671 |  */
672 | MT6701I2COutputMode MT6701I2C::getOutputMode(void) {
673 |   return (MT6701I2COutputMode)((MT_RequestSingleRegister(MT6701_I2C_EEPROM_OUT_MODE_REG) >> MT6701_I2C_EEPROM_OUT_MODE_BIT) & 0x01);
674 | }
675 | /* 
676 |  * @brief: установить режим выхода Аналог
677 |  */
678 | void MT6701I2C::setOutputModeAnalog(void) {
679 |   uint8_t bkup = MT_RequestSingleRegister(MT6701_I2C_EEPROM_OUT_MODE_REG);
680 |   bkup &= ~(1 << MT6701_I2C_EEPROM_OUT_MODE_BIT);
681 |   MT_WriteOneByte(MT6701_I2C_EEPROM_OUT_MODE_REG, bkup);
682 | }
683 | /* 
684 |  * @brief: установить режим выхода Аналог с проверкой
685 |  * @return:
686 |  *  MT6701I2C_DEFAULT_REPORT_ERROR - не установлено
687 |  *  MT6701I2C_DEFAULT_REPORT_OK - установлено
688 |  */
689 | bool MT6701I2C::setOutputModeAnalogVerify(void) {
690 |   setOutputModeAnalog();
691 |   return getOutputMode() == MT6701I2_OUTPUT_MODE_ANALOG ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR;
692 | }
693 | /* 
694 |  * @brief: установить режим выхода ШИМ
695 |  */
696 | void MT6701I2C::setOutputModePWM(void) {
697 |   uint8_t bkup = MT_RequestSingleRegister(MT6701_I2C_EEPROM_OUT_MODE_REG);
698 |   bkup |= 1 << MT6701_I2C_EEPROM_OUT_MODE_BIT;
699 |   MT_WriteOneByte(MT6701_I2C_EEPROM_OUT_MODE_REG, bkup);
700 | }
701 | /* 
702 |  * @brief: установить режим выхода ШИМ с проверкой
703 |  * @return:
704 |  *  MT6701I2C_DEFAULT_REPORT_ERROR - не установлено
705 |  *  MT6701I2C_DEFAULT_REPORT_OK - установлено
706 |  */
707 | bool MT6701I2C::setOutputModePWMVerify(void) {
708 |   setOutputModePWM();
709 |   return getOutputMode() == MT6701I2_OUTPUT_MODE_PWM ? MT6701I2C_DEFAULT_REPORT_OK : MT6701I2C_DEFAULT_REPORT_ERROR;
710 | }
711 | 


--------------------------------------------------------------------------------
/src/MT6701_I2C.h:
--------------------------------------------------------------------------------
  1 | /* 
  2 |  * Класс для Arduino IDE реализующий множество методов
  3 |  * взаимодействия с бесконтактным датчиком положения
  4 |  * MT6701 от компании MagnTek http://www.magntek.com.cn/en/index.htm
  5 |  * 
  6 |  * Документация к датчику:
  7 |  ** http://www.magntek.com.cn/en/list/177/559.htm
  8 |  ** http://www.magntek.com.cn/upload/MT6701_Rev.1.5.pdf
  9 |  * 
 10 |  * Контакты:
 11 |  ** GitHub - https://github.com/S-LABc
 12 |  ** Gmail - romansklyar15@gmail.com
 13 |  * 
 14 |  * Copyright (C) 2022. v1.2 / License MIT / Скляр Роман S-LAB
 15 |  */
 16 | 
 17 | #pragma once
 18 | #include "Arduino.h"
 19 | #include "Wire.h"
 20 | 
 21 | /*=== Настройки шины I2C датчика ===*/
 22 | const uint32_t MT6701_I2C_CLOCK_100KHZ = 100000;
 23 | const uint32_t MT6701_I2C_CLOCK_400KHZ = 400000;
 24 | const uint32_t MT6701_I2C_CLOCK_1MHZ   = 1000000;
 25 | const uint8_t MT6701_I2C_ADDRESS = 0x06;
 26 | 
 27 | /*=== Выводы MODE на разных платах (зависит от ядра) ===*/
 28 | #define STM32_MT6701_MODE_PIN   PC13
 29 | #define ESP8266_MT6701_MODE_PIN 2
 30 | #define ESP32_MT6701_MODE_PIN   4
 31 | #define ARDUINO_MT6701_MODE_PIN 3
 32 | 
 33 | /*=== Адреса регистров датчика ===*/
 34 | // Angle Data Register
 35 | const uint8_t MT6701_I2C_ANGLE_DATA_REG_H = 0x03;
 36 | const uint8_t MT6701_I2C_ANGLE_DATA_REG_L = 0x04;
 37 | // UVW_MUX только для корпуса QFN
 38 | const uint8_t MT6701_I2C_EEPROM_UVW_MUX_REG = 0x25;
 39 | const uint8_t MT6701_I2C_EEPROM_UVW_MUX_BIT = 7;
 40 | // ABZ_MUX
 41 | const uint8_t MT6701_I2C_EEPROM_ABZ_MUX_REG = 0x29;
 42 | const uint8_t MT6701_I2C_EEPROM_ABZ_MUX_BIT = 6;
 43 | // DIR
 44 | const uint8_t MT6701_I2C_EEPROM_DIR_REG = 0x29;
 45 | const uint8_t MT6701_I2C_EEPROM_DIR_BIT = 1;
 46 | // UVW_RES
 47 | const uint8_t MT6701_I2C_EEPROM_UVW_RES_REG   = 0x30;
 48 | const uint8_t MT6701_I2C_EEPROM_UVW_MUX_BIT_S = 4;
 49 | // ABZ_RES
 50 | const uint8_t MT6701_I2C_EEPROM_ABZ_RES_REG_H = 0x30;
 51 | const uint8_t MT6701_I2C_EEPROM_ABZ_RES_REG_L = 0x31;
 52 | const uint8_t MT6701_I2C_EEPROM_ABZ_MUX_BIT_S = 0;
 53 | // HYST
 54 | const uint8_t MT6701_I2C_EEPROM_HYST_REG_H = 0x32;
 55 | const uint8_t MT6701_I2C_EEPROM_HYST_REG_L = 0x34;
 56 | // Z_PULSE_WIDTH
 57 | const uint8_t MT6701_I2C_EEPROM_Z_PULSE_WIDTH_REG   = 0x32;
 58 | const uint8_t MT6701_I2C_EEPROM_Z_PULSE_WIDTH_BIT_S = 4;
 59 | // ZERO
 60 | const uint8_t MT6701_I2C_EEPROM_ZERO_REG_H = 0x32;
 61 | const uint8_t MT6701_I2C_EEPROM_ZERO_REG_L = 0x33;
 62 | // PWM_FREQ
 63 | const uint8_t MT6701_I2C_EEPROM_PWM_FREQ_REG = 0x38;
 64 | const uint8_t MT6701_I2C_EEPROM_PWM_FREQ_BIT = 7;
 65 | // PWM_POL
 66 | const uint8_t MT6701_I2C_EEPROM_PWM_POL_REG = 0x38;
 67 | const uint8_t MT6701_I2C_EEPROM_PWM_POL_BIT = 6;
 68 | // OUT_MODE
 69 | const uint8_t MT6701_I2C_EEPROM_OUT_MODE_REG = 0x38;
 70 | const uint8_t MT6701_I2C_EEPROM_OUT_MODE_BIT = 5;
 71 | // A_START
 72 | const uint8_t MT6701_I2C_EEPROM_A_START_REG_H = 0x3E;
 73 | const uint8_t MT6701_I2C_EEPROM_A_START_REG_L = 0x3F;
 74 | // A_STOP
 75 | const uint8_t MT6701_I2C_EEPROM_A_STOP_REG_H = 0x3E;
 76 | const uint8_t MT6701_I2C_EEPROM_A_STOP_REG_L = 0x40;
 77 | const uint8_t MT6701_I2C_EEPROM_A_STOP_BIT_S = 4;
 78 | // 7.2 EEPROM Programming
 79 | const uint8_t MT6701_I2C_EEPROM_PROG_KEY_REG   = 0x09;
 80 | const uint8_t MT6701_I2C_EEPROM_PROG_KEY_VALUE = 0xB3;
 81 | const uint8_t MT6701_I2C_EEPROM_PROG_CMD_REG   = 0x0A;
 82 | const uint8_t MT6701_I2C_EEPROM_PROG_CMD_VALUE = 0x05;
 83 | 
 84 | /*=== Вспомогательные значения ===*/
 85 | // Тип конфигурации выходного интерфейса (только для корпуса QFN)
 86 | enum MT6701I2CConfigurationOutputType {
 87 |   MT6701I2_CONFIG_OUTPUT_TYPE_UVW,
 88 |   MT6701I2_CONFIG_OUTPUT_TYPE_A_B_Z,
 89 | };
 90 | // Тип выходного интерфейса
 91 | enum MT6701I2COutputType {
 92 |   MT6701I2_OUTPUT_TYPE_ABZ,
 93 |   MT6701I2_OUTPUT_TYPE_UVW,
 94 | };
 95 | // Положительное направление вращения
 96 | enum MT6701I2CDirection {
 97 |   MT6701I2_DIRECTION_COUNTERCLOCKWISE, // Против часовй стрелки
 98 |   MT6701I2_DIRECTION_CLOCKWISE, // По часовой стрелке
 99 | };
100 | // Ширина импульса Z
101 | enum MT6701I2CZPulseWidth {
102 |   MT6701I2_Z_PULSE_WIDTH_1LSB,
103 |   MT6701I2_Z_PULSE_WIDTH_2LSB,
104 |   MT6701I2_Z_PULSE_WIDTH_4LSB,
105 |   MT6701I2_Z_PULSE_WIDTH_8LSB,
106 |   MT6701I2_Z_PULSE_WIDTH_12LSB,
107 |   MT6701I2_Z_PULSE_WIDTH_16LSB,
108 |   MT6701I2_Z_PULSE_WIDTH_180DEG,
109 |   MT6701I2_Z_PULSE_WIDTH_1LSB_2,
110 | };
111 | // Частота ШИМ
112 | enum MT6701I2CFrequencyPWM {
113 |   MT6701I2_PWM_FREQUENCY_9944,
114 |   MT6701I2_PWM_FREQUENCY_4972,
115 | };
116 | // Полярность ШИМ
117 | enum MT6701I2CPolarityPWM {
118 |   MT6701I2_PWM_POLARITY_HIGH,
119 |   MT6701I2_PWM_POLARITY_LOW,
120 | };
121 | // Режим выхода
122 | enum MT6701I2COutputMode {
123 |   MT6701I2_OUTPUT_MODE_ANALOG,
124 |   MT6701I2_OUTPUT_MODE_PWM,
125 | };
126 | // Ответы стандартного вида успех/ошибка
127 | const uint8_t MT6701I2C_DEFAULT_REPORT_ERROR = 0;
128 | const uint8_t MT6701I2C_DEFAULT_REPORT_OK    = 1;
129 | // Выбор интерфейсов датчика
130 | const uint8_t MT6701I2C_MODE_I2C_SSI = 0;
131 | const uint8_t MT6701I2C_MODE_UVW_ABZ = 1;
132 | 
133 | 
134 | class MT6701I2C {
135 |   private:
136 |     TwoWire* _wire_; // Объект для использования методов I2C
137 |     int8_t _pin_mode_ = -1; // Контакт микроконтроллера к которому подключен вывод MODE датчика
138 | 
139 |   protected:
140 |     uint8_t MT_RequestSingleRegister(uint8_t _reg_addr); // Запрос значения регистра размером 1 байт
141 |     void MT_WriteOneByte(uint8_t _reg_addr, uint8_t _payload); // Запись одного байта в однобайтовый регистр
142 | 
143 |   public:
144 |     MT6701I2C(TwoWire* _twi); // Конструктор с использованием только интерфейса I2C
145 | 
146 |     void begin(void); // Вызов Wire.begin()
147 | #if defined(ESP8266) || defined(ESP32) || defined(ARDUINO_ARCH_STM32)
148 |     void begin(int8_t _sda_pin, int8_t _scl_pin); // Вызов Wire.begin(SDA, SCL) с указанием выводов
149 | #endif
150 |     void setClock(uint32_t _clock = MT6701_I2C_CLOCK_400KHZ); // Настройка частоты на 100кГц, 400кГц, 1МГц, или пользовательское значение (по умолчанию 400кГц)
151 | 
152 |     void saveNewValues(void); // Метод производителя для сохранения значений в памяти EEPROM. Рекомендуется выполнять при напряжение питания от 4.5В до 5.5В
153 | 
154 |     bool isConnected(void); // Проверка по стандартному алгоритму поиска устройств на линии I2C
155 | 
156 |     void attachModePin(byte _pin_mode); // Назначить контакт микроконтроллера для управления режимом интерфейса
157 |     void detachModePin(void); // Освоободить назначенный контакт микроконтроллера для управления режимом интерфейса
158 | 
159 |     void enableI2CorSSI(void); // Включить интерфейс I2C/SSI. MT6701I2C_MODE_I2C_SSI
160 |     void enableUVWorABZ(void); // Включить интерфейс UVW/ABZ. MT6701I2C_MODE_UVW_ABZ
161 | 
162 |     word getRawAngle(void); // Получить угол в чистом виде. 0 - 16383
163 |     float getDegreesAngle(void); // Получить угол в градусах. 0.00 - 359.98
164 |     float getRadiansAngle(void); // Получить угол в радианах. 0.00 - 6.28 
165 | 
166 |     MT6701I2CConfigurationOutputType getConfigurationOutputType(void); // Получить тип конфигурации выходного интерфейса (только для корпуса QFN). MT6701I2_CONFIG_OUTPUT_TYPE_UVW, MT6701I2_CONFIG_OUTPUT_TYPE_A_B_Z
167 |     void setConfigurationOutputTypeABZ(void); // Установить тип конфигурации выходного интерфейса -A-B-Z (только для корпуса QFN)
168 |     bool setConfigurationOutputTypeABZVerify(void); // То же самое, но с подтверждением (только для корпуса QFN)
169 |     void setConfigurationOutputTypeUVW(void); // Установить тип конфигурации выходного интерфейса UVW (только для корпуса QFN)
170 |     bool setConfigurationOutputTypeUVWVerify(void); // То же самое, но с подтверждением (только для корпуса QFN)
171 | 
172 |     MT6701I2COutputType getOutputType(void); // Получить тип выходного интерфейса. MT6701I2_OUTPUT_TYPE_ABZ, MT6701I2_OUTPUT_TYPE_UVW
173 |     void setOutputTypeABZ(void); // Установить тип выходного интерфейса ABZ
174 |     bool setOutputTypeABZVerify(void); // То же самое, но с подтверждением
175 |     void setOutputTypeUVW(void); // Установить тип выходного интерфейса UVW
176 |     bool setOutputTypeUVWVerify(void); // То же самое, но с подтверждением
177 | 
178 |     MT6701I2CDirection getOutputRotationDirection(void); // Получить направление вращения. MT6701I2_DIRECTION_COUNTERCLOCKWISE, MT6701I2_DIRECTION_CLOCKWISE
179 |     void setOutputRotationDirectionCounterclockwise(void); // Установить направление вращения против часовой
180 |     bool setOutputRotationDirectionCounterclockwiseVerify(void); // То же самое, но с подтверждением
181 |     void setOutputRotationDirectionClockwise(void); // Установить направление вращения по часовой
182 |     bool setOutputRotationDirectionClockwiseVerify(void); // То же самое, но с подтверждением
183 | 
184 |     byte getOutputResolutionUVW(void); // Получить значение выходного разрешения в режиме UVW. 1 - 16
185 |     void setOutputResolutionUVW(byte _resolution); // Установить значение выходного разрешения в режиме UVW. 1 - 16
186 |     bool setOutputResolutionUVWVerify(byte _resolution); // То же самое, но с подтверждением
187 | 
188 |     word getOutputResolutionABZ(void); // Получить значение выходного разрешения в режиме ABZ. 1 - 1024
189 |     void setOutputResolutionABZ(word _resolution); // Установить значение выходного разрешения в режиме ABZ. 1 - 1024
190 |     bool setOutputResolutionABZVerify(word _resolution); // То же самое, но с подтверждением
191 | 
192 |     MT6701I2CZPulseWidth getZPulseWidth(void); // Получить значение ширины импульса на контакте Z в режиме ABZ. MT6701I2_Z_PULSE_WIDTH_1LSB, MT6701I2_Z_PULSE_WIDTH_2LSB,
193 |     // MT6701I2_Z_PULSE_WIDTH_4LSB, MT6701I2_Z_PULSE_WIDTH_8LSB, MT6701I2_Z_PULSE_WIDTH_12LSB, MT6701I2_Z_PULSE_WIDTH_16LSB, MT6701I2_Z_PULSE_WIDTH_180DEG, MT6701I2_Z_PULSE_WIDTH_1LSB_2,
194 |     void setZPulseWidth1LSB(void); // Установить ширину импульса 1LSB
195 |     bool setZPulseWidth1LSBVerify(void); // То же самое, но с подтверждением
196 |     void setZPulseWidth2LSB(void); // Установить ширину импульса 2LSB
197 |     bool setZPulseWidth2LSBVerify(void); // То же самое, но с подтверждением
198 |     void setZPulseWidth4LSB(void); // Установить ширрину импульса 4LSB
199 |     bool setZPulseWidth4LSBVerify(void); // То же самое, но с подтверждением
200 |     void setZPulseWidth8LSB(void); // Установить ширину импульса 8LSB
201 |     bool setZPulseWidth8LSBVerify(void); // То же самое, но с подтверждением
202 |     void setZPulseWidth12LSB(void); // Установить ширину импульса 12LSB
203 |     bool setZPulseWidth12LSBVerify(void); // То же самое, но с подтверждением
204 |     void setZPulseWidth16LSB(void); // Установить ширину импульса 16LSB
205 |     bool setZPulseWidth16LSBVerify(void); // То же самое, но с подтверждением
206 |     void setZPulseWidth180DEG(void); // Установить ширину импульса 180 градсуов
207 |     bool setZPulseWidth180DEGVerify(void); // То же самое, но с подтверждением
208 | 
209 |     word getZeroDegreePositionData(void); // Получить значение нулевого положения. Смотреть таблицу в документации стр 28. 0x000 - 0xFFF
210 |     void setZeroDegreePositionData(word _zero_position_data); // Установить значение нулевого положения. Смотреть таблицу в документации
211 |     bool setZeroDegreePositionDataVerify(word _zero_position_data); // То же самое, но с подтверждением
212 | 
213 |     MT6701I2CFrequencyPWM getFrequencyPWM(void); // Получить значение частоты ШИМ. MT6701I2_PWM_FREQUENCY_9944, MT6701I2_PWM_FREQUENCY_4972
214 |     void setFrequencyPWM9944(void); // Установить частоту ШИМ 994.4Гц
215 |     bool setFrequencyPWM9944Verify(void); // То же самое, но с подтверждением
216 |     void setFrequencyPWM4972(void); // Установить частоту ШИМ 497.2Гц
217 |     bool setFrequencyPWM4972Verify(void); // То же самое, но с подтверждением
218 | 
219 |     MT6701I2CPolarityPWM getPolarityPWM(void); // Получить значение полярности ШИМ. MT6701I2_PWM_POLARITY_HIGH, MT6701I2_PWM_POLARITY_LOW
220 |     void setPolarityPWMHigh(void); // Установить полярность ШИМ HIGH
221 |     bool setPolarityPWMHighVerify(void); // То же самое, но с подтверждением
222 |     void setPolarityPWMLow(void); // Установить полярность ШИМ LOW
223 |     bool setPolarityPWMLowVerify(void); // То же самое, но с подтверждением
224 | 
225 |     MT6701I2COutputMode getOutputMode(void); // Получить режима выхода. MT6701I2_OUTPUT_MODE_ANALOG, MT6701I2_OUTPUT_MODE_PWM
226 |     void setOutputModeAnalog(void); // Установить режим выхода Аналог
227 |     bool setOutputModeAnalogVerify(void); // То же самое, но с подтверждением
228 |     void setOutputModePWM(void); // Установить режим выхода ШИМ
229 |     bool setOutputModePWMVerify(void); // То же самое, но с подтверждением
230 | };
231 | 


--------------------------------------------------------------------------------