PhysicalDevice/Machine/MachineryECOM/Deliver/Include/SCF.Detail.h

#pragma once


#ifndef SCF_EXPORTS
#ifdef _WIN64
#ifdef _DEBUG
#pragma comment (lib, "DIOS.Dev.SCFX64D.lib")
#else
#pragma comment (lib, "DIOS.Dev.SCFX64.lib")
#endif
#else
#ifdef _DEBUG
#pragma comment (lib, "DIOS.Dev.SCFD.lib")
#else
#pragma comment (lib, "DIOS.Dev.SCF.lib")
#endif
#endif
#endif



#ifdef SCF_EXPORTS
#define SCF_API __declspec (dllexport)
#define SCF_C_API extern "C" __declspec (dllexport)
#else
#define SCF_API  __declspec (dllimport)
#define SCF_C_API extern "C" __declspec (dllimport)
#endif


#include <string>
#include <memory>
#include <functional>

#include "SyncEvent.hpp"

#include "ResDataObject.h"
#include "DiosLock.h"
#include "DiosDevThread.h"

#include "SCF.Define.hpp"


#pragma warning (disable:4251)	// m_pPacketParser”: class“std::function<PACKET_RET (const char *,DWORD,DWORD &)>”需要有 dll 接口由 class“DIOS::Dev::SCF::Detail::_SCF”的客户端使用


SCF_C_API PVOID MallocSCFPacket ();//申请SCFPACKET
SCF_C_API void ReleaseSCFPacket (PVOID pObj);//释放SCFPACKET


class CircleBuff;


namespace DIOS
{
namespace Dev
{
namespace Communication
{
namespace Detail
{

class SCF_API  SCFPacket
{
protected:
	char* m_PacketBuff;
	DWORD m_PacketBuffLen;

	DWORD m_PacketLength;

	bool ReAlloc (DWORD BaseLen);

public:
	SCFPacket ();
	SCFPacket (char* pData, DWORD Length);

	virtual ~SCFPacket ();

	bool SetBuffLen (DWORD Len);
	DWORD GetBuffLen ();

	SCFPacket& operator = (const SCFPacket &tValue);

	int SetPacket (const char* pData, DWORD Length);

	int AddTail (const char* pData, DWORD Length);

	void SetPacketLen (DWORD Len);
	DWORD GetPacketLen ();
	operator char* ();

	int GetPacket (char* pData, DWORD Length);
};

class SCF_API SCFBuffer : public DiosLock
{
	DWORD m_CurPacketIdx;
	SCFPacket *m_pPacket[2];

public:
	SCFBuffer ();
	~SCFBuffer ();

	bool SetBuff (DWORD Len);

	int Add (const char * data, DWORD len);
	int Del (DWORD len);

	const char *GetBuff ();
	DWORD GetPacketLen ();

	void ClearData ();

};



class SCF_API  SCFDetail : public DiosLock, public Dios_Thread
{
public:
	SCFDetail (void);
	virtual ~SCFDetail ();

public:
	std::function <void ()> OnPassiveDisconnected;
	//	HANDLE GetScfNotifyHandle () ;//获取SCF收到Notify后通知的事件句柄
	std::function <void ()> OnNewPacket;

protected:
	HMODULE m_LibHandle;

	tPacketPredate m_pPacketParser;

	SCF_TRANSFERTYPE m_TransferType;

	//根路径是SCF路径,pFileName是偏移值，如 "COM\COM2.log"
	void InitSCF (const char *pLogFileName = NULL);

	//设置本地属性 特定通信情况下需要，串口，网络，USB的连接不需要设置
	bool SetSourceAttribute (ResDataObject & Sourceprameters) ;

public:
	//设置连接，参数也由json传过来
	/* -- 串口类型
	{
		"type":"COM",
		"port":"COM1",
		"baudrate":"3200",
		"bytesize":"8",
		"parity":"1",
		"stopbits":"1"
	}
	*/
	/* -- 网络类型
	{
		"type":"TCPIP",
		"ip":"192.168.2.77",
		"port":"2020"
	}
	*/
	void SetBuffersize (DWORD NormalPackSize, DWORD MaxBuffLimit);

	virtual int Connect (ResDataObject & Connectprameters, tPacketPredate callback = nullptr, SCF_TRANSFERTYPE TransferType = SCF_NORMAL_TRANSFER, DWORD msTimeOut = 0);
	//断开连接
	virtual void Disconnect ();
	//判断是否连接
	virtual bool isConnected () const = 0;
	//获取连接类型，由继承类实现
	virtual const char* GetConnectionType ();
	//获取连接参数
	ResDataObject GetConnectionAttributes ();

	//发数据
	virtual int SendPacket (const char *pPacket, DWORD length, DWORD timeout);
	virtual int SendPacket (SCFPacket *pPacket, DWORD timeout);

	//读数据
	int ReceivePacket (char *pPacket, DWORD length, DWORD timeout);
	int ReceivePacket (SCFPacket *pPacket, DWORD timeout);

	DWORD GetReceivePacketSize ();
	DWORD GetNotifyPacketSize ();


	/// 将不需要的数据包存入Notify数据缓存队列
	int  EnqueueNotifyPacket (const char *pPacket, DWORD length);
	int  EnqueueNotifyPacket (SCFPacket *pPacket);

	// 读取Notify数据缓存中的数据包，当SCF处于解锁状态下接收的数据都会放入Notify缓存中，
	// 需要调用DeQueNotifyPacket来读取缓存中的数据包
	// 读取成功返回接收数据的实际长度，失败返回 SCF_ERR
	int  DequeueNotifyPacket (char *pPacket, DWORD length, DWORD timeout);
	int  DequeueNotifyPacket (SCFPacket *pPacket, DWORD timeout);

	//SCF的锁
	DWORD SCFLock (DWORD timeout);
	void SCFUnLock ();

	//被动掉线事件
//	void SetPassiveDisconnectEvt (HANDLE evt);
	void SetPassiveDisconnect (std::function <void ()> fun);
	void PassiveDisconnected ();

	DWORD GetCommunicateTimeout ();

protected:

//	HANDLE m_PassiveDisconEvt;

	virtual int ReadData (char *pPacket, DWORD length, DWORD timeout);
	//virtual int ReadData (SCFPacket *pPacket, DWORD timeout);

	DWORD m_CommunicateTimeout;
	ResDataObject m_ConnectionParams;
	//---------------server part
	DWORD MaxComLen;
	DWORD NormalPackLen;

	DWORD ReadWaitTime;

	SCFBuffer m_RawBuffer;

	SCFPacket* m_pTransferBuffer;//将Receive数据转入Notify
	SCFPacket* m_pRtoNBuffer;//将Receive数据转入Notify

	bool StartSCFServer ();//开启读线程
	void StopSCFServer ();//关闭读线程

	int ProcessCmd (const char * data, int datalength);

	int ReceivetoNotify ();
	int ReceivetoNotify_Ex ();

	int WritetoNotify (const char *pPacket, int length);

	virtual bool Exec () override;



	CircleBuff * m_pNotifybuffer;
	CircleBuff * m_pReceivebuffer;

	SyncEvent::Manual  m_EventNotify;
//	HANDLE m_hNotifyhandle;
	HANDLE m_hReceivehandle;

	HANDLE	EventHandleWrite;	// 当命令写入时,发送事件
	HANDLE	EventHandleRead;	// 当读取到命令时,发送事件

private:
	void NotifyNewPacket ();
};



}
}
}
}

//SCF_C_API SCF* LoadScf (const char *pFilename);
//SCF_C_API void UnLoadScf (SCF* pHandle);

//typedef SCF * (*GetSCF_Proc) ();
//typedef void (*ReleaseSCF_Proc) (SCF *);