STM32F103ZET_JDASMBIC/Bluecell_Src/uart.c

/*
 * uart.c
 *
 *  Created on: 2019. 5. 27.
 *      Author: parkyj
 */
#include <stdio.h>
#include <stdint.h>
#include "main.h"
#include "uart.h"

#include "string.h"
#include "Bluecell_operate.h"
#include "CRC.h"


#define DEBUG_PRINT 0


UARTQUEUE TerminalQueue;
UARTQUEUE WifiQueue;
uart_hal_tx_type uart_hal_tx;
extern volatile uint32_t UartRxTimerCnt;

extern bool Bluecell_Operate(uint8_t* data);
extern void MBIC_Operate(uint8_t * data);

void InitUartQueue(pUARTQUEUE pQueue)
{
  pQueue->data = pQueue->head = pQueue->tail = 0;
  uart_hal_tx.output_p = uart_hal_tx.input_p = 0;
//  HAL_UART_Receive_IT(&huart2,rxBuf,5);



  //if (HAL_UART_Receive_IT(&hTerminal, TerminalQueue.Buffer, 1) != HAL_OK)
  if (HAL_UART_Receive_IT(&hTerminal, pQueue->Buffer + pQueue->head, 1) != HAL_OK)
  {
    printf("Comunication ERROR \r\n");
//    _Error_Handler(__FILE__, __LINE__);
  }  
//  if (HAL_UART_Receive_DMA(&hTest, TerminalQueue.Buffer, 1) != HAL_OK)
//  {
////    _Error_Handler(__FILE__, __LINE__);
//  }
  //HAL_UART_Receive_DMA(&hTerminal,  TerminalQueue.Buffer, 1);
  //HAL_UART_Receive_IT(hTerminal, pQueue->Buffer + pQueue->head, 1);
}

void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
//    UART_HandleTypeDef *dst = (huart->Instance == USART2 ? &hTest:&hTerminal);
    pUARTQUEUE pQueue;
   // printf("Function : %s : \r\n",__func__);
    //printf("%02x ",uart_buf[i]);
    UartRxTimerCnt = 0;
    pQueue = &TerminalQueue;
    pQueue->head++;
    if (pQueue->head >= QUEUE_BUFFER_LENGTH) pQueue->head = 0;
    pQueue->data++;
    if (pQueue->data >= QUEUE_BUFFER_LENGTH)
        GetDataFromUartQueue(huart);
      if (HAL_UART_Receive_IT(&hTerminal, pQueue->Buffer + pQueue->head, 1) != HAL_OK)
      {
        printf("Comunication ERROR \r\n");
    //    _Error_Handler(__FILE__, __LINE__);
      }  

//    HAL_UART_Receive_DMA(&hTest, pQueue->Buffer + pQueue->head, 1);
   // Set_UartRcv(true);
}



void PutDataToUartQueue(UART_HandleTypeDef *huart, uint8_t data)
{
    pUARTQUEUE pQueue = &TerminalQueue;
    if (pQueue->data >= QUEUE_BUFFER_LENGTH)
        GetDataFromUartQueue(huart);
    pQueue->Buffer[pQueue->head++] = data;
    if (pQueue->head == QUEUE_BUFFER_LENGTH) pQueue->head = 0;
    pQueue->data++;
   // HAL_UART_Receive_DMA(&hTerminal,  pQueue->Buffer + pQueue->head, 10);
}

volatile uint8_t uart_buf[QUEUE_BUFFER_LENGTH];
void GetDataFromUartQueue(UART_HandleTypeDef *huart)
{
    volatile static int cnt;
    bool chksumret = 0;
    uint16_t Length = 0;
    uint16_t CrcChk = 0;
//    UART_HandleTypeDef *dst = (huart->Instance == USART2 ? &hTest:&hTerminal);
//    UART_HandleTypeDef *dst = &hTerminal;
    pUARTQUEUE pQueue = &TerminalQueue;
//    if (HAL_UART_Transmit(dst, pQueue->Buffer + pQueue->tail, 1, 3000) != HAL_OK)
//    {
//       _Error_Handler(__FILE__, __LINE__);
//    }
    uart_buf[cnt++] = *(pQueue->Buffer + pQueue->tail); 
//#ifdef DEBUG_PRINT
//    printf("%02x ",*(pQueue->Buffer + pQueue->tail)) ;
//#endif /* DEBUG_PRINT */

    pQueue->tail++;
    pQueue->data--;
    if (pQueue->tail >= QUEUE_BUFFER_LENGTH) {
        pQueue->tail = 0;
    }
    
    
    if(pQueue->data == 0){

//        printf("data cnt zero !!!  \r\n");
        //RF_Ctrl_Main(&uart_buf[Header]);
//        HAL_UART_Transmit(dst, &temp_buf[BLUECELL_HEADER00], 11, 3000);
#if DEBUG_PRINT// PYJ.2019.07.15_BEGIN --
            printf("\r\n[RX]");
            for(int i = 0; i < cnt; i++){
                printf("%02x ",uart_buf[i]);
            }
            printf(ANSI_COLOR_GREEN"\r\n CNT : %d \r\n"ANSI_COLOR_RESET,cnt);
#endif // PYJ.2019.07.15_END --
            if(uart_buf[0] == 0xbe){
                Length = uart_buf[BLUECELL_LENGTH_H] << 8  |  uart_buf[BLUECELL_LENGTH_L] ;
                CrcChk = uart_buf[Length + 1] << 8 | uart_buf[Length  + 2] ;
                if(CRC16_Check(&uart_buf[BLUECELL_TYPE], Length,CrcChk) == NO_ERROR && Length != 0){
                  	Bluecell_Operate(uart_buf);
                }
            }else if(uart_buf[0] == MBIC_PREAMBLE0
                   &&uart_buf[1] == MBIC_PREAMBLE1
                   &&uart_buf[2] == MBIC_PREAMBLE2
                   &&uart_buf[3] == MBIC_PREAMBLE3)
           {
               if(Chksum_Check(uart_buf,MBIC_HEADER_SIZE - 4,uart_buf[MBIC_CHECKSHUM_INDEX]))
               {
                    Length = ((uart_buf[MBIC_LENGTH_0] << 8) | uart_buf[MBIC_LENGTH_1]);
                    CrcChk = ((uart_buf[MBIC_PAYLOADSTART + Length ] << 8) | (uart_buf[MBIC_PAYLOADSTART + Length + 1]));
                    if(CRC16_Check(&uart_buf[MBIC_PAYLOADSTART], Length,CrcChk) == NO_ERROR)
                        MBIC_Operate(uart_buf);
                    else
                      printf("CRC ERROR \r\n");
               }
               else
               {
                    printf("CHECK SUM ERR \r\n");
               }
            }
            memset(uart_buf,0x00,QUEUE_BUFFER_LENGTH);
//        for(int i  = 0; i < cnt; i++)
//            uart_buf[i] = 0;
        cnt = 0;
//        HAL_Delay(1);
    }

}
void Uart_Check(void){
  while (TerminalQueue.data > 0 && UartRxTimerCnt > 50) GetDataFromUartQueue(&hTerminal);
}


void Uart1_Data_Send(uint8_t* data,uint16_t size){
//    HAL_UART_Transmit(&hTerminal, &data[0],size,0xFFFF);
//    HAL_UART_Transmit(&hTerminal, &data[0],size,0xFFFF);
//    HAL_UART_Transmit(&hTest, &data[0],size,0xFFFF);
      HAL_UART_Transmit_DMA(&hTerminal, &data[0],size);

  //HAL_UART_Transmit_IT(&hTerminal, &data[0],size);
//    printf("data[278] : %x \r\n",data[278]);
////    HAL_Delay(1);   
#if DEBUG_PRINT // PYJ.2020.07.19_BEGIN -- 
    printf("\r\n [TX] : ");
    for(int i = 0; i< size; i++)
        printf("%02x ",data[i]);
//    printf("};\r\n\tCOUNT : %d \r\n",size);
    printf("\r\n");
#endif // PYJ.2020.07.19_END -- 
//    printf("\r\n [TX] : {");
//    for(int i = 0; i< size; i++){
//        printf(",%02x ",data[i]);
//        data[i] = 0;
//    }
//    printf("};\r\n\tCOUNT : %d \r\n",size);
//    printf("\r\n");
    
}