void initUploadDpms()
{
UploadDpms = App.Store.asyncAction <MqActions.UploadDpms, bool>(
async(dispatch, getState, instance) => {
dispatch(instance);
return(await Task.Run(() => {
try {
activeMq.SendP2POneMessage(HmiConfig.QueueDpms, JsonConvert.SerializeObject(instance.MqUploadDpms));
App.Store.Dispatch(new SysActions.ShowNotification(new SysNotificationMsg()
{
Title = "提交成功"
}));
App.Store.Dispatch(new SimpleAction(MqActions.UPLOAD_DPMS_SUCCESS));
return true;
} catch {
App.Store.Dispatch(new SysActions.ShowNotification(new SysNotificationMsg()
{
Title = "提交失败",
Content = "请检查网络连接或联系管理员"
}));
App.Store.Dispatch(new SimpleAction(MqActions.UPLOAD_DPMS_FAILED));
}
return false;
}));
}
);
}
/// <summary>
/// 上传任何基于MongoDoc的数据
/// </summary>
void initUploadDocMongo()
{
UploadDocToMongo = App.Store.asyncActionVoid <DbActions.UploadDocToMongo>(async(dispatch, getState, instance) => {
dispatch(instance);
await MongoService.GetDatabase(instance.DbName).GetCollection <MongoDoc>(instance.Collection)
.InsertOneAsync(instance.Doc);
App.Store.Dispatch(new SimpleAction(DbActions.UPLOAD_DOC_TO_MONGO_SUCCESS));
});
}
/// <summary>
/// 上传采集参数到时态数据库
/// </summary>
void initUploadCpmsInfluxDb()
{
UploadCpmsInfluxDb = App.Store.asyncActionVoid <DbActions.UploadCpmsInfluxDb>(
async(dispatch, getState, instance) => {
dispatch(instance);
updateCache2(instance);
//updateCache1(instance);
});
}
/// <summary>
/// 加载 GlobalConfig 和 初始化 xxHelper
/// </summary>
void initLoadGlobalConfig()
{
LoadGlobalConfig = App.Store.asyncAction <LoadActions.LoadGlobalConfig, bool>(
async(dispatch, getState, instance) => {
dispatch(instance);
return(await Task.Run(() =>
globalConfigLoad()
));
});
}
public MockEffects(MqService mqService)
{
this.mqService = mqService;
MockSchTaskAccept =
App.Store.asyncActionVoid <MockActions.MockSchTaskAccpet>(async(dispatch, getState, instance) => {
await Task.Run(() => {
mqService.SchTaskAccept(JsonConvert.SerializeObject(instance.SchTask));
});
});
}
/// <summary>
/// 加载 MachineConfig，主要是初始化 CpmInfo
/// </summary>
void initLoadMachineConfig()
{
LoadMachineConfig = App.Store.asyncAction <LoadActions.LoadMachieConfig, bool>(
async(dispatch, getState, instance) => {
dispatch(instance);
updateLoadingMessage("正在加载机台配置...", 0.4);
return(await Task.Run(() => {
loadConfigByGlobal();
return true;
}));
});
}
void initStartUploadCpmsIntervalEffect()
{
StartUploadCpmsInterval =
App.Store.asyncActionVoid <MqActions.StartUploadCpmsInterval>(async(dipatch, getState, instance) => {
dipatch(instance);
await Task.Run(() => {
YUtil.SetInterval(instance.Interval, () => {
App.Store.Dispatch(UploadCpms(new MqActions.UploadCpms(getState().CpmState.OnlineCpmsDict, instance.QueueName)));
});
});
});
}
/// <summary>
/// 初始化上面的 Effect
/// </summary>
/// <param name="sysService"></param>
public SysEffects(SysService sysService)
{
UnityIocService.AssertIsFirstInject(GetType());
Logger = LoggerHelper.CreateLogger(GetType().ToString());
//启动http解析服务
StartHttpSystem = App.Store.asyncAction <SysActions.StartHttpSystem, bool>(
async(dispatch, getState, instance) => {
dispatch(instance);
var isStarted = await sysService.StartHttpSystem(instance);
if (isStarted)
{
App.Store.Dispatch(new SysActions.StartHttpSystemSuccess());
}
else
{
App.Store.Dispatch(new SysActions.StartHttpSystemFailed());
}
return(isStarted);
});
//启动关闭显示器定时器
StartCloseScreenTimer = App.Store.asyncActionVoid <SysActions.StartCloseScreenTimer>(
async(dispatch, getState, instance) => {
dispatch(instance);
await Task.Run(() => {
if (CloseScrrenTimer != null)
{
YUtil.RecoveryTimeout(CloseScrrenTimer);
}
else
{
CloseScrrenTimer = YUtil.SetInterval(instance.Interval, () => {
App.Store.Dispatch(new SysActions.CloseScreen());
});
}
});
});
//停止关闭显示器定时器
StopCloseScrenTimer = App.Store.asyncActionVoid <SysActions.StopCloseScreenTimer>(
async(dispatch, getState, instance) => {
dispatch(instance);
await Task.Run(() => {
if (CloseScrrenTimer != null)
{
YUtil.ClearTimeout(CloseScrrenTimer);
}
});
});
}
void initUploadAlarm()
{
UploadAlarm = App.Store.asyncActionVoid <MqActions.UploadAlarmMq>(async(dispatch, getState, instance) => {
dispatch(instance);
await Task.Run(() => {
try {
activeMq.SendP2POneMessage(instance.QueueName, JsonConvert.SerializeObject(instance.MqAlarm));
App.Store.Dispatch(new SimpleAction(MqActions.UPLOAD_ALARM_SUCCESS));
} catch (Exception e) {
App.Store.Dispatch(new SimpleAction(MqActions.UPLOAD_ALARM_FAILED));
Logger.Error("上传报警到Mq失败", e);
}
});
});
}
void initUploadSchTaskManu()
{
UploadSchTaskManu = App.Store.asyncAction <MqActions.UploadSchTaskManu, bool>(
async(dispatch, getState, instance) => {
dispatch(instance);
return(await Task.Run(() => {
try {
activeMq.SendP2POneMessage(instance.QueueName, JsonConvert.SerializeObject(instance.MqUploadManu));
return true;
} catch {
}
return false;
}));
});
}
void initStartListenCmd()
{
StartListenCmd = App.Store.asyncAction <MqActions.StartListenCmd, bool>(
async(dispatch, getState, instance) => {
dispatch(instance);
return(await Task.Run(() => {
try {
activeMq.ListenTopic(instance.TopicName, instance.Id, null, mqService.CmdAccept);
return true;
} catch (Exception e) {
dispatch(new SimpleAction(MqActions.START_LISTEN_CMD_FAILED, e));
}
return false;
}));
});
}
/// <summary>
/// 上传能耗
/// </summary>
void initUploadElecPower()
{
UploadElecPower = App.Store.asyncAction <MqActions.UploadElecPower, bool>(
async(dispatch, getState, instance) => {
return(await Task.Run(() => {
try {
String str = JsonConvert.SerializeObject(instance.elec);
App.Logger.Info("回传总电能：" + str);
activeMq.SendP2POneMessage(HmiConfig.QueUploadPowerElec, str);
return true;
} catch (Exception e) {
App.Logger.Error("上传能耗失败", e);
}
return false;
}));
});
}
void initCallSystem()
{
CallSystem = App.Store.asyncAction <MqActions.CallSystem, bool>(
async(dispatch, getState, instance) => {
dispatch(instance);
return(await Task.Run(() => {
try {
activeMq.SendP2POneMessage(HmiConfig.QueueCallSystem, JsonConvert.SerializeObject(instance.MqCall));
dispatch(new SimpleAction(MqActions.CALL_SYSTEM_SUCCESS));
return true;
} catch (Exception e) {
dispatch(new SimpleAction(MqActions.CALL_SYSTEM_FAILED, e));
}
return false;
}));
});
}
public CpmEffects(StorePro <AppState> store, CpmCore cpmCore)
{
CpmCore = cpmCore;
StorePro = store;
StartServer = store.asyncAction <CpmActions.StartServer, bool>(async(dispatch, getState, startServer) => {
dispatch(startServer);
try {
await cpmCore.StartAsync(startServer.Ip, startServer.Port);
dispatch(new CpmActions.StartServerSuccess());
return(true);
} catch (Exception e) {
dispatch(new CpmActions.StartServerFailed()
{
Exception = e
});
}
return(false);
});
}
void initStartListenEmpRfid()
{
StartListenEmpRfid = App.Store.asyncAction <MqActions.StartListenEmpRfid, bool>(
async(dispatch, getState, instance) => {
dispatch(instance);
return(await Task.Run(() => {
try {
activeMq.ListenTopic(instance.TopicName, instance.Id, null, mqService.EmpRfidAccept);
dispatch(new MqActions.StartListenEmpRfidSuccess());
return true;
} catch (Exception e) {
dispatch(new MqActions.StartListenEmpRfidFailed(e));
}
return false;
}));
}
);
}
void initSchTaskEffect()
{
StartListenSchTask =
App.Store.asyncAction <MqActions.StartListenSchTask, bool>(async(dispatch, getState, instance) => {
dispatch(instance);
var result = await Task.Run(() => {
try {
activeMq.ListenP2PMessage(instance.QueueName, this.mqService.SchTaskAccept);
dispatch(new MqActions.StartListenSchTaskSuccess(instance.MachineCode));
return(true);
} catch (Exception e) {
dispatch(new MqActions.StartListenSchTaskFailed()
{
Exp = e, MachineCode = instance.MachineCode
});
}
return(false);
});
return(result);
});
}
private void initWriteStringAsync()
{
WriteCmd = App.Store.asyncAction <PipeActions.WriteCmd, bool>(
async(dispatch, getState, instance) => {
dispatch(instance);
return(await Task.Run(() => {
try {
NamedPipeClientStream pipeStream = new NamedPipeClientStream(instance.PipeServerName, instance.PipeName, PipeDirection.Out, PipeOptions.Asynchronous);
pipeStream.Connect(3000);
var str = JsonConvert.SerializeObject(instance.Cmd);
byte[] buffer = Encoding.UTF8.GetBytes(str);
pipeStream.BeginWrite(buffer, 0, buffer.Length, asyncSend, pipeStream);
return true;
} catch (Exception e) {
App.Store.Dispatch(new SimpleAction(PipeActions.WRITE_CMD_FAILED, e));
Logger.Error("往管道写入数据失败", e);
}
return false;
}));
});
}
void initStartListenScanMaterial()
{
StartListenScanMaterial =
App.Store.asyncAction <MqActions.StartListenScanMaterial, bool>(async(dispatch, getState, instance) => {
dispatch(instance);
return(await Task.Run(() => {
try {
activeMq.ListenP2PMessage(instance.QueueName, json => {
mqService.ScanMaterialAccept(instance.MachineCode, json);
});
App.Store.Dispatch(new MqActions.StartListenScanMaterialSuccess(instance.MachineCode));
return true;
} catch (Exception e) {
App.Store.Dispatch(new MqActions.StartListenScanMaterialFailed()
{
Exp = e, MachineCode = instance.MachineCode
});
}
return false;
}));
});
}
/// <summary>
/// 对程序进行配置
/// </summary>
/// <param name="e"></param>
protected override void OnStartup(StartupEventArgs e)
{
base.OnStartup(e);
ReduxIoc.Init();
if (!YUtil.CheckProcessIsExist(HmiConfig.AsylumProcessName))
{
string asylumnArgs = "";
if (HmiConfig.IsDevUserEnv)
{
asylumnArgs = "--autostart false --HmiPath " + YUtil.GetAbsolutePath(".\\HmiPro.exe");
}
//YUtil.Exec(YUtil.GetAbsolutePath(@".\Asylum\Asylum.exe"), asylumnArgs);
}
Store = UnityIocService.ResolveDepend <StorePro <AppState> >();
//异步初始化，直接进入 DxWindow
Task.Run(() => {
hmiConfigInit(e);
initSubscribe();
//通知 DxWindow 初始化完毕
Store.Dispatch(new SysActions.AppXamlInited(e));
});
}
public static void Init()
{
UnityIocService.AssertIsFirstInject(typeof(ReduxIoc));
//== 注入 redux 相关数据
var reducer = new CompositeReducer <AppState>()
.Part(s => s.CpmState, CpmReducer.Create())
.Part(s => s.SysState, SysReducer.Create())
.Part(s => s.MqState, MqReducer.Create())
.Part(s => s.AlarmState, AlarmReducer.Create())
.Part(s => s.OeeState, OeeReducer.Create())
.Part(s => s.DMesState, DMesReducer.Create())
.Part(s => s.ViewStoreState, ViewStoreReducer.Create())
.Part(s => s.DpmStore, DpmReducer.Create());
var storePro = new StorePro <AppState>(reducer);
//== 设置依赖注入
UnityIocService.RegisterGlobalDepend(storePro);
UnityIocService.RegisterGlobalDepend <CpmCore>();
UnityIocService.RegisterGlobalDepend <CpmEffects>();
UnityIocService.RegisterGlobalDepend <SysService>();
UnityIocService.RegisterGlobalDepend <SysEffects>();
UnityIocService.RegisterGlobalDepend <MqService>();
UnityIocService.RegisterGlobalDepend <MqEffects>();
UnityIocService.RegisterGlobalDepend <MockEffects>();
UnityIocService.RegisterGlobalDepend <DbEffects>();
UnityIocService.RegisterGlobalDepend <DMesCore>();
UnityIocService.RegisterGlobalDepend <SchCore>();
UnityIocService.RegisterGlobalDepend <OeeCore>();
UnityIocService.RegisterGlobalDepend <AlarmCore>();
UnityIocService.RegisterGlobalDepend <ViewStoreCore>();
UnityIocService.RegisterGlobalDepend <DpmCore>();
UnityIocService.RegisterGlobalDepend <PipeEffects>();
UnityIocService.RegisterGlobalDepend <LoadEffects>();
UnityIocService.RegisterGlobalDepend <HookCore>();
}
void initUploadCpmsEffect()
{
UploadCpms = App.Store.asyncActionVoid <MqActions.UploadCpms>(async(dispatch, getState, instance) => {
var task = Task.Run(() => {
var cpmsDict = instance.CpmsDict;
foreach (var pair in cpmsDict)
{
var machineCode = pair.Key;
var machineCpms = pair.Value;
MqUploadCpms uCpms = new MqUploadCpms();
uCpms.machineCode = machineCode;
var setting = GlobalConfig.MachineSettingDict[machineCode];
var cpmNameToCodeDict = MachineConfig.MachineDict[machineCode].CpmNameToCodeDict;
//fix: 2018-1-24
if (cpmNameToCodeDict.ContainsKey(setting.MqNeedSpeed))
{
if (getState().CpmState.OnlineCpmsDict[machineCode]
.TryGetValue(cpmNameToCodeDict[setting.MqNeedSpeed], out var speedCpm))
{
uCpms.macSpeed = speedCpm.Value;
}
}
// fix: 2018-1-24
if (cpmNameToCodeDict.ContainsKey(setting.Od))
{
if (getState().CpmState.OnlineCpmsDict[machineCode]
.TryGetValue(cpmNameToCodeDict[setting.Od], out var od))
{
uCpms.diameter = od.Value.ToString();
}
}
//update:2018-4-13，添加总电能
if (cpmNameToCodeDict.ContainsKey(setting.totalPower))
{
if (getState().CpmState.OnlineCpmsDict[machineCode]
.TryGetValue(cpmNameToCodeDict[setting.totalPower], out var tp))
{
uCpms.totalPower = tp.Value.ToString();
}
}
uCpms.TimeEff = getState().OeeState.OeeDict[machineCode].TimeEff.ToString("0.00");
uCpms.SpeedEff = getState().OeeState.OeeDict[machineCode].SpeedEff.ToString("0.00");
uCpms.QualityEff = getState().OeeState.OeeDict[machineCode].QualityEff.ToString("0.00");
//机台状态
string state = MqUploadCpms.MachineState.Running;
var machineState = getState().CpmState.MachineStateDict[machineCode];
if (machineState.Count > 0)
{
if (machineState.Last().StatePoint == MachineState.State.Start)
{
state = MqUploadCpms.MachineState.Running;
}
else if (machineState.Last().StatePoint == MachineState.State.Stop)
{
state = MqUploadCpms.MachineState.Closed;
}
else if (machineState.Last().StatePoint == MachineState.State.Repair)
{
state = MqUploadCpms.MachineState.Repairing;
}
}
uCpms.machineState = state;
uCpms.paramInfoList = new List <UploadParamInfo>();
//如果底层没有采集到数据则不上传
bool canUpload = false;
foreach (var cpmPair in machineCpms)
{
var cpm = cpmPair.Value;
if (cpm.ValueType == SmParamType.Signal && cpm.Code >= 500 && cpm.Code < 1000)
{
canUpload = true;
}
var uInfo = new UploadParamInfo()
{
paramCode = cpm.Code.ToString(),
paramName = cpm.Name,
paramValue = cpm.Value,
valueType = cpm.ValueType,
pickTimeStamp = cpm.PickTimeStampMs,
};
uCpms.paramInfoList.Add(uInfo);
}
try {
if (canUpload)
{
activeMq.SendP2POneMessage(instance.QueueName, JsonConvert.SerializeObject(uCpms));
}
else
{
App.Logger.Info("所有数据为空，不上传 Mq", false, ConsoleColor.White);
}
App.Store.Dispatch(new MqActions.UploadCpmsSuccess());
} catch (Exception e) {
App.Store.Dispatch(new MqActions.UploadCpmsFailed()
{
Exp = e
});
}
}
});
//每个机台等待3s
var awaitTime = MachineConfig.MachineDict.Count * 3000;
if (await Task.WhenAny(task, Task.Delay(awaitTime)) == task)
{
//在时间之内完成了task
}
else
{
//超时
Logger.Error("上传实时参数到 Mq 超时", 36000);
App.Store.Dispatch(new MqActions.UploadCpmsFailed()
{
Exp = new Exception($"上传超时 {awaitTime / 1000}s ")
});
}
task.Dispose();
});
}
