ESP8266 Wifi Data 못가져오는 버그 수정

Data 딜레이로 인한 Data 손실 특정 헤더 검색 시  data 가져오기

Debug/Src/esp8266.su

@@ -1,3 +1,4 @@
-esp8266.c:12:6:ESP8266_Initialize	8	static
-esp8266.c:62:9:ESP8266_Strindex	8	static
-esp8266.c:65:9:ESP8266_StrFilter	16	static
+esp8266.c:13:6:ESP8266_Initialize	8	static
+esp8266.c:63:9:ESP8266_StrLength	8	static
+esp8266.c:66:9:ESP8266_StrIndexSearch	16	static
+esp8266.c:75:9:ESP8266_StrFilter	32	static

Debug/Src/main.su

@@ -1,6 +1,6 @@
-main.c:87:6:HAL_TIM_PeriodElapsedCallback	0	static
-main.c:97:5:_write	8	static
-main.c:102:10:ADC_Value_RetFunc	0	static
-main.c:196:6:SystemClock_Config	96	static
-main.c:113:5:main	96	static
-main.c:630:6:Error_Handler	0	static
+main.c:88:6:HAL_TIM_PeriodElapsedCallback	0	static
+main.c:98:5:_write	8	static
+main.c:103:10:ADC_Value_RetFunc	0	static
+main.c:201:6:SystemClock_Config	96	static
+main.c:114:5:main	96	static
+main.c:635:6:Error_Handler	0	static

Debug/Src/uart.su

@@ -1,6 +1,8 @@
-uart.c:12:6:InitUartQueue	8	static
-uart.c:56:6:GetDataFromUartQueue	16	static
-uart.c:24:6:HAL_UART_RxCpltCallback	16	static
-uart.c:37:6:PutDataToUartQueue	16	static
-uart.c:88:6:Uart1_Data_Send	0	static
-uart.c:91:6:Uart2_Data_Send	0	static
+uart.c:14:6:InitUartQueue	8	static
+uart.c:40:6:UartDataRecvSet	0	static
+uart.c:43:6:UartDataRecvGet	0	static
+uart.c:67:6:GetDataFromUartQueue	16	static
+uart.c:26:6:HAL_UART_RxCpltCallback	16	static
+uart.c:47:6:PutDataToUartQueue	16	static
+uart.c:102:6:Uart1_Data_Send	0	static
+uart.c:105:6:Uart2_Data_Send	0	static

Inc/esp8266.h

@@ -10,7 +10,7 @@
 
 #include "main.h"
 
-uint8_t ESP8266_Strindex(uint8_t* str);
+uint8_t ESP8266_StrLength(uint8_t* str);
 void ESP8266_Initialize(void);
 uint8_t ESP8266_StrFilter(uint8_t* str);
 

Inc/uart.h

@@ -31,7 +31,8 @@ extern UARTQUEUE WifiQueue;
 void PutDataToUartQueue(UART_HandleTypeDef *huart, uint8_t data);
 void InitUartQueue(UART_HandleTypeDef *huart,pUARTQUEUE pQueue);
 void GetDataFromUartQueue(UART_HandleTypeDef *huart);
-bool Get_UartRcv(void);
-void Set_UartRcv(bool);
+void UartDataRecvSet(bool);
+bool UartDataRecvGet(void);
+
 
 #endif /* UART_H_ */

Src/esp8266.c

@@ -6,6 +6,7 @@
  */
 
 #include <string.h>
+#include <stdlib.h>
 #include "esp8266.h"
 
 
@@ -35,21 +36,21 @@ void ESP8266_Initialize(void){
 #if 1 // PYJ.2019.12.13_BEGIN -- 
 	  switch(seq){
     	  case 0:
-              Uart2_Data_Send("AT+CWMODE=3\r\n",ESP8266_Strindex("AT+CWMODE=3\r\n"));
+              Uart2_Data_Send("AT+CWMODE=3\r\n",ESP8266_StrLength("AT+CWMODE=3\r\n"));
     		  seq++;
     		  break;
     	  case 1:
-              Uart2_Data_Send("AT+CIPMUX=1\r\n",ESP8266_Strindex("AT+CIPMUX=1\r\n"));
+              Uart2_Data_Send("AT+CIPMUX=1\r\n",ESP8266_StrLength("AT+CIPMUX=1\r\n"));
     		  seq++;
     		  break;
     	  case 2:
-              Uart2_Data_Send("AT+CWSAP=\"BLUE_TEST\",\"\",5,0\r\n",ESP8266_Strindex("AT+CWSAP=\"BLUE_TEST\",\"\",5,0\r\n"));
+              Uart2_Data_Send("AT+CWSAP=\"BLUE_TEST\",\"\",5,0\r\n",ESP8266_StrLength("AT+CWSAP=\"BLUE_TEST\",\"\",5,0\r\n"));
     		  seq++;
     		  break;
     	  case 3:
-              Uart2_Data_Send("AT+CIPSERVER=1,4000\r\n",ESP8266_Strindex("AT+CIPSERVER=1,4000\r\n"));
+              Uart2_Data_Send("AT+CIPSERVER=1,4000\r\n",ESP8266_StrLength("AT+CIPSERVER=1,4000\r\n"));
               HAL_Delay(5);
-              Uart2_Data_Send("AT+CIFSR\r\n",ESP8266_Strindex("AT+CIFSR\r\n"));
+              Uart2_Data_Send("AT+CIFSR\r\n",ESP8266_StrLength("AT+CIFSR\r\n"));
     		  printf("ESP Setting Complete \r\n");
     		  seq++;
     		  break;
@@ -59,18 +60,48 @@ void ESP8266_Initialize(void){
 #endif // PYJ.2019.12.13_END -- 
 
 }
-uint8_t ESP8266_Strindex(uint8_t* str){
+uint8_t ESP8266_StrLength(uint8_t* str){
     return strlen(str);
 }
+uint8_t ESP8266_StrIndexSearch(uint8_t* str,uint8_t* searchstr){
+    for(int i = 0; i < ESP8266_StrLength(str); i++){
+        if(*(str + i) == *searchstr){
+//            printf("\"%s \" index : %d \r\n",*searchstr, i);
+            return i;
+        }
+    }
+    return 0;
+}
 uint8_t ESP8266_StrFilter(uint8_t* str){
-    char *ptr = strstr(str, ":");      // den으로 시작하는 문자열 검색, 포인터 반환
-    
+    uint8_t *ptr = strstr(str, "+IPD,0,30:");      // den으로 시작하는 문자열 검색, 포인터 반환
+    uint8_t temp_index;
+    uint8_t temp_length;
+    uint8_t temp_str[5] = {NULL,};
     //printf("first : %s\n", ptr);    // den Diary
-    
-    printf("\r\nResult : ");
-    for(int i = 0; i < ESP8266_Strindex(ptr); i++)
-        printf("%d", ptr[i]);    // den Diary
-
-    printf("\r\n");
+    if(strstr(ptr, "+IPD,0,30:") != NULL){
+        temp_index= ESP8266_StrIndexSearch(ptr,":"); 
+        if(temp_index == 0 || *(ptr + (temp_index + 1)) != 0xbe){
+            return 0;
+        }else{
+            temp_str[0] = ptr[temp_index - 2];
+            temp_str[1] = ptr[temp_index - 1];
+        
+            temp_length = atoi(temp_str);
+    //        temp_length += atoi(ptr[temp_index - 1]);
+    //        printf("(+IPD,0,)Length%d \r\n",ESP8266_StrLength("+IPD,0,"));
+    //        printf("Length Result : %d \r\n",temp_length);
+            //if(ptr != NULL){
+                printf("\r\n %d Result : ",ESP8266_StrLength(ptr));
+                for(int i = (temp_index + 1); i < temp_length + (temp_index + 1) + 9; i++)
+                    printf("%d ", *(ptr + i));    // den Diary
+                printf("\r\n");
+            //}
+        }
+    }else{
+  //      for(int i = 0; i < ESP8266_StrLength(ptr); i++) 
+//            printf("%c",*(ptr+ i));
+        printf("I am not found\r\n");
+    }
 
+    return 0;
 }

Src/main.c

@@ -21,6 +21,7 @@
 /* Includes ------------------------------------------------------------------*/
 #include <stdio.h>
 #include <string.h>
+#include <stdbool.h>
 #include "main.h"
 
 /* Private includes ----------------------------------------------------------*/
@@ -179,8 +180,12 @@ int main(void)
 //	      printf("ADC Vale : %f \r\n",temp_tmp * temp_val);
 	      AdcTimerCnt = 0;
 	  }
-	   while (TerminalQueue.data > 0) GetDataFromUartQueue(&hTerminal);
-	   while (WifiQueue.data > 0) GetDataFromUartQueue(&hWifi);
+      if(UartTimerCnt > 300 && UartDataRecvGet()){
+          while (TerminalQueue.data > 0) GetDataFromUartQueue(&hTerminal);
+          while (WifiQueue.data > 0) GetDataFromUartQueue(&hWifi);
+          UartTimerCnt = 0;
+          UartDataRecvSet(false);
+      }
        HAL_Delay(1);
     /* USER CODE END WHILE */
 

Src/uart.c

@@ -6,9 +6,11 @@
  */
 
 #include "uart.h"
-
+#include <stdbool.h>
 UARTQUEUE TerminalQueue;
 UARTQUEUE WifiQueue;
+bool UartDataisReved;
+
 void InitUartQueue(UART_HandleTypeDef *huart,pUARTQUEUE pQueue)
 {
     UART_HandleTypeDef *dst = (huart->Instance == USART2 ? &hWifi:&hTerminal);
@@ -32,8 +34,16 @@ void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
     if (pQueue->data >= QUEUE_BUFFER_LENGTH)
         GetDataFromUartQueue(huart);
     HAL_UART_Receive_DMA(dst, pQueue->Buffer + pQueue->head, 1);
+    UartDataRecvSet(true);
    // Set_UartRcv(true);
 }
+void UartDataRecvSet(bool val){
+    UartDataisReved = val;
+}
+bool UartDataRecvGet(void){
+    return UartDataisReved;
+}
+
 void PutDataToUartQueue(UART_HandleTypeDef *huart, uint8_t data)
 {
     pUARTQUEUE pQueue = (huart->Instance == USART2 ? &WifiQueue:&TerminalQueue);
@@ -52,6 +62,7 @@ typedef enum{
 }Bluecell_Prot_p;
 
 uint8_t uart_buf[QUEUE_BUFFER_LENGTH];
+bool GoodDataStatus = false;
 
 void GetDataFromUartQueue(UART_HandleTypeDef *huart)
 {
@@ -67,6 +78,8 @@ if(huart->Instance == USART1){
 #endif // PYJ.2019.12.13_END -- 
     printf("%c",*(pQueue->Buffer + pQueue->tail));
     uart_buf[cnt++] = *(pQueue->Buffer + pQueue->tail); 
+    if(*(pQueue->Buffer + pQueue->tail) == 0xbe)
+        GoodDataStatus = true;
     
 
 //    printf("Function : %s : ",__func__);
@@ -79,10 +92,11 @@ if(huart->Instance == USART1){
     pQueue->tail++;
     if (pQueue->tail >= QUEUE_BUFFER_LENGTH) pQueue->tail = 0;
     pQueue->data--;
-    if(pQueue->data == 0){
+    if(pQueue->data == 0 && GoodDataStatus == true){
         ESP8266_StrFilter(&uart_buf[Header]);
         memset(uart_buf,NULL,cnt);
         cnt = 0;
+        GoodDataStatus = false;
     }
 }
 void Uart1_Data_Send(uint8_t* data,uint8_t size){

insight/STM32F103_WifiAttenCtrlTest.si4project/Backup/esp8266(1154).c

@@ -0,0 +1,76 @@
+/*
+ * esp8266.c
+ *
+ *  Created on: Jul 9, 2019
+ *      Author: parkyj
+ */
+
+#include <string.h>
+#include "esp8266.h"
+
+
+void ESP8266_Initialize(void){
+	  volatile static bool init = false;
+	  volatile static uint8_t seq = 0;
+    uint8_t str[100] = {0,};
+	  if(init == false ||  seq < 4){
+		  init = true;
+	  }else{
+	  /* * * * *DATA SEND COMMADN * * * * * */
+#if 0 // PYJ.2019.08.06_BEGIN --
+    Uart2_Data_Send("AT+CIPSEND=0,4\r\n",ESP8266_Strindex("AT+CIPSEND=0,4\r\n"));
+    HAL_Delay(1000);
+    sprintf(str,"%d", ADC_Value_RetFunc());
+    Uart2_Data_Send(str,ESP8266_Strindex(str));
+    printf("%s\r\n INDEX : %d",str,ESP8266_Strindex(str));
+    HAL_Delay(500);
+//          Uart2_Data_Send("be\r\n",ESP8266_Strindex("123456789\r\n"));
+          
+#endif // PYJ.2019.08.06_END -- 
+//          Uart2_Data_Send("AT+CIPSEND=1,1\r\n",ESP8266_Strindex("AT+CIPSEND=1,1\r\n"));
+//          HAL_Delay(5); 
+//          Uart2_Data_Send("1\r\n",ESP8266_Strindex("1\r\n"));              
+        return;
+	  }
+#if 1 // PYJ.2019.12.13_BEGIN -- 
+	  switch(seq){
+    	  case 0:
+              Uart2_Data_Send("AT+CWMODE=3\r\n",ESP8266_Strindex("AT+CWMODE=3\r\n"));
+    		  seq++;
+    		  break;
+    	  case 1:
+              Uart2_Data_Send("AT+CIPMUX=1\r\n",ESP8266_Strindex("AT+CIPMUX=1\r\n"));
+    		  seq++;
+    		  break;
+    	  case 2:
+              Uart2_Data_Send("AT+CWSAP=\"BLUE_TEST\",\"\",5,0\r\n",ESP8266_Strindex("AT+CWSAP=\"BLUE_TEST\",\"\",5,0\r\n"));
+    		  seq++;
+    		  break;
+    	  case 3:
+              Uart2_Data_Send("AT+CIPSERVER=1,4000\r\n",ESP8266_Strindex("AT+CIPSERVER=1,4000\r\n"));
+              HAL_Delay(5);
+              Uart2_Data_Send("AT+CIFSR\r\n",ESP8266_Strindex("AT+CIFSR\r\n"));
+    		  printf("ESP Setting Complete \r\n");
+    		  seq++;
+    		  break;
+    	  default:
+    		  break;
+	  }
+#endif // PYJ.2019.12.13_END -- 
+
+}
+uint8_t ESP8266_Strindex(uint8_t* str){
+    return strlen(str);
+}
+uint8_t ESP8266_StrFilter(uint8_t* str){
+    char *ptr = strstr(str, ":");      // den으로 시작하는 문자열 검색, 포인터 반환
+    
+    //printf("first : %s\n", ptr);    // den Diary
+    
+    printf("\r\nResult : ");
+    for(int i = 0; i < ESP8266_Strindex(ptr); i++)
+        printf("%d", *(ptr + i));    // den Diary
+
+    printf("\r\n");
+
+}

insight/STM32F103_WifiAttenCtrlTest.si4project/Backup/esp8266(1956).c

@@ -0,0 +1,99 @@
+/*
+ * esp8266.c
+ *
+ *  Created on: Jul 9, 2019
+ *      Author: parkyj
+ */
+
+#include <string.h>
+#include <stdlib.h>
+#include "esp8266.h"
+
+
+void ESP8266_Initialize(void){
+	  volatile static bool init = false;
+	  volatile static uint8_t seq = 0;
+    uint8_t str[100] = {0,};
+	  if(init == false ||  seq < 4){
+		  init = true;
+	  }else{
+	  /* * * * *DATA SEND COMMADN * * * * * */
+#if 0 // PYJ.2019.08.06_BEGIN --
+    Uart2_Data_Send("AT+CIPSEND=0,4\r\n",ESP8266_Strindex("AT+CIPSEND=0,4\r\n"));
+    HAL_Delay(1000);
+    sprintf(str,"%d", ADC_Value_RetFunc());
+    Uart2_Data_Send(str,ESP8266_Strindex(str));
+    printf("%s\r\n INDEX : %d",str,ESP8266_Strindex(str));
+    HAL_Delay(500);
+//          Uart2_Data_Send("be\r\n",ESP8266_Strindex("123456789\r\n"));
+          
+#endif // PYJ.2019.08.06_END -- 
+//          Uart2_Data_Send("AT+CIPSEND=1,1\r\n",ESP8266_Strindex("AT+CIPSEND=1,1\r\n"));
+//          HAL_Delay(5); 
+//          Uart2_Data_Send("1\r\n",ESP8266_Strindex("1\r\n"));              
+        return;
+	  }
+#if 1 // PYJ.2019.12.13_BEGIN -- 
+	  switch(seq){
+    	  case 0:
+              Uart2_Data_Send("AT+CWMODE=3\r\n",ESP8266_StrLength("AT+CWMODE=3\r\n"));
+    		  seq++;
+    		  break;
+    	  case 1:
+              Uart2_Data_Send("AT+CIPMUX=1\r\n",ESP8266_StrLength("AT+CIPMUX=1\r\n"));
+    		  seq++;
+    		  break;
+    	  case 2:
+              Uart2_Data_Send("AT+CWSAP=\"BLUE_TEST\",\"\",5,0\r\n",ESP8266_StrLength("AT+CWSAP=\"BLUE_TEST\",\"\",5,0\r\n"));
+    		  seq++;
+    		  break;
+    	  case 3:
+              Uart2_Data_Send("AT+CIPSERVER=1,4000\r\n",ESP8266_StrLength("AT+CIPSERVER=1,4000\r\n"));
+              HAL_Delay(5);
+              Uart2_Data_Send("AT+CIFSR\r\n",ESP8266_StrLength("AT+CIFSR\r\n"));
+    		  printf("ESP Setting Complete \r\n");
+    		  seq++;
+    		  break;
+    	  default:
+    		  break;
+	  }
+#endif // PYJ.2019.12.13_END -- 
+
+}
+uint8_t ESP8266_StrLength(uint8_t* str){
+    return strlen(str);
+}
+uint8_t ESP8266_StrIndexSearch(uint8_t* str,uint8_t* searchstr){
+    for(int i = 0; i < ESP8266_StrLength(str); i++){
+        if(*(str + i) == *searchstr){
+//            printf("\"%s \" index : %d \r\n",*searchstr, i);
+            return i;
+        }
+    }
+    return 0;
+}
+uint8_t ESP8266_StrFilter(uint8_t* str){
+    uint8_t *ptr = strstr(str, "+IPD,0,");      // den으로 시작하는 문자열 검색, 포인터 반환
+    uint8_t temp_index;
+    uint8_t temp_length;
+    uint8_t temp_str[5] = {NULL,};
+    //printf("first : %s\n", ptr);    // den Diary
+    if(strstr(ptr, "+IPD,0,") != NULL){
+        temp_index= ESP8266_StrIndexSearch(ptr,":"); 
+        temp_str[0] = ptr[temp_index - 2];
+        temp_str[1] = ptr[temp_index - 1];
+    
+        temp_length = atoi(temp_str);
+//        temp_length += atoi(ptr[temp_index - 1]);
+//        printf("(+IPD,0,)Length%d \r\n",ESP8266_StrLength("+IPD,0,"));
+//        printf("Length Result : %d \r\n",temp_length);
+        if(ptr != NULL){
+            printf("\r\n %d Result : ",ESP8266_StrLength(ptr));
+            for(int i = (temp_index + 1); i < temp_length + (temp_index + 1) + 9; i++)
+                printf("%d ", *(ptr + i));    // den Diary
+            printf("\r\n");
+        }
+    }
+
+
+}

insight/STM32F103_WifiAttenCtrlTest.si4project/Backup/esp8266(6222).h

@@ -0,0 +1,17 @@
+/*
+ * esp8266.h
+ *
+ *  Created on: Jul 9, 2019
+ *      Author: parkyj
+ */
+
+#ifndef ESP8266_H_
+#define ESP8266_H_
+
+#include "main.h"
+
+uint8_t ESP8266_Strindex(uint8_t* str);
+void ESP8266_Initialize(void);
+uint8_t ESP8266_StrFilter(uint8_t* str);
+
+#endif /* ESP8266_H_ */

insight/STM32F103_WifiAttenCtrlTest.si4project/Backup/main(1134).c

@@ -0,0 +1,655 @@
+/* USER CODE BEGIN Header */
+/**
+  ******************************************************************************
+  * @file           : main.c
+  * @brief          : Main program body
+  ******************************************************************************
+  * @attention
+  *
+  * <h2><center>&copy; Copyright (c) 2019 STMicroelectronics.
+  * All rights reserved.</center></h2>
+  *
+  * This software component is licensed by ST under BSD 3-Clause license,
+  * the "License"; You may not use this file except in compliance with the
+  * License. You may obtain a copy of the License at:
+  *                        opensource.org/licenses/BSD-3-Clause
+  *
+  ******************************************************************************
+  */
+/* USER CODE END Header */
+
+/* Includes ------------------------------------------------------------------*/
+#include <stdio.h>
+#include <string.h>
+#include "main.h"
+
+/* Private includes ----------------------------------------------------------*/
+/* USER CODE BEGIN Includes */
+
+/* USER CODE END Includes */
+
+/* Private typedef -----------------------------------------------------------*/
+/* USER CODE BEGIN PTD */
+
+/* USER CODE END PTD */
+
+/* Private define ------------------------------------------------------------*/
+/* USER CODE BEGIN PD */
+
+/* USER CODE END PD */
+
+/* Private macro -------------------------------------------------------------*/
+/* USER CODE BEGIN PM */
+
+/* USER CODE END PM */
+
+/* Private variables ---------------------------------------------------------*/
+ADC_HandleTypeDef hadc1;
+ADC_HandleTypeDef hadc2;
+ADC_HandleTypeDef hadc3;
+DMA_HandleTypeDef hdma_adc1;
+
+TIM_HandleTypeDef htim6;
+
+UART_HandleTypeDef huart4;
+UART_HandleTypeDef huart1;
+UART_HandleTypeDef huart2;
+DMA_HandleTypeDef hdma_usart1_rx;
+DMA_HandleTypeDef hdma_usart1_tx;
+DMA_HandleTypeDef hdma_usart2_rx;
+DMA_HandleTypeDef hdma_usart2_tx;
+
+/* USER CODE BEGIN PV */
+volatile uint32_t UartTimerCnt = 0;
+volatile uint32_t LedTimerCnt = 0;
+volatile uint32_t InitTimerCnt = 0;
+volatile uint32_t AdcTimerCnt = 0;
+/* USER CODE END PV */
+
+/* Private function prototypes -----------------------------------------------*/
+void SystemClock_Config(void);
+static void MX_GPIO_Init(void);
+static void MX_DMA_Init(void);
+static void MX_ADC1_Init(void);
+static void MX_ADC2_Init(void);
+static void MX_ADC3_Init(void);
+static void MX_TIM6_Init(void);
+static void MX_USART1_UART_Init(void);
+static void MX_USART2_UART_Init(void);
+static void MX_UART4_Init(void);
+static void MX_NVIC_Init(void);
+/* USER CODE BEGIN PFP */
+
+/* USER CODE END PFP */
+
+/* Private user code ---------------------------------------------------------*/
+/* USER CODE BEGIN 0 */
+void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
+{
+
+    if(htim->Instance == TIM6){
+        UartTimerCnt++;
+        LedTimerCnt++;
+        InitTimerCnt++;
+        AdcTimerCnt++;
+    }
+}
+int _write (int file, uint8_t *ptr, uint16_t len)
+{
+    HAL_UART_Transmit (&huart1, ptr, len, 10);
+    return len;
+}
+uint16_t ADC_Value_RetFunc(void){
+  return ADCvalue[0];
+}
+extern UARTQUEUE TerminalQueue;
+uint32_t ADCvalue[ADC_EA];
+/* USER CODE END 0 */
+
+/**
+  * @brief  The application entry point.
+  * @retval int
+  */
+int main(void)
+{
+  /* USER CODE BEGIN 1 */
+	uint8_t tempdata[] = {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A};
+  /* USER CODE END 1 */
+  
+
+  /* MCU Configuration--------------------------------------------------------*/
+
+  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
+  HAL_Init();
+
+  /* USER CODE BEGIN Init */
+
+  /* USER CODE END Init */
+
+  /* Configure the system clock */
+  SystemClock_Config();
+
+  /* USER CODE BEGIN SysInit */
+
+  /* USER CODE END SysInit */
+
+  /* Initialize all configured peripherals */
+  MX_GPIO_Init();
+  MX_DMA_Init();
+  MX_ADC1_Init();
+  MX_ADC2_Init();
+  MX_ADC3_Init();
+  MX_TIM6_Init();
+  MX_USART1_UART_Init();
+  MX_USART2_UART_Init();
+  MX_UART4_Init();
+
+  /* Initialize interrupts */
+  MX_NVIC_Init();
+  /* USER CODE BEGIN 2 */
+  HAL_TIM_Base_Start_IT(&htim6);
+  setbuf(stdout, NULL);
+  printf("Uart Start \r\n");
+  printf("Crc generate %x \r\n",CRC16_Generate(tempdata,11));
+  InitUartQueue(&hTerminal,&TerminalQueue);
+  InitUartQueue(&hWifi,&WifiQueue);
+
+  double temp_tmp = 3.3/4095;
+  uint16_t temp_val = 0;
+  HAL_ADC_Start_DMA(&hadc1, (uint32_t*)ADCvalue, 1);
+  /* USER CODE END 2 */
+
+  /* Infinite loop */
+  /* USER CODE BEGIN WHILE */
+  while (1)
+  {
+	  if(LedTimerCnt > 500){
+		  HAL_GPIO_TogglePin(LED_UL_G_B_GPIO_Port,LED_UL_G_B_Pin);
+		  LedTimerCnt = 0;
+	  }
+	  if(InitTimerCnt >1000){
+		  ESP8266_Initialize();
+		  InitTimerCnt = 0;
+	  }
+	  if(AdcTimerCnt > 3000){
+//		  temp_val = ((ADCvalue[0] & 0xFF00)) | (ADCvalue[0] & 0x00FF);
+	      temp_val = ADCvalue[0];
+//          printf("\r\n");
+//	      printf("ADC Vale : %d \r\n",temp_val);
+//	      printf("ADC Vale : %f \r\n",temp_tmp * temp_val);
+	      AdcTimerCnt = 0;
+	  }
+	   while (TerminalQueue.data > 0) GetDataFromUartQueue(&hTerminal);
+	   while (WifiQueue.data > 0) GetDataFromUartQueue(&hWifi);
+       HAL_Delay(1);
+    /* USER CODE END WHILE */
+
+    /* USER CODE BEGIN 3 */
+  }
+  /* USER CODE END 3 */
+}
+
+/**
+  * @brief System Clock Configuration
+  * @retval None
+  */
+void SystemClock_Config(void)
+{
+  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
+  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
+  RCC_PeriphCLKInitTypeDef PeriphClkInit = {0};
+
+  /** Initializes the CPU, AHB and APB busses clocks 
+  */
+  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
+  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
+  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
+  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
+  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI_DIV2;
+  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL16;
+  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
+  {
+    Error_Handler();
+  }
+  /** Initializes the CPU, AHB and APB busses clocks 
+  */
+  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
+                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
+  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
+  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
+  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
+  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
+
+  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
+  {
+    Error_Handler();
+  }
+  PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_ADC;
+  PeriphClkInit.AdcClockSelection = RCC_ADCPCLK2_DIV6;
+  if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
+  {
+    Error_Handler();
+  }
+}
+
+/**
+  * @brief NVIC Configuration.
+  * @retval None
+  */
+static void MX_NVIC_Init(void)
+{
+  /* DMA1_Channel6_IRQn interrupt configuration */
+  HAL_NVIC_SetPriority(DMA1_Channel6_IRQn, 0, 0);
+  HAL_NVIC_EnableIRQ(DMA1_Channel6_IRQn);
+  /* DMA1_Channel5_IRQn interrupt configuration */
+  HAL_NVIC_SetPriority(DMA1_Channel5_IRQn, 0, 0);
+  HAL_NVIC_EnableIRQ(DMA1_Channel5_IRQn);
+  /* DMA1_Channel4_IRQn interrupt configuration */
+  HAL_NVIC_SetPriority(DMA1_Channel4_IRQn, 0, 0);
+  HAL_NVIC_EnableIRQ(DMA1_Channel4_IRQn);
+  /* DMA1_Channel7_IRQn interrupt configuration */
+  HAL_NVIC_SetPriority(DMA1_Channel7_IRQn, 0, 0);
+  HAL_NVIC_EnableIRQ(DMA1_Channel7_IRQn);
+  /* ADC3_IRQn interrupt configuration */
+  HAL_NVIC_SetPriority(ADC3_IRQn, 0, 0);
+  HAL_NVIC_EnableIRQ(ADC3_IRQn);
+  /* UART4_IRQn interrupt configuration */
+  HAL_NVIC_SetPriority(UART4_IRQn, 0, 0);
+  HAL_NVIC_EnableIRQ(UART4_IRQn);
+  /* TIM6_IRQn interrupt configuration */
+  HAL_NVIC_SetPriority(TIM6_IRQn, 0, 0);
+  HAL_NVIC_EnableIRQ(TIM6_IRQn);
+  /* ADC1_2_IRQn interrupt configuration */
+  HAL_NVIC_SetPriority(ADC1_2_IRQn, 0, 0);
+  HAL_NVIC_EnableIRQ(ADC1_2_IRQn);
+  /* USART1_IRQn interrupt configuration */
+  HAL_NVIC_SetPriority(USART1_IRQn, 0, 0);
+  HAL_NVIC_EnableIRQ(USART1_IRQn);
+  /* USART2_IRQn interrupt configuration */
+  HAL_NVIC_SetPriority(USART2_IRQn, 0, 0);
+  HAL_NVIC_EnableIRQ(USART2_IRQn);
+  /* DMA1_Channel1_IRQn interrupt configuration */
+  HAL_NVIC_SetPriority(DMA1_Channel1_IRQn, 0, 0);
+  HAL_NVIC_EnableIRQ(DMA1_Channel1_IRQn);
+}
+
+/**
+  * @brief ADC1 Initialization Function
+  * @param None
+  * @retval None
+  */
+static void MX_ADC1_Init(void)
+{
+
+  /* USER CODE BEGIN ADC1_Init 0 */
+
+  /* USER CODE END ADC1_Init 0 */
+
+  ADC_ChannelConfTypeDef sConfig = {0};
+
+  /* USER CODE BEGIN ADC1_Init 1 */
+
+  /* USER CODE END ADC1_Init 1 */
+  /** Common config 
+  */
+  hadc1.Instance = ADC1;
+  hadc1.Init.ScanConvMode = ADC_SCAN_DISABLE;
+  hadc1.Init.ContinuousConvMode = ENABLE;
+  hadc1.Init.DiscontinuousConvMode = DISABLE;
+  hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START;
+  hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
+  hadc1.Init.NbrOfConversion = 1;
+  if (HAL_ADC_Init(&hadc1) != HAL_OK)
+  {
+    Error_Handler();
+  }
+  /** Configure Regular Channel 
+  */
+  sConfig.Channel = ADC_CHANNEL_9;
+  sConfig.Rank = ADC_REGULAR_RANK_1;
+  sConfig.SamplingTime = ADC_SAMPLETIME_239CYCLES_5;
+  if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
+  {
+    Error_Handler();
+  }
+  /* USER CODE BEGIN ADC1_Init 2 */
+
+  /* USER CODE END ADC1_Init 2 */
+
+}
+
+/**
+  * @brief ADC2 Initialization Function
+  * @param None
+  * @retval None
+  */
+static void MX_ADC2_Init(void)
+{
+
+  /* USER CODE BEGIN ADC2_Init 0 */
+
+  /* USER CODE END ADC2_Init 0 */
+
+  ADC_ChannelConfTypeDef sConfig = {0};
+
+  /* USER CODE BEGIN ADC2_Init 1 */
+
+  /* USER CODE END ADC2_Init 1 */
+  /** Common config 
+  */
+  hadc2.Instance = ADC2;
+  hadc2.Init.ScanConvMode = ADC_SCAN_DISABLE;
+  hadc2.Init.ContinuousConvMode = DISABLE;
+  hadc2.Init.DiscontinuousConvMode = DISABLE;
+  hadc2.Init.ExternalTrigConv = ADC_SOFTWARE_START;
+  hadc2.Init.DataAlign = ADC_DATAALIGN_RIGHT;
+  hadc2.Init.NbrOfConversion = 1;
+  if (HAL_ADC_Init(&hadc2) != HAL_OK)
+  {
+    Error_Handler();
+  }
+  /** Configure Regular Channel 
+  */
+  sConfig.Channel = ADC_CHANNEL_10;
+  sConfig.Rank = ADC_REGULAR_RANK_1;
+  sConfig.SamplingTime = ADC_SAMPLETIME_1CYCLE_5;
+  if (HAL_ADC_ConfigChannel(&hadc2, &sConfig) != HAL_OK)
+  {
+    Error_Handler();
+  }
+  /* USER CODE BEGIN ADC2_Init 2 */
+
+  /* USER CODE END ADC2_Init 2 */
+
+}
+
+/**
+  * @brief ADC3 Initialization Function
+  * @param None
+  * @retval None
+  */
+static void MX_ADC3_Init(void)
+{
+
+  /* USER CODE BEGIN ADC3_Init 0 */
+
+  /* USER CODE END ADC3_Init 0 */
+
+  ADC_ChannelConfTypeDef sConfig = {0};
+
+  /* USER CODE BEGIN ADC3_Init 1 */
+
+  /* USER CODE END ADC3_Init 1 */
+  /** Common config 
+  */
+  hadc3.Instance = ADC3;
+  hadc3.Init.ScanConvMode = ADC_SCAN_DISABLE;
+  hadc3.Init.ContinuousConvMode = DISABLE;
+  hadc3.Init.DiscontinuousConvMode = DISABLE;
+  hadc3.Init.ExternalTrigConv = ADC_SOFTWARE_START;
+  hadc3.Init.DataAlign = ADC_DATAALIGN_RIGHT;
+  hadc3.Init.NbrOfConversion = 1;
+  if (HAL_ADC_Init(&hadc3) != HAL_OK)
+  {
+    Error_Handler();
+  }
+  /** Configure Regular Channel 
+  */
+  sConfig.Channel = ADC_CHANNEL_11;
+  sConfig.Rank = ADC_REGULAR_RANK_1;
+  sConfig.SamplingTime = ADC_SAMPLETIME_1CYCLE_5;
+  if (HAL_ADC_ConfigChannel(&hadc3, &sConfig) != HAL_OK)
+  {
+    Error_Handler();
+  }
+  /* USER CODE BEGIN ADC3_Init 2 */
+
+  /* USER CODE END ADC3_Init 2 */
+
+}
+
+/**
+  * @brief TIM6 Initialization Function
+  * @param None
+  * @retval None
+  */
+static void MX_TIM6_Init(void)
+{
+
+  /* USER CODE BEGIN TIM6_Init 0 */
+
+  /* USER CODE END TIM6_Init 0 */
+
+  TIM_MasterConfigTypeDef sMasterConfig = {0};
+
+  /* USER CODE BEGIN TIM6_Init 1 */
+
+  /* USER CODE END TIM6_Init 1 */
+  htim6.Instance = TIM6;
+  htim6.Init.Prescaler = 6400-1;
+  htim6.Init.CounterMode = TIM_COUNTERMODE_UP;
+  htim6.Init.Period = 10-1;
+  htim6.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
+  if (HAL_TIM_Base_Init(&htim6) != HAL_OK)
+  {
+    Error_Handler();
+  }
+  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
+  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
+  if (HAL_TIMEx_MasterConfigSynchronization(&htim6, &sMasterConfig) != HAL_OK)
+  {
+    Error_Handler();
+  }
+  /* USER CODE BEGIN TIM6_Init 2 */
+
+  /* USER CODE END TIM6_Init 2 */
+
+}
+
+/**
+  * @brief UART4 Initialization Function
+  * @param None
+  * @retval None
+  */
+static void MX_UART4_Init(void)
+{
+
+  /* USER CODE BEGIN UART4_Init 0 */
+
+  /* USER CODE END UART4_Init 0 */
+
+  /* USER CODE BEGIN UART4_Init 1 */
+
+  /* USER CODE END UART4_Init 1 */
+  huart4.Instance = UART4;
+  huart4.Init.BaudRate = 115200;
+  huart4.Init.WordLength = UART_WORDLENGTH_8B;
+  huart4.Init.StopBits = UART_STOPBITS_1;
+  huart4.Init.Parity = UART_PARITY_NONE;
+  huart4.Init.Mode = UART_MODE_TX_RX;
+  huart4.Init.HwFlowCtl = UART_HWCONTROL_NONE;
+  huart4.Init.OverSampling = UART_OVERSAMPLING_16;
+  if (HAL_UART_Init(&huart4) != HAL_OK)
+  {
+    Error_Handler();
+  }
+  /* USER CODE BEGIN UART4_Init 2 */
+
+  /* USER CODE END UART4_Init 2 */
+
+}
+
+/**
+  * @brief USART1 Initialization Function
+  * @param None
+  * @retval None
+  */
+static void MX_USART1_UART_Init(void)
+{
+
+  /* USER CODE BEGIN USART1_Init 0 */
+
+  /* USER CODE END USART1_Init 0 */
+
+  /* USER CODE BEGIN USART1_Init 1 */
+
+  /* USER CODE END USART1_Init 1 */
+  huart1.Instance = USART1;
+  huart1.Init.BaudRate = 115200;
+  huart1.Init.WordLength = UART_WORDLENGTH_8B;
+  huart1.Init.StopBits = UART_STOPBITS_1;
+  huart1.Init.Parity = UART_PARITY_NONE;
+  huart1.Init.Mode = UART_MODE_TX_RX;
+  huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
+  huart1.Init.OverSampling = UART_OVERSAMPLING_16;
+  if (HAL_UART_Init(&huart1) != HAL_OK)
+  {
+    Error_Handler();
+  }
+  /* USER CODE BEGIN USART1_Init 2 */
+
+  /* USER CODE END USART1_Init 2 */
+
+}
+
+/**
+  * @brief USART2 Initialization Function
+  * @param None
+  * @retval None
+  */
+static void MX_USART2_UART_Init(void)
+{
+
+  /* USER CODE BEGIN USART2_Init 0 */
+
+  /* USER CODE END USART2_Init 0 */
+
+  /* USER CODE BEGIN USART2_Init 1 */
+
+  /* USER CODE END USART2_Init 1 */
+  huart2.Instance = USART2;
+  huart2.Init.BaudRate = 115200;
+  huart2.Init.WordLength = UART_WORDLENGTH_8B;
+  huart2.Init.StopBits = UART_STOPBITS_1;
+  huart2.Init.Parity = UART_PARITY_NONE;
+  huart2.Init.Mode = UART_MODE_TX_RX;
+  huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
+  huart2.Init.OverSampling = UART_OVERSAMPLING_16;
+  if (HAL_UART_Init(&huart2) != HAL_OK)
+  {
+    Error_Handler();
+  }
+  /* USER CODE BEGIN USART2_Init 2 */
+
+  /* USER CODE END USART2_Init 2 */
+
+}
+
+/** 
+  * Enable DMA controller clock
+  */
+static void MX_DMA_Init(void) 
+{
+
+  /* DMA controller clock enable */
+  __HAL_RCC_DMA1_CLK_ENABLE();
+
+}
+
+/**
+  * @brief GPIO Initialization Function
+  * @param None
+  * @retval None
+  */
+static void MX_GPIO_Init(void)
+{
+  GPIO_InitTypeDef GPIO_InitStruct = {0};
+
+  /* GPIO Ports Clock Enable */
+  __HAL_RCC_GPIOC_CLK_ENABLE();
+  __HAL_RCC_GPIOA_CLK_ENABLE();
+  __HAL_RCC_GPIOB_CLK_ENABLE();
+  __HAL_RCC_GPIOD_CLK_ENABLE();
+
+  /*Configure GPIO pin Output Level */
+  HAL_GPIO_WritePin(GPIOC, BOOT_LED_Pin|PLL_LD_B_Pin|PLL_EN_B_Pin, GPIO_PIN_RESET);
+
+  /*Configure GPIO pin Output Level */
+  HAL_GPIO_WritePin(GPIOA, LED_UL_G_B_Pin|LED_SD_R_B_Pin|PWR_LED_B_Pin|LED_DL_G_B_Pin 
+                          |LED_DL_R_B_Pin|ATT_DATA_B_Pin|ATT_EN1_B_Pin|ATT_EN2_B_Pin, GPIO_PIN_RESET);
+
+  /*Configure GPIO pin Output Level */
+  HAL_GPIO_WritePin(GPIOB, RST_WIFI_B_Pin|PA_EN_B_Pin|EXT_PA_EN_B_Pin|PLL_CLK_B_Pin 
+                          |PLL_DATA_B_Pin, GPIO_PIN_RESET);
+
+  /*Configure GPIO pin Output Level */
+  HAL_GPIO_WritePin(ATT_CLK_B_GPIO_Port, ATT_CLK_B_Pin, GPIO_PIN_RESET);
+
+  /*Configure GPIO pins : BOOT_LED_Pin PLL_LD_B_Pin PLL_EN_B_Pin */
+  GPIO_InitStruct.Pin = BOOT_LED_Pin|PLL_LD_B_Pin|PLL_EN_B_Pin;
+  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
+  GPIO_InitStruct.Pull = GPIO_NOPULL;
+  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
+  HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
+
+  /*Configure GPIO pins : LED_UL_G_B_Pin LED_SD_R_B_Pin PWR_LED_B_Pin LED_DL_G_B_Pin 
+                           LED_DL_R_B_Pin ATT_DATA_B_Pin ATT_EN1_B_Pin ATT_EN2_B_Pin */
+  GPIO_InitStruct.Pin = LED_UL_G_B_Pin|LED_SD_R_B_Pin|PWR_LED_B_Pin|LED_DL_G_B_Pin 
+                          |LED_DL_R_B_Pin|ATT_DATA_B_Pin|ATT_EN1_B_Pin|ATT_EN2_B_Pin;
+  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
+  GPIO_InitStruct.Pull = GPIO_NOPULL;
+  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
+  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
+
+  /*Configure GPIO pins : RST_WIFI_B_Pin PA_EN_B_Pin EXT_PA_EN_B_Pin PLL_CLK_B_Pin 
+                           PLL_DATA_B_Pin */
+  GPIO_InitStruct.Pin = RST_WIFI_B_Pin|PA_EN_B_Pin|EXT_PA_EN_B_Pin|PLL_CLK_B_Pin 
+                          |PLL_DATA_B_Pin;
+  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
+  GPIO_InitStruct.Pull = GPIO_NOPULL;
+  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
+  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
+
+  /*Configure GPIO pin : ATT_CLK_B_Pin */
+  GPIO_InitStruct.Pin = ATT_CLK_B_Pin;
+  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
+  GPIO_InitStruct.Pull = GPIO_NOPULL;
+  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
+  HAL_GPIO_Init(ATT_CLK_B_GPIO_Port, &GPIO_InitStruct);
+
+}
+
+/* USER CODE BEGIN 4 */
+
+/* USER CODE END 4 */
+
+/**
+  * @brief  This function is executed in case of error occurrence.
+  * @retval None
+  */
+void Error_Handler(void)
+{
+  /* USER CODE BEGIN Error_Handler_Debug */
+  /* User can add his own implementation to report the HAL error return state */
+
+  /* USER CODE END Error_Handler_Debug */
+}
+
+#ifdef  USE_FULL_ASSERT
+/**
+  * @brief  Reports the name of the source file and the source line number
+  *         where the assert_param error has occurred.
+  * @param  file: pointer to the source file name
+  * @param  line: assert_param error line source number
+  * @retval None
+  */
+void assert_failed(uint8_t *file, uint32_t line)
+{ 
+  /* USER CODE BEGIN 6 */
+  /* User can add his own implementation to report the file name and line number,
+     tex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
+  /* USER CODE END 6 */
+}
+#endif /* USE_FULL_ASSERT */
+
+/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

insight/STM32F103_WifiAttenCtrlTest.si4project/Backup/uart(6080).c

@@ -0,0 +1,95 @@
+/*
+ * uart.c
+ *
+ *  Created on: 2019. 5. 27.
+ *      Author: parkyj
+ */
+
+#include "uart.h"
+
+UARTQUEUE TerminalQueue;
+UARTQUEUE WifiQueue;
+void InitUartQueue(UART_HandleTypeDef *huart,pUARTQUEUE pQueue)
+{
+    UART_HandleTypeDef *dst = (huart->Instance == USART2 ? &hWifi:&hTerminal);
+    pQueue->data = pQueue->head = pQueue->tail = 0;
+
+    if (HAL_UART_Receive_DMA(dst, pQueue->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)
+{
+    pUARTQUEUE pQueue = (huart->Instance == USART2 ? &WifiQueue:&TerminalQueue);
+    UART_HandleTypeDef *dst = (huart->Instance == USART2 ? &hWifi:&hTerminal);
+
+    pQueue->head++;
+    if (pQueue->head >= QUEUE_BUFFER_LENGTH) pQueue->head = 0;
+    pQueue->data++;
+    if (pQueue->data >= QUEUE_BUFFER_LENGTH)
+        GetDataFromUartQueue(huart);
+    HAL_UART_Receive_DMA(dst, pQueue->Buffer + pQueue->head, 1);
+   // Set_UartRcv(true);
+}
+void PutDataToUartQueue(UART_HandleTypeDef *huart, uint8_t data)
+{
+    pUARTQUEUE pQueue = (huart->Instance == USART2 ? &WifiQueue:&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);
+}
+typedef enum{
+    Header = 0,
+    Type,
+    Length,
+    Crcindex,
+}Bluecell_Prot_p;
+
+uint8_t uart_buf[QUEUE_BUFFER_LENGTH];
+
+void GetDataFromUartQueue(UART_HandleTypeDef *huart)
+{
+    UART_HandleTypeDef *dst = (huart->Instance == USART2 ? &hWifi:&hTerminal);
+    pUARTQUEUE pQueue = (huart->Instance == USART2 ? &WifiQueue:&TerminalQueue);
+    volatile static int cnt;
+#if 0 // PYJ.2019.12.13_BEGIN -- 
+if(huart->Instance == USART1){
+    HAL_UART_Transmit_DMA(&hWifi, pQueue->Buffer + pQueue->tail, 1);
+}else{
+    printf("%c",*(pQueue->Buffer + pQueue->tail));
+}
+#endif // PYJ.2019.12.13_END -- 
+    printf("%c",*(pQueue->Buffer + pQueue->tail));
+    uart_buf[cnt++] = *(pQueue->Buffer + pQueue->tail); 
+    
+
+//    printf("Function : %s : ",__func__);
+//    if (HAL_UART_Transmit_DMA(dst, pQueue->Buffer + pQueue->tail, 1) != HAL_OK)
+    //if (HAL_UART_Transmit_DMA(&hTerminal, pQueue->Buffer + pQueue->tail, 1) != HAL_OK)
+    //{
+//       _Error_Handler(__FILE__, __LINE__);
+    //}
+//    printf("\r\n");
+    pQueue->tail++;
+    if (pQueue->tail >= QUEUE_BUFFER_LENGTH) pQueue->tail = 0;
+    pQueue->data--;
+    if(pQueue->data == 0){
+        ESP8266_StrFilter(&uart_buf[Header]);
+        memset(uart_buf,NULL,cnt);
+        cnt = 0;
+    }
+}
+void Uart1_Data_Send(uint8_t* data,uint8_t size){
+    HAL_UART_Transmit_DMA(&huart1, data,size); 
+}
+void Uart2_Data_Send(uint8_t* data,uint8_t size){
+    HAL_UART_Transmit_DMA(&huart2, data,size); 
+}
+
+

insight/STM32F103_WifiAttenCtrlTest.si4project/Backup/uart(6947).c

@@ -0,0 +1,95 @@
+/*
+ * uart.c
+ *
+ *  Created on: 2019. 5. 27.
+ *      Author: parkyj
+ */
+
+#include "uart.h"
+
+UARTQUEUE TerminalQueue;
+UARTQUEUE WifiQueue;
+void InitUartQueue(UART_HandleTypeDef *huart,pUARTQUEUE pQueue)
+{
+    UART_HandleTypeDef *dst = (huart->Instance == USART2 ? &hWifi:&hTerminal);
+    pQueue->data = pQueue->head = pQueue->tail = 0;
+
+    if (HAL_UART_Receive_DMA(dst, pQueue->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)
+{
+    pUARTQUEUE pQueue = (huart->Instance == USART2 ? &WifiQueue:&TerminalQueue);
+    UART_HandleTypeDef *dst = (huart->Instance == USART2 ? &hWifi:&hTerminal);
+
+    pQueue->head++;
+    if (pQueue->head >= QUEUE_BUFFER_LENGTH) pQueue->head = 0;
+    pQueue->data++;
+    if (pQueue->data >= QUEUE_BUFFER_LENGTH)
+        GetDataFromUartQueue(huart);
+    HAL_UART_Receive_DMA(dst, pQueue->Buffer + pQueue->head, 1);
+   // Set_UartRcv(true);
+}
+void PutDataToUartQueue(UART_HandleTypeDef *huart, uint8_t data)
+{
+    pUARTQUEUE pQueue = (huart->Instance == USART2 ? &WifiQueue:&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);
+}
+typedef enum{
+    Header = 0,
+    Type,
+    Length,
+    Crcindex,
+}Bluecell_Prot_p;
+
+uint8_t uart_buf[QUEUE_BUFFER_LENGTH];
+
+void GetDataFromUartQueue(UART_HandleTypeDef *huart)
+{
+    UART_HandleTypeDef *dst = (huart->Instance == USART2 ? &hWifi:&hTerminal);
+    pUARTQUEUE pQueue = (huart->Instance == USART2 ? &WifiQueue:&TerminalQueue);
+    volatile static int cnt;
+#if 0 // PYJ.2019.12.13_BEGIN -- 
+if(huart->Instance == USART1){
+    HAL_UART_Transmit_DMA(&hWifi, pQueue->Buffer + pQueue->tail, 1);
+}else{
+    printf("%c",*(pQueue->Buffer + pQueue->tail));
+}
+#endif // PYJ.2019.12.13_END -- 
+    printf("%c",*(pQueue->Buffer + pQueue->tail));
+    uart_buf[cnt++] = *(pQueue->Buffer + pQueue->tail); 
+    
+
+//    printf("Function : %s : ",__func__);
+//    if (HAL_UART_Transmit_DMA(dst, pQueue->Buffer + pQueue->tail, 1) != HAL_OK)
+    //if (HAL_UART_Transmit_DMA(&hTerminal, pQueue->Buffer + pQueue->tail, 1) != HAL_OK)
+    //{
+//       _Error_Handler(__FILE__, __LINE__);
+    //}
+//    printf("\r\n");
+    pQueue->tail++;
+    if (pQueue->tail >= QUEUE_BUFFER_LENGTH) pQueue->tail = 0;
+    pQueue->data--;
+    if(pQueue->data == 0){
+        ESP8266_StrFilter(&uart_buf[Header]);
+        memset(uart_buf,NULL,cnt);
+        cnt = 0;
+    }
+}
+void Uart1_Data_Send(uint8_t* data,uint8_t size){
+    HAL_UART_Transmit_DMA(&huart1, data,size); 
+}
+void Uart2_Data_Send(uint8_t* data,uint8_t size){
+    HAL_UART_Transmit_DMA(&huart2, data,size); 
+}
+
+

insight/STM32F103_WifiAttenCtrlTest.si4project/Backup/uart(905).h

@@ -0,0 +1,37 @@
+/*
+ * uart.h
+ *
+ *  Created on: 2019. 5. 27.
+ *      Author: parkyj
+ */
+
+#ifndef UART_H_
+#define UART_H_
+
+#include "main.h"
+
+#define hTerminal    huart1
+#define hWifi        huart2
+
+#define QUEUE_BUFFER_LENGTH 1024
+
+typedef struct
+{
+    int head, tail, data;
+    uint8_t Buffer[QUEUE_BUFFER_LENGTH];
+}UARTQUEUE, *pUARTQUEUE;
+
+extern UART_HandleTypeDef huart1;
+extern UART_HandleTypeDef huart2;
+extern UART_HandleTypeDef huart3;
+
+
+extern UARTQUEUE TerminalQueue;
+extern UARTQUEUE WifiQueue;
+void PutDataToUartQueue(UART_HandleTypeDef *huart, uint8_t data);
+void InitUartQueue(UART_HandleTypeDef *huart,pUARTQUEUE pQueue);
+void GetDataFromUartQueue(UART_HandleTypeDef *huart);
+bool Get_UartRcv(void);
+void Set_UartRcv(bool);
+
+#endif /* UART_H_ */