QT系统集成组

#pragma once

#include "AxiomAcs.h"

#include "iostream"

#include "fstream"

#ifdef WIN32

#include <direct.h>

#include <io.h>

#else

#include <sys/stat.h>

#include <sys/io.h>

#include <stdio.h>

#include <unistd.h>

#include <sys/types.h>

#endif

#ifndef WIN32

#include <iconv.h>

#endif

#define far

typedef void far  *LPVOID;

int AxionAcs::GetNowSecond() {

	CSeTime     SE_T;

	TCriterionTime tmptime;

	SE_T.GetNow(&tmptime);

	return (int)tmptime;

}

std::string convertTime(int timestamp) {

	time_t tick = (time_t)(timestamp);//ת??ʱ??

	struct tm tm;

	char s[40];

	tm = *localtime(&tick);

	strftime(s, sizeof(s), "%Y-%m-%d %H:%M:%S", &tm);

	std::string str(s);

	return str;

}

unsigned long long GetTimeStamp() {

	unsigned long long stampNow = 0;

	time_t timer;

	timer = time(NULL);

	stampNow = timer;

	return stampNow;

}

void Inver2byte(uint8* Src, int num) {

	int t = 0;

	for (int i = 0; i < num / 2; i++) {

		t = Src[2 * i];

		Src[2 * i] = Src[2 * i + 1];

		Src[2 * i + 1] = t;

	}

}

unsigned int rxprocess(LPVOID rxptr) {

	AxionAcs* rtxpPara = NULL;

	rtxpPara = (AxionAcs*)rxptr;

	sint32 rtuno = rtxpPara->Get_Rtuno();

	bool doorflag = true;

	while (doorflag) {

		if (rtxpPara->GetDoors() == 1) {		//??ȡ?????????ݳɹ?

			doorflag = false;

		}

		if (doorflag) {

			rtxpPara->PrintLog(LOG_ERROR, "??״̬ǰ??׼??ʧ?ܣ??ȴ?2s");

			SeSleep(2000);

		}

	}

	while (rtxpPara->rxflag) {

		for (int i = 0; i < rtxpPara->doorNum; i++) {

			if (rtxpPara->httpflag_doors == false) {

				rtxpPara->fclient_door.init_mg();

				rtxpPara->httpflag_doors = true;

				rtxpPara->httpflag1_doors = true;

				rtxpPara->PrintLog(LOG_INFORMATION, "??ʼ????״̬???ӣ?");

			}

			rtxpPara->GetDoorState(i + 1);

		}

		SeSleep(500);

	}

	return 0;

}

unsigned int txprocess(LPVOID txptr) {

	AxionAcs* rtxpPara = NULL;

	rtxpPara = (AxionAcs*)txptr;

	sint32 rtuno = rtxpPara->Get_Rtuno();

	while (rtxpPara->txflag) {

		S_RAWCMD rawcmd;

		while (rtxpPara->Get_CmdNum() >0 ) {

			if (rtxpPara->Get_ACmd(rtuno, &rawcmd) == 0) break;

			rtxpPara->PrintLog(LOG_INFORMATION, "?յ?%d???ն? ????:%d ", rtuno, rawcmd.type);

			uint8 len = 0;

			ST_TRACK_ADDR 	m_cmdaddr;     //?????ⲿ???ͨ???˱????????ⲿ?????ַ??Ϣ

			m_cmdaddr = rawcmd.src;

			switch (rawcmd.type) {

			case DC_K_CMD_DOOPER:{	//ң?أ??ؿ?????

									 S_DO_CTL *cmdinfo;

									 cmdinfo = (S_DO_CTL *)(&rawcmd.data);

									 uint16 ykno = (uint16)cmdinfo->ptAddr;//ң?غ?

									 switch (cmdinfo->funcCode) {

									 case DC_K_CTL_DOSEL:	//ѡ??

										 //ֱ?ӷ?У

										 rawcmd.type = DC_K_CMDRET_DOOPER;

										 rawcmd.len = sizeof(cmdinfo);

										 rawcmd.src = m_cmdaddr;

										 cmdinfo->retCode = 1;

										 rtxpPara->Rpt_AResult(rtuno, rawcmd);

										 break;

									 case DC_K_CTL_DOEXE:	//ִ??

										 uint16 ykvalue;

										 ykvalue = cmdinfo->ctlVal;

										 if (ykno % 10 == 4){

											 if (ykvalue == 1) { //Զ?̿???

												 //????yknoΪ??

												 //											 rtxpPara->PrintLog(LOG_INFORMATION, "ɾ??һ???յ?%d???ն????? ", rtuno);

												 rtxpPara->SetDoorOpen(ykno / 10);

											 }

											 if (ykvalue == 0) { //Զ?̹???

												 //????yknoΪ?ر?

												 rtxpPara->SetDoorClose(ykno / 10);

											 }

										 }

										 if ((ykno % 10 == 5) && (ykvalue == 1)){	//????

											 rtxpPara->SetDoorMode(ykno / 10, "4");

										 }

										 if ((ykno % 10 == 5) && (ykvalue == 0)){	//????

											 rtxpPara->SetDoorMode(ykno / 10, "5");

										 }

										 if ((ykno % 10 == 5) && (ykvalue == 2)){	//?Զ?

											 rtxpPara->SetDoorMode(ykno / 10, "0");

										 }

										 break;

									 case DC_K_CTL_DODEL://????

										 break;

									 }

			}

				break;

				default:

					break;

			}

			rtxpPara->Del_ACmd(rtuno);

			rtxpPara->PrintLog(LOG_INFORMATION, "ɾ??һ???յ?%d???ն????? ", rtuno);

		}

		SeSleep(500);

	}

	return 0;

}

unsigned int xxprocess(LPVOID xxptr) {

	AxionAcs* rtxpPara = NULL;

	rtxpPara = (AxionAcs*)xxptr;

	sint32 rtuno = rtxpPara->Get_Rtuno();

	int eventNum = 0;

	bool devicesflag = true;

	while (devicesflag) {

		if (rtxpPara->GetDevices() == 1) {		//??ȡ?????Ž??豸???ݳɹ?

			devicesflag = false;

		}

		if (devicesflag) {

			rtxpPara->PrintLog(LOG_ERROR, "?¼?ǰ??׼??ʧ?ܣ??ȴ?2s");

			SeSleep(2000);

		}

	}

	while (rtxpPara->xxflag) {

		if (rtxpPara->httpflag_devices == false) {

			rtxpPara->fclient_device.init_mg();

			rtxpPara->httpflag_devices = true;

			rtxpPara->httpflag1_devices = true;

			rtxpPara->PrintLog(LOG_INFORMATION, "??ʼ???¼????ӣ?");

		}

		eventNum = rtxpPara->GetSwipecard();

		if (eventNum != 0) {

			for (int i = 0; i < eventNum; i++) {

				if ((rtxpPara->lastEventId) < (rtxpPara->eventid[rtxpPara->eventidex[i]])) {

					rtxpPara->lastEventId = rtxpPara->eventid[rtxpPara->eventidex[i]];

					string doorid = rtxpPara->GetDoorId(rtxpPara->eventidex[i]);

					string cardId = rtxpPara->GetCardId(rtxpPara->eventidex[i]);

					string eventtime = rtxpPara->GetEventTime(rtxpPara->eventidex[i]);

					int reason = rtxpPara->GetaccessBlockedReason(rtxpPara->eventidex[i]);

					int doorno;

					for (int j = 0; j < rtxpPara->doorNum; j++) {

						if (doorid == rtxpPara->Getmapdoor(j + 1)) {

							doorno = j + 1;

						}

					}

					if (reason == 0) {

						rtxpPara->PrintLog(LOG_INFORMATION, "?Ž?ˢ??ʵʱ?¼???ˢ???ɹ?????[%d] ʱ??[%s] ????[%s]", doorno, eventtime.c_str(), cardId.c_str());

						rtxpPara->PutSoe(rtuno, doorno * 10 + 2, eventtime, cardId);

					} else {

						rtxpPara->PrintLog(LOG_ERROR, "?Ž?ˢ??ʵʱ?¼???ˢ??ʧ?ܣ???[%d] ʱ??[%s] ????[%s] ??????[%d]", doorno, eventtime.c_str(), cardId.c_str(), reason);

						rtxpPara->PutSoe(rtuno, doorno * 10 + 3, eventtime, cardId);

					}

				}

			}

		}

		SeSleep(1000);

	}

}

void AxionAcs::Init(S_PROTOCOLCFG* pcfg) {

	PRawCtrl = pcfg->PRawCtrl;

	pCmdMem = pcfg->pCmdMem;

	pRtu = pcfg->pRtu;

	pLink = pcfg->pLink;

	deviceNum = 0;

	doorNum = 0;

	lastEventId = 0;

	eventid[100] = { 0 };					

	eventidex[100] = { 0 };

	username[128] = { 0 };

	password[128] = { 0 };

	rxflag = true;

	txflag = true;

	xxflag = true;

	httpflag_doors = false;

	httpflag_devices = false;

	ReadIni();

	PrintLog(LOG_INFORMATION, "????rx?߳?%s %s !",username,password);

	if (rxflag) {

		rxthread = SE_CreateThread((PTHREAD_FUNC_DEF)rxprocess, this, 100);

	}

	PrintLog(LOG_INFORMATION, "????rx?߳? !");

	if (txflag) {

		txthread = SE_CreateThread((PTHREAD_FUNC_DEF)txprocess, this, 100);

	}

	PrintLog(LOG_INFORMATION, "????tx?߳? !");

	if (xxflag) {

		xxthread = SE_CreateThread((PTHREAD_FUNC_DEF)xxprocess, this, 100);

	}

	PrintLog(LOG_INFORMATION, "????xx?߳? !");

	/*

	//????restful???񣬽??ܲ???????????Ϣ	

	strCallback.iotprotocols = this;

	strCallback.rtuno = iotpLink->GetRtuNo();

	restfulServer();

	*/

}

//-----------------------------------------------------------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------------------------------------------------------

sint32 AxionAcs::Get_Rtuno() {

	return (pLink->GetRtuNo());

}

void AxionAcs::Put_AYx(uint16 Rtuno, uint16 YxNo, uint8 YxValue) {

	PRawCtrl->PutAYx(Rtuno, YxNo, YxValue);

}

sint32 AxionAcs::Get_CmdNum() {

	sint32 rtuno = pLink->GetRtuNo();

	return (pCmdMem->GetCmdNum(rtuno));

}

sint32 AxionAcs::Get_ACmd(sint32 rtuno, S_RAWCMD* cmd) {

	return pCmdMem->GetACmd(rtuno, cmd);

}

sint32 AxionAcs::Del_ACmd(sint32 rtuno) {

	return pCmdMem->DelACmd(rtuno);

}

sint32 AxionAcs::Rpt_AResult(sint32 rtuno, S_RAWCMD cmd) {

	return pCmdMem->RptAResult(rtuno, cmd);

}

/*

int AxionAcs::GetEventId(int i) {

	return events[i].eventId;

}

*/

string AxionAcs::Getusername() {

	return username;

}

string AxionAcs::Getpassword() {

	return password;

}

string AxionAcs::GetDoorId(int i) {

	return events[i].subDeviceId;

}

string AxionAcs::GetEventTime(int i) {

	return events[i].eventTime;

}

string AxionAcs::GetCardId(int i) {

	return events[i].cardNo;

}

int AxionAcs::GetaccessBlockedReason(int i) {

	return events[i].accessBlockedReason;

}

string AxionAcs::Getmapdoor(int i) {

	return map_door[i];

}

void AxionAcs::PutSoe(int rtuno, int yxno, string time, string cardId) {

	char ti[50] = { 0 };

	char id[50] = { 0 };

	if (time.length() < 50) { strcpy(ti, time.c_str()); 

	} else { PrintLog(LOG_ERROR, "??ȡʵʱ?¼????Ƿ???ʱ?䣡"); return; }

	if (cardId.length() < 50) {strcpy(id, cardId.c_str());

	} else { PrintLog(LOG_ERROR, "??ȡʵʱ?¼????Ƿ??Ŀ??ţ?"); return; }

	sint8 year = (ti[0] - 48) * 1000 + (ti[1] - 48) * 100 + (ti[2] - 48) * 10 + (ti[3] - 48);

	sint8 month = (ti[5] - 48) * 10 + (ti[6] - 48);

	sint8 day = (ti[8] - 48) * 10 + (ti[9] - 48);

	sint8 hour = (ti[11] - 48) * 10 + (ti[12] - 48);

	sint8 minute = (ti[14] - 48) * 10 + (ti[15] - 48);

	sint8 second = (ti[17] - 48) * 10 + (ti[18] - 48);

	int length = strlen(id);

	if (length>15) {

		length = 15;

		PrintLog(LOG_ERROR, "??ȡʵʱ?¼?????ȡ???Ŀ??Ź?????ֻȡǰ15????");

	}

	S_RAWSOEEX soe;

	soe.Source = DC_K_RTUSOE;

	soe.Year = year;

	soe.Month = month;

	soe.Day = day;

	soe.Hour = hour;

	soe.Minute = minute;

	soe.Second = second;

	soe.Ms = 0;

	soe.Rtuno = rtuno;

	soe.Yxno = yxno;

	soe.Val = 1;

	soe.Type = DC_SOEEX_ACSCARD;

	for (int i = 0; i < length; i++) {

		soe.Data[i] = id[i];

	}

	soe.Data[length] = 0;

	PRawCtrl->PutASoeEx(soe);

}

//??ȡ????????????

int AxionAcs::Getareas() {

	int status = 0;

	sint32 rtuno = Get_Rtuno();

	char tmp_header[128] = { 0 };

	sprintf(tmp_header, "Connection:keep-alive\r\n");

	string start_header = tmp_header;

	string urls = server_urls + "/api/v1/areas";

	string body = "";

	string callback;

	status = Fclient::Sendreq(urls, start_header, body, callback, 1);

	if (status != -1) {

		Put_AYx(rtuno, 1, 1);

	} else { Put_AYx(rtuno, 1, 0); return 0; }

	if (callback.size() <= 0) {

		PrintLog(LOG_ERROR, "??ȡ???????????ݷ??ؽ??Ϊ?գ?");

		return 0;

	}

	Json::Reader reader(Json::Features::strictMode());

	Json::Value parse_callback;

	if (reader.parse(callback, parse_callback)) {

		int status = parse_callback["status"].asInt();

		string msg = parse_callback["msg"].asString();

		if (status != 0) {

			PrintLog(LOG_ERROR, "??ȡ????????????ʧ?ܣ? ??????[%d]: %s", status, msg.c_str());

			return 0;

		}

		int size = 0;

		if (parse_callback["data"].isArray()) {

			size = parse_callback["data"].size();

		} else { return 0; }

		PrintLog(LOG_INFORMATION, "??ȡ????????ܸ???Ϊ??%d", size);

		for (int i = 0; i < size; i++) {

			int areaId = parse_callback["data"][i]["areaId"].asInt();

			string areaName = parse_callback["data"][i]["areaName"].asString();

			string areaCode = parse_callback["data"][i]["areaCode"].asString();

			int parentId = parse_callback["data"][i]["parentId"].asInt();

			area area_tmp;

			area_tmp.areaId = areaId;

			area_tmp.areaName = areaName;

			area_tmp.areaCode = areaCode;

			area_tmp.parentId = parentId;

			areas.push_back(area_tmp);

		}

	}

	return 1;

}

//??ȡ?????Ž??豸????

int AxionAcs::GetDevices() {

	int status = 0;

	sint32 rtuno = Get_Rtuno();

	char tmp_header[128] = { 0 };

	sprintf(tmp_header, "Connection:keep-alive\r\n");

	string start_header = tmp_header;

	string urls = server_urls + "/api/v1/acs/devices";

	string body = "";

	string callback;

	status = Fclient::Sendreq(urls, start_header, body, callback, 1);

//	PrintLog(3, "?Ž??豸%d  %d",status,callback.size());

	if (status != -1) {

		Put_AYx(rtuno, 1, 1);

//		PrintLog(3, "111111??");

	} else { 

		Put_AYx(rtuno, 1, 0); 

//		PrintLog(3, "000000??");

		return 0;

	}

	if (callback.size() <= 0) {

		PrintLog(LOG_ERROR, "??ȡ?????Ž??豸???ݷ??ؽ??Ϊ?գ?");

		return 0;

	}

	Json::Reader reader(Json::Features::strictMode());

	Json::Value parse_callback;

	if (reader.parse(callback, parse_callback)) {

		int status = parse_callback["status"].asInt();

		string msg = parse_callback["msg"].asString();

		if (status != 0) {

			PrintLog(LOG_ERROR, "??ȡ?????Ž??豸????ʧ?ܣ? ??????[%d]: %s", status, msg.c_str());

			return 0;

		}

		int size = 0;

		if (parse_callback["data"].isArray()) {

			size = parse_callback["data"].size();

			deviceNum = size;

		} else { return 0; }

		PrintLog(LOG_INFORMATION, "??ȡ???Ž??豸???ܸ???Ϊ??%d", size);

		for (int i = 0; i < size; i++) {

			string deviceId = parse_callback["data"][i]["deviceId"].asString();

			string deviceName = parse_callback["data"][i]["deviceName"].asString();

			int areaId = parse_callback["data"][i]["areaId"].asInt();

			string areaName = parse_callback["data"][i]["areaName"].asString();

			string deviceSn = parse_callback["data"][i]["deviceSn"].asString();

			string commAddr = parse_callback["data"][i]["commAddr"].asString();

			int isOnline = parse_callback["data"][i]["isOnline"].asInt();

			string commErrorMsg = parse_callback["data"][i]["commErrorMsg"].asString();

			device device_tmp;

			device_tmp.deviceNo = i + 1;

			device_tmp.deviceId = deviceId;

			device_tmp.deviceName = deviceName;

			device_tmp.areaId = areaId;

			device_tmp.areaName = areaName;

			device_tmp.deviceSn = deviceSn;

			device_tmp.commAddr = commAddr;

			device_tmp.isOnline = isOnline;

			device_tmp.commErrorMsg = commErrorMsg;

			devices.push_back(device_tmp);

			map_device[i + 1] = deviceId;

		}

	}

//	PrintLog(3, "222222??");

	return 1;

}

//??ȡ??????????

int AxionAcs::GetDoors() {

	int status = 0;

	sint32 rtuno = Get_Rtuno();

	char tmp_header[128] = { 0 };

	sprintf(tmp_header, "Connection:keep-alive\r\n");

	string start_header = tmp_header;

	string urls = server_urls + "/api/v1/acs/device/doors";

	string body = "";

	string callback;

	status = Fclient::Sendreq(urls, start_header, body, callback, 1);

//	PrintLog(3, "??????%d  %d", status, callback.size());

	if (status != -1) {

		Put_AYx(rtuno, 1, 1);

	} else { Put_AYx(rtuno, 1, 0); return 0; }

	/*

	doorNum = 5;

	map_door[1] = "fb6b37cf331f409d9b4e9c5161043707";

	map_door[2] = "c034f795a2c0401584bc13c767d598b6";

	map_door[3] = "80b3b27f29044b55b81b75cd8b3b10fc";

	map_door[4] = "b15b2026ed104953be046f2b1924e0a9";

	map_door[5] = "c733f78d42cb4f8d81174a3572d15957";

	*/

	if (callback.size() <= 0) {

	PrintLog(LOG_ERROR, "??ȡ?????????ݷ??ؽ??Ϊ?գ?");

	return 0;

	}

	Json::Reader reader(Json::Features::strictMode());

	Json::Value parse_callback;

	PrintLog(LOG_ERROR, "??????????");

	if (reader.parse(callback, parse_callback)) {

		int status = parse_callback["status"].asInt();

		string msg = parse_callback["msg"].asString();

		if (status != 0) {

			PrintLog(LOG_ERROR, "??ȡ??????????ʧ?ܣ? ??????[%d]: %s", status, msg.c_str());

			return 0;

		}

		int size = 0;

		if (parse_callback["data"].isArray()) {

			size = parse_callback["data"].size();

			doorNum = size;

		} else { return 0; }

		PrintLog(LOG_INFORMATION, "??ȡ???ŵ??ܸ???Ϊ??%d", size);

		std::string time;

		time = convertTime(GetNowSecond());

		std::ofstream outfile;

		outfile.open(logName, std::ios_base::app);

		outfile << "[" << time << "]  " << std::endl;

		for (int i = 0; i < size; i++) {

			string doorId = parse_callback["data"][i]["doorId"].asString();

			string doorName = parse_callback["data"][i]["doorName"].asString();

			string doorAddr = parse_callback["data"][i]["doorAddr"].asString();

			int areaId = parse_callback["data"][i]["areaId"].asInt();

			string areaName = parse_callback["data"][i]["areaName"].asString();

			string deviceId = parse_callback["data"][i]["deviceId"].asString();

			string deviceName = parse_callback["data"][i]["deviceName"].asString();

			door door_tmp;

			door_tmp.doorNo = i + 1;

			door_tmp.doorId = doorId;

			door_tmp.doorName = doorName;

			door_tmp.doorAddr = doorAddr;

			door_tmp.areaId = areaId;

			door_tmp.areaName = areaName;

			door_tmp.deviceId = deviceId;

			door_tmp.deviceName = deviceName;

			doors.push_back(door_tmp);

			map_door[i + 1] = doorId;

			outfile << "[ door" << i + 1 << " ]" << std::endl;

			outfile << "	doorId??	" << doorId << std::endl;

			outfile << "	doorName??	" << doorName << std::endl;

			outfile << "	doorAddr??	" << doorAddr << std::endl;

			outfile << "	areaId??	" << areaId << std::endl;

			outfile << "	areaName??	" << areaName << std::endl;

			outfile << "	deviceId??	" << deviceId << std::endl;

			outfile << "	deviceName??" << deviceName << std::endl;

		}

		outfile.close();

	}

	return 1;

}

//??ȡ??doorNo???ŵ?״̬

int AxionAcs::GetDoorState(int doorNo) {

	int status = 0;

	sint32 rtuno = Get_Rtuno();

	char tmp_header[128] = { 0 };

	sprintf(tmp_header, "Connection:keep-alive\r\n");

	string start_header = tmp_header;

	string urls = server_urls + "/api/v1/acs/device/door/state/"+map_door[doorNo];

	string body = "";

//	string callback;

	string con_urls = "/api/v1/acs/device/door/state/" + map_door[doorNo];

//	PrintLog(LOG_ERROR, "!!!!!%d   %d ", httpflag1, con_urls.find("swipecard"));

//	PrintLog(LOG_ERROR, "????????????%d??", httpflag1_doors);

//	PrintLog(LOG_ERROR, "%d%s%s%s%s??", httpflag1, urls.c_str(), start_header.c_str(), con_urls.c_str(), urls_tmp);

//	if (iii == 555) { PrintLog(LOG_INFORMATION, "ͣ???⣡"); sleep(1000000); }

	status = fclient_door.SendreqLong(urls, start_header, body, 1, httpflag1_doors, con_urls, urls_ip);

//	PrintLog(3, "??״̬%d  %d   %s", status, fclient.call_back.size(), fclient.call_back.c_str());		//---------

//	SeSleep(100000);

//	PrintLog(LOG_INFORMATION, "ͣ???⣡");

	if (status != -1) {

		Put_AYx(rtuno, 1, 1);

	} else {

		Put_AYx(rtuno, 1, 0);

		fclient_door.free_mg();

		httpflag_doors = false;

		PrintLog(LOG_ERROR, "??״̬????ʧ?ܣ? ??[%d]ID:%s", doorNo, map_door[doorNo].c_str());

		return 0;

	}

	if (fclient_door.call_back.size() <= 0) {

		PrintLog(LOG_ERROR, "??ȡ??%d???ŵ?״̬???ݷ??ؽ??Ϊ?գ?",doorNo);

		return 0;

	}

	Json::Reader reader(Json::Features::strictMode());

	Json::Value parse_callback;

	if (reader.parse(fclient_door.call_back, parse_callback)) {

		int status = parse_callback["status"].asInt();

		string msg = parse_callback["msg"].asString();

		int isOnline = parse_callback["isOnLine"].asInt();

		int isOpen = parse_callback["isOpen"].asInt();

		if (status != 0) {

			PrintLog(LOG_ERROR, "??ȡ??%d???ŵ?״̬????ʧ?ܣ? ??????[%d]: %s", doorNo, status, msg.c_str());

			return 0;

		}

		if (isOnline==0) {

			Put_AYx(rtuno, doorNo * 10, 0);

//			PrintLog(LOG_ERROR, "??ǰ??%d???Ŵ???????״̬??", doorNo);

		} else {

			Put_AYx(rtuno, doorNo * 10, 1);

			if (isOpen==1) {

				Put_AYx(rtuno, doorNo * 10 + 1, 1);

//				PrintLog(LOG_INFORMATION, "??ǰ??%d???ŵ?״̬Ϊ???򿪣?", doorNo);

			} else {

				Put_AYx(rtuno, doorNo * 10 + 1, 0);

//				PrintLog(LOG_INFORMATION, "??ǰ??%d???ŵ?״̬Ϊ???رգ?", doorNo);

			}

		}

	}

	return 1;

}

//???Ƶ?doorNO???ŵ?״̬Ϊ????

int AxionAcs::SetDoorOpen(int doorNo) {

	int status = 0;

	sint32 rtuno = Get_Rtuno();

	char tmp_header[128] = { 0 };

	sprintf(tmp_header, "Connection:keep-alive\r\n");

	string start_header = tmp_header;

	string urls = server_urls + "/api/v1/acs/device/door/open/" + username + "/" + password + "/" + map_door[doorNo];

	string body = "";

	string callback;

	status = Fclient::Sendreq(urls, start_header, body, callback, 1);

	if (status != -1) {

		Put_AYx(rtuno, 1, 1);

	} else { Put_AYx(rtuno, 1, 0); return 0; }

	if (callback.size() <= 0) {

		PrintLog(LOG_ERROR, "???Ƶ?%d???Ŵ򿪵????ݷ??ؽ??Ϊ?գ?", doorNo);

		return 0;

	}

	Json::Reader reader(Json::Features::strictMode());

	Json::Value parse_callback;

	if (reader.parse(callback, parse_callback)) {

		int status = parse_callback["status"].asInt();

		string msg = parse_callback["msg"].asString();

		if (status!=0) {

			Put_AYx(rtuno, 2, 0);

			PrintLog(LOG_ERROR, "???Ƶ?%d???Ŵ?ʧ?ܣ? ??????[%d]: %s", doorNo, status, msg.c_str());

			return 0;

		} else {

			Put_AYx(rtuno, 2, 1);

			PrintLog(LOG_INFORMATION, "???Ƶ?%d???Ŵ򿪳ɹ???", doorNo);

		}

	}

	return 1;

}

//???Ƶ?doorNO???ŵ?״̬Ϊ???ر?

int AxionAcs::SetDoorClose(int doorNo) {

	int status = 0;

	sint32 rtuno = Get_Rtuno();

	char tmp_header[128] = { 0 };

	sprintf(tmp_header, "Connection:keep-alive\r\n");

	string start_header = tmp_header;

	string urls = server_urls + "/api/v1/acs/device/door/close/" + username + "/" + password + "/" + map_door[doorNo];

	string body = "";

	string callback;

	status = Fclient::Sendreq(urls, start_header, body, callback, 1);

	if (status != -1) {

		Put_AYx(rtuno, 1, 1);

	} else { Put_AYx(rtuno, 1, 0); return 0; }

	if (callback.size() <= 0) {

		PrintLog(LOG_ERROR, "???Ƶ?%d???Źرյ????ݷ??ؽ??Ϊ?գ?", doorNo);

		return 0;

	}

	Json::Reader reader(Json::Features::strictMode());

	Json::Value parse_callback;

	if (reader.parse(callback, parse_callback)) {

		int status = parse_callback["status"].asInt();

		string msg = parse_callback["msg"].asString();

		if (status != 0) {

			Put_AYx(rtuno, 2, 0);

			PrintLog(LOG_ERROR, "???Ƶ?%d???Źر?ʧ?ܣ? ??????[%d]: %s", doorNo, status, msg.c_str());

			return 0;

		} else {

			Put_AYx(rtuno, 2, 1);

			PrintLog(LOG_INFORMATION, "???Ƶ?%d???Źرճɹ???", doorNo);

		}

	}

	return 1;

}

//???Ƶ?doorNO???ŵĹ???ģʽΪmode   0???Զ???1??ˢ????2????+???룬3?????????룬4????????5?????գ?6????????

int AxionAcs::SetDoorMode(int doorNo, string mode) {

	int status = 0;

	sint32 rtuno = Get_Rtuno();