Современные робототехнические системы, дроны и автоматизированные устройства требуют точного определения перемещения в пространстве. Один из ключевых компонентов для этой задачи — Оптический модуль визуальной инерциальной навигации, такой как 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 метр;

• FoV-камера: до 2,5 м @ 90% отражения и 600 Lux, мертвая зона FoV-камеры после 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 Буферы для сглаживания данных

********************************************************************************************************

Cтруктуры 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;
}
}

********************************************************************************************************

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

Вывод

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

Главная функция

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.

Когда мы разработали первые Arduino-совместимые изделия на MIK32 Амур - ELBEAR ACE-UNO, и они завелись без «волшебного дыма» - мы воодушевились. После нескольких правок и пары итераций запустили небольшую серию – и поняли: «Хьюстон, у нас проблемы»… Далеко не все платы заводились сразу – сказывались особенности монтажа микроконтроллера (потребовалось определенное время, чтобы набить на этом шишек и наладить тех процессы и в нанесении пасты, и в ее оплавлении, и в самом выборе пасты), и иногда ошибки при монтаже на любой из стадий - авторастановщик/печь/отмывка/ручной монтаж... Как мы поняли довольно быстро - визуальный контроль не панацея, далеко не все получалось отследить «глазками»…

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

И делали это на первых порах не ребята на производстве, а высококвалифицированные инженеры, что конечно было в целом «из пушки по воробьям».

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

Попытки улучшить и ускорить проверку

Для упрощения проверки плат ELBEAR ACE-UNO на MIK32 Амур была создана специальная тестовая плата. Предварительно перед ее использованием всё так же проверялись уровни напряжений на тестпоинтах и отсутствие коротких замыканий на плате по питанию.

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

Тестовая плата при использовании с проверочной прошивкой позволяла проверить и цифровую, и аналоговую части платы. На ней находился набор светодиодов для каждого вывода проверяемой платы, переключатели для перемычек BOOT, некоторые дополнительные кнопки и светодиоды. Проверочная прошивка загружалась в проверяемую плату UNO (вместе с ней загружался и начальный загрузчик), а после тестовая плата надевалась сверху на проверяемую. Для проведения проверки проверяемая плата подключалась к ПК по интерфейсу USB, а на ПК открывалась программа монитора последовательного порта.

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

На втором этапе проверялась работа АЦП и ЦАП – на двух каналах ЦАП формировались изменяющиеся в разные стороны уровни напряжений – один на увеличение, другой на уменьшение. Формируемые аналоговые сигналы подавались на светодиоды SDA, SCL на тестовой плате, а ожидаемые значения выводились в монитор порта. По итогам сравнения ожидаемых значений с яркостью свечения соответствующих светодиодов делался вывод о корректности работы каналов ЦАП.

Для проверки каналов АЦП в монитор порта на втором этапе выводились значения, измеренные на каждом канале. По умолчанию эти значения должны быть относительно маленькими. На тестовой плате есть кнопка, по нажатию которой на аналоговые выводы проверяемой платы подается высокий уровень напряжения. В процессе проверки платы данная кнопка нажималась, а проверяющий контролировал значения, выводимые в монитор порта – все они должны значительно увеличиться. Таким образом проверялась корректность работы каналов АЦП.

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

После выхода пакета поддержки плат ELBEAR в ArduinoIDE к проверке добавился еще один этап – загрузка проверочного скетча на проверяемую плату в ArduinoIDE по интерфейсу USB и проверка работы интерфейса UART (при получении любых сообщений микроконтроллер эхом отправлял их обратно в порт).

Автоматизированная проверка плат

С появлением плат ELBEAR ACE-NANO на MIK32 Амур появилось и желание еще как-то ускорить и улучшить проверку плат после монтажа. Хотелось использовать для проверки не светодиоды и глаза проверяющего, а другой микроконтроллер, который сам будет принимать решение об успешности прохождения проверки. И почему бы для этого не использовать микроконтроллер с точно такой же платы с точно таким же набором выводов? И специальную тестовую плату делать не придется. Так родилась наша автоматизированная насколько это возможно проверка плат. Начали мы с платы ACE-NANO.

Для проверки нужна одна уже проверенная, заведомо рабочая плата NANO – она будет платой-мастером. В эту плату загружается специальная прошивка, которая управляет процессом проверки. Проверяемая плата изначально проверяется на наличие коротких замыканий, после чего в нее загружается проверочная прошивка (а вместе с ней и начальный загрузчик), которая слушает команды от платы-мастера и выполняет их. После загрузки прошивок проверяемая плата и плата-мастер соединяются друг с другом pin-to-pin в этакий «бутерброд», и плата-мастер подключается к ПК по интерфейсу USB.

Проверка состоит из нескольких этапов:

•  Stage MISO: проверяемая плата по очереди изменяет состояние цифровых выводов, а плата-мастер считывает состояние выводов и анализирует результаты.

•  Stage MOSI: плата-мастер по очереди изменяет состояние цифровых выводов, проверяемая плата считывает состояние выводов, отправляет результаты мастеру, а тот их анализирует.

•  Stage Analog: плата-мастер по очереди подает высокий уровень на все аналоговые выводы, а проверяемая плата каждый раз измеряет напряжение на всех своих выводах и отправляет результаты мастеру, а тот их анализирует. Проверяются и прямые каналы АЦП, и переключаемые.

•  Stage OTP content: проверяемая плата считывает из OTP памяти тестовую строку и результат отправляет плате-мастеру. Если память не запитана, плата-мастер получит пустую строку, а проверяющему придется проверить плату вручную.

•  Stage End Time: на этом этапе проверятся точность работы часов реального времени на проверяемой плате – при старте проверки по команде время заводится на обеих платах, а на данном этапе проверяемая плата присылает свое текущее время. Если оно близко к времени платы-мастера – с трактом часового кварца все в порядке.

На этапах MISO, MOSI, Analog в каждый момент времени активен только один вывод. Если это так – этапы проверки пройдены успешно. Если нет – в монитор порта выводится информация о «лишних» сработавших выводах – это повод проверить указанные выводы вручную.

После успешной автоматизированной проверки проводится проверка в ArduinoIDE – по интерфейсу USB в проверяемую плату загружается проверочный скетч, в котором проверяется работа встроенного светодиода и интерфейса UART – все сообщения, полученные от ПК, микроконтроллер отправляет обратно в порт. Этот этап остался неизменным.

Такая проверка для плат ACE-NANO нам понравилась, поэтому было решено сделать аналогичную проверку для плат ACE-UNO. Проверка производится точно так же, как с платами ACE-NANO. Единственное отличие – платы ACE-UNO не получается соединять «бутербродом» из-за некоторых разъемом, поэтому платы соединяются pin-to-pin проводами.

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

Ссылка на проект: https://elron.tech/russian-arduino-compatible-board/