diff --git a/.github/workflows/python-publish.yml b/.github/workflows/python-publish.yml
index cd8c4f5a21d4a..4d0e90539c6a4 100644
--- a/.github/workflows/python-publish.yml
+++ b/.github/workflows/python-publish.yml
@@ -21,7 +21,7 @@ jobs:
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
-        pip install setuptools wheel twine
+        pip install -r requirements.txt
     - name: Build and publish
       env:
         TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }}
diff --git a/IoTGateWay/bsp/stm32/stm32f105RC/SA100/.cproject b/IoTGateWay/bsp/stm32/stm32f105RC/SA100/.cproject
index bb001b34b8fc0..3c2d73aa5b7ce 100644
--- a/IoTGateWay/bsp/stm32/stm32f105RC/SA100/.cproject
+++ b/IoTGateWay/bsp/stm32/stm32f105RC/SA100/.cproject
@@ -37,15 +37,14 @@
 								<option id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.compiler.option.optimization.level.1558248730" name="Optimization level" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.compiler.option.optimization.level" useByScannerDiscovery="false" value="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.compiler.option.optimization.level.value.os" valueType="enumerated"/>
 								<option IS_BUILTIN_EMPTY="false" IS_VALUE_EMPTY="false" id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.compiler.option.definedsymbols.1605204898" name="Define symbols (-D)" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.compiler.option.definedsymbols" useByScannerDiscovery="false" valueType="definedSymbols">
 									<listOptionValue builtIn="false" value="STM32F105xC"/>
-									<listOptionValue builtIn="false" value="TS710S"/>
 									<listOptionValue builtIn="false" value="DEBUG"/>
 									<listOptionValue builtIn="false" value="USE_HAL_DRIVER"/>
+									<listOptionValue builtIn="false" value="SA100"/>
 								</option>
 								<option IS_BUILTIN_EMPTY="false" IS_VALUE_EMPTY="false" id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.compiler.option.includepaths.149448483" name="Include paths (-I)" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.compiler.option.includepaths" useByScannerDiscovery="false" valueType="includePath">
 									<listOptionValue builtIn="false" value="&quot;${workspace_loc:/SA100/board}&quot;"/>
 									<listOptionValue builtIn="false" value="&quot;${workspace_loc:/SA100/include}&quot;"/>
 									<listOptionValue builtIn="false" value="&quot;${workspace_loc:/SA100/stm32_hal/STM32F1xx_HAL_Driver/Inc}&quot;"/>
-									<listOptionValue builtIn="false" value="&quot;${workspace_loc:/SA100/components/finsh}&quot;"/>
 									<listOptionValue builtIn="false" value="&quot;${workspace_loc:/SA100/stm32_hal/CMSIS/Device/ST/STM32F1xx/Include}&quot;"/>
 									<listOptionValue builtIn="false" value="&quot;${workspace_loc:/SA100/stm32_hal/CMSIS/Include}&quot;"/>
 									<listOptionValue builtIn="false" value="&quot;${workspace_loc:/SA100/stm32_drive/config}&quot;"/>
diff --git a/IoTGateWay/bsp/stm32/stm32f105RC/application/application.c b/IoTGateWay/bsp/stm32/stm32f105RC/application/application.c
index 7744a2057f6f5..aada4ec8c5d65 100644
--- a/IoTGateWay/bsp/stm32/stm32f105RC/application/application.c
+++ b/IoTGateWay/bsp/stm32/stm32f105RC/application/application.c
@@ -4,9 +4,6 @@
 
 #include <board.h>
 #include <drivers/rtc.h>
-#ifdef RT_USING_FINSH
-    #include <finsh.h>
-#endif
 
 #include "application.h"
 #include <config/appconfig.h>
@@ -92,88 +89,3 @@ rt_bool_t InitApplication(void)
 
 	return retVal;
 }
-
-#if defined (RT_USING_FINSH)
-    void bk_read(int argc, char **argv)
-    {
-        rt_device_t rtc_dev;
-        rt_err_t    err;
-        rt_uint32_t idx;
-        rt_bk_data_t bk_read;
-
-        if (argc != 2) {
-            rt_kprintf("usage : bk_read 3\r\n");
-            rt_kprintf("read backup 3rd memory and return 4 bytes data\r\n");
-            rt_kprintf("index [1 .. 19]\r\n");
-            return;
-        }
-
-        rtc_dev = rt_device_find("rtc");
-        if (rtc_dev == RT_NULL)
-        {
-            rt_kprintf("rtc is not installed\r\n");
-            return;
-        }
-
-        idx = atoi(argv[1]);
-        bk_read.bk_id = idx;
-
-        err = rt_device_control(rtc_dev, RT_DEVICE_CTRL_RTC_GET_BKDATA, (void *)&bk_read);
-        if (err != RT_EOK)
-        {
-            rt_kprintf("read backup memory error : %d\r\n", err);
-            return;
-        }
-        rt_kprintf("backup memory %d => 0x%08x\r\n", idx, bk_read.bk_data);
-
-        return;
-    }
-    MSH_CMD_EXPORT(bk_read, read backup memory);
-
-    void bk_write(int argc, char **argv)
-    {
-        rt_device_t rtc_dev;
-        rt_err_t    err;
-        rt_uint32_t idx, value;
-        rt_bk_data_t bk_read;
-
-        if (argc != 3) {
-            rt_kprintf("usage : bk_write 3 a5a57878\r\n");
-            rt_kprintf("write backup 3rd memory writing value is 0xA5A57878\r\n");
-            rt_kprintf("index [1 .. 19]\r\n");
-            return;
-        }
-
-        rtc_dev = rt_device_find("rtc");
-        if (rtc_dev == RT_NULL)
-        {
-            rt_kprintf("rtc is not installed\r\n");
-            return;
-        }
-
-        idx = atoi(argv[1]);
-        value = strtoul(argv[2], RT_NULL, 16);
-        bk_read.bk_id = idx;
-        bk_read.bk_data = value;
-
-        err = rt_device_control(rtc_dev, RT_DEVICE_CTRL_RTC_SET_BKDATA, (void *)&bk_read);
-        if (err != RT_EOK)
-        {
-            rt_kprintf("write backup memory error : %d\r\n", err);
-            return;
-        }
-        rt_kprintf("write backup memory %d => 0x%08x\r\n", idx, (rt_uint32_t)bk_read.bk_data);
-
-        bk_read.bk_data = 0;
-        err = rt_device_control(rtc_dev, RT_DEVICE_CTRL_RTC_GET_BKDATA, (void *)&bk_read);
-        if (err != RT_EOK)
-        {
-            rt_kprintf("read backup memory error : %d\r\n", err);
-            return;
-        }
-        rt_kprintf("read BK memory %d => 0x%08x\r\n", idx, (rt_uint32_t)bk_read.bk_data);
-
-        return;
-    }
-    MSH_CMD_EXPORT(bk_write, write backup memory);
-#endif
diff --git a/IoTGateWay/bsp/stm32/stm32f105RC/application/config/configuration.c b/IoTGateWay/bsp/stm32/stm32f105RC/application/config/configuration.c
index 9260e6661c892..0d219da406cb6 100644
--- a/IoTGateWay/bsp/stm32/stm32f105RC/application/config/configuration.c
+++ b/IoTGateWay/bsp/stm32/stm32f105RC/application/config/configuration.c
@@ -171,7 +171,7 @@ rt_uint8_t GetDhcpMode(void)
 	return configInfo.cfg.networkdCofig.dhcpMode;
 }
 
-void SetDhcpMode(rt_uint16_t data)
+void SetDhcpMode(rt_uint8_t data)
 {
 	Config *pCfg = &configInfo.cfg;
 
diff --git a/IoTGateWay/bsp/stm32/stm32f105RC/application/config/configuration.h b/IoTGateWay/bsp/stm32/stm32f105RC/application/config/configuration.h
index 34612319c5f65..5f009f3fc0c02 100644
--- a/IoTGateWay/bsp/stm32/stm32f105RC/application/config/configuration.h
+++ b/IoTGateWay/bsp/stm32/stm32f105RC/application/config/configuration.h
@@ -53,7 +53,7 @@ void SetApPassword(rt_uint8_t *pData, rt_size_t dataSize);
 rt_uint8_t *GetApSSID(void);
 void SetApSSID(rt_uint8_t *pData, rt_size_t dataSize);
 rt_uint8_t GetDhcpMode(void);
-void SetDhcpMode(rt_uint16_t data);
+void SetDhcpMode(rt_uint8_t data);
 rt_uint8_t *GetMacAddress(void);
 rt_bool_t SetMacAddress(rt_uint8_t *pData, rt_size_t dataSize);
 rt_uint8_t GetManufactureMode(void);
diff --git a/IoTGateWay/bsp/stm32/stm32f105RC/application/device/uart/plccomm.c b/IoTGateWay/bsp/stm32/stm32f105RC/application/device/uart/plccomm.c
index 3fc316fe10bd9..16f40359cb09c 100644
--- a/IoTGateWay/bsp/stm32/stm32f105RC/application/device/uart/plccomm.c
+++ b/IoTGateWay/bsp/stm32/stm32f105RC/application/device/uart/plccomm.c
@@ -21,8 +21,9 @@
 #define PV				"PV" //PV
 #define TS				"TS" 
 #define TK				"TK" 
-#define DEV_TYPE_TS		0 //TS 
-#define DEV_TYPE_TK		1 //TK
+#define DEV_TYPE_TS			0
+#define DEV_TYPE_TK			1
+#define DEV_TYPE_INVALID	2
 #define PV_LEN			2
 #define TB_VALUE_LEN	2	//2 bytes value len
 #define FB_VALUE_LEN	4	//4 bytes value len
@@ -45,9 +46,10 @@
 #define SensorCode_15	0x000F
 #define SensorCode_16	0x0010
 #define SensorCode_17	0x0011
+#define SensorCode_18	0x0012
+#define SensorCode_19	0x0013
 
 typedef struct dustCommInfo_tag {
-	rt_mq_t plcMq;
 	MqData_t mqData;
 
 	rt_device_t uport;
@@ -79,7 +81,7 @@ void SetTcpStatus(rt_uint8_t tcpOn)
 	}
 }
 
-static rt_err_t dustcomm_rx_ind(rt_device_t dev, rt_size_t size)
+static rt_err_t plccomm_rx_ind(rt_device_t dev, rt_size_t size)
 {
     return rt_event_send(plcCommInfo.rx_event, SMSG_RX_DATA);
 }
@@ -124,29 +126,23 @@ rt_size_t MakeSensorValue(rt_uint16_t sensorCode, rt_uint8_t *pData, rt_size_t p
 	rt_memcpy(pos, PV, PV_LEN);
 	pos += PV_LEN;
 
+	rt_uint32_t u32Val = 0;
+	length = sizeof(u32Val);
+
 	//Sensor Value
+	rt_memcpy(&u32Val,pData,length);
+	u32Val = HTONL(u32Val);
+	rt_memcpy(pos,&u32Val,length);
+	pos += length;
+
 	if((innerPress == sensorCode) || (outerPress == sensorCode))
 	{
-		rt_uint32_t u32Val = 0;
-		rt_uint8_t length = sizeof(u32Val);
-
-		rt_memcpy(&u32Val,pData,length);
-		u32Val = HTONL(u32Val);
-		rt_memcpy(pos,&u32Val,length);
-		pos += length;
 		flaotingPoint = 3;
 		*pos++ = flaotingPoint;
 
 	}
 	else
 	{
-		rt_uint16_t u16Val = 0;
-		rt_uint8_t 	length = sizeof(u16Val);
-
-		rt_memcpy(&u16Val,pData,length);
-		u16Val = HTONS(u16Val);
-		rt_memcpy(pos,&u16Val,length);
-		pos += length;
 		flaotingPoint = 1;
 		*pos++ = flaotingPoint;
 	}
@@ -165,42 +161,42 @@ static rt_size_t MakeSensorPayloadData(rt_uint8_t *pData, rt_uint16_t length)
 
 	begin++;//Skip STX of PLC Data
 	//sensor 1
-	if( SensorCode_1 ==  sensorCodeCount)
+	if( SensorCode_1 ==  sensorCodeCount) //Voltage1 RS
 	{
 		size += MakeSensorValue(SensorCode_1, begin, size);
 	}
 	begin += TB_VALUE_LEN;
 
 	//sensor 2
-	if( SensorCode_2 ==  sensorCodeCount)
+	if( SensorCode_2 ==  sensorCodeCount) //Voltage1 ST
 	{
 		size += MakeSensorValue(SensorCode_2, begin, size);
 	}
 	begin += TB_VALUE_LEN;
 
 	//sensor 3
-	if( SensorCode_3 ==  sensorCodeCount)
+	if( SensorCode_3 ==  sensorCodeCount) //Voltage1 RT
 	{
 		size += MakeSensorValue(SensorCode_3, begin, size);
 	}
 	begin += TB_VALUE_LEN;
 
 	//sensor 4
-	if( SensorCode_4 ==  sensorCodeCount)
+	if( SensorCode_4 ==  sensorCodeCount) //Current1 R
 	{
 		size += MakeSensorValue(SensorCode_4, begin, size);
 	}
 	begin += TB_VALUE_LEN;
 
 	//sensor 5
-	if( SensorCode_5 ==  sensorCodeCount)
+	if( SensorCode_5 ==  sensorCodeCount) //Current1 T
 	{
 		size += MakeSensorValue(SensorCode_5, begin, size);
 	}
 	begin += TB_VALUE_LEN;
 
 	//sensor 6
-	if( SensorCode_6 ==  sensorCodeCount)
+	if( SensorCode_6 ==  sensorCodeCount) //Current1 T
 	{
 		size += MakeSensorValue(SensorCode_6, begin, size);
 	}
@@ -231,18 +227,25 @@ static rt_size_t MakeSensorPayloadData(rt_uint8_t *pData, rt_uint16_t length)
 		begin += FB_VALUE_LEN;
 
 		//sensor 9
-		if( SensorCode_9 ==  sensorCodeCount)
+		if( SensorCode_9 ==  sensorCodeCount) //temperature PV
 		{
 			size += MakeSensorValue(SensorCode_9, begin, size);
 		}
 		begin += TB_VALUE_LEN;
-		begin += TB_VALUE_LEN;
 
 		//sensor 10
-		if( SensorCode_10 ==  sensorCodeCount)
+		if( SensorCode_10 ==  sensorCodeCount) //temperature SV
 		{
 			size += MakeSensorValue(SensorCode_10, begin, size);
 		}
+		begin += TB_VALUE_LEN;
+		begin += TB_VALUE_LEN;
+
+		//sensor 11
+		if( SensorCode_11 ==  sensorCodeCount) //over temp
+		{
+			size += MakeSensorValue(SensorCode_11, begin, size);
+		}
 	}
 	else// TK
 	{
@@ -288,6 +291,14 @@ static rt_size_t MakeSensorPayloadData(rt_uint8_t *pData, rt_uint16_t length)
 
 		//sensor 17
 		size += MakeSensorValue(SensorCode_17, begin, size);
+		begin += TB_VALUE_LEN;
+
+		//sensor 18
+		size += MakeSensorValue(SensorCode_18, begin, size);
+		begin += TB_VALUE_LEN;
+
+		//sensor 19
+		size += MakeSensorValue(SensorCode_19, begin, size);
 	}
 
 	pos = p_base+size;
@@ -359,7 +370,7 @@ static void plccomm_rx_thread(void *params)
     err = rt_device_open(p_handle->uport, RT_DEVICE_OFLAG_RDONLY | RT_DEVICE_FLAG_INT_RX);
 	RT_ASSERT(err == RT_EOK);
 
-	rt_device_set_rx_indicate(p_handle->uport, dustcomm_rx_ind);
+	rt_device_set_rx_indicate(p_handle->uport, plccomm_rx_ind);
 	while(1)
 	{	
 		if(RT_EOK == (err=rt_event_recv(p_handle->rx_event, SMSG_RX_DATA, (RT_EVENT_FLAG_OR|RT_EVENT_FLAG_CLEAR), RT_WAITING_FOREVER, &events))
@@ -433,11 +444,15 @@ void InitPlcCommInfo(rt_uint8_t *pData)
 	{
 		plcCommInfo.devType = DEV_TYPE_TS; //TS
 	}
-	else
+	else if(0 == rt_strncmp((char *)plcCommInfo.devInfo,TK,rt_strlen(TK)))
 	{
 		plcCommInfo.devType = DEV_TYPE_TK; //TK
 	}
-
+	else
+	{
+		plcCommInfo.devType = DEV_TYPE_INVALID;
+		rt_kprintf("Invalid Device\r\n");
+	}
 }	
 
 rt_bool_t InitPlcComm(void)
diff --git a/IoTGateWay/bsp/stm32/stm32f105RC/application/network/networkmanager.c b/IoTGateWay/bsp/stm32/stm32f105RC/application/network/networkmanager.c
index a8af1fdc3080d..9460d3c5164f1 100644
--- a/IoTGateWay/bsp/stm32/stm32f105RC/application/network/networkmanager.c
+++ b/IoTGateWay/bsp/stm32/stm32f105RC/application/network/networkmanager.c
@@ -13,11 +13,14 @@
 
 #define TCP_BUFFER_MAX	256
 #define RETRY_MAX		3
+#define TCP_RESPONSE_TIMEOUT_DELAY	10000
 
 typedef struct _NetworkInfo
 {
 	rt_mq_t networkManagerMq;
 	rt_thread_t tid;
+	rt_timer_t	responseTimeoutTimer;
+
 	NetworkInfoData networkInfoData;
 	rt_uint16_t tcpSendLength; //Set Tcp data length
 	rt_uint8_t retryCount; //retry count variable
@@ -27,6 +30,12 @@ typedef struct _NetworkInfo
 
 NetworkInfo networkInfo;
 
+void ResponseTimeoutTimer(void *params)
+{
+	rt_kprintf("Receive TimeOut\r\n");
+	SendWifiCommand(CMD_RESTART);
+}
+
 void NetworkMangerSendMessage(MqData_t *pMqData)
 {
 	if(-RT_EFULL == rt_mq_send(networkInfo.networkManagerMq, (void *)&pMqData, sizeof(void*)))
@@ -53,7 +62,7 @@ void NetworkManagerThread(void *params)
 	NetworkInfo *p_handle = (NetworkInfo *)params;
 	MqData_t *pMqData = RT_NULL;
 
-	SendWifiCommand(CDM_ECHO_OFF);
+	SendWifiCommand(CMD_ECHO_OFF);
 
 	while(1)
 	{
@@ -67,6 +76,7 @@ void NetworkManagerThread(void *params)
 			{
 			case SMSG_WIFI_OK:
 				rt_kprintf("Wi-Fi Response: OK\r\n");
+				p_handle->retryCount = 0;
 				switch(p_handle->networkInfoData.networkStatus)
 				{
 				case STATUS_WIFI_RESTART:
@@ -74,6 +84,9 @@ void NetworkManagerThread(void *params)
 					DeviceReboot();
 					break;
 				case STATUS_ECHO_OFF:
+					SendWifiCommand(CMD_SET_POWER);
+					break;
+				case STATUS_SET_RFPOWER:
 					SendWifiCommand(CMD_DISABLE_SLEEP_MODE);
 					break;
 				case STATUS_DISABLE_SLEEP_MODE:
@@ -154,6 +167,7 @@ void NetworkManagerThread(void *params)
 				case STATUS_SEND_DATA:
 					rt_kprintf("Send OK. \r\n");
 					p_handle->networkInfoData.networkStatus = STATUS_WAIT_ACK;
+					rt_timer_start(p_handle->responseTimeoutTimer);
 					break;
 				case STATUS_TCP_DISCONNECT:
 					rt_kprintf("TCP Disconnection Success \r\n");
@@ -161,6 +175,7 @@ void NetworkManagerThread(void *params)
 					break;
 				case STATUS_RECEIVE_DATA:
 					rt_kprintf("Success Sending Data. \r\n");
+					rt_timer_stop(p_handle->responseTimeoutTimer);
 					p_handle->networkInfoData.networkStatus = STATUS_STANDBY_SEND;
 					break;
 				default:
@@ -168,7 +183,7 @@ void NetworkManagerThread(void *params)
 				}
 				break;
 			case SMSG_WIFI_ERROR:
-				rt_kprintf("Wi-Fi Response: ERROR\r\n");
+				rt_kprintf("[%d]Wi-Fi Response: ERROR\r\n",p_handle->networkInfoData.networkStatus);
 				switch(p_handle->networkInfoData.networkStatus)
 				{
 				case STATUS_SEND_DATA:
@@ -181,6 +196,16 @@ void NetworkManagerThread(void *params)
 						SendWifiCommand(CMD_TCP_DISCONNECT);
 					}
 					break;
+				case STATUS_READY_TO_SEND_DATA:
+					if( RETRY_MAX > p_handle->retryCount++)
+					{
+						TcpSendData(p_handle->tcpSendBuffer,p_handle->tcpSendLength );
+					}
+					else
+					{
+						SendWifiCommand(CMD_TCP_DISCONNECT);
+					}
+					break;
 				default:
 					if(ENABLE == GetTcpStatus())
 					{
@@ -190,11 +215,16 @@ void NetworkManagerThread(void *params)
 					{
 						SendWifiCommand(CMD_RESTART);
 					}
+					if( RETRY_MAX > p_handle->retryCount++)
+					{
+						DeInitWifi();
+						DeviceReboot();
+					}
 					break;
 				}
 				break;
 			case SMSG_WIFI_FAIL:
-				rt_kprintf("Wi-Fi Response: FAIL\r\n");
+				rt_kprintf("[%d]Wi-Fi Response: FAIL\r\n",p_handle->networkInfoData.networkStatus);
 				switch(p_handle->networkInfoData.networkStatus)
 				{
 				case STATUS_CONNECT_WIFI:
@@ -220,7 +250,7 @@ void NetworkManagerThread(void *params)
 				}
 				break;
 			case SMSG_WIFI_TIMEOUT:
-				rt_kprintf("Wi-Fi Response Timeout\r\n");
+				rt_kprintf("[%d]Wi-Fi Response Timeout\r\n",p_handle->networkInfoData.networkStatus);
 				switch(p_handle->networkInfoData.networkStatus)
 				{
 				case STATUS_CONNECT_WIFI:
@@ -291,5 +321,8 @@ rt_bool_t InitNetworkManager(void)
 	h_data->tid = rt_thread_create("networkmanager", NetworkManagerThread, (void *)h_data, NETWORKMANAGER_STACK_SIZE, RT_MAIN_THREAD_PRIORITY, 20);
 	RT_ASSERT(RT_NULL != h_data->tid);
 
+	h_data->responseTimeoutTimer = rt_timer_create("responseTimeoutTimer", ResponseTimeoutTimer, (void *)h_data, rt_tick_from_millisecond(TCP_RESPONSE_TIMEOUT_DELAY), RT_TIMER_FLAG_ONE_SHOT);
+	RT_ASSERT(RT_NULL != h_data->responseTimeoutTimer);
+
 	return (retVal=InitWifi());
 }
diff --git a/IoTGateWay/bsp/stm32/stm32f105RC/application/network/networkmanager.h b/IoTGateWay/bsp/stm32/stm32f105RC/application/network/networkmanager.h
index b5167331201c9..3a965ac02e544 100644
--- a/IoTGateWay/bsp/stm32/stm32f105RC/application/network/networkmanager.h
+++ b/IoTGateWay/bsp/stm32/stm32f105RC/application/network/networkmanager.h
@@ -18,6 +18,7 @@ typedef enum
 	STATUS_NONE,
 	STATUS_WIFI_RESTART,
 	STATUS_ECHO_OFF,
+	STATUS_SET_RFPOWER,
 	STATUS_DISABLE_SLEEP_MODE,
 	STATUS_CHECK_WIFI_MODE,
 	STATUS_GET_WIFI_MODE,
diff --git a/IoTGateWay/bsp/stm32/stm32f105RC/application/network/wifi/wifi.c b/IoTGateWay/bsp/stm32/stm32f105RC/application/network/wifi/wifi.c
index 2ebc7b035d5e5..66f6fc67a200e 100644
--- a/IoTGateWay/bsp/stm32/stm32f105RC/application/network/wifi/wifi.c
+++ b/IoTGateWay/bsp/stm32/stm32f105RC/application/network/wifi/wifi.c
@@ -24,6 +24,7 @@
 #define SEND_DATA_FAIL	"SEND FAIL"
 #define TCP_RECEIVE		"+IPD" //Received Data
 #define ENTER_THE_DATA	">" //Enter The Data
+#define TCP_ERROR		"ER"
 #define WIFI_BAUD_RATE	BAUD_RATE_115200
 #define CMD_MAX_LEN		256 //128 -> 256
 #define WIFI_MAX_LEN	64
@@ -33,7 +34,8 @@
 // ID, COMMAND, COMMAND DESCRIPTION
 static WIFICOMMANDINFO commandInfo[] = {
 	{CMD_RESTART,"RST","[Restart.]\r\n"},
-	{CDM_ECHO_OFF, "ATE0", "[Sets Echo Off.]\r\n"},
+	{CMD_ECHO_OFF, "ATE0", "[Sets Echo Off.]\r\n"},
+	{CMD_SET_POWER,"RFPOWER","[Set RF Power]\r\n"},
 	{CMD_DISABLE_SLEEP_MODE, "SLEEP", "[Sets Sleep Mode.]\r\n"},
 	{CMD_SET_MODE, "CWMODE_DEF", "[Sets the default Wi-Fi mode (Station/AP/Station+AP).]\r\n"},
 	{CMD_QUERY_MODE, "CWMODE_DEF?", "[Query the current Wi-Fi mode.]\r\n"},
@@ -174,11 +176,15 @@ rt_err_t SendWifiCommand(wifiCommandID id)
 		wifiInfo.networkInfoData.networkStatus = STATUS_WIFI_RESTART; //set status
 		len = rt_sprintf((char *)cmd,"%s%s",WIFI_CMD_PREFIX,commandInfo[CMD_RESTART].szCli);
 		break;
-	case CDM_ECHO_OFF: //uart echo off
+	case CMD_ECHO_OFF: //uart echo off
 		wifiInfo.networkInfoData.networkStatus = STATUS_ECHO_OFF;
-		len = rt_sprintf((char *)cmd,"%s",commandInfo[CDM_ECHO_OFF].szCli);
+		len = rt_sprintf((char *)cmd,"%s",commandInfo[CMD_ECHO_OFF].szCli);
 		break;
-	case CMD_DISABLE_SLEEP_MODE: //disable sleep mode
+	case CMD_SET_POWER:
+		wifiInfo.networkInfoData.networkStatus = STATUS_SET_RFPOWER;
+		len = rt_sprintf((char *)cmd,"%s%s=82",WIFI_CMD_PREFIX,commandInfo[CMD_SET_POWER].szCli);
+		break;
+	case CMD_DISABLE_SLEEP_MODE:
 		wifiInfo.networkInfoData.networkStatus = STATUS_DISABLE_SLEEP_MODE;
 		len = rt_sprintf((char *)cmd,"%s%s=0",WIFI_CMD_PREFIX,commandInfo[CMD_DISABLE_SLEEP_MODE].szCli);
 		break;
@@ -450,12 +456,13 @@ rt_size_t ParserWifiData(rt_uint8_t *p_base, rt_size_t rx_size, NetworkInfoData
 							wifiInfo.networkInfoData.networkStatus = STATUS_GET_MAC_INFO;
 							break;
 						case CMD_RECEIVE_DATA: //treat the response of server
+							rt_timer_stop(wifiInfo.sendTimeoutTimer);
+							wifiInfo.networkInfoData.networkStatus = STATUS_RECEIVE_DATA;
 							if(0 == rt_strncmp((char *)value,WIFI_OK,rt_strlen(WIFI_OK)))
 							{
 								pNetworkInfoData->response = RESPONSE_WIFI_OK;
-								wifiInfo.networkInfoData.networkStatus = STATUS_RECEIVE_DATA;
 							}
-							else if(0 == rt_strncmp((char *)value,"ER",rt_strlen("ER")))
+							else if(0 == rt_strncmp((char *)value,TCP_ERROR,rt_strlen(TCP_ERROR)))
 							{
 								pNetworkInfoData->response = RESPONSE_WIFI_ERROR;
 							}
diff --git a/IoTGateWay/bsp/stm32/stm32f105RC/application/network/wifi/wifi.h b/IoTGateWay/bsp/stm32/stm32f105RC/application/network/wifi/wifi.h
index 34ff63f3cef69..5a12c40b47482 100644
--- a/IoTGateWay/bsp/stm32/stm32f105RC/application/network/wifi/wifi.h
+++ b/IoTGateWay/bsp/stm32/stm32f105RC/application/network/wifi/wifi.h
@@ -45,7 +45,8 @@ typedef enum
 typedef enum _WifiCommandID
 {
 	CMD_RESTART,
-	CDM_ECHO_OFF,
+	CMD_ECHO_OFF,
+	CMD_SET_POWER,
 	CMD_DISABLE_SLEEP_MODE,
 	CMD_SET_MODE,
 	CMD_QUERY_MODE,
diff --git a/iiot_tk4s_agent.py b/iiot_edge_gateway_agent.py
similarity index 84%
rename from iiot_tk4s_agent.py
rename to iiot_edge_gateway_agent.py
index b6e1c501f5497..7af022b18833c 100644
--- a/iiot_tk4s_agent.py
+++ b/iiot_edge_gateway_agent.py
@@ -5,7 +5,7 @@
 import time
 import math
 
-from instrument_driver.autonics.modbus_tk4s import autonics_pid_tk4s
+from instrument_driver.autonics.instrument_bridge import instrument
 
 host = 'localhost'
 port = 1233
@@ -20,9 +20,8 @@ def __init__(self):
 
     def send_data(self,pv, precision):
         try:
-            d = datetime.datetime.utcnow()
-            unixtime = calendar.timegm(d.utctimetuple())
-
+            timestamp = datetime.datetime.utcnow()
+            unixtime = calendar.timegm(timestamp.utctimetuple())
             str_hex_utc_time = str(hex(unixtime)).replace('0x', '').encode()
 
             stx = str.encode('{:1x}'.format(2))
@@ -60,7 +59,7 @@ def send_data(self,pv, precision):
     MODE_ASCII = "ascii"
     widows_port = 'COM3'
     mac_port = '/dev/cu.usbserial-AQ00WOQH'
-    tk4s = autonics_pid_tk4s(port=mac_port, station_id=1, baudrate=19200, databits=8, parity=PARITY_NONE, stopbits=2, mode=MODE_RTU)
+    tk4s = instrument(port=mac_port,station_id=1,baudrate=19200,databits=8,parity=PARITY_NONE,stopbits=2,mode=MODE_RTU)
     while True:
         pv, precision = tk4s.scan_pv()
         client.send_data(pv, precision)
diff --git a/iiot_server.py b/iiot_server.py
index 62271714314e4..0a7685496f514 100644
--- a/iiot_server.py
+++ b/iiot_server.py
@@ -1,3 +1,5 @@
+import unittest
+
 import asyncio
 import socket
 import logging
@@ -7,9 +9,9 @@
 import json
 import pika
 
-from net_socket.iiot_tcp_async_server import  AsyncServer
+from net_socket.iiot_tcp_async_server import AsyncServer
 
-logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)
+logging.basicConfig(stream=sys.stdout,level=logging.DEBUG)
 
 """
 grafana docker
@@ -22,135 +24,150 @@
 Please refer https://www.open-plant.com/knowledge-base/how-to-install-influxdb-docker-for-windows-10/
 """
 
-def connect_redis(host, port):
-    """
-    Get connector for redis
-    If you don't have redis, you can use redis on docker with follow steps.
-    Getting most recent redis image
-    shell: docker pull redis
-    
-    docker pull redis
-    docker run --name whaleshark-redis -d -p 6379:6379 redis
-    docker run -it --link whaleshark-redis:redis --rm redis redis-cli -h redis -p 6379
-    
-    :param host: redis access host ip
-    :param port: redis access port
-    :return: redis connector
-    """
-    redis_obj = None
-    try:
-        conn_params = {
-        "host":host,
-        "port": port,
-        }
-        redis_obj = redis.StrictRedis(**conn_params)
-
-    except Exception as e:
-        logging.error(str(e))
-
-    return redis_obj
-
-
-def config_equip_desc(address, port, init = False):
-    '''
-    Configure redis for equipment sensor desc(sensor_cd)
-    key : const sensor_cd
-    value : dictionary or map has sensor_cd:sensor description
-    :return: redis connector
-    '''
-    redis_con = None
-    try:
-        redis_con = connect_redis(address, port)
-        facilities_dict = redis_con.get('facilities_info')
-        
-        if facilities_dict == None:
-            facilities_dict = {'TS0001':{
-                                '0001':'TS_VOLT1_(RS)',
-                                '0002':'TS_VOLT1_(ST)',
-                                '0003':'TS_VOLT1_(RT)',
-                                '0004':'TS_AMP1_(R)',
-                                '0005':'TS_AMP1_(S)',
-                                '0006':'TS_AMP1_(T)',
-                                '0007':'INNER_PRESS',
-                                '0008':'PUMP_PRESS',
-                                '0009':'TEMPERATURE1',
-                                '0010':'OVER_TEMP'
-                            }
-            }
-            facilities_json = json.dumps(facilities_dict)
-            redis_con.set('facilities_info', facilities_json)
-            logging.debug('put key facilities_info ')
-            facilities_json = json.loads(redis_con.get('facilities_info'))
-
-            print(facilities_json)
-        else:
-            if init == True:
-                redis_con.delete('facilities_info')
-                
-    except Exception as e:
-        logging.error(str(e))
-
-    return redis_con
-
-
-def get_messagequeue(address, port):
-    '''
-    If you don't have rabbitmq, you can use docker.
-    docker run -d --hostname whaleshark --name whaleshark-rabbit -p 5672:5672 -p 8080:15672 -e RABBITMQ_DEFAULT_USER=whaleshark -e RABBITMQ_DEFAULT_PASS=whaleshark rabbitmq:3-management
-
-    get message queue connector (rabbit mq) with address, port
-    :param address: rabbit mq server ip
-    :param port: rabbitmq server port(AMQP)
-    :return: rabbitmq connection channel
-    '''
-    channel = None
-    try:
-        credentials = pika.PlainCredentials('whaleshark', 'whaleshark')
-        param = pika.ConnectionParameters(address,port, '/',credentials )
-        connection = pika.BlockingConnection(param)
-        channel = connection.channel()
-        channel.exchange_declare(exchange='facility', exchange_type='fanout')
-    except Exception as e:
-        logging.exception(str(e))
-
-    return channel
-
-if __name__ == '__main__':
-
-    try:
-        with open('config/config_server_develop.yaml', 'r') as file:
-            config_obj = yaml.load(file, Loader=yaml.FullLoader)
-            tcp_host = config_obj['iiot_server']['tcp_server']['ip_address']
-            tcp_port = config_obj['iiot_server']['tcp_server']['port']
-
-            redis_host = config_obj['iiot_server']['redis_server']['ip_address']
-            redis_port = config_obj['iiot_server']['redis_server']['port']
-
-            rabbitmq_host = config_obj['iiot_server']['rabbit_mq']['ip_address']
-            rabbitmq_port = config_obj['iiot_server']['rabbit_mq']['port']
-
-        redis_con = config_equip_desc(address=redis_host, port=redis_port)
-        if redis_con == None:
-            logging.error('redis configuration fail')
-            sys.exit()
-
-        mq_channel = get_messagequeue(address=rabbitmq_host, port=rabbitmq_port)
-        if mq_channel == None:
-            logging.error('rabbitmq configuration fail')
-            sys.exit()
-            
-        server_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        server_sock.setblocking(0)
-        server_sock.bind(('', tcp_port))
-        server_sock.listen(1)
-        print('IIoT Client Ready ({ip}:{port})'.format(ip=tcp_host, port=tcp_port))
-        msg_size = 27
-
-        async_server = AsyncServer()
-        event_manger = asyncio.get_event_loop()
-        event_manger.run_until_complete(async_server.get_client(event_manger, server_sock, msg_size, redis_con, mq_channel))
-
-    except Exception as e:
-        print(str(e))
-
-    
+
+class tcp_server:
+
+	def __init__(self:  'tcp_server') -> 'tcp_server':
+		with open('config/config_server_develop.yaml','r') as file:
+			config_obj=yaml.load(file,Loader=yaml.FullLoader)
+			self.tcp_host=config_obj['iiot_server']['tcp_server']['ip_address']
+			self.tcp_port=config_obj['iiot_server']['tcp_server']['port']
+
+			self.redis_host=config_obj['iiot_server']['redis_server']['ip_address']
+			self.redis_port=config_obj['iiot_server']['redis_server']['port']
+
+			self.rabbitmq_host=config_obj['iiot_server']['rabbit_mq']['ip_address']
+			self.rabbitmq_port=config_obj['iiot_server']['rabbit_mq']['port']
+
+	def connect_redis(self,host,port):
+		"""
+		Get connector for redis
+		If you don't have redis, you can use redis on docker with follow steps.
+		Getting most recent redis image
+		shell: docker pull redis
+
+		docker pull redis
+		docker run --name whaleshark-redis -d -p 6379:6379 redis
+		docker run -it --link whaleshark-redis:redis --rm redis redis-cli -h redis -p 6379
+
+		:param host: redis access host ip
+		:param port: redis access port
+		:return: redis connector
+		"""
+		redis_obj=None
+		try:
+			conn_params={
+				"host":host,
+				"port":port,
+			}
+			redis_obj=redis.StrictRedis(**conn_params)
+
+		except Exception as e:
+			logging.error(str(e))
+
+		return redis_obj
+
+	def config_equip_desc(self,address,port,init=False):
+		'''
+		Configure redis for equipment sensor desc(sensor_cd)
+		key : const sensor_cd
+		value : dictionary or map has sensor_cd:sensor description
+		:return: redis connector
+		'''
+		redis_con=None
+		try:
+			redis_con=self.connect_redis(address,port)
+			facilities_dict=redis_con.get('facilities_info')
+
+			if facilities_dict==None:
+				facilities_dict={'TS0001':{
+					'0001':'TS_VOLT1_(RS)',
+					'0002':'TS_VOLT1_(ST)',
+					'0003':'TS_VOLT1_(RT)',
+					'0004':'TS_AMP1_(R)',
+					'0005':'TS_AMP1_(S)',
+					'0006':'TS_AMP1_(T)',
+					'0007':'INNER_PRESS',
+					'0008':'PUMP_PRESS',
+					'0009':'TEMPERATURE1',
+					'0010':'OVER_TEMP'
+				}
+				}
+				redis_con.set('facilities_info',json.dumps(facilities_dict))
+			else:
+				if init==True:
+					redis_con.delete('facilities_info')
+
+		except Exception as e:
+			logging.error(str(e))
+
+		return redis_con
+
+	def get_messagequeue(self,address,port):
+		'''
+		If you don't have rabbitmq, you can use docker.
+		docker run -d --hostname whaleshark --name whaleshark-rabbit -p 5672:5672 -p 8080:15672 -e RABBITMQ_DEFAULT_USER=whaleshark -e RABBITMQ_DEFAULT_PASS=whaleshark rabbitmq:3-management
+
+		get message queue connector (rabbit mq) with address, port
+		:param address: rabbit mq server ip
+		:param port: rabbitmq server port(AMQP)
+		:return: rabbitmq connection channel
+		'''
+		channel=None
+		try:
+			credentials=pika.PlainCredentials('whaleshark','whaleshark')
+			param=pika.ConnectionParameters(address,port,'/',credentials)
+			connection=pika.BlockingConnection(param)
+			channel=connection.channel()
+			channel.exchange_declare(exchange='facility',exchange_type='fanout')
+		except Exception as e:
+			logging.exception(str(e))
+
+		return channel
+
+	def init_config(self):
+		self.redis_con=self.config_equip_desc(address=self.redis_host,port=self.redis_port)
+		if self.redis_con==None:
+			logging.error('redis configuration fail')
+			sys.exit()
+
+		self.mq_channel=self.get_messagequeue(address=self.rabbitmq_host,port=self.rabbitmq_port)
+		if self.mq_channel==None:
+			logging.error('rabbitmq configuration fail')
+			sys.exit()
+
+
+	def get_redis_con(self):
+		return self.redis_con
+
+
+	def get_mq_channel(self):
+		return self.mq_channel
+
+
+	def get_server_socket(self):
+		server_socket=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
+		server_socket.setblocking(0)
+		server_socket.bind(('',self.tcp_port))
+		server_socket.listen(1)
+		logging.debug('IIoT Client Ready ({ip}:{port})'.format(ip=self.tcp_host,port=self.tcp_port))
+		return server_socket
+
+
+if __name__=='__main__':
+	try:
+		server=tcp_server()
+		server.init_config()
+		redis_con=server.get_redis_con()
+		mq_channel=server.get_mq_channel()
+		server_socket=server.get_server_socket()
+		msg_size=27
+		async_server=AsyncServer()
+		event_manger=asyncio.get_event_loop()
+		event_manger.run_until_complete(
+			async_server.get_client(event_manger,server_socket,msg_size,redis_con,mq_channel))
+
+	except Exception as e:
+		print(str(e))
+
+
diff --git a/instrument_driver/autonics/config/autonics_map.yaml b/instrument_driver/autonics/config/autonics_map.yaml
deleted file mode 100644
index 4f3b4e4189719..0000000000000
--- a/instrument_driver/autonics/config/autonics_map.yaml
+++ /dev/null
@@ -1,4 +0,0 @@
-controller:
-  tk4s:
-    pv: 1000
-    precision: 1001
\ No newline at end of file
diff --git a/instrument_driver/autonics/instrument_bridge.py b/instrument_driver/autonics/instrument_bridge.py
new file mode 100644
index 0000000000000..3cdf5838e537e
--- /dev/null
+++ b/instrument_driver/autonics/instrument_bridge.py
@@ -0,0 +1,36 @@
+import minimalmodbus
+import math
+import yaml
+
+class instruments:
+
+	def __init__(self):
+		pass
+
+
+	def connect(self,slave_desc):
+		self.instrument=minimalmodbus.Instrument(slave_desc['port'],
+		                                         slave_desc['stationid'],
+		                                         slave_desc['mode'])
+		self.instrument.serial.baudrate=slave_desc['baudrate']
+		self.instrument.serial.bytesize=slave_desc['databits']
+		self.instrument.serial.parity=slave_desc['parity']
+		self.instrument.serial.stopbits=slave_desc['stopbits']
+		self.instrument.serial.timeout=slave_desc['timeout']
+		self.instrument.mode=slave_desc['mode']
+
+	def scan_pv(self):
+		"""
+		get pv value of pid controller (model name : AUTONICS tk4s)
+		"""
+		try:
+			pv = self.instrument.read_register(self.pv_address, 0, functioncode=int('0x04', 16))
+			precision = self.instrument.read_register(self.precision_address, 0, functioncode=int('0x04', 16))
+			if precision > 0:
+				pv = float(pv) * math.pow(10, precision)
+			return pv, precision
+
+		except Exception as e:
+			print(e)
+
+
diff --git a/instrument_driver/autonics/modbus_tk4s.py b/instrument_driver/autonics/modbus_tk4s.py
deleted file mode 100644
index 2b5ec890c4673..0000000000000
--- a/instrument_driver/autonics/modbus_tk4s.py
+++ /dev/null
@@ -1,41 +0,0 @@
-import minimalmodbus
-import math
-import yaml
-
-class autonics_pid_tk4s:
-
-    """
-    init rs232 serial port
-    """
-    
-    def __init__(self, port, station_id, baudrate, databits, parity, stopbits, mode):
-        with open('config/autonics_map.yaml', 'r') as file:
-            config_obj = yaml.load(file, Loader=yaml.FullLoader)
-            self.pv_address = config_obj['controller']['tk4s']['pv']
-            self.precision_address = config_obj['controller']['tk4s']['precision']
-            
-            self.instrument = minimalmodbus.Instrument(port, station_id, mode)
-            self.instrument.serial.baudrate = baudrate
-            self.instrument.serial.bytesize = databits
-            self.instrument.serial.parity = parity
-            self.instrument.serial.stopbits = stopbits
-            self.instrument.serial.timeout = 1.5
-            self.instrument.mode = mode
-        
-        
-    def scan_pv(self):
-        """
-        get pv value of pid controller (model name : AUTONICS tk4s)
-        """
-    
-        try:
-            pv = self.instrument.read_register(self.pv_address, 0, functioncode=int('0x04', 16))
-            precision = self.instrument.read_register(self.precision_address, 0, functioncode=int('0x04', 16))
-            precision = math.pow(10, precision)
-            pv = float(pv) / precision
-            return pv, precision
-
-        except Exception as e:
-            print(e)
-
-
diff --git a/instrument_driver/config/instrument_desc.yaml b/instrument_driver/config/instrument_desc.yaml
new file mode 100644
index 0000000000000..d2b3054191327
--- /dev/null
+++ b/instrument_driver/config/instrument_desc.yaml
@@ -0,0 +1,32 @@
+---
+slaves:
+- slave1
+- slave2
+slave1:
+  vendor: 'autonics series'
+  model_name: 'tk4s'
+  stationid: 1
+  port: "/dev/tty.usbserial-AQ00WOQH"
+  baudrate: 19200
+  databits: 8
+  parity: 'None'
+  stopbits: 2
+  timeout: 1.5
+  mode: 'rtu'
+  pv: 1000
+  precision: 1001
+  sv: 1003
+slave2:
+  vendor: 'autonics series'
+  model_name: 'tk4s'
+  stationid: 2
+  port: "/dev/tty.usbserial-AQ00WOQH"
+  baudrate: 19200
+  databits: 8
+  parity: 'None'
+  stopbits: 2
+  timeout: 1.5
+  mode: 'rtu'
+  pv: 1000
+  precision: 1001
+  sv: 1003
\ No newline at end of file
diff --git a/instrument_monitor.py b/instrument_monitor.py
new file mode 100644
index 0000000000000..d89e1beb9c83b
--- /dev/null
+++ b/instrument_monitor.py
@@ -0,0 +1,82 @@
+import codecs
+import socket
+import struct
+from datetime import datetime
+from time import gmtime, strftime
+import datetime
+import calendar
+import time
+import minimalmodbus
+import yaml
+
+from instrument_driver.autonics.instrument_bridge import instruments
+
+client_socket = socket.socket()
+host = 'localhost'
+port = 1233
+
+class sock_client:
+
+	def __init__(self):
+		self.client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+		self.client_socket.connect((host, port))
+		pass
+
+	def send_data(self,pv, precision):
+		try:
+			hex_stx='{:02x}'.format(2)
+			timestamp=datetime.datetime.now()
+			unixtime=calendar.timegm(timestamp.utctimetuple())
+			str_hex_unixtime=str(hex(unixtime)).replace('0x','')
+			full_message=bytearray.fromhex(hex_stx)
+			full_message+=bytearray.fromhex('{:02x}'.format(0))
+			full_message+=bytearray.fromhex('{:02x}'.format(0))
+			full_message+=bytearray.fromhex('{:02x}'.format(0))
+			full_message+=bytearray.fromhex('{:02x}'.format(0))
+			equip_name=format(ord("T"),"x")+format(ord("S"),"x")
+			full_message+=bytearray.fromhex(equip_name)
+			equip_id='{:02x}'.format(0)+'{:02x}'.format(1)
+			full_message+=bytearray.fromhex(equip_id)
+			sensor_code='{:02x}'.format(0)+'{:02x}'.format(9)
+			full_message+=bytearray.fromhex(sensor_code)
+			function_code=format(ord("P"),"x")+format(ord("V"),"x")
+			full_message+=bytearray.fromhex(function_code)
+			function_value='{:04x}'.format(pv)
+			full_message+=bytearray.fromhex(function_value)
+			precision='{:02x}'.format(precision)
+			full_message+=bytearray.fromhex(precision)
+			hex_etx='{:02x}'.format(3)
+			full_message+=bytearray.fromhex(hex_etx)
+			print(full_message, len(full_message))
+			self.client_socket.send(full_message)
+			recv = self.client_socket.recv(1024)
+			print("data is ",recv)
+			time.sleep(0.5)
+
+		except socket.error as e:
+			print(str(e))
+			self.client_socket.close()
+
+
+if __name__ == '__main__':
+	slaves_desc={}
+	with open('instrument_driver/config/instrument_desc.yaml','r') as file:
+		instrument_config=yaml.load(file,Loader=yaml.FullLoader)
+		for slave in instrument_config['slaves']:
+			slaves_desc[slave]=instrument_config[slave]
+
+	slave_list=[]
+	for slave_desc in slaves_desc.keys():
+		instrument=instruments()
+		print(slaves_desc[slave_desc])
+		print(slaves_desc[slave_desc]['vendor'])
+		print(slaves_desc[slave_desc]['model_name'])
+		print(slaves_desc[slave_desc]['stationid'])
+		instrument.connect(slaves_desc[slave_desc])
+		slave_list.append(instrument)
+
+	tcp_server=sock_client()
+	while True:
+		for slave_instrument in slave_list:
+			pv, precision = slave_instrument.scan_pv()
+			tcp_server.send_data(pv, precision)
\ No newline at end of file
diff --git a/net_socket/iiot_tcp_async_server.py b/net_socket/iiot_tcp_async_server.py
index 9eb69134a9a29..50cc5adc880d4 100644
--- a/net_socket/iiot_tcp_async_server.py
+++ b/net_socket/iiot_tcp_async_server.py
@@ -8,207 +8,183 @@
 import time
 from datetime import datetime, timedelta
 import datetime
+
+import pika
+
 from net_socket.signal_killer import GracefulInterruptHandler
 
 logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)
 
 class AsyncServer:
-    
-    def convert(self, list):
-        return tuple(i for i in list)
-    
-    
-    def convert_hex2decimal(self, packet_bytes, readable_sock):
-        """
-        In the packet, the hexadecimal value is converted to a decimal value, structured in json format, and returned.
-        
-        packet           TCP Stream packet from IIot Gateway
-        readable_sock       client socket object
-        
-        packet specification
-        stx is the starting code, the hex value matching STX in the ascii code table
-        utc time is the time when the sensor value is received from the iiot gate
-        equipment id means the id of the equipment and is predefined in the database.
-        sensor code is means the sensor's type like as tempeatur, pressure, voltage,...
-        precision means the accuracy of sensor value, decimal point.
-        The sensor value means the sensor value installed in the facility.
-        """
-        status = 'ER'
-        modbus_dict = {'equipment_id': '', 'meta': {'ip': '',
-                                                             'port': '',
-                                                             'time':'' ,
-                                                             'sensor_cd':'' ,
-                                                             'fun_cd':'' ,
-                                                             'sensor_value': '',
-                                                             'precision':''
-                                                             }}
-        try:
-            byte_tuple = self.convert(list(packet_bytes))
-            print(byte_tuple)
-            
-            if byte_tuple[0] == 2 and (byte_tuple[16] == 3 or byte_tuple[18] == 3):
-                group = chr(byte_tuple[5]) + chr(byte_tuple[6])
-                group_code = int('0x{:02x}'.format(byte_tuple[7]) + '{:02x}'.format(byte_tuple[8]), 16)
-                group_code = '{0:04d}'.format(group_code)
-    
-                sensor_code = int('0x{:02x}'.format(byte_tuple[9]) + '{:02x}'.format(byte_tuple[10]), 16)
-                sensor_code = '{0:04d}'.format(sensor_code)
-
-                if sensor_code == '0007' or sensor_code == '0008':
-                    """
-                    Pressure Exception Controll
-                    """
-                    logging.debug('pressure:' + str(sensor_code))
-                    pv = '0x{:02x}'.format(byte_tuple[13]) + '{:02x}'.format(byte_tuple[14]) + '{:02x}'.format(
-                        byte_tuple[15]) + '{:02x}'.format(byte_tuple[16])
-                    precision = int('0x{:02x}'.format(byte_tuple[17]), 16)
-                else:
-                    pv = '0x{:02x}'.format(byte_tuple[13]) + '{:02x}'.format(byte_tuple[14])
-                    precision = int('0x{:02x}'.format(byte_tuple[15]), 16)
-                sensor_value = int(pv, 16)
-                
-                
-                d = datetime.datetime.utcnow()+ timedelta(hours=9)
-                unixtime = calendar.timegm(d.utctimetuple())
-                str_hex_utc_time = str(d)
-                
-                host, port = readable_sock.getpeername()
-                modbus_dict = {'equipment_id': group+group_code, 'meta': {'ip': host,
-                                                                    'port': port,
-                                                                    'time': str_hex_utc_time,
-                                                                    'sensor_cd': sensor_code,
-                                                                    'fun_cd': 'PV',
-                                                                    'sensor_value': sensor_value,
-                                                                    'precision': precision
-                                                                    }}
-    
-                status = 'OK'
-            else:
-                status = 'ER'
-        except Exception as e:
-            logging.exception(str(e))
-        logging.debug(status + str(packet_bytes) + str(modbus_dict))
-        return status, str(packet_bytes), modbus_dict
-    
-    
-    async def get_client(self, event_manger, server_sock, msg_size,redis_con, mq_channel):
-        """
-        It create client socket with server sockt
-        event_manger        It has asyncio event loop
-        server_socket       Socket corresponding to the client socket
-        msg_size            It means the packet size to be acquired at a time from the client socket.
-        msg_queue           It means the queue containing the message transmitted from the gateway.
-        """
-        with GracefulInterruptHandler() as h:
-            while True:
-                if not h.interrupted:
-                    client, _ = await event_manger.sock_accept(server_sock)
-                    event_manger.create_task(self.manage_client(event_manger,  client, msg_size, redis_con,mq_channel))
-                else:
-                    client.close()
-                    server_sock.close()
-                    sys.exit(0)
-
-    @asyncio.coroutine
-    def do_work(self, envelope, body):
-        yield from asyncio.sleep(int(body))
-        print("consumer {} recved {} ({})".format(envelope.consumer_tag, body, envelope.delivery_tag))
-
-    @asyncio.coroutine
-    def callback(self, body, envelope, properties):
-        loop = asyncio.get_event_loop()
-        loop.create_task(self.do_work(envelope, body))
-        
-    async def manage_client(self, event_manger, client, msg_size, redis_con, mq_channel):
-        
-            
-        """
-            It receives modbus data from iiot gateway using client socket.
-            event_manger        It has asyncio event loop
-            client              It is a client socket that works with multiple iiot gateways.
-            msg_size            It means the packet size to be acquired at a time from the client socket.
-            msg_queue           It means the queue containing the message transmitted from the gateway.
-        """
-        facilities_dict = {}
-        facilities_info = json.loads(redis_con.get('facilities_info').decode())
-        equipment_keys = facilities_info.keys()
-        for equipment_key in equipment_keys:
-            facilities_dict[equipment_key]={}
-            for sensor_id in  facilities_info[equipment_key].keys():
-                sensor_desc = facilities_info[equipment_key][sensor_id]
-                if sensor_desc not in facilities_dict[equipment_key].keys():
-                    facilities_dict[equipment_key][sensor_desc]=0.0
-        with GracefulInterruptHandler() as h:
-            while True:
-                if not h.interrupted:
-                    try:
-                        packet = (await event_manger.sock_recv(client, msg_size))
-                        if packet:
-                            try:
-                                logging.debug('try convert')
-                                status, packet, modbus_udp = self.convert_hex2decimal(packet, client)
-                                if status == 'OK':
-                                    str_modbus_udp = str(modbus_udp)
-                                    logging.debug('Queue put:' + str_modbus_udp)
-                                    equipment_id = modbus_udp['equipment_id']
-                                    sensor_code = modbus_udp['meta']['sensor_cd']
-                                    redis_sensor_info = json.loads(redis_con.get('facilities_info'))
-                                    if equipment_id in redis_sensor_info.keys():
-                                        sensor_desc = redis_sensor_info[equipment_id][sensor_code]
-                                        routing_key = modbus_udp['equipment_id']
-                                        facilities_dict[equipment_key]['time']=modbus_udp['meta']['time']
-                                        facilities_dict[equipment_key][sensor_desc] = modbus_udp['meta']['sensor_value']
-                                        logging.debug(routing_key + ','+ sensor_desc + ', update')
-                                        logging.debug(str(facilities_dict))
-                                        mq_channel.basic_publish(exchange='facility', routing_key=routing_key, body=json.dumps(facilities_dict))
-                                    else:
-                                        acq_message = status + packet + 'no exist key\r\n'
-                                        client.sendall(acq_message.encode())
-                                        continue
-                                acq_message = status + packet + '\r\n'
-                                client.sendall(acq_message.encode())
-                            except Exception as e:
-                                client.sendall(packet.encode())
-                                logging.exception('message error:' + str(e))
-                        else:
-                            client.close()
-                    except Exception as e:
-                        logging.exception('manage client exception:' + str(e))
-                        break
-                else:
-                    client.close()
-                    sys.exit(0)
-                
-
-    async def apply_sensor_name(self, db_con, message):
-        equipment_id = message['equipment_id']
-        sensor_code = message['meta']['sensor_cd']
-        redis_sensor_info = json.loads(db_con.get('facilities_info'))
-        sensor_desc = redis_sensor_info[equipment_id][sensor_code]
-        message['meta']['sensor_desc'] = sensor_desc
-        return message
-    
-    
-    def modbus_mqtt_publish(self, msg_queue, redis_con, mq_channel, u_test=False):
-       while True:
-           time.sleep(0.01)
-           if msg_queue.qsize() > 0:
-            if u_test == True:
-                print('Test Mode')
-            msg_json = msg_queue.get()
-            if u_test == True:
-                return msg_json
-            else:
-                try:
-                    msg_json = self.apply_sensor_name(db_con=redis_con, message=msg_json)
-                    routing_key = msg_json['equipment_id']
-                    # msg_body = str(msg_json['meta'])
-                    msg_body = json.dumps(msg_json['meta'])
-                    logging.debug('equipment_id:'+routing_key)
-                    logging.debug('mqtt publish:' + str(msg_body))
-                    # mq_channel.basic_publish(exchange='', routing_key=routing_key, body=msg_body)
-                except Exception as e:
-                    print(e)
 
+	def convert(self, list):
+		return tuple(i for i in list)
+
+
+	def convert_hex2decimal(self, packet_bytes, host,port):
+		"""
+		In the packet, the hexadecimal value is converted to a decimal value, structured in json format, and returned.
+
+		packet		   TCP Stream packet from IIot Gateway
+		readable_sock	   client socket object
+
+		packet specification
+		stx is the starting code, the hex value matching STX in the ascii code table
+		utc time is the time when the sensor value is received from the iiot gate
+		equipment id means the id of the equipment and is predefined in the database.
+		sensor code is means the sensor's type like as tempeatur, pressure, voltage,...
+		precision means the accuracy of sensor value, decimal point.
+		The sensor value means the sensor value installed in the facility.
+		"""
+		status = 'ER'
+		modbus_dict = {'equipment_id': '', 'meta': {'ip': '',
+															 'port': '',
+															 'time':'' ,
+															 'sensor_cd':'' ,
+															 'fun_cd':'' ,
+															 'sensor_value': '',
+															 'precision':''
+															 }}
+		try:
+			byte_tuple = self.convert(list(packet_bytes))
+			logging.debug('byte message'+str(byte_tuple))
+			if byte_tuple[0] == 2 and (byte_tuple[16] == 3 or byte_tuple[18] == 3):
+				group = chr(byte_tuple[5]) + chr(byte_tuple[6])
+				group_code = int('0x{:02x}'.format(byte_tuple[7]) + '{:02x}'.format(byte_tuple[8]), 16)
+				group_code = '{0:04d}'.format(group_code)
+				sensor_code = int('0x{:02x}'.format(byte_tuple[9]) + '{:02x}'.format(byte_tuple[10]), 16)
+				sensor_code = '{0:04d}'.format(sensor_code)
+				if sensor_code == '0007' or sensor_code == '0008':
+					"""
+					Pressure Exception Controll
+					"""
+					logging.debug('**8Byte pressure:' + str(sensor_code))
+					pv = '0x{:02x}'.format(byte_tuple[13]) + '{:02x}'.format(byte_tuple[14]) + '{:02x}'.format(
+						byte_tuple[15]) + '{:02x}'.format(byte_tuple[16])
+					precision = int('0x{:02x}'.format(byte_tuple[17]), 16)
+				else:
+					logging.debug('**4Byte Normal:'+str(sensor_code))
+					pv = '0x{:02x}'.format(byte_tuple[13]) + '{:02x}'.format(byte_tuple[14])
+					precision = int('0x{:02x}'.format(byte_tuple[15]), 16)
+				sensor_value = int(pv, 16)
+				timestamp = datetime.datetime.utcnow()+ timedelta(hours=9)
+				str_hex_utc_time = str(timestamp)[0:len('2020-08-15 21:04:58')]
+				modbus_dict = {'equipment_id': group+group_code, 'meta': {'ip': host,
+																	'port': port,
+																	'time': str_hex_utc_time,
+																	'sensor_cd': sensor_code,
+																	'fun_cd': 'PV',
+																	'sensor_value': sensor_value,
+																	'precision': precision
+																	}}
+
+				status = 'OK'
+			else:
+				status = 'ER'
+		except Exception as e:
+			logging.exception(str(e))
+		logging.debug(status + str(packet_bytes) + str(modbus_dict))
+		return status, str(packet_bytes), modbus_dict
+
+
+	async def get_client(self, event_manger, server_sock, msg_size,redis_con, mq_channel):
+		"""
+		It create client socket with server sockt
+		event_manger		It has asyncio event loop
+		server_socket	   Socket corresponding to the client socket
+		msg_size			It means the packet size to be acquired at a time from the client socket.
+		msg_queue		   It means the queue containing the message transmitted from the gateway.
+		"""
+		self.redis_con = redis_con
+		with GracefulInterruptHandler() as h:
+			client = None
+			while True:
+				if not h.interrupted:
+					client, _ = await event_manger.sock_accept(server_sock)
+					event_manger.create_task(self.manage_client(event_manger, client, msg_size, mq_channel))
+				else:
+					client.close()
+					server_sock.close()
+					sys.exit(0)
+
+
+	async def manage_client(self, event_manger, client, msg_size, mq_channel):
+		"""
+			It receives modbus data from iiot gateway using client socket.
+			event_manger		It has asyncio event loop
+			client			  It is a client socket that works with multiple iiot gateways.
+			msg_size			It means the packet size to be acquired at a time from the client socket.
+			msg_queue		   It means the queue containing the message transmitted from the gateway.
+		"""
+		facilities_dict = {}
+		facilities_info = json.loads(self.redis_con.get('facilities_info').decode())
+		equipment_keys = facilities_info.keys()
+		for equipment_key in equipment_keys:
+			facilities_dict[equipment_key]={}
+			for sensor_id in  facilities_info[equipment_key].keys():
+				sensor_desc = facilities_info[equipment_key][sensor_id]
+				if sensor_desc not in facilities_dict[equipment_key].keys():
+					facilities_dict[equipment_key][sensor_desc]=0.0
+
+		with GracefulInterruptHandler() as h:
+			while True:
+				if not h.interrupted:
+					try:
+						packet = (await event_manger.sock_recv(client, msg_size))
+						if packet:
+							try:
+								logging.debug('try convert')
+								host,port=client.getpeername()
+								status, packet, modbus_udp = self.convert_hex2decimal(packet, host,port)
+								if status == 'OK':
+									str_modbus_udp = str(modbus_udp)
+									logging.debug('Queue put:' + str_modbus_udp)
+									equipment_id = modbus_udp['equipment_id']
+									sensor_code = modbus_udp['meta']['sensor_cd']
+									redis_sensor_info = json.loads(self.redis_con.get('facilities_info'))
+									if equipment_id in redis_sensor_info.keys():
+										sensor_desc = redis_sensor_info[equipment_id][sensor_code]
+										routing_key = modbus_udp['equipment_id']
+										facilities_dict[equipment_key]['time']=modbus_udp['meta']['time']
+										pv = modbus_udp['meta']['sensor_value']
+										precision = modbus_udp['meta']['precision']
+										pv = float(pv) * math.pow(10, float(precision))
+										precision = math.pow(10, float(precision))
+										modbus_udp['meta']['sensor_value'] = pv / precision
+										logging.debug('redis:'+'gateway_cvt set')
+										self.redis_con.set('remote_log:modbus_udp', json.dumps(modbus_udp))
 
+										facilities_dict[equipment_key][sensor_desc] = modbus_udp['meta']['sensor_value']
+										logging.debug('mq exchange:facility')
+										logging.debug('mq routing_key:'+routing_key)
+										logging.debug('mq body:'+str(json.dumps(facilities_dict)))
 
+										if mq_channel.is_open == True:
+											logging.debug('mqtt open')
+											mq_channel.basic_publish(exchange='facility',routing_key=routing_key,
+											                         body=json.dumps(facilities_dict))
+											self.redis_con.set('remote_log:mqttpubish',json.dumps(facilities_dict))
+										else:
+											logging.debug('mqtt closed')
+											logging.debug('reconnecting to queue')
+											mq_channel.connect()
+											mq_channel.basic_publish(exchange='facility',routing_key=routing_key,
+											                         body=json.dumps(facilities_dict))
+									else:
+										acq_message = status + packet + 'no exist key\r\n'
+										client.sendall(acq_message.encode())
+										continue
+								acq_message = status + packet + '\r\n'
+								logging.debug('rtn:'+ acq_message)
+								client.sendall(acq_message.encode())
+							except Exception as e:
+								client.sendall(packet.encode())
+								logging.exception('message error:' + str(e))
+						else:
+							client.close()
+					except Exception as e:
+						logging.exception('manage client exception:' + str(e))
+						break
+				else:
+					client.close()
+					sys.exit(0)
\ No newline at end of file