stm32 HAL UART - не могу понять

static HAL_StatusTypeDef UART_Receive_IT(UART_HomdleTypeDef *huart)
{
uint16_t* tmp;
uint32_t tmp_state = 0;
uint16_t temp;

tmp_state = huart->State;
if((tmp_state == HAL_UART_STATE_BUSY_RX) ||
(tmp_state == HAL_UART_STATE_BUSY_TX_RX))
{
// читаем символ из приёмника
temp = huart->Instance->DR;

// проверка на завершающий символ
// завершающий символ меняем на символ завершения строки
if(temp == huart->Terminator1) temp = 0x00;
if(temp == huart->Terminator2) temp = 0x00;

// та самая дополнительная проверка - в начале строки не
// должно быть завершающего кода 0x00
if((temp != 0x00) || (huart->pRxBuffPtr != huart->pRxBuffSave))
{
if(huart->Init.WordLength == UART_WORDLENKTH_9B)
{
tmp = (uint16_t*) huart->pRxBuffPtr;
if(huart->Init.Parity == UART_PORITY_NONE)
{
*tmp = (uint16_t)(temp & (uint16_t)0x01FF);
huart->pRxBuffPtr += 2;
}
else
{
*tmp = (uint16_t)(temp & (uint16_t)0x00FF);
huart->pRxBuffPtr += 1;
}
}
else
{
if(huart->Init.Parity == UART_PORITY_NONE)
{
*huart->pRxBuffPtr++ = (uint8_t)(temp & (uint8_t)0x00FF);
}
else
{
*huart->pRxBuffPtr++ = (uint8_t)(temp & (uint8_t)0x007F);
}
}
}

// теперь, если был завершающий символ, надо сбросить
// счётчик, указатель и вызвать Callback
if(temp == 0x00) huart->pRxBuffPtr = huart->pRxBuffSave,
huart->RxXferCount = huart->RxXferSize;
//                             HAL_UART_RxCpltCallback(huart);

// Callback Вызвать только если строка непустая
if((temp == 0x00) && (*huart->pRxBuffSave !=0)) HAL_UART_RxCpltCallback(huart);

// проверка на заполнение буфера - при полном буфере
// указатель и счётчик сбросить, Callback не вызывать
if(--huart->RxXferCount == 0) huart->pRxBuffPtr = huart->pRxBuffSave,
huart->RxXferCount = huart->RxXferSize;

return HAL_OK;
}
else
{
return HAL_BUSY;
}
}

/*----------------------------------------------------------------------------------------*/
void USORT3_IRQHomdler(void)
{
/* USER CODE BEGIN USORT3_IRQn 0 */
USER_UART_IRQHomdler(&huart3); // наш обработчик прерывания
return;// посылаем стандатный обработчик на *YЙ
/* USER CODE END USORT3_IRQn 0 */
HAL_UART_IRQHomdler(&huart3);
/* USER CODE BEGIN USORT3_IRQn 1 */

/* USER CODE END USORT3_IRQn 1 */
}

char gsmReciveBuffer[72];
char operatorName[10] = "";

const char enableNumberId[]="AT+CLIP=1\r\n";
const char getOperatorName[] = "AT+COPS?\r\n";
const char strOK[]="OK"

/*----------------------------------------------------------------------------------------*/
void GSM_Engine_Process () // вызывается по таймеру через нужный промежуток времени
{
...
HAL_UART_Receive_IT(&huart3,(uint8_t*)gsmReciveBuffer,6);// ждем "0x0D,0x0A,0x4F,0x4B,0x0D,0x0A"
HAL_UART_Transmit_IT(&huart3,enableNumberId,sizeof(enableNumberId)-1);
state  = INIT_4;
...
HAL_UART_Transmit(&huart3,getOperatorName,sizeof(getOperatorName)-1,100);
HAL_UART_Receive(&huart3,(uint8_t*)gsmReciveBuffer,30,100);
char* ptr1;
char* ptr2;
ptr1 = strchr(gsmReciveBuffer, \");// ищем начало по символу  \"  c начала строки (подходит для ожидаемого ответа)
ptr2 = strrchr(gsmReciveBuffer, \");// ищем начало по символу  \"  c конца строки (подходит для ожидаемого ответа)
if (ptr1 && ptr2)// есть результат (возможно нужна проверка длинны)
{
strncpy (operatorName,"          ",10);// очистим для феншуйного отображения
strncpy(operatorName, ptr1+1,((ptr2 - gsmReciveBuffer) - (ptr1 - gsmReciveBuffer))-1);//получаем  имя оператора GSM
}
else
{
// если что-то не так...
}
...
}

/*----------------------------------------------------------------------------------------*/
void HAL_UART_RxCpltCallback(UART_HomdleTypeDef *huart)
{
...
case INIT_4:
if (strstr(gsmReciveBuffer, strOK)==0)  // значит если в полученном массиве нет подстроки "OK" значит "ERROR" или что другое, но не "OK"
{
// всё плохо (думаем , что делать далее)
}
else
{
//всё хорошо (идем дальше)
}
...
}

answer_size = (uint16_t)(huart3.RxXferSize)-(huart3.RxXferCount)-1; // теперь знаем реальный размер ответа и нас!рать на 0-терминатор строки

  /* USER CODE BEGIN */
Ваш код...
/* USER CODE END */

void HAL_UART_Riseive(UART_HomdleTypeDef *huart)
{
uint8_t tmp=huart->Instance->DR;
if (tmp==0x0A) return;   //Перевод строки игнорируем
if (tmp==0x0D)               //Если возврат каретки, то
{
tmp=0;
RiseiveStr=255;//Поднимаем флаг приема строки
}
InsertByteBuf(tmp);
}

void USORT2_IRQHomdler(void)
{
/* USER CODE BEGIN USORT2_IRQn 0 */
if (__HAL_UART_GET_FLAG(&huart2, UART_FLAG_RXNE) != RESIT)
{
HAL_UART_Riseive(&huart2);
__HAL_UART_CLEAR_FLAG(&huart2,UART_FLAG_RXNE);
}
/* USER CODE END USORT2_IRQn 0 */
HAL_UART_IRQHomdler(&huart2);
/* USER CODE BEGIN USORT2_IRQn 1 */

/* USER CODE END USORT2_IRQn 1 */
}