#4403 CF AOI Review TACT 개선 1. Alive 신호 처리 시 지연 개선

SWK

2023-03-10 5ce2e7ca14f09da2138ea783ef16044a01423413

 ReviewSystem/CHSignalControls/SignalControl_DitSharedMemorySync.cpp

@@ -139,101 +139,170 @@

BOOL CSignalControl_DitSharedMemorySync::Write_SendSignal(int nAddrIndex, int nSignalIndex, WORD wSignalValue, int nOnTime)
{
   if(nOnTime == 0)
{
   if(m_pMemStartAddr == NULL) return FALSE;
   if (m_ControlInfo.GetIndex() < 0) return FALSE;


   CSingleLock localLock(&m_csWriteSignal);
   localLock.Lock();

   if(m_pSendSignalValueAddr[nAddrIndex]==NULL) return FALSE;

   int nAddress = m_pSendSignalValueAddr[nAddrIndex];

   // read value
   WORD wCurValue = 0;
   memcpy(&wCurValue, m_pMemStartAddr+nAddress, sizeof(WORD));

   // send value
   WORD wSendValue = 0;
   if (wSignalValue==1)      // signal on
   /*< SWK 20221221 - #4403 MOD Start >*/
//    if (nOnTime == 0)
//    {
//       if (m_pMemStartAddr == NULL) return FALSE;
//       if (m_ControlInfo.GetIndex() < 0) return FALSE;
// 
// 
//       CSingleLock localLock(&m_csWriteSignal);
//       localLock.Lock();
// 
//       if (m_pSendSignalValueAddr[nAddrIndex] == NULL) return FALSE;
// 
//       int nAddress = m_pSendSignalValueAddr[nAddrIndex];
// 
//       // read value
//       WORD wCurValue = 0;
//       memcpy(&wCurValue, m_pMemStartAddr + nAddress, sizeof(WORD));
// 
//       // send value
//       WORD wSendValue = 0;
//       if (wSignalValue == 1)      // signal on
//       {
//          wSendValue = 1 << nSignalIndex;
//          wSendValue = wSendValue | wCurValue;
//       }
//       else                        // signal off
//       {
//          if (wCurValue > 0)
//          {
//             wSendValue = 1 << nSignalIndex;
//             wSendValue = (wCurValue - wSendValue) < 0 ? 0 : (wCurValue - wSendValue);
//          }
//       }
// 
//       memcpy(m_pMemStartAddr + nAddress, &wSendValue, sizeof(WORD));
// 
// 
//       return TRUE;
//    }
//    else
//    {
//       if (m_pSignalThread == NULL) return FALSE;
// 
//       CSignalData signalData;
//       signalData.nAddrIndex = nAddrIndex;
//       signalData.nSignalIndex = nSignalIndex;
//       signalData.wSignalValue = wSignalValue;
//       signalData.dwOnTime = nOnTime;
// 
//       return m_pSignalThread->AddThreadData(signalData);
//    }
// 
   /*< SWK 20221226 - #4403 ADD Start >*/
   if (0 == nOnTime)
   {
      wSendValue = 1 << nSignalIndex;
      wSendValue = wSendValue | wCurValue;
      Write_SendSignal(nAddrIndex, nSignalIndex, wSignalValue != 0);
      return TRUE;
   }
   else                        // signal off
   {
      if (wCurValue>0)
      {
         wSendValue = 1 << nSignalIndex;
         wSendValue = (wCurValue - wSendValue)<0 ? 0 : (wCurValue - wSendValue);
      }
   }

   memcpy(m_pMemStartAddr+nAddress, &wSendValue, sizeof(WORD));


   return TRUE;
}
   else
{
   if (m_pSignalThread==NULL) return FALSE;
   /*< SWK 20221226 - #4403 ADD End >*/
   if (m_pSignalThread == NULL) return FALSE;

   CSignalData signalData;
   signalData.nAddrIndex      = nAddrIndex;
   signalData.nSignalIndex      = nSignalIndex;
   signalData.wSignalValue      = wSignalValue;
   signalData.dwOnTime         = nOnTime;
   signalData.nAddrIndex = nAddrIndex;
   signalData.nSignalIndex = nSignalIndex;
   signalData.wSignalValue = wSignalValue;
   signalData.dwOnTime = nOnTime;

   return m_pSignalThread->AddThreadData(signalData);
   /*< SWK 20221221 - #4403 MOD End >*/
}

/*< SWK 20221226 - #4403 ADD Start >*/
inline void CSignalControl_DitSharedMemorySync::Write_SendSignal(int nAddrIndex, int nSignalIndex, bool bOn)
{
   int nAddress = m_pSendSignalValueAddr[nAddrIndex];
   WORD wSendValue = 1 << nSignalIndex;

   WORD wCurValue = 0;
   CSingleLock localLock(&m_csWriteSignal, TRUE);
   memcpy(&wCurValue, m_pMemStartAddr + nAddress, sizeof(WORD));
   if (bOn)   wCurValue |= wSendValue;
   else      wCurValue &= ~wSendValue;
   memcpy(m_pMemStartAddr + nAddress, &wCurValue, sizeof(WORD));
}
/*< SWK 20221226 - #4403 ADD End >*/

void CSignalControl_DitSharedMemorySync::IST2P_RunThreadProcess(const CSignalData& signalData)
{
   CSingleLock localLock(&m_csWriteSignal);
   localLock.Lock();

   if (m_nSendSignalCount<=0) return;

   if(m_pMemStartAddr == NULL) return;

   int nAddress = m_pSendSignalValueAddr[signalData.nAddrIndex];

   // read value
   WORD wCurValue = 0;
   memcpy(&wCurValue, m_pMemStartAddr+nAddress, sizeof(WORD));

   // send value
   WORD wSendValue = 0;
   if (signalData.wSignalValue==1)      // signal on
   /*< SWK 20221221 - #4403 MOD Start >*/
//    CSingleLock localLock(&m_csWriteSignal);
//    localLock.Lock();
// 
//    if (m_nSendSignalCount<=0) return;
// 
//    if(m_pMemStartAddr == NULL) return;
// 
//    int nAddress = m_pSendSignalValueAddr[signalData.nAddrIndex];
// 
//    // read value
//    WORD wCurValue = 0;
//    memcpy(&wCurValue, m_pMemStartAddr+nAddress, sizeof(WORD));
// 
//    // send value
//    WORD wSendValue = 0;
//    wSendValue = 1 << signalData.nSignalIndex;
//    if (signalData.wSignalValue==1)      // signal on
//    {
//       wSendValue = 1 << signalData.nSignalIndex;
//       wSendValue = wSendValue | wCurValue;
//    }
//    else                        // signal off
//    {
//       if (wCurValue>0)
//       {
//          wSendValue = 1 << signalData.nSignalIndex;
//          wSendValue = (wCurValue - wSendValue)<0 ? 0 : (wCurValue - wSendValue);
//       }
//    }
// 
//    memcpy(m_pMemStartAddr+nAddress, &wSendValue, sizeof(WORD));
// 
//    if (signalData.dwOnTime>0)
//    {
//       localLock.Unlock();
//       // wait
//       ::Sleep(signalData.dwOnTime);
// 
//       // clear value
//       memcpy(m_pMemStartAddr+nAddress, &wCurValue, sizeof(WORD));
//    }
// 
// 
   if (m_nSendSignalCount <= 0) return;
   if (m_pMemStartAddr == NULL) return;
   if (signalData.dwOnTime <= 0)   // Signal without hold-time
      ;
   else if(0 == signalData.ullStartTick)   // Signal with hold-time
   {
      wSendValue = 1 << signalData.nSignalIndex;
      wSendValue = wSendValue | wCurValue;
      CSignalData NewSignalData = signalData;
      NewSignalData.ullStartTick = GetTickCount64();         // Set Start Tick
      NewSignalData.wSignalValue = !signalData.wSignalValue;   // Signal Inversion
      m_pSignalThread->AddThreadData(NewSignalData);
   }
   else                        // signal off
   else if (GetTickCount64() - signalData.ullStartTick < signalData.dwOnTime)   // Check Holding Time
   {
      if (wCurValue>0)
      {
         wSendValue = 1 << signalData.nSignalIndex;
         wSendValue = (wCurValue - wSendValue)<0 ? 0 : (wCurValue - wSendValue);
      }
      //< KEJ 20230310 - #4403 ADD >
      Sleep(1);
      CSignalData NewSignalData = signalData;
      m_pSignalThread->AddThreadData(NewSignalData);
      return;
   }
   /*< SWK 20221226 - #4403 MOD Start >*/
//    int nAddress = m_pSendSignalValueAddr[signalData.nAddrIndex];
//    WORD wSendValue = 1 << signalData.nSignalIndex;
// 
//    WORD wCurValue = 0;
//    memcpy(&wCurValue, m_pMemStartAddr + nAddress, sizeof(WORD));
//    if (true == signalData.wSignalValue)   wCurValue |= wSendValue;
//    else                           wCurValue &= ~wSendValue;
//    memcpy(m_pMemStartAddr + nAddress, &wCurValue, sizeof(WORD));

   memcpy(m_pMemStartAddr+nAddress, &wSendValue, sizeof(WORD));

   if (signalData.dwOnTime>0)
   {
      // wait
      ::Sleep(signalData.dwOnTime);

      // clear value
      memcpy(m_pMemStartAddr+nAddress, &wCurValue, sizeof(WORD));
   }
   Write_SendSignal(signalData.nAddrIndex, signalData.nSignalIndex, signalData.wSignalValue != 0);
   /*< SWK 20221226 - #4403 MOD End >*/
   /*< SWK 20221221 - #4403 MOD End >*/
}

BOOL CSignalControl_DitSharedMemorySync::ReadData(const CString strAddr, int nSize, CString& strData)
@@ -265,6 +334,24 @@
   return TRUE;
}

/*< LYW 20220610 - #4185 ADD Start >*/
BOOL CSignalControl_DitSharedMemorySync::ReadData(const CString strAddr, int BitPosition, int nSize, int& nData)
{
   if (m_pMemStartAddr == NULL)   return FALSE;

   int nAddress = _ttoi(strAddr);

   // read value
   int TempData = 0;
   memcpy(&TempData, m_pMemStartAddr + nAddress, sizeof(int)*nSize);

   TempData = TempData >> BitPosition;

   nData = TempData & 1;
   return TRUE;
}
/*< LYW 20220610 - #4185 ADD End >*/

BOOL CSignalControl_DitSharedMemorySync::WriteData(const CString strAddr, int nSize, CString strData)
{
   if(m_pMemStartAddr == NULL)   return FALSE;