liulb@mesnac.com 1 year ago
parent 957f1c50bc
commit 477909a205

File diff suppressed because it is too large Load Diff

@ -25,12 +25,10 @@ namespace Admin.Core.Extensions
System.Diagnostics.Stopwatch stopwatch = new System.Diagnostics.Stopwatch();
StringBuilder sb = new StringBuilder();
stopwatch.Start(); // 开始监视代码
///////////////////////////////////////操作代码/////////////////////////////////////////////////////
///////////////////////////////////////操作代码/////////////////////////////////////////////////////
await plc.StartMelsecMcSeverAsync();
await plc.StartSiemensSever();
await plc.StartMelsecPlcAsync();
await plc.StartSiemensPlcAsync();
////////////////////////////////////////////////////////////////////////////////////////////////////
stopwatch.Stop(); // 停止监视
TimeSpan timeSpan = stopwatch.Elapsed; // 获取总时间

@ -1,5 +1,7 @@
using Admin.Core.Model;
using Admin.Core.Model.Model_New;
using Admin.Core.Model.ViewModels;
using System.Collections.Generic;
using System.Threading.Tasks;
namespace Admin.Core.IRepository
{
@ -8,5 +10,6 @@ namespace Admin.Core.IRepository
/// </summary>
public interface IBaseMaterialInfoRepository : IBaseRepository<BaseMaterialInfo>
{
Task<List<MaterialTypeView>> GetMaterialType();
}
}

@ -1,5 +1,6 @@
using Admin.Core.IService;
using Admin.Core.Model;
using Admin.Core.Model.ViewModels;
using System.Collections.Generic;
using System.Threading.Tasks;
@ -15,5 +16,10 @@ namespace Admin.Core.IService
/// 查出BASE_MATERIALINFO中存在的成品类型
/// </summary>
public Task<List<BaseMaterialInfo>> queryAsyncLike(string search);
/// <summary>
/// 物料类型
/// </summary>
/// <returns></returns>
Task<List<MaterialTypeView>> GetMaterialType();
}
}

@ -0,0 +1,31 @@
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Admin.Core.Model.ViewModels
{
/// <summary>
/// 获取订单物料型号
/// </summary>
public class MaterialTypeView
{
/// <summary>
/// 物料编码
/// </summary>
[SugarColumn(ColumnName = "MATERIAL_CODE")]
public string MaterialCode { get; set; }
/// <summary>
/// 物料名称
/// </summary>
[SugarColumn(ColumnName = "MATERIAL_NAME")]
public string MaterialName { get; set; }
/// <summary>
/// 部件型号
/// </summary>
[SugarColumn(ColumnName = "MATERIAL_SPECIFICATIONS")]
public string MaterialSpecifications { get; set; }
}
}

@ -1,5 +1,8 @@
using Admin.Core.IRepository;
using Admin.Core.Model;
using Admin.Core.Model.ViewModels;
using System.Collections.Generic;
using System.Threading.Tasks;
namespace Admin.Core.Repository
{
@ -11,5 +14,13 @@ namespace Admin.Core.Repository
public BaseMaterialInfoRepository(IUnitOfWork unitOfWork) : base(unitOfWork)
{
}
public async Task<List<MaterialTypeView>> GetMaterialType()
{
string sql = @"SELECT p.MATERIAL_CODE,p.MATERIAL_NAME,b.MATERIAL_SPECIFICATIONS FROM PRODUCT_PLANINFO p
inner join BASE_MATERIALINFO b on p.MATERIAL_CODE=b.MATERIAL_CODE where p.PRODUCTLINE_CODE= 1001";
return await Db.CopyNew().Ado.SqlQueryAsync<MaterialTypeView>(sql);
}
}
}

@ -17,7 +17,7 @@
<ItemGroup>
<ProjectReference Include="..\Admin.Core.IRepository\Admin.Core.IRepository.csproj" />
<ProjectReference Include="..\Admin.Core.IService\Admin.Core.IService.csproj" />
<ProjectReference Include="..\Aucma.Core.PLc\Aucma.Core.PLc.csproj" />
<ProjectReference Include="..\Aucma.Core.HwPLc\Aucma.Core.HwPLc.csproj" />
</ItemGroup>
</Project>

@ -2,6 +2,7 @@
using Admin.Core.IService;
using Admin.Core.Model;
using Admin.Core.Model.Model_New;
using Admin.Core.Model.ViewModels;
using log4net;
using Microsoft.AspNetCore.Razor.TagHelpers;
using Microsoft.IdentityModel.Logging;
@ -26,6 +27,11 @@ namespace Admin.Core.Service
_baseMaterialInfoRepository = baseMaterialInfoRepository;
}
public async Task<List<MaterialTypeView>> GetMaterialType()
{
return await _baseMaterialInfoRepository.GetMaterialType();
}
/// <summary>
/// 1.条件查询使用,查出BASE_MATERIALINFO中存在的成品类型
/// </summary>

@ -5,13 +5,13 @@ using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using System;
using Aucma.Core.PLc;
using Admin.Core.Common;
using log4net;
using SqlSugar;
using System.Linq.Expressions;
using StackExchange.Profiling.Internal;
using Admin.Core.Model.ViewModels;
using Aucma.Core.HwPLc;
namespace Admin.Core.Service
{

@ -41,8 +41,6 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Aucma.Core.SheetMetal", "Au
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "6.Other", "6.Other", "{F8FB57F6-5465-4E60-B052-D3A63C3C56AE}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Aucma.Core.PLc", "Aucma.Core.PLc\Aucma.Core.PLc.csproj", "{9EE12F11-F9E4-46DD-935D-F6EDD495A6FC}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Aucma.Core.RunPlc", "Aucma.Core.RunPlc\Aucma.Core.RunPlc.csproj", "{680718C5-E39C-442F-AC9E-4A56E15AF261}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Aucma.Core.HwPLc", "Aucma.Core.HwPLc\Aucma.Core.HwPLc.csproj", "{A1473270-1D54-40D5-9E68-5C917347CFE8}"
@ -95,10 +93,6 @@ Global
{AD2C008F-7D9F-43EB-9B44-F15A46F05583}.Debug|Any CPU.Build.0 = Debug|Any CPU
{AD2C008F-7D9F-43EB-9B44-F15A46F05583}.Release|Any CPU.ActiveCfg = Release|Any CPU
{AD2C008F-7D9F-43EB-9B44-F15A46F05583}.Release|Any CPU.Build.0 = Release|Any CPU
{9EE12F11-F9E4-46DD-935D-F6EDD495A6FC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{9EE12F11-F9E4-46DD-935D-F6EDD495A6FC}.Debug|Any CPU.Build.0 = Debug|Any CPU
{9EE12F11-F9E4-46DD-935D-F6EDD495A6FC}.Release|Any CPU.ActiveCfg = Release|Any CPU
{9EE12F11-F9E4-46DD-935D-F6EDD495A6FC}.Release|Any CPU.Build.0 = Release|Any CPU
{680718C5-E39C-442F-AC9E-4A56E15AF261}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{680718C5-E39C-442F-AC9E-4A56E15AF261}.Debug|Any CPU.Build.0 = Debug|Any CPU
{680718C5-E39C-442F-AC9E-4A56E15AF261}.Release|Any CPU.ActiveCfg = Release|Any CPU
@ -129,7 +123,6 @@ Global
{9505AA00-0CB3-4825-8989-AF96FFD0BB27} = {CB159E16-8DA0-4125-B42F-BB5381AEDD4D}
{73F3C0A3-D255-4A8A-9510-F3F556E28BCA} = {FA2FF2A3-135E-4CA2-9042-76BB71623D5A}
{AD2C008F-7D9F-43EB-9B44-F15A46F05583} = {BD987F3A-4E6C-4C47-B28F-1671F875EAE3}
{9EE12F11-F9E4-46DD-935D-F6EDD495A6FC} = {F8FB57F6-5465-4E60-B052-D3A63C3C56AE}
{680718C5-E39C-442F-AC9E-4A56E15AF261} = {F8FB57F6-5465-4E60-B052-D3A63C3C56AE}
{A1473270-1D54-40D5-9E68-5C917347CFE8} = {F8FB57F6-5465-4E60-B052-D3A63C3C56AE}
{F78F41F3-8B38-4CA1-A254-C18CCDCA8291} = {F8FB57F6-5465-4E60-B052-D3A63C3C56AE}

@ -1,18 +0,0 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>netstandard2.1</TargetFramework>
<Nullable>enable</Nullable>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="log4net" Version="2.0.15" />
</ItemGroup>
<ItemGroup>
<Reference Include="HslCommunication">
<HintPath>..\dll\HslCommunication.dll</HintPath>
</Reference>
</ItemGroup>
</Project>

@ -1,119 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Aucma.Core.PLc
{
public interface IPlc
{
/// <summary>
/// 是否连接
/// </summary>
bool IsConnected { get; set; }
/// <summary>
/// 建立连接
/// </summary>
/// <param name="IP"></param>
/// <param name="port"></param>
/// <returns></returns>
bool Connect(string IP, int port);
/// <summary>
/// 断开连接
/// </summary>
/// <returns></returns>
bool DisConnect();
/// <summary>
/// 读取byte数据
/// </summary>
/// <param name="address"></param>
/// <returns></returns>
byte[] ReadBytes(string address);
/// <summary>
/// 读取
/// </summary>
/// <param name="address"></param>
/// <returns></returns>
byte[] Read(string address, ushort len);
/// <summary>
/// 读取bool
/// </summary>
/// <param name="address"></param>
/// <returns></returns>
bool ReadBool(string address);
/// <summary>
/// 读取int16
/// </summary>
/// <param name="address"></param>
/// <returns></returns>
int ReadInt16(string address);
/// <summary>
/// 读取int32
/// </summary>
/// <param name="address"></param>
/// <returns></returns>
int ReadInt32(string address);
/// <summary>
/// 读取string
/// </summary>
/// <param name="address"></param>
/// <returns></returns>
string ReadString(string address);
/// <summary>
/// 单精度浮点型数据
/// </summary>
/// <param name="address"></param>
/// <returns></returns>
float ReadFloat(string address);
/// <summary>
/// 双精度浮点型数据
/// </summary>
/// <param name="address"></param>
/// <returns></returns>
double ReadDouble(string address);
/// <summary>
/// 写入int16
/// </summary>
/// <param name="address"></param>
/// <param name="value"></param>
/// <returns></returns>
bool WriteInt16(string address, string value);
/// <summary>
/// 写入int32
/// </summary>
/// <param name="address"></param>
/// <param name="value"></param>
/// <returns></returns>
bool WriteInt32(string address, int value);
/// <summary>
/// 写入string
/// </summary>
/// <param name="address"></param>
/// <param name="value"></param>
/// <returns></returns>
bool WriteString(string address, string value);
/// <summary>
/// 写入byte
/// </summary>
/// <param name="address"></param>
/// <param name="bytes"></param>
/// <returns></returns>
bool WriteByte(string address, byte[] bytes);
/// <summary>
/// 写入byte
/// </summary>
/// <param name="address"></param>
/// <param name="value"></param>
/// <returns></returns>
bool WriteFloat(string address, float value);
/// <summary>
/// 心跳使用——喂狗
/// </summary>
/// <param name="address"></param>
/// <returns></returns>
Task<bool> Read(string address);
}
}

@ -1,530 +0,0 @@
using HslCommunication;
using HslCommunication.Profinet;
using HslCommunication.Profinet.Melsec;
using log4net;
using System;
using System.Text;
using System.Threading.Tasks;
namespace Aucma.Core.PLc
{
/// <summary>
/// 三菱PLC
/// </summary>
public class MelsecPlc : IPlc
{
private readonly log4net.ILog log = LogManager.GetLogger(typeof(MelsecPlc));
private MelsecMcNet melsecMcNet = null;
#region 构造函数
//public MelsecPlc()
//{
// if (!HslCommunication.Authorization.SetAuthorizationCode("ed1415f8-e06a-43ad-95f7-c04f7ae93b41"))
// {
// //log.Info("HslCommunication激活失败");
// return;
// }
// Console.WriteLine("HslCommunication激活成功!");
// melsecMcNet = new MelsecMcNet();
// melsecMcNet.ConnectTimeOut = 2000;
//}
public MelsecPlc(string iP, int port)
{
if (!HslCommunication.Authorization.SetAuthorizationCode("ed1415f8-e06a-43ad-95f7-c04f7ae93b41"))
{
//log.Info("HslCommunication激活失败");
return;
}
Console.WriteLine("HslCommunication激活成功!");
melsecMcNet = new MelsecMcNet();
melsecMcNet.ConnectTimeOut = 2000;
Connect(iP, port);//建立连接
}
#endregion
#region 注册
public bool Registed()
{
if (!HslCommunication.Authorization.SetAuthorizationCode("ed1415f8-e06a-43ad-95f7-c04f7ae93b41"))
{
log.Info("HslCommunication激活失败");
return false;
}
Console.WriteLine("HslCommunication激活成功!");
melsecMcNet = new MelsecMcNet();
melsecMcNet.ConnectTimeOut = 2000;
return true;
}
#endregion
#region 是否连接
/// <summary>
/// 是否连接
/// </summary>
public bool IsConnected { get; set; }
#endregion
#region 建立连接
/// <summary>
/// 建立连接
/// </summary>
/// <param name="IP"></param>
/// <param name="port"></param>
/// <returns></returns>
public bool Connect(string iP, int port)
{
melsecMcNet.IpAddress = iP;//正式环境开启
melsecMcNet.Port = port;
// 如果网络不太理想,配置了两个端口,一个有问题,立即切换另一个的话,可以配置如下的代码
//melsecMcNet.GetPipeSocket().SetMultiPorts(new int[] { 6000, 6001 });
try
{
// 先关闭再重连,防止多次重连
melsecMcNet.ConnectClose();
OperateResult connect = melsecMcNet.ConnectServer();
if (connect.IsSuccess)
{
IsConnected = true;
return true;
}
else
{
melsecMcNet.RemoteStopAsync();
melsecMcNet.ConnectCloseAsync();
IsConnected = false;
Console.WriteLine("连接失败!");
return false;
}
}
catch (Exception ex)
{
log.Error(ex.Message);
IsConnected = false;
return false;
}
}
#endregion
#region 断开连接
/// <summary>
/// 断开连接
/// </summary>
/// <returns></returns>
public bool DisConnect()
{
return melsecMcNet.ConnectClose().IsSuccess;
}
#endregion
#region 读取byte数据
/// <summary>
/// 读取byte数据
/// </summary>
/// <param name="address"></param>
/// <returns></returns>
public byte[] ReadBytes(string address)
{
byte[] bytes = null;
try
{
OperateResult<byte[]> read = melsecMcNet.Read(address, 26);
if (read.IsSuccess)
{
byte[] code = new byte[read.Content.Length - 2];
Array.Copy(read.Content, 2, code, 0, 24);
string scode = Encoding.ASCII.GetString(code, 0, code.Length);
bytes = code;
}
}
catch (Exception ex)
{
log.Error("ReadBytes方法异常" + ex.ToString());
}
return bytes;
}
#endregion
#region 读取bool
/// <summary>
/// 读取bool
/// </summary>
/// <param name="address"></param>
/// <returns></returns>
public bool ReadBool(string address)
{
bool iflag = false;
try
{
OperateResult<bool> read = melsecMcNet.ReadBool(address);
if (read.IsSuccess)
{
iflag = read.Content;
}
return iflag;
}
catch (Exception ex)
{
log.Error("ReadBool方法异常" + ex.ToString());
}
return iflag;
}
#endregion
#region 读取int16
/// <summary>
/// 读取int16
/// </summary>
/// <param name="address"></param>
/// <returns></returns>
public int ReadInt16(string address)
{
int returnflag = 0;
try
{
OperateResult<Int16> read = melsecMcNet.ReadInt16(address);
if (read.IsSuccess)
{
returnflag = read.Content;
}
}
catch (Exception ex)
{
log.Error("ReadInt16方法异常" + ex.ToString());
}
return returnflag;
}
#endregion
#region 读取int32
/// <summary>
/// 读取int32
/// </summary>
/// <param name="address"></param>
/// <returns></returns>
public int ReadInt32(string address)
{
int returnflag = 0;
try
{
OperateResult<Int32> read = melsecMcNet.ReadInt32(address);
if (read.IsSuccess)
{
returnflag = read.Content;
}
}
catch (Exception ex)
{
log.Error("ReadInt32方法异常" + ex.ToString());
}
return returnflag;
}
#endregion
#region 读取string
/// <summary>
/// 读取string
/// </summary>
/// <param name="address"></param>
/// <returns></returns>
public string ReadString(string address)
{
string returnflag = "";
try
{
OperateResult<string> read = melsecMcNet.ReadString(address, 10);
if (read.IsSuccess)
{
returnflag = read.Content;
}
}
catch (Exception ex)
{
log.Error("ReadString方法异常" + ex.ToString());
}
return returnflag;
}
#endregion
#region 读取Float
/// <summary>
/// 读取Float
/// </summary>
/// <param name="address"></param>
/// <returns></returns>
public float ReadFloat(string address)
{
float flag = 0;
try
{
OperateResult<float> read = melsecMcNet.ReadFloat(address);
if (read.IsSuccess)
{
flag = read.Content;
}
}
catch (Exception ex)
{
log.Error("ReadFloat方法异常" + ex.ToString());
}
return flag;
}
#endregion
#region 读取Double
/// <summary>
/// 读取Double
/// </summary>
/// <param name="address"></param>
/// <returns></returns>
public double ReadDouble(string address)
{
double flag = 0;
try
{
OperateResult<double> read = melsecMcNet.ReadDouble(address);
if (read.IsSuccess)
{
flag = read.Content;
}
}
catch (Exception ex)
{
log.Error("ReadDouble方法异常" + ex.ToString());
}
return flag;
}
#endregion
#region 写入int16
/// <summary>
/// 写入int16
/// </summary>
/// <param name="address"></param>
/// <param name="value"></param>
/// <returns></returns>
public bool WriteInt16(string address, string value)
{
bool iflag = false;
try
{
OperateResult write = melsecMcNet.Write(address, short.Parse(value));
//Task<OperateResult<TimeSpan>> operateResult = melsecMcNet.Wait(address, short.Parse(value));
if (write.IsSuccess)
{
iflag = true;
}
else
{
iflag = false;
}
return iflag;
}
catch (Exception ex)
{
log.Error("WriteInt16方法异常" + ex.ToString());
return iflag;
}
}
#endregion
#region 写入int32
/// <summary>
/// 写入int32
/// </summary>
/// <param name="address"></param>
/// <param name="value"></param>
/// <returns></returns>
public bool WriteInt32(string address, int value)
{
bool iflag = false;
try
{
OperateResult write = melsecMcNet.Write(address, value);
if (write.IsSuccess)
{
iflag = true;
}
else
{
iflag = false;
}
return iflag;
}
catch (Exception ex)
{
log.Error("WriteInt32方法异常" + ex.ToString());
return iflag;
}
}
#endregion
#region 写入string
/// <summary>
/// 写入string
/// </summary>
/// <param name="address"></param>
/// <param name="value"></param>
/// <returns></returns>
public bool WriteString(string address, string value)
{
bool iflag = false;
try
{
OperateResult write = melsecMcNet.Write(address, value);
if (write.IsSuccess)
{
iflag = true;
}
else
{
iflag = false;
}
}
catch (Exception ex)
{
log.Error("WriteString方法异常" + ex.ToString());
iflag = false;
}
return iflag;
}
#endregion
#region 写入byte
/// <summary>
/// 写入byte
/// </summary>
/// <param name="address"></param>
/// <param name="bytes"></param>
/// <returns></returns>
public bool WriteByte(string address, byte[] bytes)
{
bool iflag = false;
try
{
OperateResult write = melsecMcNet.Write(address, bytes);
if (write.IsSuccess)
{
iflag = true;
}
else
{
iflag = false;
}
}
catch (Exception ex)
{
log.Error("WriteByte方法异常" + ex.ToString());
iflag = false;
}
return iflag;
}
#endregion
#region 写入Float
/// <summary>
/// 写入byte
/// </summary>
/// <param name="address"></param>
/// <param name="bytes"></param>
/// <returns></returns>
public bool WriteFloat(string address, float value)
{
bool iflag = false;
try
{
OperateResult write = melsecMcNet.Write(address, value);
if (write.IsSuccess)
{
iflag = true;
}
else
{
iflag = false;
}
}
catch (Exception ex)
{
log.Error("WriteByte方法异常" + ex.ToString());
iflag = false;
}
return iflag;
}
#endregion
#region 心跳使用——喂狗
/// <summary>
/// 心跳使用
/// </summary>
/// <param name="address"></param>
/// <returns></returns>
public async Task<bool> Read(string address)
{
try
{
melsecMcNet.ReceiveTimeOut = 2000;
OperateResult<bool> read = await melsecMcNet.ReadBoolAsync(address);
if (read.IsSuccess)
{
IsConnected = true;
return true;
}
else
{
var k = read.ErrorCode < 0 ? false : true;
if (k)
{
IsConnected = true;
return true;
}
else
{
IsConnected = false;
return false;
}
}
}
catch (Exception ex)
{
log.Error("ReadInt32方法异常" + ex.ToString());
}
return false;
}
#endregion
/// <summary>
/// 读取byte
/// </summary>
/// <param name="address">地址</param>
/// <param name="len">长度</param>
/// <returns></returns>
public byte[] Read(string address, ushort len)
{
OperateResult<byte[]> readbyte = melsecMcNet.Read(address, len);
if (readbyte.IsSuccess)
{
IsConnected = true;
return readbyte.Content;
}
else
{
IsConnected = false;
return null;
}
}
}
}

@ -1,525 +0,0 @@
using HslCommunication;
using HslCommunication.Profinet.Melsec;
using HslCommunication.Profinet.Siemens;
using log4net;
using System;
using System.Text;
using System.Threading.Tasks;
namespace Aucma.Core.PLc
{
/// <summary>
/// 西门子PLC
/// </summary>
public class SiemensPlc : IPlc
{
private readonly log4net.ILog log = LogManager.GetLogger(typeof(MelsecPlc));
private SiemensS7Net siemensS7Net;
private SiemensPLCS siemensPLCS = SiemensPLCS.S1200;
#region 构造函数
//public MelsecPlc()
//{
// if (!HslCommunication.Authorization.SetAuthorizationCode("ed1415f8-e06a-43ad-95f7-c04f7ae93b41"))
// {
// //log.Info("HslCommunication激活失败");
// return;
// }
// Console.WriteLine("HslCommunication激活成功!");
// siemensS7Net = new SiemensS7Net();
// siemensS7Net.ConnectTimeOut = 2000;
//}
public SiemensPlc(string iP, int port)
{
if (!HslCommunication.Authorization.SetAuthorizationCode("ed1415f8-e06a-43ad-95f7-c04f7ae93b41"))
{
log.Error("HslCommunication激活失败");
return;
}
Console.WriteLine("HslCommunication激活成功!");
siemensS7Net = new SiemensS7Net(siemensPLCS);
siemensS7Net.ConnectTimeOut = 2000;
Connect(iP, port);//建立连接
}
#endregion
#region 注册
public bool Registed()
{
if (!HslCommunication.Authorization.SetAuthorizationCode("ed1415f8-e06a-43ad-95f7-c04f7ae93b41"))
{
log.Info("HslCommunication激活失败");
return false;
}
Console.WriteLine("HslCommunication激活成功!");
siemensS7Net = new SiemensS7Net(siemensPLCS);
siemensS7Net.ConnectTimeOut = 2000;
return true;
}
#endregion
#region 是否连接
/// <summary>
/// 是否连接
/// </summary>
public bool IsConnected { get; set; }
#endregion
#region 建立连接
/// <summary>
/// 建立连接
/// </summary>
/// <param name="IP"></param>
/// <param name="port"></param>
/// <returns></returns>
public bool Connect(string iP, int port)
{
siemensS7Net.IpAddress = iP;//正式环境开启
siemensS7Net.Port = port;
try
{
OperateResult connect = siemensS7Net.ConnectServer();
if (connect.IsSuccess)
{
IsConnected = true;
return true;
}
else
{
siemensS7Net.StopAsync();
IsConnected = false;
return false;
}
}
catch (Exception ex)
{
log.Error($"PLCl连接失败{ex.Message}");
IsConnected = false;
return false;
}
}
#endregion
#region 断开连接
/// <summary>
/// 断开连接
/// </summary>
/// <returns></returns>
public bool DisConnect()
{
return siemensS7Net.ConnectClose().IsSuccess;
}
#endregion
#region 读取byte数据
/// <summary>
/// 读取byte数据
/// </summary>
/// <param name="address"></param>
/// <returns></returns>
public byte[] ReadBytes(string address)
{
byte[] bytes = null;
try
{
OperateResult<byte[]> read = siemensS7Net.Read(address, 26);
if (read.IsSuccess)
{
byte[] code = new byte[read.Content.Length - 2];
Array.Copy(read.Content, 2, code, 0, 24);
string scode = Encoding.ASCII.GetString(code, 0, code.Length);
bytes = code;
}
}
catch (Exception ex)
{
log.Error("ReadBytes方法异常" + ex.ToString());
}
return bytes;
}
#endregion
#region 读取bool
/// <summary>
/// 读取bool
/// </summary>
/// <param name="address"></param>
/// <returns></returns>
public bool ReadBool(string address)
{
bool iflag = false;
try
{
OperateResult<bool> read = siemensS7Net.ReadBool(address);
if (read.IsSuccess)
{
iflag = read.Content;
}
return iflag;
}
catch (Exception ex)
{
log.Error("ReadBool方法异常" + ex.ToString());
}
return iflag;
}
#endregion
#region 读取int16
/// <summary>
/// 读取int16
/// </summary>
/// <param name="address"></param>
/// <returns></returns>
public int ReadInt16(string address)
{
int returnflag = 0;
try
{
OperateResult<Int16> read = siemensS7Net.ReadInt16(address);
if (read.IsSuccess)
{
returnflag = read.Content;
}
}
catch (Exception ex)
{
log.Error("ReadInt16方法异常" + ex.ToString());
}
return returnflag;
}
#endregion
#region 读取int32
/// <summary>
/// 读取int32
/// </summary>
/// <param name="address"></param>
/// <returns></returns>
public int ReadInt32(string address)
{
int returnflag = 0;
try
{
OperateResult<Int32> read = siemensS7Net.ReadInt32(address);
if (read.IsSuccess)
{
returnflag = read.Content;
}
}
catch (Exception ex)
{
log.Error("ReadInt32方法异常" + ex.ToString());
}
return returnflag;
}
#endregion
#region 读取string
/// <summary>
/// 读取string
/// </summary>
/// <param name="address"></param>
/// <returns></returns>
public string ReadString(string address)
{
string returnflag = "";
try
{
OperateResult<string> read = siemensS7Net.ReadString(address, 10);
if (read.IsSuccess)
{
returnflag = read.Content;
}
}
catch (Exception ex)
{
log.Error("ReadString方法异常" + ex.ToString());
}
return returnflag;
}
#endregion
#region 读取Float
/// <summary>
/// 读取string
/// </summary>
/// <param name="address"></param>
/// <returns></returns>
public float ReadFloat(string address)
{
float flag = 0;
try
{
OperateResult<float> read = siemensS7Net.ReadFloat(address);
if (read.IsSuccess)
{
flag = read.Content;
}
}
catch (Exception ex)
{
log.Error("ReadString方法异常" + ex.ToString());
}
return flag;
}
#endregion
#region 读取Double
/// <summary>
/// 读取double
/// </summary>
/// <param name="address"></param>
/// <returns></returns>
public double ReadDouble(string address)
{
double flag = 0;
try
{
OperateResult<double> read = siemensS7Net.ReadDouble(address);
if (read.IsSuccess)
{
flag = read.Content;
}
}
catch (Exception ex)
{
log.Error("ReadString方法异常" + ex.ToString());
}
return flag;
}
#endregion
#region 写入int16
/// <summary>
/// 写入int16
/// </summary>
/// <param name="address"></param>
/// <param name="value"></param>
/// <returns></returns>
public bool WriteInt16(string address, string value)
{
bool iflag = false;
try
{
OperateResult write = siemensS7Net.Write(address, short.Parse(value));
//Task<OperateResult<TimeSpan>> operateResult = siemensS7Net.Wait(address, short.Parse(value));
if (write.IsSuccess)
{
iflag = true;
}
else
{
iflag = false;
}
return iflag;
}
catch (Exception ex)
{
log.Error("WriteInt16方法异常" + ex.ToString());
return iflag;
}
}
#endregion
#region 写入int32
/// <summary>
/// 写入int32
/// </summary>
/// <param name="address"></param>
/// <param name="value"></param>
/// <returns></returns>
public bool WriteInt32(string address, int value)
{
bool iflag = false;
try
{
OperateResult write = siemensS7Net.Write(address, value);
if (write.IsSuccess)
{
iflag = true;
}
else
{
iflag = false;
}
return iflag;
}
catch (Exception ex)
{
log.Error("WriteInt32方法异常" + ex.ToString());
return iflag;
}
}
#endregion
#region 写入string
/// <summary>
/// 写入string
/// </summary>
/// <param name="address"></param>
/// <param name="value"></param>
/// <returns></returns>
public bool WriteString(string address, string value)
{
bool iflag = false;
try
{
OperateResult write = siemensS7Net.Write(address, value);
if (write.IsSuccess)
{
iflag = true;
}
else
{
iflag = false;
}
}
catch (Exception ex)
{
log.Error("WriteString方法异常" + ex.ToString());
iflag = false;
}
return iflag;
}
#endregion
#region 写入byte
/// <summary>
/// 写入byte
/// </summary>
/// <param name="address"></param>
/// <param name="bytes"></param>
/// <returns></returns>
public bool WriteByte(string address, byte[] bytes)
{
bool iflag = false;
try
{
OperateResult write = siemensS7Net.Write(address, bytes);
if (write.IsSuccess)
{
iflag = true;
}
else
{
iflag = false;
}
}
catch (Exception ex)
{
log.Error("WriteByte方法异常" + ex.ToString());
iflag = false;
}
return iflag;
}
#endregion
#region 写入Float
/// <summary>
/// 写入byte
/// </summary>
/// <param name="address"></param>
/// <param name="bytes"></param>
/// <returns></returns>
public bool WriteFloat(string address, float value)
{
bool iflag = false;
try
{
OperateResult write = siemensS7Net.Write(address, value);
if (write.IsSuccess)
{
iflag = true;
}
else
{
iflag = false;
}
}
catch (Exception ex)
{
log.Error("WriteByte方法异常" + ex.ToString());
iflag = false;
}
return iflag;
}
#endregion
#region 心跳使用——喂狗
/// <summary>
/// 心跳使用
/// </summary>
/// <param name="address"></param>
/// <returns></returns>
public async Task<bool> Read(string address)
{
try
{
siemensS7Net.ReceiveTimeOut = 2000;
OperateResult<bool> read = await siemensS7Net.ReadBoolAsync(address);
if (read.IsSuccess)
{
IsConnected = true;
return true;
}
else
{
var k = read.ErrorCode < 0 ? false : true;
if (k)
{
IsConnected = true;
return true;
}
else
{
IsConnected = false;
return false;
}
}
}
catch (Exception ex)
{
log.Error("ReadInt32方法异常" + ex.ToString());
}
return false;
}
#endregion
/// <summary>
/// 读取byte
/// </summary>
/// <param name="address">地址</param>
/// <param name="len">长度</param>
/// <returns></returns>
public byte[] Read(string address, ushort len)
{
OperateResult<byte[]> readbyte = siemensS7Net.Read(address, len);
if (readbyte.IsSuccess)
{
IsConnected = true;
return readbyte.Content;
}
else
{
IsConnected = false;
return null;
}
}
}
}

@ -1,35 +0,0 @@

namespace Aucma.Core.PLc
{
/// <summary>
/// PLC
/// </summary>
public class PlcModel
{
/// <summary>
/// 编号
/// </summary>
public int Id { get; set; }
/// <summary>
/// 设备名称
/// </summary>
public string EquipName { get; set; }
/// <summary>
/// 设备IP
/// </summary>
public string IP { get; set; }
/// <summary>
/// 设备端口
/// </summary>
public int Port { get; set; }
/// <summary>
/// 是否连接
/// </summary>
public bool IsConnect { get; set; }
/// <summary>
/// 对象
/// </summary>
public IPlc plc;
}
}

@ -1,12 +0,0 @@
using System;
using System.Collections.Generic;
using System.Text;
namespace Aucma.Core.PLc
{
public class PlcHelper
{
public static List<PlcModel> melsecList = new List<PlcModel>();
public static List<PlcModel> siemensList = new List<PlcModel>();
}
}

@ -4,8 +4,6 @@ namespace Aucma.Core.RunPlc
public interface IRunPlcService
{
Task StartMelsecMcSeverAsync();
Task StartSiemensSever();
Task StartMelsecPlcAsync();
Task StartSiemensPlcAsync();
}
}

@ -17,15 +17,12 @@ namespace Aucma.Core.RunPlc
}
#endregion
public async Task StartMelsecMcSeverAsync()
{
await StartMelsecMcPlcServer();
}
public async Task StartSiemensSever()
{
await StartSiemensPlcServer();
}
#region 心跳
public async Task StartMelsecPlcAsync()
{
@ -38,20 +35,6 @@ namespace Aucma.Core.RunPlc
timer.Start();//timer.Start()的内部原理还是设置timer.Enabled = true;
await Task.CompletedTask;
});
}
public async Task StartSiemensPlcAsync()
{
await Task.Run(async () =>
{
System.Timers.Timer timer = new System.Timers.Timer(3000);//创建定时器设置间隔时间为1000毫秒
timer.Elapsed += new System.Timers.ElapsedEventHandler(ExecSiemensHeartTask);
timer.AutoReset = true;//设置是执行一次false还是一直执行(true)
timer.Enabled = true;//需要调用 timer.Start()或者timer.Enabled = true来启动它
timer.Start();//timer.Start()的内部原理还是设置timer.Enabled = true;
await Task.CompletedTask;
});
}
private static async Task StartMelsecMcPlcServer()
{
@ -73,25 +56,6 @@ namespace Aucma.Core.RunPlc
await Task.CompletedTask;
}
private static async Task StartSiemensPlcServer()
{
List<PlcModel> allPlcServices = Appsettings.app<PlcModel>("PLCServer").ToList();
if (allPlcServices == null) return;
var list = allPlcServices.FindAll(d => d.PlcType == "Siemens" && d.Enabled == true);
foreach (var item in list)
{
PlcModel model = new PlcModel();
model.Id = item.Id;
model.EquipName = item.EquipName;
model.IP = item.IP;
model.Port = item.Port;
model.PlcType = item.PlcType;
model.plc = new SiemensPlc(item.IP, item.Port);
PlcHelper.siemensList.Add(model);
}
await Task.CompletedTask;
}
#endregion
#region 心跳检测
@ -134,44 +98,7 @@ namespace Aucma.Core.RunPlc
}
await Task.CompletedTask;
}
private async void ExecSiemensHeartTask(object? sender, ElapsedEventArgs e)
{
int num = PlcHelper.siemensList.Count;
if (num == 0) return;
for (int i = 1; i <= num; i++)
{
var item = PlcHelper.siemensList.Where(c => c.Id == i).FirstOrDefault();
if (item == null) continue;
if (await item.plc.Read("M100"))
{
item.IsConnect = true;
item.plc.IsConnected = true;
//Console.WriteLine(item.melsecPlc.ReadBool("M100"));
//Console.WriteLine($"{item.EquipName}:PLC连接成功");
}
else
{
if (item.plc.IsConnected == false)
{
item.IsConnect = false;
//Console.WriteLine($"{item.EquipName}:PLC连接失败");
System.GC.Collect();
bool r = item.plc.Connect(item.IP, item.Port);
if (r)
{
item.plc.IsConnected = r;
item.IsConnect = r;
}
else
{
item.plc.IsConnected = r;
item.plc.DisConnect();
}
}
}
}
}
#endregion
}
}

@ -118,7 +118,7 @@ namespace Aucma.Core.SheetMetal.Business
if (obj_backPanel.plc.IsConnected)
{
Console.WriteLine("===============采集后板开始===============");
byte[] info = obj_sidePanel.plc.Read("D7000", 3000);
byte[] info = obj_backPanel.plc.Read("D7000", 3000);
if (info == null)
{
Thread.Sleep(1000);
@ -161,9 +161,11 @@ namespace Aucma.Core.SheetMetal.Business
}
else
{
if (string.IsNullOrEmpty(obj.SmModel) && string.IsNullOrEmpty(mode)) continue;
if (obj.SmModel.Equals(mode)) continue;
else
if (string.IsNullOrEmpty(obj.SmModel))
{
obj.SmModel = mode;
}
{
obj.SmProductId = j.ToString();
obj.SmModel = mode.Trim();

@ -55,10 +55,9 @@ namespace Aucma.Core.SheetMetal
//注册业务服务
AddServices(services);
//ÈÎÎñµ÷¶È
//services.AddJobSetup();
//PLC
services.AddPlcSetup();
//<2F>ם¼<D79D>מ<EFBFBD>½נ<C2BD><D7A0><EFBFBD>ס
services.AddAucmaSheetMetalTaskSetup();
//services.AddScannerGunSetup();
//支持编码大全 例如:支持 System.Text.Encoding.GetEncoding("GB2312") System.Text.Encoding.GetEncoding("GB18030")
@ -85,13 +84,10 @@ namespace Aucma.Core.SheetMetal
{
// 使用静态文件
app.UseStaticFiles();
// ¿ªÆôQuartzNetJobµ÷¶È·þÎñ
//app.UseQuartzJobMildd(tasksQzService, schedulerCenter);
//PLC
app.UsePlcMildd(runPlcService);
//澳柯玛任务处理中间件
app.UseAucamSheetMetalTaskMildds(aucamSheetMetalTaskService);
//app.UseScannerGunMildd(scannerGun);// IScannerGunService scannerGun,
}
#region 注册服务

@ -66,17 +66,10 @@ namespace Aucma.Core.SheetMetal.ViewModels
MaterialDataGrid.Clear();
int i = 1;
string station = Appsettings.app("StationInfo", "StationCode");
var materialList = _baseMaterialInfoServices.QueryAsync().Result;
var modelList = from d in materialList
select new
{
d.MaterialCode,
d.MaterialName,
d.MaterialSpecifications
};
if (modelList == null) return;
foreach (var item in modelList)
var materialTypeList =await _baseMaterialInfoServices.GetMaterialType();
if (materialTypeList == null) return;
foreach (var item in materialTypeList)
{
MaterialDataGrid.Add(new BaseMaterialInfoModel()
{
@ -87,7 +80,6 @@ namespace Aucma.Core.SheetMetal.ViewModels
});
i++;
}
}
catch (Exception ex)
{

@ -133,7 +133,7 @@
"EquipName": "SidePanelPlc",
"PlcType": "Melsec",
"Enabled": true,
"IP": "10.10.91.1",
"IP": "127.0.0.1",//"10.10.91.1",
"Port": 5552
},
{
@ -141,7 +141,7 @@
"EquipName": "BackPanelPLC",
"PlcType": "Melsec",
"Enabled": true,
"IP": "10.10.91.6",
"IP": "127.0.0.1", //"10.10.91.6",
"Port": 5553
}
]

@ -1,5 +1,4 @@

using Admin.Core.Common;
using Admin.Core.Common;
using Admin.Core.IService;
using Admin.Core.Model.Model_New;
using Admin.Core.Model;
@ -106,15 +105,15 @@ namespace Aucma.Core.SheetMetalTasks
public Task SheetMetalTasks()
{
Task.Run(async () =>
{
await InitSendSidePanelPlan();
});
//Task.Run(async () =>
//{
// await InitSendSidePanelPlan();
//});
Task.Run(async () =>
{
await InitSendBackPanelPlan();
});
//Task.Run(() =>
//{
// UpdateComplatePlan();//更新计划数
@ -124,10 +123,10 @@ namespace Aucma.Core.SheetMetalTasks
// await ReadSideBlanking();//获取前板下料
//});
//Task.Run(async () =>
//{
// await QuerySidePanelMode();//获取型号
//});
Task.Run(async () =>
{
await QuerySidePanelMode();//获取型号
});
//Task.Run(async () =>
//{
// await QueryBackPanelMode();
@ -152,7 +151,11 @@ namespace Aucma.Core.SheetMetalTasks
while (true)
{
List<SheetMetaSendPlanInfoView> planInfoList = await _executePlanInfoServices.QuerySheetMetalSendPlanData("1001");
if (planInfoList == null || planInfoList.Count == 0) continue;
if (planInfoList == null || planInfoList.Count == 0)
{
Console.WriteLine("未获取到需要下发的前板任务");
continue;
}
planInfoList = planInfoList.Where(d => d.PlanAmount > d.SidePanelAmount&&(d.ExecuteStatus == 1 || d.ExecuteStatus == 2)).ToList();
if (planInfoList == null || planInfoList.Count == 0) continue;
planInfoList = planInfoList.Where(d => d.ExecuteStatus == 1 || d.ExecuteStatus == 2).ToList();
@ -194,6 +197,7 @@ namespace Aucma.Core.SheetMetalTasks
if (backBin == null || sideBin == null)
{
planInfos.Remove(planInfo);//移除list中当前的对象执行下一个计划
Console.WriteLine($"移除数据:{planInfo.ToJson()}");
sideFlag = true;
}
@ -225,7 +229,7 @@ namespace Aucma.Core.SheetMetalTasks
/// </summary>
public async Task InitSendBackPanelPlan()
{
Thread.Sleep(5000);
//Thread.Sleep(5000);
var obj_backPanel = PlcHelper.melsecList.FirstOrDefault(d => d.EquipName.Equals("BackPanelPLC"));
var obj_sidePanel = PlcHelper.melsecList.FirstOrDefault(d => d.EquipName.Equals("SidePanelPlc"));
while (true)
@ -233,7 +237,10 @@ namespace Aucma.Core.SheetMetalTasks
try
{
var planInfoList = await _executePlanInfoServices.QuerySheetMetalSendPlanData("1001");
if (planInfoList == null || planInfoList.Count == 0) continue;
if (planInfoList == null || planInfoList.Count == 0) {
Console.WriteLine("未获取到需要下发的前板任务");
continue;
}
planInfoList = planInfoList.Where(d => d.PlanAmount > d.SidePanelAmount).ToList();
if (planInfoList == null || planInfoList.Count == 0) continue;
planInfoList = planInfoList.Where(d => d.ExecuteStatus == 1 || d.ExecuteStatus == 2).ToList();

Loading…
Cancel
Save