#include "StdAfx.h"
#include <WinDef.h>
#include <WinBase.h>
#include "Keyence_Laser.h"

#define MAX_STORAGE_DATA_SIZE        65536

CKeyence_Laser::CKeyence_Laser()
{
  m_hLkif=NULL;
  m_bIsStorage=FALSE;
  m_iSetOutNo=0;
  m_StoredDataNumber=0;
  m_NeedStorageDataNumber=0;
  m_StorageCycle=LKIF_STORAGECYCLE_100;
  m_ProgramNO=1;
}

CKeyence_Laser::~CKeyence_Laser()
{
  if (m_hLkif)
  {
    FreeLibrary(m_hLkif);
  }
}
//========================================
void CKeyence_Laser::KeyenceLaserInit(void)
{
  if (!m_hLkif)
  {
    m_hLkif=(HMODULE)LoadLibrary(GetAppPath()+_T("\\LkIF.dll"));
    if(m_hLkif)
    {
      m_pGetCalcData=(pLKIF_GetCalcData)GetProcAddress(m_hLkif,"LKIF_GetCalcData");
      m_pDataStorageStart=(pLKIF_DataStorageStart)GetProcAddress(m_hLkif,"LKIF_DataStorageStart");
      m_pDataStorageStop=(pLKIF_DataStorageStop)GetProcAddress(m_hLkif,"LKIF_DataStorageStop");
      m_pDataStorageInit=(pLKIF_DataStorageInit)GetProcAddress(m_hLkif,"LKIF_DataStorageInit");
      m_pDataStorageGetData=(pLKIF_DataStorageGetData)GetProcAddress(m_hLkif,"LKIF_DataStorageGetData");
      m_pDataStorageGetStatus=(pLKIF_DataStorageGetStatus)GetProcAddress(m_hLkif,"LKIF_DataStorageGetStatus");
      m_pSetDataStorage=(pLKIF_SetDataStorage)GetProcAddress(m_hLkif,"LKIF_SetDataStorage");
      m_pSetProgramNo=(pLKIF_SETPROGRAMNO)GetProcAddress(m_hLkif,"LKIF_SetProgramNo");
      m_pSetScaling=(pLKIF_SetScaling)GetProcAddress(m_hLkif,"LKIF_SetScaling");
      m_pGetScaling=(pLKIF_GetScaling)GetProcAddress(m_hLkif,"LKIF_GetScaling");
      m_pSetDisplayUnit=(pLKIF_SetDisplayUnit)GetProcAddress(m_hLkif,"LKIF_SetDisplayUnit");
      m_pGetDisplayUnit=(pLKIF_GetDisplayUnit)GetProcAddress(m_hLkif,"LKIF_GetDisplayUnit");
      m_pSetPanel=(pLKIF_SetPanel)GetProcAddress(m_hLkif,"LKIF_SetPanel");
      m_pSetMeasureMode=(pLKIF_SetMeasureMode)GetProcAddress(m_hLkif,"LKIF_SetMeasureMode");
      m_pSetCalcMethod=(pLKIF_SetCalcMethod)GetProcAddress(m_hLkif,"LKIF_SetCalcMethod");
      m_pSetMutualInterferencePrevention=(pLKIF_SetMutualInterferencePrevention)GetProcAddress(m_hLkif,"LKIF_SetMutualInterferencePrevention");
    }
    else
    {
      MessageBox(NULL, _T("Load LkIF.dll failed!"), _T("Message"), MB_OK);
    }
  }
}
//==============================================
void CKeyence_Laser::Get_KeyenceLaserData(float *LaserValue1,float *LaserValue2)
{
  *LaserValue1=10;
  *LaserValue2=10;
  LKIF_FLOATVALUE GetVal1,GetVal2;
  if(m_pGetCalcData(&GetVal1,&GetVal2)!=1)
  {
    return ;
  }
  switch(GetVal1.FloatResult)
  {
  case LKIF_FLOATRESULT_RANGEOVER_P:
    {
      *LaserValue1=50;
      break;
    }
  case LKIF_FLOATRESULT_RANGEOVER_N:
    {
      *LaserValue1=-50;
      break;
    }
  case LKIF_FLOATRESULT_WAITING:
    {
      *LaserValue1=0;
      break;
    }
  default:
    {
      *LaserValue1=GetVal1.Value;
      break;
    }
  }

  switch(GetVal2.FloatResult)
  {
  case LKIF_FLOATRESULT_RANGEOVER_P:
    {
      *LaserValue2=50;
      break;
    }
  case LKIF_FLOATRESULT_RANGEOVER_N:
    {
      *LaserValue2=-50;
      break;
    }
  case LKIF_FLOATRESULT_WAITING:
    {
      *LaserValue2=0;
      break;
    }
  default:
    {
      *LaserValue2=GetVal2.Value;
      break;
    }
  }
}

//==============================================
BOOL CKeyence_Laser::StartStoreData(int  _NeedStorageDataNumber,int _SampleTime)
{
  BOOL bStatus(FALSE);
  GetStoreDataStatus();
  if (!m_bIsStorage)
  {
    bStatus=m_pDataStorageInit();
    if (_NeedStorageDataNumber<1)
    {
      _NeedStorageDataNumber=1;
    } 
    else if (_NeedStorageDataNumber>65536)
    {
      _NeedStorageDataNumber=65536;
    }
    m_NeedStorageDataNumber=_NeedStorageDataNumber;

    if (_SampleTime<0.4)
    {
      m_StorageCycle=LKIF_STORAGECYCLE_1;
    }
    else if (_SampleTime<1)
    {
      m_StorageCycle=LKIF_STORAGECYCLE_2;
    }    
    else if (_SampleTime<2)
    {
      m_StorageCycle=LKIF_STORAGECYCLE_5;
    }    
    else if (_SampleTime<4)
    {
      m_StorageCycle=LKIF_STORAGECYCLE_10;
    }    
    else if (_SampleTime<10)
    {
      m_StorageCycle=LKIF_STORAGECYCLE_20;
    }    
    else if (_SampleTime<20)
    {
      m_StorageCycle=LKIF_STORAGECYCLE_50;
    }    
    else if (_SampleTime<40)
    {
      m_StorageCycle=LKIF_STORAGECYCLE_100;
    }    
    else if (_SampleTime<100)
    {
      m_StorageCycle=LKIF_STORAGECYCLE_200;
    }    
    else if (_SampleTime<200)
    {
      m_StorageCycle=LKIF_STORAGECYCLE_500;
    }
    else
    {
      m_StorageCycle=LKIF_STORAGECYCLE_1000;
    }    
    bStatus=m_pSetDataStorage(LKIF_TARGETOUT_OUT1,m_NeedStorageDataNumber,m_StorageCycle);

    if (bStatus)
    {
      bStatus=m_pDataStorageStart();
    }
  } 
  return bStatus;
};
//==============================================
BOOL CKeyence_Laser::StopStoreData()
{
  BOOL bStatus(FALSE);
  GetStoreDataStatus();
  if (m_bIsStorage)
  {
    bStatus=m_pDataStorageStop();
  } 
  return bStatus;
};
//==============================================
BOOL CKeyence_Laser::PauseScanAndGetData(float *GetStorageData,int *GetStorageNumber)
{
  BOOL bStatus(FALSE);
  GetStoreDataStatus();
  if (m_bIsStorage)
  {
    bStatus=m_pDataStorageStop();
    bStatus=GetStoredData(GetStorageData,GetStorageNumber);
    bStatus=m_pDataStorageStart();
  }
  else
  {
    bStatus=GetStoredData(GetStorageData,GetStorageNumber);
  }
  return bStatus;
};
//==============================================
BOOL CKeyence_Laser::GetStoredData(float *GetStorageData,int *GetStorageNumber)
{
  BOOL bStatus(FALSE);
  GetStoreDataStatus();
  if (!m_bIsStorage)
  {
    LKIF_FLOATVALUE GetStorageValue[MAX_STORAGE_DATA_SIZE];
    bStatus=m_pDataStorageGetData(m_iSetOutNo,m_StoredDataNumber,GetStorageValue,GetStorageNumber);
    for(int i=0;i<*GetStorageNumber;i++)
    {
      switch(GetStorageValue[i].FloatResult)
      {
      case LKIF_FLOATRESULT_RANGEOVER_P:
        {
          *GetStorageData++=50;
          break;
        }
      case LKIF_FLOATRESULT_RANGEOVER_N:
        {
          *GetStorageData++=-50;
          break;
        }
      case LKIF_FLOATRESULT_WAITING:
        {
          *GetStorageData++=0;
          break;
        }
      default:
        {
          *GetStorageData++=GetStorageValue[i].Value;
          break;
        }
      }
    }

  } 
  return bStatus;
};
//==============================================
BOOL CKeyence_Laser::GetStoreDataStatus()
{
  BOOL bStatus(FALSE);
  bStatus=m_pDataStorageGetStatus(m_iSetOutNo,&m_bIsStorage,&m_StoredDataNumber);
  return bStatus;
};
//==============================================
BOOL CKeyence_Laser::SetProgramNO(int ProNO)
{
  BOOL bStatus(FALSE);
  bStatus=m_pSetProgramNo(ProNO);
  m_ProgramNO=ProNO;
  return bStatus;
};

//==============================================
BOOL CKeyence_Laser::SetOutValueScaling(double _CalibVal)
{
  BOOL bStatus(FALSE);
  double DisplayUnit(0.0001);
  bStatus=m_pSetDisplayUnit(0,LKIF_DISPLAYUNIT_00_0001MM);
  bStatus=m_pSetDisplayUnit(1,LKIF_DISPLAYUNIT_00_0001MM);
  int InputValue1(0),OutputValue1(0),InputValue2(10000),OutputValue2(10000);
  bStatus=m_pSetScaling(0,0,InputValue1,OutputValue1,InputValue2,OutputValue2);
  bStatus=m_pSetScaling(1,1,InputValue1,OutputValue1,InputValue2,OutputValue2);
  Sleep(20);
  float OutValue1(0.0),OutValue2(0.0);
  Get_KeyenceLaserData(&OutValue1,&OutValue2);
  InputValue2=static_cast<int>((static_cast<double>(OutValue1))/DisplayUnit);
  OutputValue2=static_cast<int>((_CalibVal)/DisplayUnit);
  bStatus=m_pSetScaling(0,0,InputValue1,OutputValue1,InputValue2,OutputValue2);

  InputValue2=static_cast<int>((static_cast<double>(OutValue2))/DisplayUnit);
  bStatus=m_pSetScaling(1,1,InputValue1,OutputValue1,InputValue2,OutputValue2);
  return bStatus;
};

//==============================================
BOOL CKeyence_Laser::GetOutValueScaling(double* _CalibratedScale)
{
  BOOL bStatus(FALSE);
  double DisplayUnit(0.0001);
  bStatus=m_pSetDisplayUnit(0,LKIF_DISPLAYUNIT_00_0001MM);
  bStatus=m_pSetDisplayUnit(1,LKIF_DISPLAYUNIT_00_0001MM);
  int InputValue1(0),OutputValue1(0),InputValue2(0),OutputValue2(0);
  bStatus=m_pGetScaling(0,0,&InputValue1,&OutputValue1,&InputValue2,&OutputValue2);
  _CalibratedScale[0]=static_cast<double>(InputValue1)*DisplayUnit;
  _CalibratedScale[1]=static_cast<double>(OutputValue1)*DisplayUnit;
  _CalibratedScale[2]=static_cast<double>(InputValue2)*DisplayUnit;
  _CalibratedScale[3]=static_cast<double>(OutputValue2)*DisplayUnit;
  Sleep(20);
  bStatus=m_pGetScaling(1,1,&InputValue1,&OutputValue1,&InputValue2,&OutputValue2);
  _CalibratedScale[4]=static_cast<double>(InputValue1)*DisplayUnit;
  _CalibratedScale[5]=static_cast<double>(OutputValue1)*DisplayUnit;
  _CalibratedScale[6]=static_cast<double>(InputValue2)*DisplayUnit;
  _CalibratedScale[7]=static_cast<double>(OutputValue2)*DisplayUnit;
  return bStatus;
};
//==============================================
BOOL CKeyence_Laser::SetProgram(char _MeasureMode)
{
  BOOL bStatus(FALSE);
  switch(_MeasureMode)
  {
  case 1:
    {
      bStatus=m_pSetPanel(2);
      bStatus=m_pSetMeasureMode(0,LKIF_MEASUREMODE_TRAN_2);
      bStatus=m_pSetMeasureMode(1,LKIF_MEASUREMODE_TRAN_2);

      bStatus=m_pSetCalcMethod(0,LKIF_CALCMETHOD_HEAD_HEADA_TRANSPARENT,LKIF_CALCTARGET_PEAK_1_2);
      bStatus=m_pSetCalcMethod(1,LKIF_CALCMETHOD_HEAD_HEADB_TRANSPARENT,LKIF_CALCTARGET_PEAK_1_2);

      bStatus=m_pSetMutualInterferencePrevention(TRUE);

      break;
    }
  default:
    break;
  }
  return bStatus;
}