PhysicalDevice/Detector/Trixel/DIOS.Dev.FPD.TrixellDR/DIOS.Dev.FPDDeviceMould/TemperatureMould.hpp

#pragma once
#include <memory>
#include "ResDataObject.h"
#include "CCOS.Dev.IODevice.hpp"
#include "CCOS.Dev.MouldDefine.hpp"

namespace CCOS::Dev::Detail
{
	class DeviceTemperatureMould : public FloatMouldWithWarn
	{
		typedef enum ZSKK_Templerature_state
		{
			ZSKK_TEM_STATE_TOO_LOW = 0,
			ZSKK_TEM_STATE_LOW,
			ZSKK_TEM_STAE_NORMAL,
			ZSKK_TEM_STATE_HIGH,
			ZSKK_TEM_STATE_TOO_HIGH
		}ZSKK_TEMPERATURE_STATE;

		float m_CurrentValue;
		std::shared_ptr <CCOS::Dev::IOEventCenter>  m_EventCenter;
		std::string m_Key;

	public:
		using super = FloatMouldWithWarn;

		DeviceTemperatureMould(const char* strkey, float initialvalue, float min, float WarnMin, 
			float WarnMax, float CalibWarnMin, float CalibWarnMax, float max, float accuracy,
			std::shared_ptr <CCOS::Dev::IOEventCenter>  EventCenter)
		: super(strkey, initialvalue, min, WarnMin, WarnMax, CalibWarnMin, CalibWarnMax, max, accuracy)
		{
			m_Key = strkey;
			m_EventCenter = EventCenter;
			m_CurrentValue = initialvalue;
			m_WarningMax = WarnMax;
			m_WarningMin = WarnMin;
			m_CalibWarningMax = CalibWarnMax;
			m_CalibWarningMin = CalibWarnMin;
			m_ErrorMax = max;
			m_ErrorMin = min;
		}

		~DeviceTemperatureMould() {}

		std::string GetDescription()
		{
			ResDataObject temp, result;
			temp.add(ValKey::UPPERLIMIT, m_LimitMax);
			temp.add(ValKey::LOWERLIMIT, m_LimitMin);
			temp.add(ValKey::WARNUPPERLIMIT, m_WarningMax);
			temp.add(ValKey::WARNLOWERLIMIT, m_WarningMin);
			temp.add(ValKey::ACCURACY, m_Accuracy);
			temp.add(ValKey::UNIT, m_Key.c_str());
			result.add(Key.c_str(), temp);
			return result.encode();
		}

		RET_STATUS JSGetCurrentTemperatureValue(std::string & out)
		{
			char szFDinfo[MAX_STRING] = { 0 };
			sprintf_s(szFDinfo, "%f", m_CurrentValue);
			out = szFDinfo;
			return RET_STATUS::RET_SUCCEED;
		}

		RET_STATUS JSGetTemperatureWarningMax(std::string & out)
		{
			char szFDinfo[MAX_STRING] = { 0 };
			sprintf_s(szFDinfo, "%f", m_WarningMax);
			out = szFDinfo;
			return RET_STATUS::RET_SUCCEED;
		}

		RET_STATUS JSGetTemperatureWarningMin(std::string & out)
		{
			char szFDinfo[MAX_STRING] = { 0 };
			sprintf_s(szFDinfo, "%f", m_WarningMin);
			out = szFDinfo;
			return RET_STATUS::RET_SUCCEED;
		}

		RET_STATUS JSGetTemperatureCalibWarningMax(std::string & out)
		{
			char szFDinfo[MAX_STRING] = { 0 };
			sprintf_s(szFDinfo, "%f", m_CalibWarningMax);
			out = szFDinfo;
			return RET_STATUS::RET_SUCCEED;
		}

		RET_STATUS JSGetTemperatureCalibWarningMin(std::string & out)
		{
			char szFDinfo[MAX_STRING] = { 0 };
			sprintf_s(szFDinfo, "%f", m_CalibWarningMin);
			out = szFDinfo;
			return RET_STATUS::RET_SUCCEED;
		}

		RET_STATUS JSGetTemperatureErrorMax(std::string & out)
		{
			char szFDinfo[MAX_STRING] = { 0 };
			sprintf_s(szFDinfo, "%f", m_ErrorMax);
			out = szFDinfo;
			return RET_STATUS::RET_SUCCEED;
		}

		RET_STATUS JSGetTemperatureErrorMin(std::string & out)
		{
			char szFDinfo[MAX_STRING] = { 0 };
			sprintf_s(szFDinfo, "%f", m_ErrorMin);
			out = szFDinfo;
			return RET_STATUS::RET_SUCCEED;
		}

		RET_STATUS SetTemperatureWarningMax(string strValue)
		{
			float temp = stof(strValue);
			if (m_WarningMax == temp)
			{
				return RET_STATUS::RET_SUCCEED;
			}
			m_WarningMax = temp;

			char szFDinfo[MAX_STRING] = { 0 };
			sprintf_s(szFDinfo, "%f", m_WarningMax);
			m_EventCenter->OnNotify((int)ATTRACTION_SET, "TempUpperLimit", szFDinfo);
			return RET_STATUS::RET_SUCCEED;
		}	

		RET_STATUS SetTemperatureWarningMin(string strValue)
		{
			float temp = stof(strValue);
			if (m_WarningMin == temp)
			{
				return RET_STATUS::RET_SUCCEED;
			}
			m_WarningMin = temp;

			char szFDinfo[MAX_STRING] = { 0 };
			sprintf_s(szFDinfo, "%f", m_WarningMin);
			m_EventCenter->OnNotify((int)ATTRACTION_SET, "TempLowerLimit", szFDinfo);
			return RET_STATUS::RET_SUCCEED;
		}

		RET_STATUS SetTemperatureCalibWarningMax(string strValue)
		{
			float temp = stof(strValue);
			if (m_CalibWarningMax == temp)
			{
				return RET_STATUS::RET_SUCCEED;
			}
			m_CalibWarningMax = temp;

			char szFDinfo[MAX_STRING] = { 0 };
			sprintf_s(szFDinfo, "%f", m_CalibWarningMax);
			m_EventCenter->OnNotify((int)ATTRACTION_SET, "TemperatureCalibUpWarn", szFDinfo);
			return RET_STATUS::RET_SUCCEED;
		}	

		RET_STATUS SetTemperatureCalibWarningMin(string strValue)
		{
			float temp = stof(strValue);
			if (m_CalibWarningMin == temp)
			{
				return RET_STATUS::RET_SUCCEED;
			}
			m_CalibWarningMin = temp;
			char szFDinfo[MAX_STRING] = { 0 };
			sprintf_s(szFDinfo, "%f", m_CalibWarningMin);
			m_EventCenter->OnNotify((int)ATTRACTION_SET, "TemperatureCalibLowWarn", szFDinfo);
			return RET_STATUS::RET_SUCCEED;
		}

		RET_STATUS SetTemperatureErrorMax(string strValue)
		{
			float temp = stof(strValue);
			if (m_ErrorMax == temp)
			{
				return RET_STATUS::RET_SUCCEED;
			}
			m_ErrorMax = temp;

			char szFDinfo[MAX_STRING] = { 0 };
			sprintf_s(szFDinfo, "%f", m_ErrorMax);
			m_EventCenter->OnNotify((int)ATTRACTION_SET, "TempMaxLimit", szFDinfo);
			return RET_STATUS::RET_SUCCEED;
		}

		RET_STATUS SetTemperatureErrorMin(string strValue)
		{
			float temp = stof(strValue);
			if (m_ErrorMin == temp)
			{
				return RET_STATUS::RET_SUCCEED;
			}
			m_ErrorMin = temp;

			char szFDinfo[MAX_STRING] = { 0 };
			sprintf_s(szFDinfo, "%f", m_ErrorMin);
			m_EventCenter->OnNotify((int)ATTRACTION_SET, "TempMinLimit", szFDinfo);
			return RET_STATUS::RET_SUCCEED;
		}

		bool SetTemperature(float nValue, int & nState)
		{
			if (nValue != m_CurrentValue)
			{
				m_CurrentValue = nValue;

				if (m_CurrentValue > m_LimitMax)
				{
					nState = ZSKK_TEM_STATE_TOO_HIGH;
				}
				else if (m_CurrentValue <= m_LimitMax && m_CurrentValue > m_WarningMax)
				{
					nState = ZSKK_TEM_STATE_HIGH;
				}
				else if (m_CurrentValue <= m_WarningMax && m_CurrentValue >= m_WarningMin)
				{
					nState = ZSKK_TEM_STAE_NORMAL;
				}
				else if (m_CurrentValue < m_WarningMin && m_CurrentValue >= m_LimitMin)
				{
					nState = ZSKK_TEM_STATE_LOW;
				}
				else if (m_CurrentValue < m_LimitMin)
				{
					nState = ZSKK_TEM_STATE_TOO_LOW;
				}

				char szFDinfo[MAX_STRING] = { 0 };
				sprintf_s(szFDinfo, "%f", nValue);
				m_EventCenter->OnNotify((int)ATTRACTION_SET,"Temperature_Value", szFDinfo);
			}
			return true;
		}

		RET_STATUS JSUpdateTemperatureWarningMax(string in,string& out)
		{
			out = in;
			return SetTemperatureWarningMax(in);
		}

		RET_STATUS JSUpdateTemperatureWarningMin(string in, string& out)
		{
			out = in;
			return SetTemperatureWarningMin(in);
		}

		RET_STATUS JSUpdateTemperatureErrorMax(string in, string& out)
		{
			out = in;
			return SetTemperatureErrorMax(in);
		}

		RET_STATUS JSUpdateTemperatureErrorMin(string in, string& out)
		{
			out = in;
			return SetTemperatureErrorMin(in);
		}

		RET_STATUS JSUpdateTemperatureCalibWarningMax(string in, string& out)
		{
			out = in;
			return SetTemperatureCalibWarningMax(in);
		}

		RET_STATUS JSUpdateTemperatureCalibWarningMin(string in, string& out)
		{
			out = in;
			return SetTemperatureCalibWarningMin(in);
		}

	};//DeviceTemperatureMould
}