Ongoing60 #3486 CF AOI Review Review History 프로그램 테스트 및 적용

LYW

2021-07-08 9cbd9e554f9956b3b945b51602f1d4a3fa0353e1

 ReviewHistory/ReveiwHistory/akIPCNetAOISystem.cpp

»õ ÆÄÀÏ
@@ -0,0 +1,189 @@
#include "StdAfx.h"
#include "akIPCNetAOISystem.h"
#include <process.h>

#define SHAREDMEMNAME "DIT.AOISYSTEM.SHAREDMEM"

akIPCNetAOISystem::akIPCNetAOISystem(void)
: m_mxSignalProcess(FALSE, _T("IPC_NETWORKSYSTEM_MUTEX"))
{
   m_pParent = NULL;
   m_nThreadSignalFlag = 0;
   m_pIPCAOISystem = NULL;
   m_hMapIPCAOISystem = NULL;
	
   InitializeCriticalSection(&m_csSignalProcess);
}

akIPCNetAOISystem::~akIPCNetAOISystem(void)
{
   if(m_nThreadSignalFlag == 1) m_nThreadSignalFlag = 2;
   while(m_nThreadSignalFlag != 0)
   {
      Sleep(0);
   }

   if (m_pIPCAOISystem!=NULL)
   {
      ::UnmapViewOfFile(m_pIPCAOISystem);
      m_pIPCAOISystem = NULL;
   }

   if (m_hMapIPCAOISystem != NULL)
   {
      ::CloseHandle(m_hMapIPCAOISystem);
      m_hMapIPCAOISystem = NULL;
   }

}

bool akIPCNetAOISystem::Create( CWnd* pParent )
{
   if(m_pIPCAOISystem) return false;


   BOOL bCreateSharedMem = FALSE;//공유메모리 ìƒì„± [김태현 2018/9/10]
   {
      BOOL bCreateMem = TRUE;

      m_hMapIPCAOISystem = ::CreateFileMapping(INVALID_HANDLE_VALUE,NULL,PAGE_READWRITE
         , 0, sizeof(_IPCAOISystem), SHAREDMEMNAME);

      if (::GetLastError() == ERROR_ALREADY_EXISTS)
      {
         m_hMapIPCAOISystem = ::OpenFileMapping(FILE_MAP_ALL_ACCESS,FALSE,SHAREDMEMNAME);
         bCreateMem = FALSE;
      }

      if (m_hMapIPCAOISystem)
      {
         m_pIPCAOISystem = (_IPCAOISystem*)::MapViewOfFile(m_hMapIPCAOISystem, FILE_MAP_ALL_ACCESS, 0, 0, sizeof(_IPCAOISystem));
         if (m_pIPCAOISystem)
         {
            bCreateSharedMem = TRUE;
         }
      }
		
      //0으로 ì´ˆê¸°í™”
      if(bCreateMem && m_pIPCAOISystem) ZeroMemory(m_pIPCAOISystem,sizeof(_IPCAOISystem));
   }

   if(bCreateSharedMem == FALSE) return false;

   m_pParent = pParent;

   _beginthread(threadSignal, NULL, this);

   return true;
}

void akIPCNetAOISystem::threadSignal( void* arg )
{
   akIPCNetAOISystem* pThis = (akIPCNetAOISystem*)arg;

   pThis->m_nThreadSignalFlag = 1;
   pThis->processSignal();
   pThis->m_nThreadSignalFlag = 0;
}

void akIPCNetAOISystem::processSignal()
{
   char m_nSignalPreAOI[INA_SIGNALNUM]={};
   char m_nSignalCurAOI[INA_SIGNALNUM]={};
   char m_nSignalPreReview[INA_SIGNALNUM]={};
   char m_nSignalCurReview[INA_SIGNALNUM]={};

   DWORD dwTickCount =0;

   while(m_nThreadSignalFlag == 1)
   {
      dwTickCount = GetTickCount();

      m_mxSignalProcess.Lock();
      memcpy(m_nSignalCurAOI, getAOIProtocol()->m_nSignal, sizeof(char)*INA_SIGNALNUM);
      memcpy(m_nSignalCurReview, getReviewProtocol()->m_nSignal, sizeof(char)*INA_SIGNALNUM);
      m_mxSignalProcess.Unlock();
      //Signal ê°ì§€ ë¶€ë¶„ [김태현 2018/9/10]
      {
         for(int i=0; i<INA_SIGNALNUM; i++)
         {
            if(m_nSignalCurAOI[i] == 1 && m_nSignalPreAOI[i] == 0)
            {
               RecvSignal(ST_AOI, i);
            }
         }
         for(int i=0; i<INA_SIGNALNUM; i++)
         {
            if(m_nSignalCurReview[i] == 1 && m_nSignalPreReview[i] == 0)
            {
               RecvSignal(ST_Review, i);
            }
         }
      }

      //signal time off ì²˜ë¦¬ ë¶€ë¶„
      {
         EnterCriticalSection(&m_csSignalProcess);
         for(int i=m_vecSignalTimeOff.size()-1; i>=0; i--)
         {
            if(m_vecSignalTimeOff[i].nTimeBitOff < dwTickCount)
            {
               *m_vecSignalTimeOff[i].pSignal = 0;
               m_vecSignalTimeOff.erase(m_vecSignalTimeOff.begin()+i);
            }
            else if(*m_vecSignalTimeOff[i].pSignal == 0)
            {
               m_vecSignalTimeOff.erase(m_vecSignalTimeOff.begin()+i);
            }
         }
         LeaveCriticalSection(&m_csSignalProcess);
      }

      memcpy(m_nSignalPreAOI, m_nSignalCurAOI, sizeof(char)*INA_SIGNALNUM);
      memcpy(m_nSignalPreReview, m_nSignalCurReview, sizeof(char)*INA_SIGNALNUM);

      Sleep(50);
   }
}

bool akIPCNetAOISystem::SetSignal( emSystemType nSystemType, int nSignalIndex, int nTimeMS /*= 500*/ )
{
   char* pSignal = NULL;
   if(nSystemType == ST_AOI)
   {
      pSignal = &getAOIProtocol()->m_nSignal[nSignalIndex];
   }
   else if(nSystemType == ST_Review)
   {
      pSignal = &getReviewProtocol()->m_nSignal[nSignalIndex];
   }


   EnterCriticalSection(&m_csSignalProcess);
   for(int i=0; i<m_vecSignalTimeOff.size(); i++)
   {
      if(m_vecSignalTimeOff[i].pSignal == pSignal)
      {
         LeaveCriticalSection(&m_csSignalProcess);
         return false;
      }
   }

   _SignalTimerOff signaloff;
   signaloff.pSignal = pSignal;
   signaloff.nTimeBitOff = GetTickCount()+nTimeMS;
   m_vecSignalTimeOff.push_back(signaloff);
   LeaveCriticalSection(&m_csSignalProcess);

   m_mxSignalProcess.Lock();
   *pSignal = 1;
   m_mxSignalProcess.Unlock();
	
   return true;
}

void akIPCNetAOISystem::RecvSignal( emSystemType nSystemType, int nSignal )
{
   if(m_pParent) m_pParent->PostMessage(UM_IPCNETAOISYSTEM, nSignal, (int)nSystemType);
}