Untitled

package servlet

import (
	"fmt"
	"jkgouser/comm_layer"
	"jkgouser/config"
	"jkgouser/entity"
	"jkgouser/interface/JKTool"
	"jkgouser/utils"
	"time"

	"github.com/sirupsen/logrus"
)

// 机床通信结构体

// 业务流程初始化,读取配置文件，初始化机床，启动机床状态采集线程
func CentralControlStart() {
	// 1. 根据机床配置Json，生成对应的机床对象切片与机床属性类的切片

	// 初始化全局变量，分配空间
	entity.MapMachineInfo = make(map[string]*entity.Machine_Info)
	entity.MapMachineComm = make(map[string]comm_layer.CNCInterface)
	// entity.MapMachineJsonConfig = make(map[string]json_entity.MachineConfigInfo)
	// entity.MapCurMachineStatus = make(map[string]*entity.MachineStatus)
	// entity.MapLastMachineStatus = make(map[string]*entity.MachineStatus)
	// entity.MapMachineStatusTimer = make(map[string]*entity.CNCStatusTimer)
	// entity.MapMachineInfo = make(map[string]*entity.MachineInfo)

	// 加载配置json
	err := utils.LoadJson(config.AppConfig.ProgramConfig.FilePath.Cnc_config, &entity.MapMachineInfo)
	if err != nil {
		logrus.Error("加载机床配置失败！错误信息： ", err)
	} else if err == nil {
		logrus.Info("加载机床配置成功！")
	}
	for _, cnc_info := range entity.MapMachineInfo {
		fmt.Println(cnc_info.IP, cnc_info.RBT_ID, cnc_info.ModbusOffset, cnc_info.Manufacturer)
	}

	// 连接三菱中转
	// go comm_layer.StartDataReceiver(config.AppConfig.WebSocket.Address, config.AppConfig.WebSocket.Port)

	// 启动RGV TCP服务器线程
	go RGVTCPServerThread()

	// 遍历机床配置，初始化每个机床的流程
	// for cnc_id, cnc_info := range entity.MapMachineJsonConfig {
	logrus.Info("初始化机床连接！")
	for cnc_id, cnc_info := range entity.MapMachineInfo {
		m_id := cnc_id
		m_info := cnc_info
		go func() {
			// 先获取厂商名称,进行初始化
			_, ok := entity.MapMachineComm[m_id]
			if !ok {
				entity.MapMachineComm[m_id] = comm_layer.CNCInterfaceFactory(m_info.Manufacturer)
			}
			// 初始化机床对象
			entity.MapMachineInfo[m_id] = entity.NewMachine(m_id, m_info.IP, m_info.RBT_ID, m_info.ModbusOffset, m_info.Manufacturer)
			for {
				if m_info.Manufacturer == "FANUC" {
					// 初始化连接
					cncHandle, err := entity.MapMachineComm[m_id].Connect(m_info.IP, config.AppConfig.Machine.FanucPort, config.AppConfig.Machine.ConnTimeout, m_id)
					if err != nil {
						logrus.Warningf("%s 机床连接失败！", m_id)
					} else {
						logrus.Warningf("%s 机床连接成功！", m_id)
						// 保存通信句柄
						entity.MapMachineInfo[m_id].SetCommHandle(cncHandle)
					}
					getCNCMachineStatusThread(entity.MapMachineInfo[m_id], entity.MapMachineComm[m_id])
					entity.MapMachineComm[m_id].Disconnect(cncHandle, m_id)
				} else if m_info.Manufacturer == "MITSUBISHI" {
					// 初始化连接
					_, err := entity.MapMachineComm[m_id].Connect(m_info.IP, 0, config.AppConfig.Machine.ConnTimeout, m_id)
					if err != nil {
						logrus.Warningf("%s 机床连接失败！", m_id)
					} else {
						logrus.Warningf("%s 机床连接成功！", m_id)
					}
				}
				JKTool.Msleep(5000)
			}
		}()
	}
	fmt.Println("MapMachineComm长度", len(entity.MapMachineComm))
}

// 单个机床的采集线程
func getCNCMachineStatusThread(machineInfo *entity.Machine_Info, machineComm comm_layer.CNCInterface) {
	fmt.Println("进入状态采集线程")
	CncStatusTemp := &entity.MachineStatus{}
	// 预处理 提取信息
	cnc_id := machineInfo.GetCnc_id()
	cncHandle := machineInfo.GetCommHandle()
	// ip := machineInfo.GetCnc_ip()

	// 读取机床节拍信息
	cycleTime, err := machineComm.CycleTimeRead(cncHandle, cnc_id)
	// 写入节拍信息到变量
	if err != nil {
		machineInfo.SetCycleTime(0)
		logrus.Warningf("%s 机床读取节拍失败！%s", cnc_id, err)
	} else {
		logrus.Warningf("%s 机床读取节拍成功！", cnc_id)
		machineInfo.SetCycleTime(cycleTime)
	}

	// 读取白班产能
	dayShiftFinishData, err := machineComm.DayShiftFinishNumberRead(cncHandle, cnc_id)
	// 写入产能信息到结构体
	if err != nil {
		logrus.Warningf("%s 机床读取白班产能失败！%s", cnc_id, err)
	} else {
		logrus.Warningf("%s 机床读取白班产能成功！", cnc_id)
		machineInfo.SetDayShiftFinishData(dayShiftFinishData)
	}

	// 读取报警信息
	alarmCode, alarmMsg, err := machineComm.AlarmRead(cncHandle, cnc_id)
	// 写入报警信息到结构体
	if err != nil {
		logrus.Warningf("%s 机床读取报警信息失败！%s", cnc_id, err)
	} else {
		logrus.Warningf("%s 机床读取报警信息成功！", cnc_id)
		machineInfo.SetAlarm_code(alarmCode)
		machineInfo.SetAlarm_msg(alarmMsg)
	}

	// 读取夜班产能
	nightShiftFinishData, err := machineComm.NightShiftFinishNumberRead(cncHandle, cnc_id)
	// 写入产能信息到结构体
	if err != nil {
		logrus.Warningf("%s 机床读取夜班产能失败！%s", cnc_id, err)
	} else {
		logrus.Warningf("%s 机床读取夜班产能成功！", cnc_id)
		machineInfo.SetNightShiftFinishData(nightShiftFinishData)
	}

	// 读取更新时间
	cncUpdataTime, plcUpdata, err := machineComm.UpdateTimeRead(cncHandle, cnc_id)
	// 写入更新时间到结构体
	if err != nil {
		logrus.Warningf("%s 机床读取更新时间失败！%s", cnc_id, err)
	} else {
		logrus.Warningf("%s 机床读取更新时间成功！", cnc_id)
		machineInfo.SetCommonVarUpdataTime(utils.ConvertToUnixTimestamp(cncUpdataTime))
		machineInfo.SetPlcUpdataTime(utils.ConvertToUnixTimestamp(plcUpdata))
		CncStatusTemp.SetCommonVarUpdataTime(utils.ConvertToUnixTimestamp(cncUpdataTime))
		CncStatusTemp.SetPLCUpdataTime(utils.ConvertToUnixTimestamp(plcUpdata))
	}

	// 读取机床正常运行状态
	runningStatus, err := machineComm.GetRunningState(cncHandle, cnc_id)
	// 写入状态到结构体
	if err != nil {
		logrus.Warningf("%s 机床读取运行状态失败！%s", cnc_id, err)
	} else {
		logrus.Warningf("%s 机床读取运行状态成功！", cnc_id)
		CncStatusTemp.SetCncRunStatus(runningStatus)
	}

	// 读取机床热机状态
	prepareStatus, err := machineComm.GetPrepareState(cncHandle, cnc_id)
	// 写入状态到结构体
	if err != nil {
		logrus.Warningf("%s 机床读取热机状态失败！%s", cnc_id, err)
	} else {
		logrus.Warningf("%s 机床读取热机状态成功！", cnc_id)
		CncStatusTemp.SetCNCPrepareStatus(prepareStatus)
	}

	// 读取PLC-发订单
	sendOrder, err := machineComm.GetSendOrderState(cncHandle, cnc_id)
	if err != nil {
		logrus.Warningf("%s 读取PLC-发订单失败！%s", cnc_id, err)
	}
	// 写入状态到结构体
	CncStatusTemp.SetCNCOrderStatus(sendOrder)
	// 检查是否出现了发订单的信号
	if sendOrder == true {
		// 检查是否是新出现的信号
		if machineInfo.GetCNC_Order_Status() == false {
			// 发送机床信号到调度
			// go SendOrderByCNCID(cnc_id)
		}
	}

	// 读取PLC-取消订单
	cancelOrder, err := machineComm.GetCancelOrderState(cncHandle, cnc_id)
	if err != nil {
		logrus.Warningf("%s 读取PLC-取消订单失败！%s", cnc_id, err)
	}
	// 写入状态到结构体
	CncStatusTemp.SetCNCCancelOrderStatus(cancelOrder)
	// 检查是否出现了取消订单的信号
	if cancelOrder == true {
		// 检查是否是新出现的信号
		if machineInfo.GetCNC_Cancel_Order_Status() == false {
			// 发送机床取消订单到调度
			// go CancelOrderByCNCID(cnc_id)
		}
	}

	// 读取PLC-加工完成
	finishedState, err := machineComm.GetFinishedState(cncHandle, cnc_id)
	if err != nil {
		logrus.Warningf("%s 机床读取加工完成状态失败！%s", cnc_id, err)
	} else {
		logrus.Warningf("%s 机床读取加工完成状态成功！", cnc_id)
		// 写入状态到结构体
		CncStatusTemp.SetCNCFinishStatus(finishedState)
	}

	// 读取PLC-开门到位
	doorOpenState, err := machineComm.GetDoorOpenState(cncHandle, cnc_id)
	if err != nil {
		logrus.Warningf("%s 机床读取开门到位状态失败！%s", cnc_id, err)
	} else {
		logrus.Warningf("%s 机床读取开门到位状态成功！", cnc_id)
		// 写入状态到结构体
		CncStatusTemp.SetCNCDoorOpenStatus(doorOpenState)
	}

	// 读取PLC-关门到位
	doorCloseState, err := machineComm.GetDoorCloseState(cncHandle, cnc_id)
	if err != nil {
		logrus.Warningf("%s 机床读取关门到位状态失败！%s", cnc_id, err)
	} else {
		logrus.Warningf("%s 机床读取关门到位状态成功！", cnc_id)
		// 写入状态到结构体
		CncStatusTemp.SetCNCDoorCloseStatus(doorCloseState)
	}

	// 读取PLC-手动暂停
	manualPauseState, err := machineComm.GetPauseState(cncHandle, cnc_id)
	if err != nil {
		logrus.Warningf("%s 机床读取手动暂停状态失败！%s", cnc_id, err)
	} else {
		logrus.Warningf("%s 机床读取手动暂停状态成功！", cnc_id)
		// 写入状态到结构体
		CncStatusTemp.SetCNCPauseStatus(manualPauseState)
	}

	// 读取PLC-机器人状态
	rbtIdleState, err := machineComm.GetRbtIdleState(cncHandle, cnc_id)
	if err != nil {
		logrus.Warningf("%s 机床读取机器人状态失败！%s", cnc_id, err)
	} else {
		logrus.Warningf("%s 机床读取机器人状态成功！", cnc_id)
		// 写入状态到结构体
		CncStatusTemp.SetRobotStatus(rbtIdleState)
	}

	// 读取PLC-机床绿灯PLC
	pilotGre, err := machineComm.GetCNCPilotGreenStatus(cncHandle, cnc_id)
	if err != nil {
		logrus.Warningf("%s 机床读取机床绿灯状态失败！%s", cnc_id, err)
	} else {
		logrus.Warningf("%s 机床读取机床绿灯状态成功！", cnc_id)
		CncStatusTemp.SetCNCPilotGreenStatus(pilotGre)
	}

	// 将当前的状态复制到last中
	machineInfo.CopyFrom(CncStatusTemp)

	// 休眠指定的线程毫秒
	// 读取配置文件中的间隔时间
	time.Sleep(time.Duration(config.AppConfig.ProgramConfig.Interval.CollectionStatusInterval) * time.Millisecond)
	logrus.Info("CNC_ID: ", cnc_id)
}