Конфигурация Parametr Settings

В параметрах USART1 (Parametr Settings) я выбираю:

• Mode: Asynchronous (асинхронный режим);

• Baud Rate: 9600 бит/с (в моем примере два модуля-gnss (rs-232 и uart) работают на скорости 9600).

все остальные параметры без изменений.

Конфигурация NVIC Settings

Захожу в параметр (NVIC Settings) и включаю глобальное прерывание

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

При работе с GPS-модулями, которые передают NMEA-сообщения раз в секунду (1Hz), важно правильно организовать прием данных, чтобы не пропустить ни одного пакета. Необходимо настроить DMA в режиме Circular данный режим минимизирует нагрузку на процессор и гарантирует надежный прием.

Конфигурация DMA Settings

Захожу в параметр DMA Settings и выполняю следующие настройки:

1. Выбор потока/канала: USART1_RX (прием данных);

2. Mode: Circular;

3. Increment Memory Address: Enabled (автоинкремент памяти);

4. Data Width: Byte (8 бит, соответствует формату NMEA).

Коротко о NMEA 0183

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

Основные особенности:

• Текстовый формат – данные передаются в виде ASCII-строк;

• Структура сообщений – каждая строка начинается с $, содержит идентификатор типа данных и заканчивается контрольной суммой;

• Скорость передачи – обычно 9600 бод (но может быть и выше для высокочастотных модулей);

• Частота обновления – чаще всего 1 раз в секунду (1Hz), но бывают 5Hz, 10Hz и более.

Пример строки (GGA – Global Positioning System Fix Data):

После обработки GGA:

• Время: 11:25:30

• Широта: 60.20576° N

• Долгота: 30.261315° E

• Качество фикса: 1

• Спутников: 10

• Высота: 45.3 м

Пример строки (RMC – Recommended Minimum Navigation Information):

После обработки RMC:

• Время: 11:25:30

• Статус: Данные действительные

• Широта: 60.20576° N

• Долгота: 30.261315° E

• Скорость: 5.12 узла (~9.48 км/ч)

• Курс: 87.45°

• Дата: 11.08.2025

Также прикрепляю еще одну ссылку, где в детальности продемонстрирована расшифровка протокола NMEA0183 [https://wiki.iarduino.ru/page/NMEA-0183/].

#include "./Project/shared.h"
#include "./Project/GNSS/uartProc_GNSS.h"
#include "./Project/GNSS/NMEA.h"
#include "./Project/DP/uart_Proc_dp.h"
#include "./Project/uart_processing.h"
#include "main.h"
#include <stdlib.h>//abs
#include <string.h>//memset
#include <stdio.h>

typedef struct{
	uint8_t code_command;
	uint8_t type_dp;
	uint8_t gps_activity;
}UART_AB_Command9;//ответ на 9 команду
UART_AB_Command9 uart_comm9;
#define STRUCT_SIZE_COMMAND9 (sizeof(struct UART_AB_Command9))

#define SIZEBUF_uart_rx_buf_com9 9 //12
uint8_t uart_rx_buf_com9[SIZEBUF_uart_rx_buf_com9]={0,};
int size_uart_rx_buf_com9=0;

#define SIZEBUF_uart_rx_buf_com2 16 //12
uint8_t uart_rx_buf_com2[SIZEBUF_uart_rx_buf_com2]={0,};
int size_uart_rx_buf_com2=0;

//прерывания от GPS
volatile uint8_t uartRxFullIRDone = 0; //сработало прерывание по полному буферу
volatile uint8_t uartRxHalfIRDone = 0; //сработало прерывание по половине

volatile uint8_t uartRx_DPFullIRDone = 0; //сработало прерывание по полному буферу
volatile uint8_t uartRx_DPHalfIRDone = 0; //сработало прерывание по половине

uint16_t uartDpiRxSize_Done=0;
uint8_t* tmpBuf_test =0;

//прерывания от АБ
volatile uint8_t uartRxABDone = 0;//сработало прерывание на прием от АБ
uint16_t uartRxSize_Done=0;
volatile uint8_t uartTxIRDone_AB = 0; //сработало прерывание на отправку в АБ
//прерывания от ДП
volatile uint8_t uartRxDPDone = 0;//сработало прерывание на прием от ДП
volatile uint8_t uartTxDPDone = 0;//сработало прерывание на отправку в ДП

char enResetUART=1;//разрешить переинициализацию UART

short status_UART=0;//1=startRecieving 2=RxHalf 3=RxCplt //отладка
short status_UART_AB=0;//1-send 2=startRecieving 3=finishRecieving 4=TxCplt

uint8_t* pData_GPS = 0;
uint16_t size_gps = 0;
uint8_t isRTK_GPS =0;
//буфер приема от АБ
#define SIZEBUF_uart_rx_buf_AB 20 // 20
uint8_t uart_rx_buf_AB[SIZEBUF_uart_rx_buf_AB]={0,};

//void buffer_gps(uint8_t* buf_gps,uint16_t size);
//void uart_transmitAB(const uint8_t *pData, uint16_t Size);
char tr_busy=0;

void fillBuff_com9(int8_t typeDP)//typeDPI 1=DPI 2=DP32 3=Encoder
{
	int8_t retDP=-1;
	isRTK_GPS = gParams.isRTK_GPS;

	if(typeDP==-1){//запрос статуса, возвращаем что есть
		retDP=gParams.type_DP;
	}else{//установка подключенного датчика перемещения
		if(gParams.typeDP_fromAB!=typeDP){
			uint8_t typeDP_prev_fromAB=gParams.typeDP_fromAB;
			gParams.typeDP_fromAB=typeDP;

			retDP=typeDP;

			gParams.type_DP=typeDP;
			if(typeDP==DP_DPI){
				if(typeDP_prev_fromAB==DP_DP32){//если были настроены на DP32
					HAL_TIM_Base_Stop_IT(&htim6);
				}
				HAL_UART_DMAStop(&huart2);//?
				HAL_UART_DeInit(&huart2);
				HAL_UART_Init(&huart2);
				uart_startRecieving_DP();//dpi

				gParams.type_DP=-1;//т.к. этот датчик отвечает, то можно выяснить наличи, поому задаём что его нет, как ответит - зададим что есть
				retDP=-1;
			}else if(typeDP==DP_DP32){
				if(typeDP_prev_fromAB==DP_DPI){//если были настроены на DPI
					HAL_UART_DMAStop(&huart2);
					HAL_UART_DeInit(&huart2);
					dp32_enc_init();
				}
			}
			else if(typeDP==DP_ENC){
				if(typeDP_prev_fromAB==DP_DPI){//если были настроены на DPI
					HAL_UART_DMAStop(&huart2);
					HAL_UART_DeInit(&huart2);
					dp32_enc_init();
				}
				if(typeDP_prev_fromAB==DP_DP32){//если были настроены на DP32
					HAL_TIM_Base_Stop_IT(&htim6);
				}

			}
		}else{
			retDP=gParams.type_DP;
		}
		dpi_resetDist();
	}
//-----Модифицированный вариант ответа на команду
	uart_rx_buf_com9[0]=0x5A;
	uart_rx_buf_com9[1]=0xA5;
	//uart_rx_buf_com9[2]=5;
	uart_rx_buf_com9[3]=0x9;
	uart_rx_buf_com9[4]=retDP;
	uart_rx_buf_com9[5]=gParams.isGPS?1:-1;
	uart_rx_buf_com9[6]=isRTK_GPS;
	uart_rx_buf_com9[7]='>';
	size_uart_rx_buf_com9=8;
	uart_rx_buf_com9[2]=size_uart_rx_buf_com9-3;//размер буфера начиная с 3 индекса включительно

	if(size_uart_rx_buf_com9>=53){
		uart_rx_buf_com9[0]=0x5A;
		uart_rx_buf_com9[1]=0xA5;
		//uart_rx_buf_com9[2]=5;
		uart_rx_buf_com9[3]=0x9;
		uart_rx_buf_com9[4]=retDP;
		uart_rx_buf_com9[5]=gParams.isGPS?1:-1;
		uart_rx_buf_com9[6]=isRTK_GPS;
		uart_rx_buf_com9[7]=0;
		uart_rx_buf_com9[8]='>';
		size_uart_rx_buf_com9=9;
		uart_rx_buf_com9[2]=size_uart_rx_buf_com9-4;//размер буфера начиная с 3 индекса включительно
	}
}

void uart_Handler(void){

	if(uartRxABDone){
		uartRxABDone = 0;
		char isTransmit=0;

		if(uart_rx_buf_AB[0] == 0xab && uart_rx_buf_AB[1] == 0xba){
			if(uart_rx_buf_AB[2]+3<=uartRxSize_Done){
				if(uart_rx_buf_AB[3]=='G'){//ответ на GPS
					//f_debug(1);
					int tmpSize;
					uint8_t* tmpBuf=dpi_getGPS_buffer(&tmpSize);
					isTransmit=1;
					uart_transmitAB(tmpBuf, tmpSize);
				}else if(uart_rx_buf_AB[3]==0x9){//ответ на 9 команду
					fillBuff_com9(uart_rx_buf_AB[4]);
					isTransmit=1;
					uart_transmitAB(uart_rx_buf_com9, size_uart_rx_buf_com9);
				}else if(uart_rx_buf_AB[3]=='Y'){//ответ на dp
					int tmpSize;
					uint8_t* tmpBuf=dpi_getDp_buffer(&tmpSize);
					tmpBuf_test = tmpBuf;
					isTransmit=1;
					uart_transmitAB(tmpBuf, tmpSize);
				}else if(uart_rx_buf_AB[3]==0x2){//версия
					int tmpSize;
					uart_rx_buf_com2[0]=0x5A;
					uart_rx_buf_com2[1]=0xA5;
					tmpSize=sprintf((char*)&uart_rx_buf_com2[3],"v%d.%d.%d>",VER_a,VER_b,VER_c);
					uart_rx_buf_com2[2]=tmpSize;
					tmpSize+=3;//размер преамбулы+поле размер
					isTransmit=1;
					uart_transmitAB(uart_rx_buf_com2, tmpSize);
				}
			}
		}

		if(isTransmit==0){
			uart_startRecieving_AB();
		}

	}

	if(uartTxIRDone_AB){
		uartTxIRDone_AB = 0;
//		dist = 0;
		uart_startRecieving_AB();
	}
}

void uart_transmitAB(const uint8_t *pData, uint16_t Size)
{
	if(pData && Size){

		if(tr_busy){
			tr_busy=5;//отладка
		}
		tr_busy=1;
		HAL_GPIO_WritePin(DE_RE_DP_GPIO_Port, DE_RE_DP_Pin, GPIO_PIN_SET);
		HAL_UART_Transmit_DMA(&huart3, pData, Size);

	}
}

void uart_startRecieving_AB(void)
{
	status_UART_AB=2;
	__HAL_UART_CLEAR_OREFLAG(&huart3);//используется для сброса флага ошибки переполнения приёмного буфера UART, который обозначается как ORE (Overrun Error). Нужно сбросить флаг для продолжения приема данных.
	__HAL_UART_CLEAR_IDLEFLAG(&huart3);//используется для сброса флага IDLE (бездействия) в структуре управления UART (huart1). Этот флаг IDLE часто используется для определения окончания передачи данных. Когда флаг IDLE устанавливается, это может означать, что передача данных завершена.
	HAL_UARTEx_ReceiveToIdle_DMA(&huart3, (uint8_t*)uart_rx_buf_AB, SIZEBUF_uart_rx_buf_AB);
	//HAL_UART_Receive_DMA(&huart3, (uint8_t*)uart_rx_buf_AB, 4);
}

void HAL_UART_RxHalfCpltCallback(UART_HandleTypeDef *huart)
{
	if(huart == &huart1){
		status_UART=2;//1=startRecieving 2=RxHalf 3=RxCplt //отладка
		uartRxHalfIRDone = 1; //сработало прерывание по половине
	}
	if(huart == &huart2){
		uartRx_DPHalfIRDone =1;
	}
}

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


	if(huart == &huart3)
	{
		HAL_UART_DMAStop(huart);
		uartRxABDone=1;
		//uartRxSize_Done=Size;
		status_UART_AB=3;//1-send 2=startRecieving 3=finishRecieving 4=TxCplt
	}
}

void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart) //Callback от UART TX
{
	if(huart == &huart3){//AB
		HAL_GPIO_WritePin(DE_RE_DP_GPIO_Port, DE_RE_DP_Pin, GPIO_PIN_RESET);
		status_UART=4;//1-send 2=startRecieving 3=finishRecieving 4=TxCplt
	    uartTxIRDone_AB=1;
	    tr_busy=0;
	}
	if(huart == &huart2){//dpi
		HAL_GPIO_WritePin(DP_OUT_GPIO_Port, DP_OUT_Pin, GPIO_PIN_RESET);//переключить 485 на приём
		uartTxDPDone = 1;
	}
}
//Callback на получение данных от АБ и ДП
void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size)
{
	if(huart == &huart3)//AB
	{
		HAL_UART_DMAStop(huart);
		uartRxABDone=1;
		uartRxSize_Done=Size;
		status_UART_AB=3;//1-send 2=startRecieving 3=finishRecieving 4=TxCplt
	}
	if(huart == &huart2){//DPI
		HAL_UART_DMAStop(huart);
		uartRx_DPFullIRDone = 1;
		uartDpiRxSize_Done=Size;
	}
}
// Обработчик ошибок UART
void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart)
{
    if (huart->Instance == USART1 && enResetUART) { //GPS
        /* Сброс ошибок и восстановление работы */
        HAL_UART_DeInit(huart);
        HAL_UART_Init(huart);
        uartRxFullIRDone = 0;
        uartRxHalfIRDone = 0;
        uart_startRecieving_GNSS();
    }

    if(huart->Instance == USART2){//dpi
    	/* Сброс ошибок и восстановление работы */
    	HAL_UART_DeInit(huart);
    	HAL_UART_Init(huart);
    	uartRxDPDone = 0;
    	uartTxDPDone = 0;
    	HAL_GPIO_WritePin(DP_OUT_GPIO_Port, DP_OUT_Pin, GPIO_PIN_RESET);//переключить 485 на приём
    	uart_startRecieving_DP();//dpi
    	uart_startTransmiting_DP();
    }

    if (huart->Instance == USART3) { //AB
		/* Сброс ошибок и восстановление работы */
		HAL_UART_DeInit(huart);
		HAL_UART_Init(huart);
		uartRxABDone = 0;
		uartTxIRDone_AB = 0;
		tr_busy=0;
		memset(uart_rx_buf_AB,0,SIZEBUF_uart_rx_buf_AB);
		HAL_GPIO_WritePin(DE_RE_DP_GPIO_Port, DE_RE_DP_Pin, GPIO_PIN_RESET);
		uart_startRecieving_AB();
	}

}

)

#include "./Project/shared.h"
#include "./Project/GNSS/uartProc_GNSS.h"
#include "./Project/DP/uart_Proc_dp.h"
#include "./Project/uart_processing.h"
#include "main.h"
#include <stdlib.h>//abs
#include <string.h>//memset
#include <stdio.h>
//{0xba,0xdc};
#define size_command_dcba 2
uint8_t command_dcba[size_command_dcba] = {0xba, 0xdc};

//буфер куда будут приходить данные от датчиков
#define SIZEBUF_uart_rx_buf_dp 60//6
uint8_t uart_rx_buf_dp[SIZEBUF_uart_rx_buf_dp]={0,};

#define SIZEBUF_uart_rx_buf_dpi 16 //16
uint8_t uart_rx_buf_dpi[SIZEBUF_uart_rx_buf_dpi]={0,};
int size_uart_rx_buf_dpi=0;

unsigned long dist = 0;//расстояние от начальной точки (в импульсах пути)//dma

extern volatile uint8_t uartRxDPDone;//сработало прерывание на прием 
extern volatile uint8_t uartTxDPDone;//сработало прерывание на отправку

extern volatile uint8_t uartRx_DPFullIRDone; //сработало прерывание по полному буферу
extern volatile uint8_t uartRx_DPHalfIRDone; //сработало прерывание по половине
extern uint16_t uartDpiRxSize_Done;

#define DELAY_DPI_SEND	1//как часто слать запрос в DPI
uint32_t dpi_time_send = 0;

//для проверки что датчик отключили
#define DELAY_DPI_STATUS_CONNECT	100
uint32_t dpi_time_status_connect = 0;
//int8_t dpi_connect_status=-1;//-1=не подключен 1=подключен
//E N D для проверки что датчик отключили

//для DP32
int32_t dp32_counter=0;
int8_t dp32_ImpCounter=0;//2=минус 3=плюс
//E N D для DP32

uint32_t dpEnc_counter=0;

unsigned short calcCRC(unsigned short* pData,int sizeInBytes)
{
	int i;
	unsigned long FCB=0;
	int Len=sizeInBytes>>1;
	if(sizeInBytes&1){
		pData[Len]&=0xFF;
		Len++;
	}
	for (i=0;i<Len;i++) FCB+=(unsigned long)pData[i];
	FCB=(FCB&0xFFFF)+(FCB>>16);
	FCB=(FCB&0xFFFF)+(FCB>>16);
	FCB=~FCB;
	return((unsigned short)(FCB&0xFFFF));
}

void uart_Proc_dp_init(void)
{
	//добавление преамбулы
	uart_rx_buf_dpi[0]=0x5A;
	uart_rx_buf_dpi[1]=0xA5;
	size_uart_rx_buf_dpi = sprintf((char*)&uart_rx_buf_dpi[3],
                                   "%lu>",0lu);
	uart_rx_buf_dpi[2]=size_uart_rx_buf_dpi;
	size_uart_rx_buf_dpi+=3;//размер преамбулы+поле размер
}

void uart_Handler_DP(void)
{

	if(gParams.typeDP_fromAB==DP_DPI){
		uint32_t ms = HAL_GetTick();


		if(uartRx_DPFullIRDone){

			uartRx_DPFullIRDone=0;
			if(uartDpiRxSize_Done==6){
				unsigned long tmp;
				unsigned short tmpCRC;
				unsigned short tmpCalcCRC;
				memcpy(&tmp,&uart_rx_buf_dp[0],4);
				memcpy(&tmpCRC,&uart_rx_buf_dp[4],2);
				tmpCalcCRC=calcCRC((unsigned short*)&tmp, 4);
				if(tmpCalcCRC==tmpCRC){
					dist=tmp;
					//добавление преамбулы
					uart_rx_buf_dpi[0]=0x5A;
					uart_rx_buf_dpi[1]=0xA5;
					size_uart_rx_buf_dpi = sprintf((char*)&uart_rx_buf_dpi[3],
                                                   "%lu>",dist);//добавление преамбулы
					uart_rx_buf_dpi[2]=size_uart_rx_buf_dpi;
					size_uart_rx_buf_dpi+=3;//размер преамбулы+поле размер

					if(size_uart_rx_buf_dpi>=52){
						memset(uart_rx_buf_dpi,0,size_uart_rx_buf_dpi);
						uart_rx_buf_dpi[0]=0x5A;
						uart_rx_buf_dpi[1]=0xA5;
						size_uart_rx_buf_dpi = sprintf((char*)&uart_rx_buf_dpi[3],"%lu%d>",dist,0);//добавление преамбулы
						uart_rx_buf_dpi[2]=size_uart_rx_buf_dpi;
						size_uart_rx_buf_dpi+=3;//размер преамбулы+поле размер
					}
					//if(dpi_connect_status!=1){
					if(gParams.type_DP!=1){//всё норм, ставим статус наличия
						//dpi_connect_status=1;
						gParams.type_DP=1;
						//fillBuff_com9(1, -1);
					}
				}else{
				}
				dpi_time_send=ms;
				dpi_time_status_connect=0;
			}else{
			}
			uart_startRecieving_DP();
		}


		if(dpi_time_send && ((ms - dpi_time_send) >= DELAY_DPI_SEND)){
			dpi_time_send=0;
			uart_startTransmiting_DP();
		}


		if(dpi_time_status_connect && ((ms - dpi_time_status_connect) >= DELAY_DPI_STATUS_CONNECT)){
			dpi_time_status_connect=0;

			if(gParams.type_DP!=-1){
				gParams.type_DP=-1;
				//dpi_connect_status=-1;//-1=не подключен 1=подключен
				//fillBuff_com9(0, -1);
			}

			uart_startTransmiting_DP();
		}
	}
}

int8_t dpi_getDpi_connect_status(void)
{
	//return dpi_connect_status;
	return gParams.type_DP;
}

uint8_t* dpi_getDp_buffer(int* ret_buff_size)
{
	if(ret_buff_size){*ret_buff_size=size_uart_rx_buf_dpi;}
	return uart_rx_buf_dpi;
}

unsigned long dpi_getDist(void)
{
	return dist;
}

void dpi_resetDist(void)
{
	dist=0;
	uart_rx_buf_dpi[0]=0x5A;
	uart_rx_buf_dpi[1]=0xA5;
	size_uart_rx_buf_dpi = sprintf((char*)&uart_rx_buf_dpi[3],
                                   "%lu>", dist);
	uart_rx_buf_dpi[2]=size_uart_rx_buf_dpi;
	size_uart_rx_buf_dpi+=3;//размер преамбулы+поле размер

	if(size_uart_rx_buf_dpi>=52){
		memset(uart_rx_buf_dpi,0,size_uart_rx_buf_dpi);
		dist=0;
		uart_rx_buf_dpi[0]=0x5A;
		uart_rx_buf_dpi[1]=0xA5;
		size_uart_rx_buf_dpi = sprintf((char*)&uart_rx_buf_dpi[3],
                                       "%lu%d>", dist,0);
		uart_rx_buf_dpi[2]=size_uart_rx_buf_dpi;
		size_uart_rx_buf_dpi+=3;//размер преамбулы+поле размер
	}

	dp32_counter=0;
	dp32_ImpCounter=0;//2=минус 3=плюс
	dpEnc_counter=0;
}

void uart_startTransmiting_DP(void)
{
	if(gParams.typeDP_fromAB==DP_DPI){
		HAL_GPIO_WritePin(DP_OUT_GPIO_Port, DP_OUT_Pin, GPIO_PIN_SET);
		HAL_UART_Transmit_DMA(&huart2, (uint8_t *)command_dcba, size_command_dcba);
		dpi_time_status_connect=HAL_GetTick();
	}
}
void uart_startRecieving_DP(void)
{
	if(gParams.typeDP_fromAB==DP_DPI){
		HAL_GPIO_WritePin(DP_OUT_GPIO_Port, DP_OUT_Pin, GPIO_PIN_RESET);//переключить 485 на приём
		memset(uart_rx_buf_dp,0,sizeof(uart_rx_buf_dp));
		HAL_UARTEx_ReceiveToIdle_DMA(&huart2, (uint8_t*)uart_rx_buf_dp, SIZEBUF_uart_rx_buf_dp);
	}
}

void dp32_enc_init(void)
{
	HAL_TIM_Base_Stop_IT(&htim6);
	//настроить ногу RX на прерывание
	GPIO_InitTypeDef GPIO_InitStruct = {0};
	/*Configure GPIO pin : PA3 */
	GPIO_InitStruct.Pin = GPIO_PIN_3;
	GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING;
	GPIO_InitStruct.Pull = GPIO_NOPULL;
	HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
	//E N D настроить ногу RX на прерывание
	dp32_counter=0;
	dp32_ImpCounter=0;//2=минус 3=плюс
	dpEnc_counter=0;
}

void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
	// Обработка прерывания на ноге PA3
	if (GPIO_Pin == GPIO_PIN_3) {
		if(gParams.typeDP_fromAB==DP_DP32){
			if (dp32_ImpCounter==0){
				__HAL_TIM_CLEAR_FLAG(&htim6, TIM_SR_UIF); // очищаем флаг//https://istarik.ru/blog/stm32/118.html
				HAL_TIM_Base_Start_IT(&htim6);
			}
			dp32_ImpCounter++;
		}
		if(gParams.typeDP_fromAB==DP_ENC){
			dpEnc_counter++;
			uart_rx_buf_dpi[0]=0x5A;
			uart_rx_buf_dpi[1]=0xA5;
			size_uart_rx_buf_dpi = sprintf((char*)&uart_rx_buf_dpi[3],
                                           "%lu>",dpEnc_counter);
			uart_rx_buf_dpi[2]=size_uart_rx_buf_dpi;
			size_uart_rx_buf_dpi+=3;//размер преамбулы+поле размер

			if(size_uart_rx_buf_dpi>=52){
				memset(uart_rx_buf_dpi,0,size_uart_rx_buf_dpi);
				dpEnc_counter++;
				uart_rx_buf_dpi[0]=0x5A;
				uart_rx_buf_dpi[1]=0xA5;
				size_uart_rx_buf_dpi = sprintf((char*)&uart_rx_buf_dpi[3],"%lu%d>",dpEnc_counter,0);
				uart_rx_buf_dpi[2]=size_uart_rx_buf_dpi;
				size_uart_rx_buf_dpi+=3;//размер преамбулы+поле размер
			}
		}
	}
}

void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim) {
	if (htim->Instance == TIM6) {
		HAL_TIM_Base_Stop_IT(&htim6);
		// Обработка прерывания от таймера TIM6
		if(dp32_ImpCounter<3){//2=минус 3=плюс
			dp32_counter--;
		}else{
			dp32_counter++;
		}
		//добавление преамбулы
		uart_rx_buf_dpi[0]=0x5A;
		uart_rx_buf_dpi[1]=0xA5;
		size_uart_rx_buf_dpi = sprintf((char*)&uart_rx_buf_dpi[3],
                                       "%lu>",dp32_counter);
		uart_rx_buf_dpi[2]=size_uart_rx_buf_dpi;
		size_uart_rx_buf_dpi+=3;//размер преамбулы+поле размер
		dp32_ImpCounter=0;

		if(size_uart_rx_buf_dpi>=52){
			memset(uart_rx_buf_dpi,0,size_uart_rx_buf_dpi);
			uart_rx_buf_dpi[0]=0x5A;
			uart_rx_buf_dpi[1]=0xA5;
			size_uart_rx_buf_dpi = sprintf((char*)&uart_rx_buf_dpi[3],"%lu%d>",dp32_counter,0);
			uart_rx_buf_dpi[2]=size_uart_rx_buf_dpi;
			size_uart_rx_buf_dpi+=3;//размер преамбулы+поле размер
			dp32_ImpCounter=0;
		}
	}
}

uint8_t GMT = 0;  //RU
uint8_t inx = 0;
uint8_t hr=0,min=0,day=0,mon=0,yr=0;
uint8_t daychange = 0;

/*Первый параметр это буфер GGA, в котором сохраняется строка GGA,
 * Второй параметр это указатель на структуру GGA*/
int decodeGGA (char *GGAbuffer, GGASTRUCT *gga)
{
	inx = 0;
	char buffer[12];
	int i = 0;
	while (GGAbuffer[inx] != ',') inx++;  // 1st ','
	inx++;
	while (GGAbuffer[inx] != ',') inx++;  // After time ','
	inx++;
	while (GGAbuffer[inx] != ',') inx++;  // after latitude ','
	inx++;
	while (GGAbuffer[inx] != ',') inx++;  // after NS ','
	inx++;
	while (GGAbuffer[inx] != ',') inx++;  // after longitude ','
	inx++;
	while (GGAbuffer[inx] != ',') inx++;  // after EW ','
	inx++;
//	while (GGAbuffer[inx] != ',') inx++;  // информация о типе вычисления координат ','
//	inx++;
	// доситиг символа/ знака для определения исправления
	//проверка шаблона в буфере прошла успешно
	/*Далее происходит проверка чисел, если в буфере число равно 1 , 2 или 6
	 * то данные являются действительными*/
	if ((GGAbuffer[inx] == '1') || (GGAbuffer[inx] == '2') || (GGAbuffer[inx] == '4') || (GGAbuffer[inx] == '5') || (GGAbuffer[inx] == '6'))   // 0 указывает на отсутствие исправления
	{
		gga->isfixValid = 1;   //данные действительны
		inx = 0;   //сбрасываю индекс, далее начну с inx = 0 и буду извлекать информацию
	}
	else
	{
		gga->isfixValid = 0;   // если данные не действительны
		return 1;  // return error
	}
	while (GGAbuffer[inx] != ',') inx++;  // 1st ','

/*********************** Get TIME ***************************/
//(Update the GMT Offset at the top of this file)
  /*Здесь я сначала копирую время в буфер
   * данные в буфере по прежнему имеют симфольный формат, мне необходимо их изменить
   * на числовой формат, сделать я это могу с помощью atoi функции исп. для преобразования строки в число*/
	inx++;   // достижение первого числа, вовремя
	memset(buffer, '\0', 12);
	i=0;
	while (GGAbuffer[inx] != ',')  // копирую время до того как поймаю ','
	{
		buffer[i] = GGAbuffer[inx];
		i++;
//	    if(i>sizeof(buffer)){
//		return 0;
//	  }
		inx++;
	}

	hr = (atoi(buffer)/10000) + GMT/100;   // получаю часы из 6-ти значного числа

	min = ((atoi(buffer)/100)%100) + GMT%100;

	//данная часть кода предназначена для регулировки времени в соответствии со смещением GMT
	if (min > 59)
	{
		min = min-60;
		hr++;
	}
	if (hr<0)
	{
		hr=24+hr;
		daychange--;
	}
	if (hr>=24)
	{
		hr=hr-24;
		daychange++;
	}

	//Сохраняю данные в tim, элемент структуры GGA
	gga->tim.hour = hr;
	gga->tim.min = min;
	gga->tim.sec = atoi(buffer)%100;
//	gga->tim.msec =  (hr+min+atoi(buffer)%100)*1000;

/***************** Get LATITUDE  **********************/
	inx++;   //Достижение первого числа в широте
	memset(buffer, '\0', 12);
	i=0;
	while (GGAbuffer[inx] != ',')   // Копировать до достижения заданной широты ','
	{
		buffer[i] = GGAbuffer[inx];
		i++;
//		if(i>sizeof(buffer)){
//			return 0;
//		}
		inx++;
	}
	if (strlen(buffer) < 6) return 2;  //Если длина буфера не подходит, вернуть ошибку
	//int16_t num;// = (atoi(buffer));   // Изменить буфер на число, он преобразует только до десятичной дроби
	int j = 0;
	float grad;
	while (buffer[j] != '.') j++;   // Выяснить, сколько цифр перед десятичной точкой
	j-=2;//++;
	grad=atof (&buffer[j])/60.0f;
	buffer[j]='#';
	grad += (atof(buffer));

//	int declen = (strlen(buffer))-j;
//	int dec = atoi ((char *) buffer+j);
//	float lat = (num/100.0) + (dec/pow(10, (declen+2)));
	gga->lcation.latitude = grad;//lat;
	inx++;
	gga->lcation.NS = GGAbuffer[inx];
	if(gga->lcation.NS=='S'){
		gga->lcation.latitude=-gga->lcation.latitude;
	}

/***********************  GET LONGITUDE **********************/
	inx++;  // ',' После символа NS
	inx++;  // Дойти до первой цифры в значении долготы
	memset(buffer, '\0', 12);
	i=0;
	while (GGAbuffer[inx] != ',')  // Копировать до достижения заданной высоты ','
	{
		buffer[i] = GGAbuffer[inx];
		i++;
//		if(i>sizeof(buffer)){
//			return 0;
//		}
		inx++;
	}
	//num = (atoi(buffer));
	j = 0;
	while (buffer[j] != '.') {
		j++;
//		if (j>sizeof(buffer)){
//			return 0;
//		}
	}
	j-=2;//++;
	grad=atof (&buffer[j])/60.0f;
	buffer[j]='#';
	grad += (atof(buffer));
//	declen = (strlen(buffer))-j;
//	dec = atoi ((char *) buffer+j);
//	lat = (num/100.0) + (dec/pow(10, (declen+2)));
	gga->lcation.longitude = grad;//lat;
	inx++;
	gga->lcation.EW = GGAbuffer[inx];
	if(gga->lcation.EW=='W'){
		gga->lcation.longitude=-gga->lcation.longitude;
	}

/**************************************************/
	//Пропустить исправление позиции
	inx++;   // ',' after E/W

	/*************** Информация о типе вычисления координат ********************/
	inx++;   // position fix
	memset(buffer, '\0', 12);
	i=0;
	while (GGAbuffer[inx] != ',')
	{
		buffer[i] = GGAbuffer[inx];
		i++;
//		if(i>sizeof(buffer)){
//		   return 0;
//		}
		inx++;
	}
	 gga->calc.calculation = atoi(buffer);
//	int declen_1 = (strlen(buffer));
//	int dec_1 = atoi ((char *) buffer);
//	int calc = (num_1) + (dec_1/pow(10, (declen_1)));
//    gga->calc.calculation = calc;
	inx++;   // ',' после фиксации позиции;
	// количесвто спутников
	memset(buffer, '\0', 12);
		i=0;
		while (GGAbuffer[inx] != ',')
		{
			buffer[i] = GGAbuffer[inx];
			i++;
//			if(i>sizeof(buffer)){
//			  return 0;
//			}
			inx++;
		}
		gga->numofsat = atoi(buffer);
	inx++;

	/***************** skip HDOP  *********************/
	while (GGAbuffer[inx] != ',') inx++;


	/*************** Altitude calculation ********************/
	inx++;
	memset(buffer, '\0', 12);
	i=0;
	while (GGAbuffer[inx] != ',')
	{
		buffer[i] = GGAbuffer[inx];
		i++;
//		if(i>sizeof(buffer)){
//			return 0;
//		}
		inx++;
	}
	float alt = (atof(buffer));
//	j = 0;
//	while (buffer[j] != '.') j++;
//	j++;
//	int declen = (strlen(buffer))-j;
//	int dec = atoi ((char *) buffer+j);
//	int lat = (num) + (dec/pow(10, (declen)));
	gga->alt.altitude = alt;//изменил

	inx++;
	gga->alt.unit = GGAbuffer[inx];

	return 0;
}

int decodeRMC (char *RMCbuffer, RMCSTRUCT *rmc)
{
	inx = 0;
	char buffer[12];
	int i = 0;
	while (RMCbuffer[inx] != ',') inx++;  // 1st ,
	inx++;
	while (RMCbuffer[inx] != ',') inx++;  // После time ,
	inx++;
	if (RMCbuffer[inx] == 'A')
	{
		rmc->isValid = 1;
	}
	else
	{
		rmc->isValid =0;
		return 1;
	}
	inx++;
	inx++;
	while (RMCbuffer[inx] != ',') inx++;  // после latitude,
	inx++;
	while (RMCbuffer[inx] != ',') inx++;  // после NS ,
	inx++;
	while (RMCbuffer[inx] != ',') inx++;  // после longitude ,
	inx++;
	while (RMCbuffer[inx] != ',') inx++;  // после EW ,

	// Получить скорость
	inx++;
	i=0;
	memset(buffer, '\0', 12);
	while (RMCbuffer[inx] != ',')
	{
		buffer[i] = RMCbuffer[inx];
		i++;
//		if(i>sizeof(buffer)){
//			return 0;
//		}
		inx++;
	}

	if (strlen (buffer) > 0){
		int16_t num = (atoi(buffer));
		int j = 0;
		while (buffer[j] != '.') j++;   // тоже, что и выше
		j++;
		int declen = (strlen(buffer))-j;
		int dec = atoi ((char *) buffer+j);
		float lat = num + (dec/pow(10, (declen)));// изменил
		rmc->speed = lat;
	}
	else rmc->speed = 0;

	// Получить курс
	inx++;
	i=0;
	memset(buffer, '\0', 12);
	while (RMCbuffer[inx] != ',')
	{
		buffer[i] = RMCbuffer[inx];
		i++;
//		if(i>sizeof(buffer)){
//			return 0;
//		}
		inx++;
	}

	if (strlen (buffer) > 0){
		int16_t num = (atoi(buffer));
		int j = 0;
		while (buffer[j] != '.') j++;
		j++;
		int declen = (strlen(buffer))-j;
		int dec = atoi ((char *) buffer+j);
		float lat = num + (dec/pow(10, (declen)));//изменил
		rmc->course = lat;
	}
	else
		{
			rmc->course = 0;
		}

	// Получить дату
	inx++;
	i=0;
	memset(buffer, '\0', 12);
	while (RMCbuffer[inx] != ',')
	{
		buffer[i] = RMCbuffer[inx];
		i++;
//		if(i>sizeof(buffer)){
//			return 0;
//		}
		inx++;
	}

	// Дата в формате 120295
	day = atoi(buffer)/10000;
	mon = (atoi(buffer)/100)%100;
	yr = atoi(buffer)%100;

	day = day+daychange;// коррекция из-за сдвига по Гринвичу

	// сохранить данные в структуру
	rmc->date.Day = day;
	rmc->date.Mon = mon;
	rmc->date.Yr = yr;

	return 0;
}

#include "./Project/shared.h"
#include "./Project/GNSS/uartProc_GNSS.h"
#include "./Project/GNSS/NMEA.h"
#include "./Project/DP/uart_Proc_dp.h"
#include "./Project/uart_processing.h"
#include "main.h"
#include <stdlib.h>//abs
#include <string.h>//memset
#include <stdio.h>

extern volatile uint8_t uartRxFullIRDone; //сработало прерывание по полному буферу
extern volatile uint8_t uartRxHalfIRDone; //сработало прерывание по половине
extern volatile uint8_t uartRxABDone;//сработало прерывание на прием от АБ
extern volatile uint8_t uartTxIRDone_AB; //сработало прерывание на отправку в АБ
extern short status_UART;

//для проверки что gps отключили
#define DELAY_GPS_STATUS_CONNECT 1000
uint32_t gps_time_recieve = 0;//когда получили данные от GPS
//uint8_t gps_connect_status=-1;//-1=не подключен 1=подключен
//E N D для проверки что gps отключили

#define SIZEBUF_result_out_ab 55 //57 //53   0x5A 0xA5 0
unsigned char  uart_rezult_buf_out_AB[SIZEBUF_result_out_ab]={0,};
		                                               //"00.0000000 00.0000000 00:00:00.000 00 0 000.0 00.0>";
                                                       //50.1234567 37.1234567 16:11:33:128 09 2 134.2 34.6
int size_rez_buf_ab=0;

//буфер для сырых данных от GPS
#define SIZEBUF_uart_rx_buf 1000
uint8_t uart_rx_buf[SIZEBUF_uart_rx_buf]={0,};

//буфер для GPS-GGA
#define SIZEBUF_buf_GGA 100
 char buf_GGA[SIZEBUF_buf_GGA]={0,};
 //буфер для GPS-RMC
#define SIZEBUF_buf_RMC 100
 char buf_RMC[SIZEBUF_buf_RMC]={0,};
// NMEA
GPSSTRUCT gpsData;
int flagGGA = 0, flagRMC = 0;

//для составления строк
#define SIZEBUF_shablon 3
char shablonGNGGA[]="GGA";
char shablonGNRMC[]="RMC";
short shablon_iGNGGA=0;
short shablon_iGNRMC=0;
char shablonMode=0;//0=ищем шаблон//1=ожидаем символ конца строки 13
char shablonMode_1=0;

//буфер для сборки строки
#define SIZEBUF_result 100
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 для составления строк


void uart_GNSS_init(void)
{
	uart_rezult_buf_out_AB[0]=0x5A;
	uart_rezult_buf_out_AB[1]=0xA5;
//	size_rez_buf_ab=strlen((const char *)uart_rezult_buf_out_AB);
	size_rez_buf_ab=sprintf((char*)&uart_rezult_buf_out_AB[3], "00.0000000 00.0000000 00:00:00.000 00 0 000.0 00.0>");
//	size_rez_buf_ab= uart_rezult_buf_out_AB[3];               //50.1234567 37.1234567 16:11:33:128 09 2 134.2 34.6
	uart_rezult_buf_out_AB[2]=(unsigned char)size_rez_buf_ab;                                                                 //"00.0000000 00.0000000 00:00:00.000 00 0 000.0 00.0>"
	size_rez_buf_ab+=3;//прембула + длина поля
}


//int ttt=0;//отладка

void uart_Handler_GNSS(void)//эту функцию нужно вызывать постоянно
{

	uint32_t ms = HAL_GetTick();

	char isData=0;
	char* pData=(char*)uart_rx_buf;

	if(uartRxFullIRDone){
		uartRxFullIRDone = 0;
		pData=(char*)&uart_rx_buf[SIZEBUF_uart_rx_buf/2];
		isData=1;
		gps_time_recieve=ms;
	}
	if(uartRxHalfIRDone){
		uartRxHalfIRDone = 0;
		isData=1;
		gps_time_recieve=ms;
	}

	if(isData){
		isData=0;
		//статус о том что gps активен
		gParams.isGPS=1;
//		if(gps_connect_status!=1){
//			gps_connect_status=1;
//			fillBuff_com9(-1, 1);
//		}

		for(int i =0;i<SIZEBUF_uart_rx_buf/2;i++){
			switch (shablonMode) {
			case 0://0=ищем шаблон
				if(pData[i]==shablonGNGGA[shablon_iGNGGA]){
					shablon_iGNGGA++;
				}else{
					shablon_iGNGGA=0;
				}
				if(pData[i]==shablonGNRMC[shablon_iGNRMC]){
					shablon_iGNRMC++;
				}else{
					shablon_iGNRMC=0;
				}

				if(shablon_iGNGGA || shablon_iGNRMC){
					uart_rezult_buf[uart_rezult_buf_i]=pData[i];uart_rezult_buf_i++;

					if(shablon_iGNGGA>=SIZEBUF_shablon || shablon_iGNRMC>=SIZEBUF_shablon){
						shablon_iGNGGA=0;
						shablon_iGNRMC=0;
						shablonMode=1;//переходим в режим поиска конца строки
					}
				}else{
					uart_rezult_buf_i=0;
				}
				break;
			case 1://1=ожидаем символ конца строки 13
				if(pData[i]==13 || pData[i]==10){
					//собрали строку
					uart_rezult_buf[uart_rezult_buf_i]='\r';
					uart_rezult_buf_i++;
					if(uart_rezult_buf_i>=SIZEBUF_result){uart_rezult_buf_i=SIZEBUF_result;}
					uart_rezult_buf[uart_rezult_buf_i]='\n';

					//переключаемся на следующий буфер
					if(uart_rezult_buf==uart_rezult_buf1){
						uart_rezult_buf=uart_rezult_buf2;
						uart_bufRow=uart_rezult_buf1;
					}else{
						uart_rezult_buf=uart_rezult_buf1;
						uart_bufRow=uart_rezult_buf2;
					}

					if(uart_bufRow[0] == 'G')//Поток данных от GGA
					{
						memcpy(buf_GGA,uart_bufRow,SIZEBUF_buf_GGA);
					}
					if(uart_bufRow[0] == 'R')//Поток данных от RMC
					{
						memcpy(buf_RMC,uart_bufRow,SIZEBUF_buf_RMC);
					}

					//-----------------------------------------Работа с NMEA--------------------------------------------------------------
					if (decodeGGA(buf_GGA, &gpsData.ggastruct) == 0) flagGGA = 2;  // 2 indicates the data is valid
					else flagGGA = 1;  // 1 indicates the data is invalid

					//if(ttt){decodeGGA(buf_GGA, &gpsData.ggastruct);}//отладка

					if (decodeRMC(buf_RMC, &gpsData.rmcstruct) == 0) flagRMC = 2;  // 2 indicates the data is valid
					else flagRMC = 1;  // 1 indicates the data is invalid

					if ((flagGGA == 2) | (flagRMC == 2))
					{
						uart_rezult_buf_out_AB[0]=0x5A;
						uart_rezult_buf_out_AB[1]=0xA5;
						size_rez_buf_ab=sprintf((char*)&uart_rezult_buf_out_AB[3], 
								 "%.6f %.6f %02d:%02d:%02d.%03d %02d %d %.2f %.2f>",
						gpsData.ggastruct.lcation.latitude,gpsData.ggastruct.lcation.longitude,
						gpsData.ggastruct.tim.hour,gpsData.ggastruct.tim.min, 
						gpsData.ggastruct.tim.sec,gpsData.ggastruct.tim.msec,
						gpsData.ggastruct.numofsat,gpsData.ggastruct.calc.calculation,
						gpsData.ggastruct.alt.altitude,gpsData.rmcstruct.course);
						gParams.isRTK_GPS = gpsData.ggastruct.calc.calculation;//параметры режима работы GPS FORA_ONE
						uart_rezult_buf_out_AB[2]=size_rez_buf_ab;
						size_rez_buf_ab+=3;//размер преамбулы+поле размер

					}
					//переходим в режим поиска шаблона
					uart_rezult_buf_i=0;
					shablonMode=0;
					//memset(uart_rezult_buf_out, 0, SIZEBUF_result_out);
				}else{
					uart_rezult_buf[uart_rezult_buf_i]=pData[i];
					uart_rezult_buf_i++;
					if(uart_rezult_buf_i>=SIZEBUF_result){uart_rezult_buf_i=SIZEBUF_result;}
				}
				break;
			}
		}
	}

	if(gps_time_recieve && ((ms - gps_time_recieve) >= DELAY_GPS_STATUS_CONNECT)){
		//dpi_time_status_connect=0;
		gParams.isGPS=0;

		uart_startRecieving_GNSS();
	}
}

uint8_t* dpi_getGPS_buffer(int* ret_buff_size)
{
	if(ret_buff_size){*ret_buff_size=size_rez_buf_ab;}
	return uart_rezult_buf_out_AB;
}

void uart_startRecieving_GNSS(void)
{
	status_UART=1;//1=startRecieving 2=RxHalf 3=RxCplt 4=прием от АБ (uart3)//отладка

	memset(uart_rx_buf,0,sizeof(uart_rx_buf));

	HAL_UART_Receive_DMA(&huart1, (uint8_t*)uart_rx_buf, SIZEBUF_uart_rx_buf);//начинаю прием данных от gps на uart1
}

#include "./Project/shared.h"
#include "./Project/proj_main.h"
#include "./Project/GNSS/uartProc_GNSS.h"
#include "./Project/DP/uart_Proc_dp.h"
#include "./Project/uart_processing.h"

void proj_main()
{
	//volatile const char *ch = ";V-F-BIN;ver: "VER_PROG(VER_a,VER_b,VER_c)";CHIP_ID="STM_CHAR_ID(S_H_I_P_ID)";MODULE_ID="STM_CHAR_ID(M_O_D_U_L_E_ID)";";(void)ch;//0x8008b00
	volatile const char *ch = ";V-F-BIN;ver: "VER_PROG(VER_a,VER_b,VER_c);(void)ch;//0x8008b00


		HAL_Delay(1);//чтобы HAL_GetTick() не выдавал ноль

		setDefaultParams();

		HAL_Delay(500);//отладка
		HAL_UART_DeInit(&huart2);
		HAL_UART_Init(&huart2);

		uart_GNSS_init();
		uart_Proc_dp_init();

		uart_startRecieving_DP();
		uart_startTransmiting_DP();

		uart_startRecieving_AB();
		uart_startRecieving_GNSS();

		while (1){
			//хэндлеры
			uart_Handler();
			uart_Handler_GNSS();
			uart_Handler_DP();

		}//while (1)
}