using SA_LTT.Base;
|
using SA_LTT.Module.RTC5;
|
using System;
|
using System.Collections.Generic;
|
using System.IO;
|
|
namespace SA_LTT.Module
|
{
|
public enum ScanMode
|
{
|
JUMP,
|
MARK,
|
}
|
|
/// <summary>
|
/// Scanner 가공 좌표.
|
/// </summary>
|
public struct Coord
|
{
|
ScanMode _scanMode;
|
int _x;
|
int _y;
|
|
public ScanMode ScanMode
|
{
|
get
|
{
|
return _scanMode;
|
}
|
|
set
|
{
|
_scanMode = value;
|
}
|
}
|
|
/// <summary>
|
/// -8388608 ~ 8388607
|
/// </summary>
|
public int X
|
{
|
get
|
{
|
return _x;
|
}
|
|
set
|
{
|
if (value > 8388607)
|
{
|
_x = 8388607;
|
}
|
else if (value < -8388608)
|
{
|
_x = -8388608;
|
}
|
else
|
{
|
_x = value;
|
}
|
}
|
}
|
|
/// <summary>
|
/// -8388608 ~ 8388607
|
/// </summary>
|
public int Y
|
{
|
get
|
{
|
return _y;
|
}
|
|
set
|
{
|
if (value > 8388607)
|
{
|
_y = 8388607;
|
}
|
else if (value < -8388608)
|
{
|
_y = -8388608;
|
}
|
else
|
{
|
_y = value;
|
}
|
}
|
}
|
|
public Coord(ScanMode scanMode, int x, int y)
|
{
|
_scanMode = ScanMode.JUMP;
|
_x = 0;
|
_y = 0;
|
|
ScanMode = scanMode;
|
X = x;
|
Y = y;
|
}
|
}
|
|
public delegate void ScanListAdded(Coord coord);
|
public delegate void ScanListCleared();
|
|
public class Scanner : XmlManager<Scanner>
|
{
|
private Equipment _equipment;
|
|
private object _lock = new object();
|
|
public event ScanListAdded ScanListAdded;
|
public event ScanListCleared ScanListCleared;
|
|
readonly string _fileName = "Scanner.xml";
|
readonly string _filePath = @"Setting\";
|
|
#region Field
|
private string _correctionFilePath;
|
|
private bool _isInitialized;
|
private bool _isBusy;
|
private uint _isPosition;
|
|
private int _encoder0;
|
private int _encoder1;
|
|
private int _encoderCountPerMmX;
|
private int _encoderCountPerMmY;
|
|
private double _fieldOfView;
|
|
private uint _halfPeriod;
|
private uint _pulseLength1;
|
private uint _timeBase;
|
|
private uint _jumpDelay;
|
private uint _markDelay;
|
private uint _polygonDelay;
|
|
private int _laserOnDelay;
|
private uint _laserOffDelay;
|
|
private double _xGain;
|
private double _yGain;
|
|
private bool _isLaserOn;
|
private List<Coord> scanList = new List<Coord>();
|
#endregion
|
|
#region Property
|
//보정 파일 위치
|
public string CorrectionFilePath
|
{
|
get
|
{
|
return _correctionFilePath;
|
}
|
|
set
|
{
|
_correctionFilePath = value;
|
}
|
}
|
|
/// <summary>
|
/// RTC5 Board 마지막 초기화 결과
|
/// </summary>
|
public bool IsInitialized
|
{
|
get
|
{
|
return _isInitialized;
|
}
|
|
set
|
{
|
_isInitialized = value;
|
}
|
}
|
|
/// <summary>
|
/// RTC5 Board Status.
|
/// </summary>
|
public bool IsBusy
|
{
|
get
|
{
|
return _isBusy;
|
}
|
|
set
|
{
|
_isBusy = value;
|
}
|
}
|
|
/// <summary>
|
/// Scanner에 연결된 Encoder 0 값
|
/// </summary>
|
public int Encoder0
|
{
|
get
|
{
|
return _encoder0;
|
}
|
|
set
|
{
|
_encoder0 = value;
|
}
|
}
|
|
/// <summary>
|
/// Scanner에 연결된 Encoder 1 값
|
/// </summary>
|
public int Encoder1
|
{
|
get
|
{
|
return _encoder1;
|
}
|
|
set
|
{
|
_encoder1 = value;
|
}
|
}
|
|
/// <summary>
|
/// X축 mm당 Encoder Count
|
/// </summary>
|
public int EncoderCountPerMmX
|
{
|
get
|
{
|
return _encoderCountPerMmX;
|
}
|
|
set
|
{
|
_encoderCountPerMmX = value;
|
}
|
}
|
|
/// <summary>
|
/// Y축 mm당 Encoder Count
|
/// </summary>
|
public int EncoderCountPerMmY
|
{
|
get
|
{
|
return _encoderCountPerMmY;
|
}
|
|
set
|
{
|
_encoderCountPerMmY = value;
|
}
|
}
|
|
/// <summary>
|
/// 1mm당 bits 수.
|
/// </summary>
|
public double BitsPerMm
|
{
|
get
|
{
|
if (FOV == 0)
|
{
|
return 0;
|
}
|
else
|
{
|
return Math.Pow(2, 20 - 1) / (FOV / 2);
|
}
|
}
|
}
|
|
/// <summary>
|
/// Scanner의 field of view
|
/// </summary>
|
public double FOV
|
{
|
get
|
{
|
return _fieldOfView;
|
}
|
|
set
|
{
|
_fieldOfView = value;
|
}
|
}
|
|
/// <summary>
|
/// Scanner Kfactor : FOV에 따라 정해짐
|
/// </summary>
|
public double KFactor
|
{
|
get
|
{
|
if (FOV == 0)
|
{
|
return 1.0;
|
}
|
else
|
{
|
return Math.Pow(2, 20) / (FOV / 2);
|
}
|
}
|
}
|
|
/// <summary>
|
/// Half of the laser signal period
|
/// 1bit equals 1/64 us. Allowed range [0 ~ 2^(32 -1)]
|
/// </summary>
|
public uint HalfPeriod
|
{
|
get
|
{
|
return _halfPeriod;
|
}
|
|
set
|
{
|
if (value > 2147483648)
|
{
|
_halfPeriod = 2147483648;
|
}
|
else
|
{
|
_halfPeriod = value;
|
}
|
}
|
}
|
|
/// <summary>
|
/// Pulse widths of signals Laser1
|
/// 1bit equals 1/64 us. Allowed range [0 ~ 2^(32 -1)]
|
/// </summary>
|
public uint PulseLength1
|
{
|
get
|
{
|
return _pulseLength1;
|
}
|
|
set
|
{
|
if (value > 2147483648)
|
{
|
_pulseLength1 = 2147483648;
|
}
|
else
|
{
|
_pulseLength1 = value;
|
}
|
}
|
}
|
|
/// <summary>
|
/// Pulse widths of signals Laser2
|
/// The value of PulseLength2 is ignored and is no longer used
|
/// </summary>
|
public uint PulseLength2
|
{
|
get
|
{
|
return _pulseLength1;
|
}
|
}
|
|
/// <summary>
|
/// time base; 0 corresponds to 1 microsecond
|
/// In RTC5 mode, the value is ignored and the clock frequency is fixed
|
/// at 64 MHz. 1 bit equals 1/64 µs
|
/// </summary>
|
public uint TimeBase
|
{
|
get
|
{
|
return _timeBase;
|
}
|
|
set
|
{
|
_timeBase = value;
|
}
|
}
|
|
/// <summary>
|
/// Jump delay in 10 microseconds
|
/// </summary>
|
public uint JumpDelay
|
{
|
get
|
{
|
return _jumpDelay;
|
}
|
|
set
|
{
|
_jumpDelay = value;
|
}
|
}
|
|
/// <summary>
|
/// Mark delay in 10 microseconds
|
/// </summary>
|
public uint MarkDelay
|
{
|
get
|
{
|
return _markDelay;
|
}
|
|
set
|
{
|
_markDelay = value;
|
}
|
}
|
|
/// <summary>
|
/// Polygon delay in 10 microseconds
|
/// </summary>
|
public uint PolygonDelay
|
{
|
get
|
{
|
return _polygonDelay;
|
}
|
|
set
|
{
|
_polygonDelay = value;
|
}
|
}
|
|
/// <summary>
|
/// Laser on delay in microseconds
|
/// </summary>
|
public int LaserOnDelay
|
{
|
get
|
{
|
return _laserOnDelay;
|
}
|
|
set
|
{
|
_laserOnDelay = value;
|
}
|
}
|
|
/// <summary>
|
/// Laser off delay in microseconds
|
/// </summary>
|
public uint LaserOffDelay
|
{
|
get
|
{
|
return _laserOffDelay;
|
}
|
|
set
|
{
|
_laserOffDelay = value;
|
}
|
}
|
|
public uint IsPosition
|
{
|
get
|
{
|
return _isPosition;
|
}
|
|
set
|
{
|
_isPosition = value;
|
}
|
}
|
|
public double XGain
|
{
|
get
|
{
|
return _xGain;
|
}
|
|
set
|
{
|
if (value < 0)
|
_xGain = 1;
|
|
_xGain = value;
|
}
|
}
|
|
public double YGain
|
{
|
get
|
{
|
return _yGain;
|
}
|
|
set
|
{
|
if (value < 0)
|
_yGain = 1;
|
|
_yGain = value;
|
}
|
}
|
|
public bool IsLaserOn
|
{
|
get
|
{
|
return _isLaserOn;
|
}
|
|
set
|
{
|
_isLaserOn = value;
|
}
|
}
|
#endregion
|
|
public Scanner(Equipment equipment)
|
{
|
_equipment = equipment;
|
TimeBase = 0;
|
Refresh();
|
}
|
|
public Scanner()
|
{
|
|
}
|
|
public void Refresh()
|
{
|
DirectoryInfo directoryInfo = new DirectoryInfo(Equipment.settingFilePath + _filePath);
|
|
if (directoryInfo.Exists == false)
|
{
|
directoryInfo.Create();
|
}
|
|
FileInfo fileInfo = new FileInfo(directoryInfo.FullName + _fileName);
|
|
if (fileInfo.Exists == false)
|
{
|
fileInfo.Create().Close();
|
|
SaveFile(fileInfo.FullName, this);
|
}
|
else
|
{
|
Scanner scanner = new Scanner();
|
|
scanner = ReadFile(fileInfo.FullName);
|
|
Copy(scanner);
|
}
|
}
|
|
/// <summary>
|
/// Error 발생했는지 확인.
|
/// </summary>
|
/// <returns></returns>
|
private bool ErrorExist()
|
{
|
uint errorCode = RTC5Wrap.get_error();
|
|
if (errorCode == 0) return false;
|
|
byte[] errorBytes = BitConverter.GetBytes(errorCode);
|
System.Collections.BitArray errorBits = new System.Collections.BitArray(errorBytes);
|
|
string str = string.Empty;
|
|
if (errorBits[0] == true)
|
_equipment.alarmManager.Occur(AlarmCode.AL_0800_RTC5_NO_BOARD_FOUND);
|
|
if (errorBits[1] == true)
|
_equipment.alarmManager.Occur(AlarmCode.AL_0801_RTC5_ACCESS_DENIED);
|
|
if (errorBits[2] == true)
|
_equipment.alarmManager.Occur(AlarmCode.AL_0802_RTC5_COMMAND_NOT_FORWARDED);
|
|
if (errorBits[3] == true)
|
_equipment.alarmManager.Occur(AlarmCode.AL_0803_RTC5_NO_RESPONSE_FROM_BOARD);
|
|
if (errorBits[4] == true)
|
_equipment.alarmManager.Occur(AlarmCode.AL_0804_RTC5_INVALID_PARAMETER);
|
|
if (errorBits[5] == true)
|
_equipment.alarmManager.Occur(AlarmCode.AL_0805_RTC5_LIST_PROCESSING_IS_NOT_ACTIVE);
|
|
if (errorBits[6] == true)
|
_equipment.alarmManager.Occur(AlarmCode.AL_0806_RTC5_LIST_COMMAND_REJECTED);
|
|
if (errorBits[7] == true)
|
_equipment.alarmManager.Occur(AlarmCode.AL_0807_RTC5_LIST_COMMAND_HAS_BEEN_COVERTED);
|
|
if (errorBits[8] == true)
|
_equipment.alarmManager.Occur(AlarmCode.AL_0808_RTC5_VERSION_ERROR_RTC5_DLL_VERSION);
|
|
if (errorBits[9] == true)
|
_equipment.alarmManager.Occur(AlarmCode.AL_0809_RTC5_VERIFY_ERROR_RTC5_DLL_VERSION);
|
|
if (errorBits[10] == true)
|
_equipment.alarmManager.Occur(AlarmCode.AL_0810_RTC5_DSP_VERSION_ERROR);
|
|
if (errorBits[11] == true)
|
_equipment.alarmManager.Occur(AlarmCode.AL_0811_RTC5_DLL_INTERNAL_WINDOWS_MEMORY_REQUEST_FAIL);
|
|
if (errorBits[12] == true)
|
_equipment.alarmManager.Occur(AlarmCode.AL_0812_RTC5_EEPROM_READ_OR_WRITE_ERROR);
|
|
if (errorBits[16] == true)
|
_equipment.alarmManager.Occur(AlarmCode.AL_0813_RTC5_ERROR_READING_PCI_CONFIGURATION_REGISTER);
|
|
RTC5Wrap.reset_error(errorCode);
|
return true;
|
}
|
|
/// <summary>
|
/// Load Program 후 반환된 코드로 Error 발생 확인.
|
/// </summary>
|
/// <param name="errorCode"></param>
|
/// <returns></returns>
|
private bool LoadProgramFileErrorExist(uint errorCode)
|
{
|
switch (errorCode)
|
{
|
case 0:
|
return false;
|
case 1:
|
_equipment.alarmManager.Occur(AlarmCode.AL_0814_RTC5_RESET_ERROR);
|
return true;
|
case 2:
|
_equipment.alarmManager.Occur(AlarmCode.AL_0815_RTC5_UNRESET_ERROR);
|
return true;
|
case 3:
|
_equipment.alarmManager.Occur(AlarmCode.AL_0816_RTC5_FILE_ERROR);
|
return true;
|
case 4:
|
_equipment.alarmManager.Occur(AlarmCode.AL_0817_RTC5_FORMAT_ERROR);
|
return true;
|
case 5:
|
_equipment.alarmManager.Occur(AlarmCode.AL_0818_RTC5_SYSTEM_ERROR);
|
return true;
|
case 6:
|
_equipment.alarmManager.Occur(AlarmCode.AL_0819_RTC5_ACCESS_ERROR);
|
return true;
|
case 7:
|
_equipment.alarmManager.Occur(AlarmCode.AL_0820_RTC5_VERSION_ERROR);
|
return true;
|
case 8:
|
_equipment.alarmManager.Occur(AlarmCode.AL_0821_RTC5_SYSTEM_DRIVER_NOT_FOUND);
|
return true;
|
case 9:
|
_equipment.alarmManager.Occur(AlarmCode.AL_0822_RTC5_DRIVER_CALL_ERROR);
|
return true;
|
case 10:
|
_equipment.alarmManager.Occur(AlarmCode.AL_0823_RTC5_CONFIGURATION_ERROR);
|
return true;
|
case 11:
|
_equipment.alarmManager.Occur(AlarmCode.AL_0824_RTC5_FPGA_FIRMWARE_ERROR);
|
return true;
|
case 12:
|
_equipment.alarmManager.Occur(AlarmCode.AL_0825_RTC5_PCI_DOWNLOAD_ERROR);
|
return true;
|
case 13:
|
_equipment.alarmManager.Occur(AlarmCode.AL_0826_RTC5_BUSY_ERROR);
|
return true;
|
case 14:
|
_equipment.alarmManager.Occur(AlarmCode.AL_0827_RTC5_DSP_MEMORY_ERROR);
|
return true;
|
case 15:
|
_equipment.alarmManager.Occur(AlarmCode.AL_0828_RTC5_VERIFY_ERROR);
|
return true;
|
case 16:
|
_equipment.alarmManager.Occur(AlarmCode.AL_0829_RTC5_PCI_ERROR);
|
return true;
|
default:
|
return true;
|
}
|
}
|
|
/// <summary>
|
/// 보정파일 읽어올때 반환된 코드로 Error 발생 확인.
|
/// </summary>
|
/// <param name="errorCode"></param>
|
/// <returns></returns>
|
private bool LoadCorrectionFileErrorExist(uint errorCode)
|
{
|
switch (errorCode)
|
{
|
case 0:
|
return false;
|
case 1:
|
_equipment.alarmManager.Occur(AlarmCode.AL_0830_RTC5_FILE_ERROR);
|
return true;
|
case 2:
|
_equipment.alarmManager.Occur(AlarmCode.AL_0831_RTC5_MEMORY_ERROR);
|
return true;
|
case 3:
|
_equipment.alarmManager.Occur(AlarmCode.AL_0832_RTC5_FILE_OPEN_ERROR);
|
return true;
|
case 4:
|
_equipment.alarmManager.Occur(AlarmCode.AL_0833_RTC5_DSP_MEMORY_ERROR);
|
return true;
|
case 5:
|
_equipment.alarmManager.Occur(AlarmCode.AL_0834_RTC5_PCI_DOWNLOAD_ERROR);
|
return true;
|
case 8:
|
_equipment.alarmManager.Occur(AlarmCode.AL_0835_RTC5_SYSTEM_DRIVER_NOT_FOUND);
|
return true;
|
case 10:
|
_equipment.alarmManager.Occur(AlarmCode.AL_0836_RTC5_PARAMETER_ERROR);
|
return true;
|
case 11:
|
_equipment.alarmManager.Occur(AlarmCode.AL_0837_RTC5_ACCESS_ERROR);
|
return true;
|
case 12:
|
_equipment.alarmManager.Occur(AlarmCode.AL_0838_RTC5_WARNING_3D_CORRECTION_TABLE);
|
return true;
|
case 13:
|
_equipment.alarmManager.Occur(AlarmCode.AL_0839_RTC5_BUSY_ERROR);
|
return true;
|
case 14:
|
_equipment.alarmManager.Occur(AlarmCode.AL_0840_RTC5_PCI_UPLOAD_ERROR);
|
return true;
|
case 15:
|
_equipment.alarmManager.Occur(AlarmCode.AL_0841_RTC5_VERIFY_ERROR);
|
return true;
|
default:
|
return true;
|
}
|
}
|
|
/// <summary>
|
/// RTC 5 DLL 초기화.
|
/// </summary>
|
/// <returns></returns>
|
private bool InitializeRTC5Dll()
|
{
|
// ====== RTC 5 Dll 초기화 ======
|
RTC5Wrap.init_rtc5_dll();
|
|
if (ErrorExist())
|
{
|
return false;
|
}
|
else
|
{
|
return true;
|
}
|
}
|
|
/// <summary>
|
/// RTC5 RBF, OUT, DAT 파일 로드
|
/// </summary>
|
/// <returns></returns>
|
private bool LoadProgramFiles()
|
{
|
uint errorCode = RTC5Wrap.load_program_file(null);
|
|
if (LoadProgramFileErrorExist(errorCode))
|
{
|
return false;
|
}
|
else
|
{
|
return true;
|
}
|
}
|
|
/// <summary>
|
/// 보정파일 로드
|
/// </summary>
|
/// <param name="filePath">보정파일 위치</param>
|
/// <returns></returns>
|
private bool LoadCorrectionFiles(string filePath)
|
{
|
uint errorCode = RTC5Wrap.load_correction_file(CorrectionFilePath,
|
1, // table; #1 is used by default
|
2); // 2D correction files and 3D correction files are sotred as a 2D correction table.
|
|
if (LoadCorrectionFileErrorExist(errorCode))
|
{
|
return false;
|
}
|
else
|
{
|
return true;
|
}
|
}
|
|
/// <summary>
|
/// RTC5 보드 초기화. [기본 위치 : 실행파일 위치]
|
/// </summary>
|
/// <param name="correctionFilePath">보정 파일 위치</param>
|
/// <returns></returns>
|
public bool Initialize(string correctionFilePath = null)
|
{
|
lock (_lock)
|
{
|
if (InitializeRTC5Dll() == false)
|
{
|
IsInitialized = false;
|
return false;
|
}
|
|
if (LoadProgramFiles() == false)
|
{
|
IsInitialized = false;
|
return false;
|
}
|
|
if (LoadCorrectionFiles(correctionFilePath) == false)
|
{
|
IsInitialized = false;
|
return false;
|
}
|
}
|
|
RTC5Wrap.home_position(0, 0);
|
|
if(SetLaserDelays() && SetLaserTiming() && SetScannerDelay())
|
{
|
IsInitialized = true;
|
}
|
else
|
{
|
IsInitialized = false;
|
}
|
|
RTC5Wrap.set_laser_control(1);
|
|
return true;
|
}
|
|
/// <summary>
|
/// List 동작 중 확인.
|
/// </summary>
|
/// <returns></returns>
|
public bool GetBusy()
|
{
|
try
|
{
|
if (IsInitialized)
|
{
|
lock (_lock)
|
{
|
uint ubusy, position;
|
RTC5Wrap.get_status(out ubusy, out position);
|
IsBusy = ubusy != 0;
|
IsPosition = position;
|
}
|
}
|
else
|
{
|
IsBusy = false;
|
}
|
return IsBusy;
|
}
|
catch(Exception e)
|
{
|
EquipmentLogManager.Instance.WriteExceptionLog(e.StackTrace);
|
return false;
|
}
|
}
|
|
public bool GetLaserOn()
|
{
|
try
|
{
|
if (IsInitialized)
|
{
|
lock (_lock)
|
{
|
IsLaserOn = RTC5Wrap.get_value((ushort)0) == (short)1;
|
}
|
}
|
else
|
{
|
IsLaserOn = false;
|
}
|
|
return IsLaserOn;
|
}
|
catch(Exception e)
|
{
|
EquipmentLogManager.Instance.WriteExceptionLog(e.StackTrace);
|
return false;
|
}
|
}
|
|
/// <summary>
|
/// Laser timing 설정 [Laser Half of signal period, Laser Pulse widths, Time Base]
|
/// </summary>
|
/// <returns></returns>
|
public bool SetLaserTiming()
|
{
|
RTC5Wrap.set_start_list(1);
|
RTC5Wrap.set_laser_timing(HalfPeriod, PulseLength1, PulseLength2, TimeBase);
|
RTC5Wrap.set_end_of_list();
|
RTC5Wrap.execute_list(1);
|
|
//CtlFrequency(1000, 0.085f);
|
if (ErrorExist())
|
{
|
return false;
|
}
|
else
|
{
|
return true;
|
}
|
}
|
|
/// <summary>
|
/// Scanner delay 설정. [jump delay, mark delay, polygon delay]
|
/// </summary>
|
/// <returns></returns>
|
public bool SetScannerDelay()
|
{
|
RTC5Wrap.set_start_list(1);
|
RTC5Wrap.set_scanner_delays(JumpDelay, MarkDelay, PolygonDelay);
|
RTC5Wrap.set_end_of_list();
|
RTC5Wrap.execute_list(1);
|
|
if (ErrorExist())
|
{
|
return false;
|
}
|
else
|
{
|
return true;
|
}
|
}
|
|
/// <summary>주파수와 펄스폭 설정</summary>
|
/// <param name="frequency">주파수 (Hz)</param>
|
/// <param name="pulseWidth">펄스폭 (usec)</param>
|
/// <returns></returns>
|
public virtual bool CtlFrequency(float frequency, float pulseWidth)
|
{
|
if (IsBusy)
|
{
|
return false;
|
}
|
|
if ((double)frequency <= 0.0 || (double)pulseWidth <= 0.0)
|
{
|
return false;
|
}
|
|
double num1 = Math.Round(1.0 / (double)frequency * 1000000.0 / 2.0, 3);
|
double num2 = Math.Round((double)pulseWidth, 3);
|
RTC5Wrap.set_start_list(1);
|
RTC5Wrap.set_laser_timing((uint)Math.Floor(num1 * 64.0), (uint)Math.Floor(num2 * 64.0), (uint)Math.Floor(num2 * 64.0), 0U);
|
RTC5Wrap.set_end_of_list();
|
RTC5Wrap.execute_list(1);
|
|
return true;
|
}
|
|
/// <summary>
|
/// Laser delay 설정 [Laser on delay, Laser off delay]
|
/// </summary>
|
/// <returns></returns>
|
public bool SetLaserDelays()
|
{
|
RTC5Wrap.set_start_list(1);
|
RTC5Wrap.set_laser_delays(LaserOnDelay, LaserOffDelay);
|
RTC5Wrap.set_end_of_list();
|
RTC5Wrap.execute_list(1);
|
|
if (ErrorExist())
|
{
|
return false;
|
}
|
else
|
{
|
return true;
|
}
|
}
|
|
public void LaserOn()
|
{
|
RTC5Wrap.laser_signal_on();
|
}
|
|
public void LaserOff()
|
{
|
RTC5Wrap.laser_signal_off();
|
}
|
|
/// <summary>
|
/// Set jump speed, mark speed
|
/// </summary>
|
/// <param name="jumpSpeed"> mm/s </param>
|
/// <param name="markSpeed"> mm/s </param>
|
/// <returns></returns>
|
public bool SetJumpMarkSpeed(double jumpSpeed, double markSpeed)
|
{
|
if (jumpSpeed == 0)
|
jumpSpeed = 10;
|
|
if (markSpeed == 0)
|
markSpeed = 10;
|
|
double jump = (BitsPerMm / 1000) * jumpSpeed;
|
double mark = (BitsPerMm / 1000) * markSpeed;
|
|
RTC5Wrap.set_start_list(1);
|
RTC5Wrap.set_jump_speed(jump);
|
RTC5Wrap.set_mark_speed(mark);
|
RTC5Wrap.set_end_of_list();
|
RTC5Wrap.execute_list(1);
|
|
if (ErrorExist())
|
{
|
return false;
|
}
|
else
|
{
|
return true;
|
}
|
}
|
|
/// <summary>
|
/// RCT5 보드에 연결되어 있는 Encoder 값 읽기.
|
/// </summary>
|
/// <returns></returns>
|
public bool GetEncoder()
|
{
|
int encoder0, encoder1;
|
|
RTC5Wrap.get_encoder(out encoder0, out encoder1);
|
|
Encoder0 = encoder0;
|
Encoder1 = encoder1;
|
|
if (ErrorExist())
|
{
|
return false;
|
}
|
else
|
{
|
return true;
|
}
|
}
|
|
/// <summary>
|
/// Scan list Data 반환
|
/// </summary>
|
/// <returns></returns>
|
public Coord[] GetScanList()
|
{
|
return scanList.ToArray();
|
}
|
|
/// <summary>
|
/// Scan list 초기화
|
/// </summary>
|
/// <returns></returns>
|
public bool ClearScanList()
|
{
|
scanList.Clear();
|
|
ScanListCleared.Invoke();
|
return true;
|
}
|
|
/// <summary>
|
/// Scan list에 가공 정보 추가
|
/// </summary>
|
/// <param name="coord"></param>
|
/// <returns></returns>
|
public bool AddScanList(Coord coord)
|
{
|
scanList.Add(coord);
|
ScanListAdded?.Invoke(coord);
|
return true;
|
}
|
|
/// <summary>
|
///
|
/// </summary>
|
/// <param name="scanMode"></param>
|
/// <param name="x">mm</param>
|
/// <param name="y">mm</param>
|
/// <returns></returns>
|
public bool AddScanList(ScanMode scanMode, double x, double y)
|
{
|
Coord coord = new Coord();
|
coord.ScanMode = scanMode;
|
coord.X = (int)Math.Floor(x * BitsPerMm);
|
coord.Y = (int)Math.Floor(y * BitsPerMm);
|
|
scanList.Add(coord);
|
ScanListAdded?.Invoke(coord);
|
|
return true;
|
}
|
|
/// <summary>
|
/// 가공 시작
|
/// </summary>
|
/// <returns></returns>
|
public bool ExcuteScanList(bool onTheFly = false)
|
{
|
RTC5Wrap.set_start_list(1);
|
|
if (onTheFly)
|
{
|
double ScaleX;
|
double ScaleY;
|
|
if (EncoderCountPerMmX == 0)
|
{
|
ScaleX = 0;
|
}
|
else
|
{
|
ScaleX = BitsPerMm / EncoderCountPerMmX;
|
RTC5Wrap.set_fly_x(ScaleX);
|
}
|
|
if (EncoderCountPerMmY == 0)
|
{
|
ScaleY = 0;
|
}
|
else
|
{
|
ScaleY = BitsPerMm / EncoderCountPerMmY;
|
RTC5Wrap.set_fly_y(ScaleY);
|
}
|
|
RTC5Wrap.set_rot_center(0, 0);
|
}
|
|
foreach (Coord coord in scanList)
|
{
|
int x = (int)(coord.X * XGain);
|
int y = (int)(coord.Y * YGain);
|
|
if (coord.ScanMode == ScanMode.JUMP)
|
{
|
//RTC5Wrap.jump_abs(coord.X, coord.Y);
|
RTC5Wrap.jump_abs(x, y);
|
}
|
else
|
{
|
//RTC5Wrap.mark_abs(coord.X, coord.Y);
|
RTC5Wrap.mark_abs(x, y);
|
}
|
}
|
|
if (onTheFly)
|
{
|
RTC5Wrap.fly_return(0, 0);
|
}
|
else
|
{
|
RTC5Wrap.jump_abs(0, 0);
|
}
|
|
RTC5Wrap.set_end_of_list();
|
|
RTC5Wrap.execute_list(1);
|
|
if (ErrorExist())
|
{
|
return false;
|
}
|
else
|
{
|
return true;
|
}
|
}
|
|
public bool Stop()
|
{
|
RTC5Wrap.stop_execution();
|
|
if (ErrorExist())
|
{
|
return false;
|
}
|
else
|
{
|
return true;
|
}
|
}
|
|
public bool Save()
|
{
|
DirectoryInfo directoryInfo = new DirectoryInfo(Equipment.settingFilePath + _filePath);
|
|
if (directoryInfo.Exists == false)
|
{
|
directoryInfo.Create();
|
}
|
|
FileInfo fileInfo = new FileInfo(directoryInfo.FullName + _fileName);
|
|
if (fileInfo.Exists == false)
|
{
|
fileInfo.Create().Close();
|
}
|
|
SetScannerDelay();
|
SetLaserDelays();
|
SetLaserTiming();
|
|
return TrySaveFile(fileInfo.FullName, this);
|
}
|
|
public void AddScanField(int linecount = 5, double fieldSize = 15)
|
{
|
double intervalLength = 0;
|
|
if (linecount % 2 == 0) // Line count가 짝수 일 때
|
{
|
intervalLength = fieldSize / linecount;
|
|
//X축 그리기.
|
for (int i = linecount / 2; i > 0; i--)
|
{
|
AddScanList(ScanMode.JUMP, -(fieldSize / 2 + 1), intervalLength * i);
|
AddScanList(ScanMode.MARK, (fieldSize / 2 + 1), intervalLength * i);
|
}
|
|
for (int i = -(linecount / 2); i < 0; i++)
|
{
|
AddScanList(ScanMode.JUMP, -(fieldSize / 2 + 1), intervalLength * i);
|
AddScanList(ScanMode.MARK, (fieldSize / 2 + 1), intervalLength * i);
|
}
|
|
//Y축 그리기
|
for (int i = linecount / 2; i > 0; i--)
|
{
|
AddScanList(ScanMode.JUMP, intervalLength * i, -(fieldSize / 2 + 1));
|
AddScanList(ScanMode.MARK, intervalLength * i, (fieldSize / 2 + 1));
|
}
|
|
for (int i = -(linecount / 2); i < 0; i++)
|
{
|
AddScanList(ScanMode.JUMP, intervalLength * i, -(fieldSize / 2 + 1));
|
AddScanList(ScanMode.MARK, intervalLength * i, (fieldSize / 2 + 1));
|
}
|
}
|
else // Line count가 홀수 일 때
|
{
|
intervalLength = fieldSize / (linecount - 1);
|
|
//X축 그리기.
|
for (int i = -(linecount - 1) / 2; i <= (linecount - 1) / 2; i++)
|
{
|
AddScanList(ScanMode.JUMP, -(fieldSize / 2 + 1), intervalLength * i);
|
AddScanList(ScanMode.MARK, (fieldSize / 2 + 1), intervalLength * i);
|
}
|
|
//Y축 그리기
|
for (int i = -(linecount - 1) / 2; i <= (linecount - 1) / 2; i++)
|
{
|
AddScanList(ScanMode.JUMP, intervalLength * i, -(fieldSize / 2 + 1));
|
AddScanList(ScanMode.MARK, intervalLength * i, (fieldSize / 2 + 1));
|
}
|
}
|
}
|
}
|
}
|
