Merge branch 'feature/#4528_CF_AOI_Review_Motor_Offset_기능_추가' into develop

KEJ

2023-11-24 9020bfb6f86ff853d5d5b3cee882132a244232da

 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)