480 lines
14 KiB
C#
480 lines
14 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Drawing;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Net;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using System.Drawing.Imaging;
|
|
using System.Runtime.InteropServices;
|
|
using AR;
|
|
using System.Security.Cryptography;
|
|
|
|
namespace Project.Device
|
|
{
|
|
public class KeyenceBarcode : IDisposable
|
|
{
|
|
public string IP { get; set; }
|
|
public int Port { get; set; }
|
|
private Winsock_Orcas.Winsock ws;
|
|
public event EventHandler<RecvDataEvent> BarcodeRecv;
|
|
public event EventHandler<RecvImageEvent> ImageRecv;
|
|
RecvDataEvent LastData = null;
|
|
RecvImageEvent LastImage = null;
|
|
|
|
public Boolean IsTriggerOn { get; set; } = false;
|
|
private DateTime LastTrigOnTime = DateTime.Now;
|
|
private System.Threading.Thread thliveimage = null;
|
|
public int LiveImagetDelay = 500;
|
|
public bool disposed = false;
|
|
bool bRunConnectionK = true;
|
|
public string Tag { get; set; }
|
|
|
|
|
|
public string baseZPL { get; set; }
|
|
|
|
public class RecvDataEvent : EventArgs
|
|
{
|
|
public string RawData { get; set; }
|
|
public RecvDataEvent(string rawdata)
|
|
{
|
|
this.RawData = rawdata;
|
|
}
|
|
}
|
|
public class RecvImageEvent : EventArgs
|
|
{
|
|
public Image Image { get; set; }
|
|
public RecvImageEvent(Image rawdata)
|
|
{
|
|
this.Image = rawdata;
|
|
}
|
|
}
|
|
|
|
public KeyenceBarcode(string ip = "192.168.100.100", int port = 9004)
|
|
{
|
|
this.IP = ip;
|
|
this.Port = port;
|
|
ws = new Winsock_Orcas.Winsock();
|
|
ws.LegacySupport = true;
|
|
ws.DataArrival += Ws_DataArrival;
|
|
ws.Connected += Ws_Connected;
|
|
thliveimage = new Thread(new ThreadStart(GetLiveImage));
|
|
thliveimage.IsBackground = false;
|
|
thliveimage.Start();
|
|
Console.WriteLine($"{ip} / Port:{port}");
|
|
}
|
|
|
|
~KeyenceBarcode()
|
|
{
|
|
Dispose(disposing: false);
|
|
}
|
|
public void Dispose()
|
|
{
|
|
Dispose(disposing: true);
|
|
GC.SuppressFinalize(this);
|
|
}
|
|
|
|
#region "Image Utility"
|
|
|
|
/// <summary>
|
|
/// 8bpp 이미지의 팔레트를 설정합니다
|
|
/// </summary>
|
|
/// <param name="bmp"></param>
|
|
public void UpdateGrayPallete(ref Bitmap bmp)
|
|
{
|
|
if (bmp.PixelFormat == System.Drawing.Imaging.PixelFormat.Format8bppIndexed)
|
|
{
|
|
System.Drawing.Imaging.ColorPalette pal = bmp.Palette;
|
|
for (int i = 0; i < 256; i++)
|
|
{
|
|
pal.Entries[i] = Color.FromArgb(i, i, i);
|
|
}
|
|
bmp.Palette = pal;
|
|
}
|
|
}
|
|
public void GetImagePtr(Bitmap bmp, out IntPtr ptr, out int stride)
|
|
{
|
|
stride = 0;
|
|
ptr = IntPtr.Zero;
|
|
try
|
|
{
|
|
BitmapData bmpdata = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), System.Drawing.Imaging.ImageLockMode.ReadOnly, bmp.PixelFormat);
|
|
ptr = bmpdata.Scan0;
|
|
stride = bmpdata.Stride;
|
|
bmp.UnlockBits(bmpdata);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
|
|
}
|
|
}
|
|
|
|
public bool IsCompatible(Bitmap source, Bitmap target)
|
|
{
|
|
if (source == null) return false;
|
|
try
|
|
{
|
|
if (source.Height != target.Height ||
|
|
source.Width != target.Width ||
|
|
source.PixelFormat != target.PixelFormat) return false;
|
|
return true;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
PUB.log.AddE("keyence compatiable : " + ex.Message);
|
|
return false;
|
|
}
|
|
|
|
|
|
}
|
|
public bool IsCompatible(Bitmap source, int w, int h, PixelFormat pf)
|
|
{
|
|
if (source == null) return false;
|
|
if (source.Height != h ||
|
|
source.Width != w ||
|
|
source.PixelFormat != pf) return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
public Bitmap CreateBitmap(int w, int h)
|
|
{
|
|
|
|
Bitmap bmp = new Bitmap(w, h, PixelFormat.Format8bppIndexed);
|
|
UpdateGrayPallete(ref bmp);
|
|
return bmp;
|
|
}
|
|
|
|
byte[] memorybuffer;
|
|
public void UpdateBitmap(Bitmap source, Bitmap target)
|
|
{
|
|
if (source.Width < 10 || source.Height < 10) return;
|
|
if (target == null || target.Width < 10 || target.Height < 10)
|
|
{
|
|
target = CreateBitmap(source.Width, source.Height);
|
|
}
|
|
|
|
var bitmaperrcnt = AR.VAR.I32[eVarInt32.BitmapCompatErr];
|
|
if (IsCompatible(source, target) == false)
|
|
{
|
|
PUB.log.AddE($"Keyence bitmap compatibility error Source:{source.Width}x{source.Height} => Target:{target.Width}x{target.Height}");
|
|
|
|
if (bitmaperrcnt > 5)
|
|
{
|
|
var o = target;
|
|
target = CreateBitmap(source.Width, source.Height);
|
|
if (o != null) o.Dispose();
|
|
bitmaperrcnt = 0;
|
|
}
|
|
else AR.VAR.I32[eVarInt32.BitmapCompatErr] += 1;
|
|
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
if (bitmaperrcnt > 0)
|
|
AR.VAR.I32[eVarInt32.BitmapCompatErr] = 0;
|
|
}
|
|
|
|
//get image pointer
|
|
BitmapData bmpdatas = source.LockBits(new Rectangle(0, 0, source.Width, source.Height), System.Drawing.Imaging.ImageLockMode.ReadOnly, source.PixelFormat);
|
|
var ptrs = bmpdatas.Scan0;
|
|
var strides = bmpdatas.Stride;
|
|
|
|
BitmapData bmpdatat = target.LockBits(new Rectangle(0, 0, target.Width, target.Height), System.Drawing.Imaging.ImageLockMode.WriteOnly, target.PixelFormat);
|
|
var ptrt = bmpdatat.Scan0;
|
|
var stridet = bmpdatat.Stride;
|
|
|
|
//read source data
|
|
var sourcesize = Math.Abs(bmpdatas.Stride) * source.Height;
|
|
if (memorybuffer == null || memorybuffer.Length != sourcesize)
|
|
{
|
|
memorybuffer = new byte[sourcesize];
|
|
}
|
|
|
|
Marshal.Copy(ptrs, memorybuffer, 0, sourcesize);
|
|
|
|
//write target data
|
|
Marshal.Copy(memorybuffer, 0, ptrt, sourcesize);
|
|
|
|
source.UnlockBits(bmpdatas);
|
|
target.UnlockBits(bmpdatat);
|
|
|
|
}
|
|
|
|
public void UpdateBitmap(Bitmap target, byte[] buffer, int w, int h)
|
|
{
|
|
if (IsCompatible(target, w, h, target.PixelFormat) == false)
|
|
{
|
|
throw new Exception("cannot udate incompatible bitmap.");
|
|
}
|
|
|
|
//get image pointer
|
|
BitmapData bmpdata = target.LockBits(new Rectangle(0, 0, target.Width, target.Height), System.Drawing.Imaging.ImageLockMode.ReadWrite, target.PixelFormat);
|
|
var ptr = bmpdata.Scan0;
|
|
var stride = bmpdata.Stride;
|
|
|
|
|
|
if (stride == w) //image x4
|
|
{
|
|
Marshal.Copy(buffer, 0, ptr, stride * h);
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0; i < target.Height; ++i)
|
|
{
|
|
Marshal.Copy(buffer, i * w, new IntPtr(ptr.ToInt64() + i * stride), w);
|
|
}
|
|
}
|
|
|
|
target.UnlockBits(bmpdata);
|
|
|
|
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
protected virtual void Dispose(bool disposing)
|
|
{
|
|
if (!this.disposed)
|
|
{
|
|
if (disposing)
|
|
{
|
|
//dipose managed resources;
|
|
bRunConnectionK = false;
|
|
Trigger(false);
|
|
ws.DataArrival -= Ws_DataArrival;
|
|
ws.Connected -= Ws_Connected;
|
|
Disconnect();
|
|
if (thliveimage != null && thliveimage.IsAlive) thliveimage.Abort();
|
|
}
|
|
|
|
//dispose unmmanged resources;
|
|
}
|
|
|
|
disposed = true;
|
|
}
|
|
|
|
void GetLiveImage()
|
|
{
|
|
while (bRunConnectionK)
|
|
{
|
|
if (IsConnect && IsTriggerOn)
|
|
{
|
|
var tagname = this.Tag;
|
|
var img = GetImage();
|
|
this.LastImage = new RecvImageEvent(img);
|
|
ImageRecv?.Invoke(this, this.LastImage);
|
|
System.Threading.Thread.Sleep(LiveImagetDelay);
|
|
}
|
|
else System.Threading.Thread.Sleep(1000);
|
|
}
|
|
}
|
|
|
|
private void Ws_Connected(object sender, Winsock_Orcas.WinsockConnectedEventArgs e)
|
|
{
|
|
this.Trigger(true);
|
|
}
|
|
|
|
public void Connect()
|
|
{
|
|
if (this.ws.State == Winsock_Orcas.WinsockStates.Closed)
|
|
{
|
|
this.ws.RemoteHost = this.IP;
|
|
this.ws.RemotePort = this.Port;
|
|
this.ws.Connect();
|
|
}
|
|
|
|
}
|
|
public void Disconnect()
|
|
{
|
|
if (this.ws.State != Winsock_Orcas.WinsockStates.Closed)
|
|
this.ws.Close();
|
|
}
|
|
|
|
private void Ws_DataArrival(object sender, Winsock_Orcas.WinsockDataArrivalEventArgs e)
|
|
{
|
|
var data = ws.Get<string>();
|
|
this.LastData = new RecvDataEvent(data);
|
|
BarcodeRecv?.Invoke(this, LastData);
|
|
}
|
|
|
|
public bool Reset()
|
|
{
|
|
//if (IsTriggerOn) return;
|
|
string cmd = "RESET";
|
|
if (IsConnect == false)
|
|
{
|
|
PUB.log.AddE("Keyence Not Connected : RESET");
|
|
return false;
|
|
}
|
|
try
|
|
{
|
|
ws.Send(cmd + "\r");
|
|
return true;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
PUB.log.AddE(ex.Message);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool BSave(int no)
|
|
{
|
|
var cmd = "BSAVE,{no}";
|
|
try
|
|
{
|
|
ws.Send(cmd + "\r");
|
|
return true;
|
|
}
|
|
catch {
|
|
return false;
|
|
}
|
|
}
|
|
public bool BLoad(int no)
|
|
{
|
|
var cmd = "BLOAD,{no}";
|
|
try
|
|
{
|
|
ws.Send(cmd + "\r");
|
|
return true;
|
|
}
|
|
catch {
|
|
return false;
|
|
}
|
|
}
|
|
public void Trigger(bool bOn)
|
|
{
|
|
//if (IsTriggerOn) return;
|
|
string cmd = bOn ? "LON" : "LOFF";
|
|
|
|
if (bOn) LastTrigOnTime = DateTime.Now;
|
|
|
|
try
|
|
{
|
|
ws.Send(cmd + "\r");
|
|
IsTriggerOn = bOn;
|
|
}
|
|
catch { }
|
|
}
|
|
public void ExecCommand(string cmd)
|
|
{
|
|
try
|
|
{
|
|
ws.Send(cmd + "\r");
|
|
}
|
|
catch { }
|
|
}
|
|
public bool IsConnect
|
|
{
|
|
get
|
|
{
|
|
if (ws == null) return false;
|
|
return ws.State == Winsock_Orcas.WinsockStates.Connected;
|
|
}
|
|
}
|
|
|
|
private bool readimage = false;
|
|
ManualResetEvent mre = new ManualResetEvent(true);
|
|
bool mreSetOK = true;
|
|
bool mreResetOK = true;
|
|
|
|
public Image GetImage()
|
|
{
|
|
Image oimg = null;
|
|
if (mreResetOK && mre.WaitOne(1000) == false)
|
|
{
|
|
mreResetOK = false;
|
|
return oimg;
|
|
}
|
|
else
|
|
{
|
|
mreResetOK = mre.Reset();
|
|
try
|
|
{
|
|
var url = $"http://{this.IP}/liveimage.jpg";
|
|
var data = UTIL.DownloadImagefromUrl(url);
|
|
var ms = new System.IO.MemoryStream(data);
|
|
oimg = Image.FromStream(ms);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
PUB.log.AddE("Keyence GetImage:" + ex.Message);
|
|
}
|
|
|
|
if (mreResetOK)
|
|
{
|
|
mreSetOK = mre.Set();
|
|
}
|
|
}
|
|
return oimg;
|
|
}
|
|
|
|
public bool SaveImage(string fn)
|
|
{
|
|
var fi = new System.IO.FileInfo(fn);
|
|
if (fi.Directory.Exists == false)
|
|
fi.Directory.Create();
|
|
|
|
|
|
|
|
if (mreResetOK && mre.WaitOne(1000) == false)
|
|
{
|
|
mreResetOK = false;
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
bool retval = false;
|
|
mreResetOK = mre.Reset();
|
|
try
|
|
{
|
|
var url = $"http://{this.IP}/liveimage.jpg";
|
|
var data = UTIL.DownloadImagefromUrl(url);
|
|
using (var ms = new System.IO.MemoryStream(data))
|
|
{
|
|
using (var oimg = Image.FromStream(ms))
|
|
oimg.Save(fi.FullName);
|
|
}
|
|
retval = true;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
|
|
}
|
|
if (mreResetOK)
|
|
mre.Set();
|
|
return retval;
|
|
}
|
|
}
|
|
|
|
public bool UpdateKeyenceImage(ref System.Windows.Forms.PictureBox pic)
|
|
{
|
|
bool retval = false;
|
|
if (readimage)
|
|
{
|
|
PUB.log.AddAT("Keyence is receiving image, command not processed");
|
|
}
|
|
else
|
|
{
|
|
readimage = true;
|
|
var oimg = pic.Image;
|
|
|
|
var newimage = GetImage();
|
|
|
|
pic.Image = newimage;
|
|
retval = newimage != null;
|
|
if (oimg != null) oimg.Dispose();
|
|
|
|
}
|
|
readimage = false;
|
|
return retval;
|
|
}
|
|
}
|
|
}
|