Оптический модуль инерциальной навигации

Современные робототехнические системы, дроны и автоматизированные устройства требуют точного определения перемещения в пространстве. Один из ключевых компонентов для этой задачи — Оптический модуль инерциальной навигации, такой как MTF02. Этот компактный и энергоэффективный сенсор позволяет устройствам «чувствовать» движение даже без GPS или внешних ориентиров.

В конструкции датчика MTF-02 интегрированы две ключевые подсистемы:

• ToF motion sensor (Time-of-Flight) для получения точечного расстояния;

• Сенсор оптического потока (Optical flow) для отслеживания движения поверхности.

Основные характеристики

• Напряжение питания:4 — 5.5В, потребление ~200мВт;

• Размеры/вес: ~25x10x4,5мм 1,5г;

• Оптический поток: 42° — при освещенности 60 ≥ Lux;

• Минимальная высота: ≥ 8см;

• Максимальная скорость: до 7м/c на высоте 1 метр;

• ToF motion sensor: до 2,5 м @ 90% отражения и 600 Lux, мертвая зона ToF-камеры после 2см;

• Длина волны ToF: 940нм.

Процесс работы MTF-02:

1. ToF motion sensor — технология измерения расстояния до объекта с помощью времени задержки отраженного сигнала (лазерного или ИК-импульса). Точечные датчики измеряют дистанцию до одной точки.

2. Оптический поток (Optical flow) — датчик захватывает изображение поверхности вниз и вычисляет относительное движение при частоте ~50 Гц, работает начиная с высоты 8см и далее для алгоритмов стабилизации движения при полете или перемещении в помещении.

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

Интерфейсы и протоколы

• UART, LVTL 3.3В;

• поддерживаемые протоколы: Micolink, Mavlink (APM +PX4), MSP(iNav):

• Частота передачи: 50 Гц.

Применение:

Дроны и квадрокоптеры

• Стабилизация в помещении без GPS;

• Точное позиционирование при посадке.

Роботы-пылесосы

• Построение карты помещения;

• Контроль пройденного пути.

Мобильная робототехника

• Навигация автономных роботов;

• Избегание столкновений.

Локализация и колижионирование

интеграция оптического потока и ToF

Аналитика движения

определение скорости движения по поверхности

Мое личное применение:

Задача стоит следующая: мне необходимо разработать такую систему, которая способна сканировать в пространстве над поверхностью т.е. по «воздуху».

Для решения поставленной задачи, был выбран датчик MTF-02, обладающий необходимыми характеристиками для одновременного определения пройденного пути, координат перемещения в плоскости (X, Y) и оценки высоты объекта.

Благодаря встроенномуToF motion sensor, обеспечивающей точное измерение расстояния, а также модулю оптического потока, MTF-02 способен адаптироваться к условиям, когда отсутствует прямая опора или контрольный фон, это делает его особенно эффективным в задачах, где важно отслеживать перемещение объекта в подвешенном состоянии или при движении над неровной/неоднородной поверхностью.

Схема подключения датчика MTF-02

Для более стабильного напряжения питания можно использовать следующую схему, в которой работает понижающий преобразователь MP231, но необходим источник +12В, в моем случае используется аккумуляторная сборка (NiMH/Pb +12В).

Вид осциллограммы передаваемых данных модуля MTF-02 по интерфейсу USART (линия TX)

Настройка микроконтроллера STM32F103 в CubeIDE

• В пункте [ 1 ] настраиваю скорость (Baud Rate [115200]), остальные параметры без изменений;

• В пункте [ 2 ] заходим в параметр «DMA Settings» и включаем его на примем данных;

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

  Для этого приемный сигнал USART(USART_RX) был сконфигурирован на работу в режиме DMA, при котором поступающие данные автоматически записываются в выделенный участок оперативной памяти без участия ядра.

  • В пункте [ 3 ] заходим в параметр «NVIC Settings» и включаем глобальное прерывание.

  Для отслеживания состояния интерфейса USART и обработки важных событий (например, завершения приема или ошибки), в разделе NVIC Settings было включено глобальное прерывание USART, это обеспечивает возможность немедленного реагирования со стороны микроконтроллера на изменения состояния периферии без постоянного опроса регистров.

Реализация программного кода(настройка и прием данных)

Создание переменных и макросов

extern volatile uint8_t uartRxFullIRDone; //сработало прерывание по полному буферу extern volatile uint8_t uartRxHalfIRDone; //сработало прерывание по половине буфера extern short status_UART;  #define UART_RX_BUFFER_SIZE 96//основной буфер uint8_t uart_rx_buffer_MTF[UART_RX_BUFFER_SIZE]={0,};  uint8_t uart_rx_buffer_MTF_copy[UART_RX_BUFFER_SIZE]={0,};  #define SIZEBUF_uart_rx_buf_mtf 64 //128 16 unsigned char uart_rx_buf_mtf[SIZEBUF_uart_rx_buf_mtf]={0,}; int size_uart_rx_buf_mtf=0;   MICOLINK_MSG_t msg; MICOLINK_PAYLOAD_RANGE_SENSOR_t payload;  //буфер для сборки строки #define SIZEBUF_result 96 char uart_rezult_buf1[SIZEBUF_result]={0,}; char uart_rezult_buf2[SIZEBUF_result]={0,}; char* uart_rezult_buf=uart_rezult_buf1; short uart_rezult_buf_i=0;//индекс char* uart_bufRow=uart_rezult_buf1;//буфер с целой строкой //E N D буфер для сборки строки //E N D для составления строк  //Данные полученные от структуры float distance_m=0.0f; int16_t flow_vel_x_cop=0; float flow_vel_x_cop_ab=0.0f; int16_t flow_vel_y_cop=0; float flow_vel_y_cop_ab=0.0f; uint32_t time_ms_s = 0; float distance_global =0.0f; //E N D данные полученные от структуры  //Данные после преобраз.сглаживания float smoothed_x = 0.0f;   // Сглаженная скорость по X (см/с) float smoothed_y = 0.0f;   // Сглаженная скорость по Y (см/с) float smoothed_distance = 0.0f; // Сглаженная дистанция (м) float total_velocity = 0.0f; // Общая скорость из сглаж. линейных скор. и дистанции (см/с) //E N D Данные после преобраз.сглаживания  static float total_path_m = 0.0f;   // Пройденный путь (метры) float total_path_m_cop = 0.0f; long total_path_m_cop_long =0; //тест static float position_x_m = 0.0f;   // Положение по X (в метрах) float position_x_m_cop = 0.0f; long position_x_m_cop_long= 0; static float position_y_m = 0.0f;   // Положение по Y (в метрах) float position_y_m_cop = 0.0f; long position_y_m_cop_long= 0; float beta_rad = 0.0f;  // Буферы для сглаживания данных #define BUFFER_SIZE 5 // Размер буфера для сглаживания, если необходимо еще медленее, уменьшать размер float flow_vel_x_buffer[BUFFER_SIZE] = {0}; // Буфер для flow_vel_x float flow_vel_y_buffer[BUFFER_SIZE] = {0}; // Буфер для flow_vel_y float distance_buffer[BUFFER_SIZE] = {0};  // Буфер для дистанции uint8_t buffer_index = 0; // Индекс текущего положения в буфере //  E N D Буферы для сглаживания данных

Структуры MICOLINK_MSG_t msg и MICOLINK_PAYLOAD_RANGE_SENSOR_t

Реализацию структур я взял с официального сайта [ https://micoair.com/docs/decoding-micolink-messages-from-mtf-01/ ]

#define MICOLINK_MSG_HEAD            0xEF #define MICOLINK_MAX_PAYLOAD_LEN     64 #define MICOLINK_MAX_LEN             MICOLINK_MAX_PAYLOAD_LEN + 7  enum {     MICOLINK_MSG_ID_RANGE_SENSOR = 0x51,     // Range Sensor }; /*     Message Structure Definition */ typedef struct {     uint8_t head;     uint8_t dev_id;     uint8_t sys_id;     uint8_t msg_id;     uint8_t seq;     uint8_t len;     uint8_t payload[MICOLINK_MAX_PAYLOAD_LEN];     uint8_t checksum;      uint8_t status;     uint8_t payload_cnt; } MICOLINK_MSG_t;  // Range Sensor typedef struct {     uint32_t  time_ms;    // System time in ms     uint32_t  distance;    // distance(mm), 0 Indicates unavailable     uint8_t   strength;            // signal strength     uint8_t   precision;    // distance precision     uint8_t   dis_status;    // distance status     uint8_t  reserved1;            // reserved     int16_t   flow_vel_x;    // optical flow velocity in x     int16_t   flow_vel_y;    // optical flow velocity in y     uint8_t   flow_quality;    // optical flow quality     uint8_t   flow_status;    // optical flow status     uint16_t  reserved2;    // reserved } MICOLINK_PAYLOAD_RANGE_SENSOR_t; 

Метод uart_Handler_MTF

Данный метод отвечает за получение, предварительную обработку и подготовку к использованию данных, поступающих от датчика MTF-02.

Основные задачи метода
• Приём данных с датчика
Метод реагирует на прерывания DMA — по заполнению первой или второй половины приёмного буфера. Это позволяет работать с потоком данных непрерывно, без потерь.

• Буферизация и переключение кадров
Используются два чередующихся буфера (uart_rezult_buf1 и uart_rezult_buf2), чтобы приём новых данных и обработка предыдущих шли параллельно.

• Декодирование пакета
Полученные байты передаются в функцию micolink_decode, которая разбирает пакет и выделяет физические величины:

flow_vel_x_cop — линейная скорость по оси X

flow_vel_y_cop — линейная скорость по оси Y

distance_m — дистанция до поверхности

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

• Интегрирование скорости в путь
На основе сглаженных скоростей выполняется интегрирование (update_position) для получения пройденного пути по осям X и Y.
Параллельно рассчитывается общая длина пути и угол движения (calculateBetaRadians).

• Подготовка данных для передачи
Формируются готовые строки (sprintf) с данными в удобном текстовом формате для отладки, логирования или передачи в другие системы.

void uart_Handler_MTF(void) { HAL_Delay(1);//чтобы HAL_GetTick() не выдавал ноль uint32_t ms = HAL_GetTick(); //uint32_t time_sec = ms / 1000; char isData=0; char* pData=(char*)uart_rx_buffer_MTF;  if(uartRxFullIRDone){ uartRxFullIRDone = 0;  // Указатель на вторую половину основного буфера DMA pData=(char*)&uart_rx_buffer_MTF[UART_RX_BUFFER_SIZE/2]; isData=1; } if(uartRxHalfIRDone){ uartRxHalfIRDone = 0; // Указатель на первую половину основного буфера DMA  pData = (char*)uart_rx_buffer_MTF; isData=1; } if(isData) { isData=0;  if(uart_rezult_buf==uart_rezult_buf1){ memcpy(uart_rezult_buf1, pData, UART_RX_BUFFER_SIZE / 2); uart_bufRow=uart_rezult_buf1; uart_rezult_buf=uart_rezult_buf2;  }else{ memcpy(uart_rezult_buf2, pData, UART_RX_BUFFER_SIZE / 2); uart_bufRow=uart_rezult_buf2; uart_rezult_buf=uart_rezult_buf1;  } memcpy(uart_rx_buffer_MTF_copy,(uint8_t*)uart_bufRow,UART_RX_BUFFER_SIZE); micolink_decode(uart_rx_buffer_MTF_copy,UART_RX_BUFFER_SIZE);              //Сглаженные значения flow_vel_x_buffer[buffer_index] = flow_vel_x_cop; flow_vel_y_buffer[buffer_index] = flow_vel_y_cop; distance_buffer[buffer_index] = distance_m; buffer_index = (buffer_index + 1) % BUFFER_SIZE; // Циклический буфер // Рассчитываем сглаженные значения  smoothed_x = calculate_average(flow_vel_x_buffer); smoothed_y = calculate_average(flow_vel_y_buffer); smoothed_distance = calculate_average(distance_buffer); //E N D Сглаженные значения float time_sec = ms/1000.0f;//перевод в секунды  update_position(smoothed_x,smoothed_y,ms);//интегрирование линейной скорости для расчёта пройденного пути, с учётом фильтрации малых шумов.  update_motion(smoothed_x,smoothed_y,smoothed_distance, ms);//расчёт общей скорости и пройденного пути  //делаю копию потому что position_x_m,y и total_path_m static (если одтать в буфер staic, то работать система не будет) position_x_m_cop = position_x_m; position_y_m_cop = position_y_m; total_path_m_cop = total_path_m*1000.0f; total_path_m_cop_long = (long)roundf(total_path_m_cop);  flow_vel_x_cop_ab=position_x_m_cop * 1000.0f;//перевод в мм flow_vel_y_cop_ab=position_y_m_cop * 1000.0f; position_x_m_cop_long = (long)roundf(flow_vel_x_cop_ab); position_y_m_cop_long = (long)roundf(flow_vel_y_cop_ab); //E N D  beta_rad = calculateBetaRadians(flow_vel_x_cop_ab, flow_vel_y_cop_ab);//получение угла в радианах  size_uart_rx_buf_mtf = sprintf((char*)&uart_rx_buf_mtf[0], "%ld %ld %.6f %ld %.3f %d %d>", position_x_m_cop_long, position_y_m_cop_long,beta_rad, total_path_m_cop_long, time_sec, 1,0);//отправка пакета UART ведущему устройству  } }

Метод update_motion

Данный метод отвечает за расчёт общей скорости и пройденного пути, он выполняет ключевую навигационную задачу — на основе данных от MTF-02 вычисляет, с какой скоростью движется объект и какое расстояние он прошёл с момента старта измерений.

Принцип работы
• Измерение времени между кадрами
Функция хранит момент предыдущего вызова (last_time_ms) и определяет, сколько секунд прошло между текущим и прошлым измерением (delta_time_s). Это позволяет интегрировать движение по времени.

• Вычисление мгновенной скорости

Используются проекции скорости по осям X и Y (flow_vel_x, flow_vel_y).

Их векторная сумма (sqrtf(…)) даёт модуль скорости в плоскости.

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

Деление на 100 применяется, если исходные скорости приходят в сантиметрах в секунду (приведение к м/с).

• Интегрирование для получения пути
Общая скорость умножается на интервал времени — это даёт приращение пути за данный шаг.
Приращение накапливается в переменной total_path_m, которая отражает суммарное пройденное расстояние с начала работы системы.

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

Простыми словами
Метод update_motion — это шагомер с точностью до миллиметров, но не по количеству шагов, а по точным данным от оптического датчика.
Он измеряет скорость движения, умножает её на прошедшее время и складывает результат в копилку пройденного пути

// Функция расчёта общей скорости и пройденного пути void update_motion(float flow_vel_x, float flow_vel_y, float distance_m,uint32_t time_ms) {  static uint32_t last_time_ms = 0;   // Время предыдущего измерения  float delta_time_s = (time_ms - last_time_ms) / 1000.0f;  // Время в секундах  if (delta_time_s > 0) { // Рассчитываем общую скорость (м/с) float total_velocity_m_per_s =distance_m * sqrtf(flow_vel_x * flow_vel_x + flow_vel_y * flow_vel_y)/100.0f;// деление на 100 если скорости передаются в см/c если в м/то не надо делить // Интегрируем скорость для расчёта пути total_path_m += total_velocity_m_per_s * delta_time_s; } last_time_ms = time_ms;  // Обновляем время последнего измерения }

Метод update_position

Данный метод отвечает за то, чтобы перевести показания датчика MTF-02 из скоростей в координаты — то есть понять, где сейчас находится объект относительно точки старта.

Как это работает
Определение времени между измерениями
Метод вычисляет, сколько секунд прошло с момента предыдущего вызова (delta_time_s).
Это нужно, чтобы правильно учесть, на какое расстояние мог сдвинуться объект.

• Отсев шумов
Если скорость по X или Y слишком мала (меньше 0,01 см/с), она считается шумом и приравнивается к нулю. Это предотвращает накопление ошибок из-за микроколебаний или дрожания датчика.

• Перевод в метры в секунду
Показания датчика приходят в сантиметрах в секунду, поэтому они делятся на 100, чтобы работать в метрической системе (м/с).

Интегрирование — путь из скорости

Скорость умножается на время, прошедшее с предыдущего измерения.

Полученное приращение добавляется к текущим координатам position_x_m и position_y_m.

Таким образом, шаг за шагом накапливается точка текущего положения в метрах.

• Обновление времени
Сохраняется момент последнего измерения, чтобы при следующем вызове правильно рассчитать delta_time_s.

Простыми словами
update_position — это математический «следопыт»:
он берёт скорости, отбрасывает шум, переводит их в пройденное расстояние и складывает с предыдущими координатами.
В результате получается текущая позиция объекта в двухмерном пространстве.

//интегрирование линейной скорости для расчёта пройденного пути, с учётом фильтрации малых шумов. void update_position(float flow_vel_x, float flow_vel_y,uint32_t time_ms){  static uint32_t last_time_ms = 0;// Время последнего измерения (мс)  // Вычисляем разницу во времени между измерениями в секундах float delta_time_s = (time_ms - last_time_ms) / 1000.0f; if (delta_time_s > 0.0f) {  // Проверка на малые скорости и шумы if (fabsf(flow_vel_x) < 0.01f) flow_vel_x = 0.0f; // Игнорируем шум по X if (fabsf(flow_vel_y) < 0.01f) flow_vel_y = 0.0f; // Игнорируем шум по Y  // Переводим скорости из см/с в м/с float velocity_x_mps = flow_vel_x / 100.0f; // Линейная скорость по X (м/с) float velocity_y_mps = flow_vel_y / 100.0f; // Линейная скорость по Y (м/с)  // Интегрируем скорости для обновления положенияx` position_x_m += velocity_x_mps * delta_time_s; // Путь = Скорость * Время position_y_m += velocity_y_mps * delta_time_s; } // Обновляем время последнего измерения last_time_ms = time_ms; }

Метод calculateBetaRadians перевод угла в радианы

float calculateBetaRadians(float flow_vel_x, float flow_vel_y) { return atan2(flow_vel_y, flow_vel_x); // Угол в радианах }

Метод calculate_average вычисление среднего значения из буфера, необходи для сглаживания данных поступающих от датчика MTF-02

 float calculate_average(float *buffer) {     float sum = 0.0;     for (int i = 0; i < BUFFER_SIZE; i++) {         sum += buffer[i];     }     return sum / BUFFER_SIZE; } //E N D функция вычисления среднего значения из буфера 

Обработка и расшифровка данных MicoLinkВ

В работе с датчиком MTF-02 информация передаётся в виде бинарных сообщений по протоколу MicoLink. Этот набор функций выполняет полный цикл приёма — от поимки первого байта до получения готовых чисел скорости и высоты.

1. Метод micolink_parse_char, осуществляет приём и разбор данных, обрабатывает поток входящих байтов, поступающих от датчика.

Каждый байт проходит через «машину состояний»:

Заголовок — признак начала пакета.

ID устройства и системы — кому адресовано сообщение.

ID сообщения — тип передаваемых данных (например, показания дальномера).

Длина полезной нагрузки — сколько байт занимает полезная информация.

Полезная нагрузка — сами измеренные значения (скорости, дистанция).

Контрольная сумма — защита от ошибок в передаче.

Если всё прошло успешно и контрольная сумма совпала — пакет считается принятым.

2. Метод micolink_check_sum, осуществляет проверку целостности
Каждое сообщение содержит контрольную сумму — специальное число, рассчитанное по всем байтам пакета.

Если расчёт на приёмной стороне совпадает с переданным значением, значит, данные достоверны.

Этот шаг защищает от искажений, которые могут возникнуть в линии связи.

3. Метод micolink_decode, осуществляет декодирование,после успешного приёма пакет разбирается по смыслу.

В случае с MICO_LINK_MSG_ID_RANGE_SENSOR из него извлекаются:

time_ms — отметка времени измерения;

distance_m — высота над поверхностью, в метрах;

flow_vel_x и flow_vel_y — линейные скорости по осям X и Y (см/с).

Эти значения затем используются для расчёта скорости, перемещения и построения траектории движения.

// Функция обработки данных uint8_t* data, size_t size   void micolink_decode(uint8_t* data, size_t size) { //static MICOLINK_MSG_t msg;  if (micolink_parse_char(&msg,data,size) == false) { return; }  switch (msg.msg_id) { case MICOLINK_MSG_ID_RANGE_SENSOR: { //MICOLINK_PAYLOAD_RANGE_SENSOR_t payload; memcpy(&payload, msg.payload, msg.len);  // Обработка данных датчика uint32_t time_ms = payload.time_ms; time_ms_s = time_ms;  uint32_t distance = payload.distance; distance_m =(float)distance/1000.0f;//перевел мм в метры // высота  int16_t flow_vel_x = payload.flow_vel_x; flow_vel_x_cop = (float)flow_vel_x; int16_t flow_vel_y = payload.flow_vel_y; flow_vel_y_cop = (float)flow_vel_y;  break; } default: // Обработка других сообщений break; } }  // Проверка контрольной суммы bool micolink_check_sum(MICOLINK_MSG_t* msg) { uint8_t length = msg->len + 6;  // Длина сообщения uint8_t temp[MICOLINK_MAX_LEN]; uint8_t checksum = 0;  memcpy(temp, msg, length);  for (uint8_t i = 0; i < length; i++) { checksum += temp[i]; }  return (checksum == msg->checksum); }  // Парсинг входящего байта bool micolink_parse_char(MICOLINK_MSG_t* msg, uint8_t* data, size_t size) {//uint8_t data for (size_t i = 0; i < size; i++) { uint8_t byte = data[i];  // Получаем очередной байт из буфера switch (msg->status) { case 0:  // Ожидание заголовка if (byte == MICOLINK_MSG_HEAD) { msg->head = byte; msg->status++; } break;  case 1:  // ID устройства msg->dev_id = byte; msg->status++; break;  case 2:  // ID системы msg->sys_id = byte; msg->status++; break;  case 3:  // ID сообщения msg->msg_id = byte; msg->status++; break;  case 4:  // Номер последовательности msg->seq = byte; msg->status++; break;  case 5:  // Длина полезной нагрузки msg->len = byte; if (msg->len == 0) { msg->status += 2; } else if (msg->len > MICOLINK_MAX_PAYLOAD_LEN) { msg->status = 0;  // Сброс из-за ошибки } else { msg->status++; } break;  case 6:  // Прием полезной нагрузки msg->payload[msg->payload_cnt++] = byte; if (msg->payload_cnt == msg->len) { msg->payload_cnt = 0; msg->status++; } break;  case 7:  // Контрольная сумма msg->checksum = byte; msg->status = 0;  // Сброс статуса  if (micolink_check_sum(msg)) {  return true;  // Сообщение успешно принято } break;  default: msg->status = 0; msg->payload_cnt = 0; break; } }  return false; }

Метод uart_startRecieving_MTF

После вызова данного метода MTF-02 начинает передавать пакеты данных по UART, а контроллер непрерывно принимает их в выделенный буфер, не тратя ресурсы на побайтовую обработку. Когда буфер наполняется наполовину или полностью, срабатывают соответствующие обработчики (uartRxHalfIRDone и uartRxFullIRDone), и начинается разбор протокола MicoLink.

void uart_startRecieving_MTF(void) { status_UART=1;//1=startRecieving 2=RxHalf 3=RxCplt   memset(uart_rx_buffer_MTF,0,sizeof(uart_rx_buffer_MTF));  HAL_UART_Receive_DMA(&huart2, (uint8_t*)uart_rx_buffer_MTF, UART_RX_BUFFER_SIZE);//начинаю прием данных от mtf_02 на uart2 }

Обработчики прерывания на прием

Данная реализация обработчиков конкретно у меня, находится в другом классе.

void HAL_UART_RxHalfCpltCallback(UART_HandleTypeDef *huart) //(перывание на прием от MTF) { if(huart == &huart2){//MTF_02 status_UART=2;//1=startRecieving 2=RxHalf 3=RxCplt //отладка uartRxHalfIRDone = 1; //сработало прерывание по половине } }  void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) //Callback от UART RX (перывание на прием от MTF) { if(huart == &huart2){//MTF_02 status_UART=3;//1=startRecieving 2=RxHalf 3=RxCplt //отладка uartRxFullIRDone = 1; //сработало прерывание по полному буферу }   }

Обработчик ошибок

void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart) { if (huart->Instance == USART2 && enResetUART) { //MTF /* Сброс ошибок и восстановление работы */ HAL_UART_DeInit(huart); HAL_UART_Init(huart); uartRxFullIRDone = 0; uartRxHalfIRDone = 0; } }

Главный метод

void proj_main() { volatile const char *ch = ";V-F-BIN;ver: "VER_PROG(VER_a,VER_b,VER_c);(void)ch;//0x8008b00   HAL_Delay(1);//чтобы HAL_GetTick() не выдавал ноль  uart_startRecieving_MTF();//Начинаю принимать данные от mtf_02  while (1){  //хэндлеры uart_Handler_MTF(); }//while (1) }

Ссылка на скачивание исходного кода [ https://t.me/ChipCraft В закрепленном сообщении [ #исскуствомк_исходный_код —Исходный код для датчика MTF-02]

Вывод

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

---

Если статья показалась Вам интересной, буду рад выпустить для Вас еще множество статей исследований по всевозможным видам устройств, так что, если не хотите их пропустить – буду благодарен за подписку на мой ТГ-канал: https://t.me/ChipCraft.