[功能修复]优化113

src/main/java/com/tmzn/devicelinkykc/constant/RedisConstant.java

@@ -41,10 +41,7 @@ public class RedisConstant {
     /**
      *订单未校验识别
      */
-    public static final String NO_RESPONSE_WAS_RECEIVED="noResponseWasReceived";
 
-    //重新登录
-    public static final String SIGN_BACK_IN ="signBackIn";
 
 
 }

src/main/java/com/tmzn/devicelinkykc/constant/ykc/StatusConstant.java

@@ -25,6 +25,7 @@ public class StatusConstant {
     public static final byte TRANSACTION_ORDER_REPORTING_ACTION_STATUS_OK=1;
     public static final byte TRANSACTION_ORDER_REPORTING_ACTION_STATUS_NO=0;
 
+
     //云快充对中间协议层上送是交易流水解析结果:0默认是未收到回复,1解析成功,2解析失败非法账单
     public static final byte TRANSACTION_ORDER_REPLY_STATUS_FAIL=0;
     public static final byte TRANSACTION_ORDER_REPLY_STATUS_SUCC=1;

src/main/java/com/tmzn/devicelinkykc/entity/TransOrder.java

@@ -98,6 +98,17 @@ public class TransOrder implements Serializable {
     * 谷金额
     */
     private BigDecimal valleyMoney;
+
+
+    /**
+     *  深谷电量
+     */
+    private BigDecimal deepValleyElec;
+    /**
+     * 深谷金额
+     */
+    private BigDecimal deepValleyMoney;
+
     /**
     * 总电量
     */

src/main/java/com/tmzn/devicelinkykc/frameMsg/frameType/CharngingPushFrame.java

@@ -96,7 +96,7 @@ public class CharngingPushFrame {
         return msg;
     }
 
-    public void endStatus(DeviceConnectionMsg deviceConnectionMsg,int port,int result,int reson){
+    public boolean endStatus(DeviceConnectionMsg deviceConnectionMsg,int port,int result,int reson){
         byte[] params = endParams(deviceConnectionMsg.getDeviceId(), port, result, reson);
         log.info("endStatus>停止充电回复>>>"+DataConversion.bytesToHexString(params));
 
@@ -108,22 +108,25 @@ public class CharngingPushFrame {
                 byte[] spliceing = FrameDataSplicing.spliceing(deviceConnectionMsg.getMessageCount(), DeviceSendYkc.STOP_CHARNGING_RESPONSE.getFrameType(), DeviceSendYkc.STOP_CHARNGING_RESPONSE.getEncryptFlag(), encrypt, encrypt.length, deviceConnectionMsg.getIs18());
                 deviceConnectionMsg.getOutputStream().write(spliceing);
                 deviceConnectionMsg.getOutputStream().flush();
+                deviceConnectionMsg.incrementMessageCount();
+                return true;
             } catch (Exception e) {
-                e.printStackTrace();
+                return false;
             }
-            deviceConnectionMsg.incrementMessageCount();
-            return;
         }
 
         try {
             byte[] spliceing = FrameDataSplicing.spliceing(deviceConnectionMsg.getMessageCount(), DeviceSendYkc.STOP_CHARNGING_RESPONSE.getFrameType(), 0, params, params.length, deviceConnectionMsg.getIs18());
             deviceConnectionMsg.getOutputStream().write(spliceing);
             deviceConnectionMsg.getOutputStream().flush();
+            deviceConnectionMsg.incrementMessageCount();
+
+            return true;
+
         } catch (Exception e) {
             e.printStackTrace();
+            return false;
         }
-        deviceConnectionMsg.incrementMessageCount();
-
 
     }
     private byte[] endParams(String pileCode,int port,int result,int reson){

src/main/java/com/tmzn/devicelinkykc/frameMsg/frameType/TransactionFlowPushFrame.java

@@ -53,8 +53,24 @@ public class TransactionFlowPushFrame {
     @Autowired
     private TransOrderService transOrderService;
 
-    public byte[] sendTrans(DeviceConnectionMsg deviceConnectionMsg,byte[] transOrder, String pileCode, byte gunPort, long createTime, long endTime, BillingModel billingModel, byte[] card, Map<String, BigDecimal> map,int reason)  {
 
+    public byte[] makeTransParams(DeviceConnectionMsg deviceConnectionMsg,byte[] transOrder, String pileCode, byte gunPort, long createTime, long endTime, BillingModel billingModel, byte[] card, Map<String, BigDecimal> map,int reason){
+
+        //1.8 4档计费
+        if(deviceConnectionMsg.getIs18()){
+            return  params(transOrder, pileCode, gunPort, createTime, endTime, billingModel, card, map,reason);
+        }
+        if(billingModel.getDeepValleyPrice().compareTo(BigDecimal.ZERO)>0 || billingModel.getDeepValleyServiceFee().compareTo(BigDecimal.ZERO)>0){
+            //深谷5档计费
+            return  paramsSg(transOrder, pileCode, gunPort, createTime, endTime, billingModel, card, map,reason);
+        }
+        //1.6 4档计费
+        return params16(transOrder, pileCode, gunPort, createTime, endTime, billingModel, card, map,reason);
+
+    }
+
+
+    public byte[] sendTrans(DeviceConnectionMsg deviceConnectionMsg,byte[] transOrder, String pileCode, byte gunPort, long createTime, long endTime, BillingModel billingModel, byte[] card, Map<String, BigDecimal> map,int reason)  {
         if(deviceConnectionMsg.getIs18()){
             byte[] encrypt = new byte[0];
             // 缓存上报的订单,上报失败30秒重试,
@@ -65,38 +81,30 @@ public class TransactionFlowPushFrame {
                 transCheck.setTrans(params);
                 transCheck.setCheck_time(0);
                 transCheck.setTime(System.currentTimeMillis());
-
-                //log.info("sendTrans>订单上送>>>"+DataConversion.bytesToHexString(params));
-//                String key = redisCache.getCacheObject(RedisConstant.KEYS+deviceConnectionMsg.getDeviceId());
                 String key = redisCache.getCacheMapValue(RedisConstant.YKC_KEY_MAP,deviceConnectionMsg.getDeviceId());
-                log.info("key>{}订单消息加密密钥>>>"+key,deviceConnectionMsg.getDeviceId());
                 encrypt = Encrytion.aesEncrypt(params, key.getBytes());
                 log.info("msg>{}订单加密消息>>>"+DataConversion.bytesToHexString(encrypt),deviceConnectionMsg.getDeviceId());
             } catch (Exception e) {
-                log.info("pileCode:" + pileCode + " TransactionFlowPush params Exception");
+                log.info("pileCode:" + pileCode + " 消息组装异常"+e.getMessage());
                 e.printStackTrace();
-                return pileCode.getBytes();
+                return null;
             }
-            if (encrypt.length > 0) {
-                byte[] bytes = FrameDataSplicing.spliceing(deviceConnectionMsg.getMessageCount(), DeviceSendYkc.TRANSACTION_RECORDS_REQUEST.getFrameType(), DeviceSendYkc.TRANSACTION_RECORDS_REQUEST.getEncryptFlag(), encrypt, encrypt.length, deviceConnectionMsg.getIs18());
-                try {
-                    //outputStream..write(bytes)
-                    //log.info("bytes>上送订单加密消息>>>"+DataConversion.bytesToHexString(bytes));
-                    // log.info("bytes.length>上送订单加密length>>>"+bytes.length);
-                    deviceConnectionMsg.getOutputStream().write(bytes);
-                    deviceConnectionMsg.getOutputStream().flush();
-
-                    //只有发送了才将校验订单写到redis里
-                    redisCache.setCacheObject(RedisConstant.NO_RESPONSE_WAS_RECEIVED+pileCode,transCheck,6,TimeUnit.MINUTES);
-                } catch (IOException e) {
-                    log.info("pileCode:" + pileCode + " ,TransactionFlow push frame Exception");
-                    e.printStackTrace();
-                }
+            if(encrypt.length<=0){
+                log.info("pileCode:" + pileCode + " 消息组装异常");
+                return null;
+            }
+            byte[] bytes = FrameDataSplicing.spliceing(deviceConnectionMsg.getMessageCount(), DeviceSendYkc.TRANSACTION_RECORDS_REQUEST.getFrameType(), DeviceSendYkc.TRANSACTION_RECORDS_REQUEST.getEncryptFlag(), encrypt, encrypt.length, deviceConnectionMsg.getIs18());
+            try {
+                deviceConnectionMsg.getOutputStream().write(bytes);
+                deviceConnectionMsg.getOutputStream().flush();
                 deviceConnectionMsg.incrementMessageCount();
-            } else {
-                log.info("pileCode:" + pileCode + " transactionFlowPush params null");
+                return encrypt;
+                //只有发送了才将校验订单写到redis里
+            } catch (IOException e) {
+                log.info("pileCode:" + pileCode + " ,订单上报异常 push frame Exception"+e.getMessage());
+                e.printStackTrace();
+                return null;
             }
-            return encrypt;
         }
 
         //todo 深谷5档位模型
@@ -111,42 +119,25 @@ public class TransactionFlowPushFrame {
              params = params16(transOrder, pileCode, gunPort, createTime, endTime, billingModel, card, map,reason);
              frameType = DeviceSendYkc.TRANSACTION_RECORDS_REQUEST_16.getFrameType();
         }
-
         byte[] encrypt = new byte[0];
-        // 缓存上报的订单,上报失败30秒重试,
-        TransCheck transCheck = new TransCheck();
-        try {
-            //密钥变化这里存订单明文
-            transCheck.setTrans(params);
-            transCheck.setCheck_time(0);
-            transCheck.setTime(System.currentTimeMillis());
-            encrypt = params;
-        } catch (Exception e) {
-            log.info("pileCode:" + pileCode + " TransactionFlowPush params Exception");
-            e.printStackTrace();
-            return pileCode.getBytes();
+        encrypt = params;
+
+        if(encrypt.length<=0){
+            log.info("pileCode:" + pileCode + " 消息组装异常");
+            return null;
         }
-        if (encrypt.length > 0) {
-            byte[] bytes = FrameDataSplicing.spliceing(deviceConnectionMsg.getMessageCount(),frameType , 0, encrypt, encrypt.length, deviceConnectionMsg.getIs18());
-            try {
-                //outputStream..write(bytes)
-                //log.info("bytes>上送订单加密消息>>>"+DataConversion.bytesToHexString(bytes));
-                // log.info("bytes.length>上送订单加密length>>>"+bytes.length);
-                deviceConnectionMsg.getOutputStream().write(bytes);
-                deviceConnectionMsg.getOutputStream().flush();
-                //只有发送了才将校验订单写到redis里
-                redisCache.setCacheObject(RedisConstant.NO_RESPONSE_WAS_RECEIVED+pileCode,transCheck,6,TimeUnit.MINUTES);
-            } catch (IOException e) {
-                log.info("pileCode:" + pileCode + " ,TransactionFlow push frame Exception");
-                e.printStackTrace();
-            }
+        byte[] bytes = FrameDataSplicing.spliceing(deviceConnectionMsg.getMessageCount(),frameType , 0, encrypt, encrypt.length, deviceConnectionMsg.getIs18());
+        try {
+            deviceConnectionMsg.getOutputStream().write(bytes);
+            deviceConnectionMsg.getOutputStream().flush();
             deviceConnectionMsg.incrementMessageCount();
-        } else {
-            log.info("pileCode:" + pileCode + " transactionFlowPush params null");
+            return encrypt;
+            //只有发送了才将校验订单写到redis里
+        } catch (IOException e) {
+            log.info("pileCode:" + pileCode + " ,订单上报异常 push frame Exception"+e.getMessage());
+            e.printStackTrace();
+            return null;
         }
-        return encrypt;
-
-
     }
 
     public byte[] paramsSg(byte[] transOrder, String pileCode, byte gunPort, long createTime, long endTime, BillingModel billingModel, byte[] card, Map<String, BigDecimal> map,int reason) {
@@ -169,6 +160,8 @@ public class TransactionFlowPushFrame {
                 transOrderServiceOne.setFlatMoney(map.get("money3"));
                 transOrderServiceOne.setValleyElec(map.get("elec4"));
                 transOrderServiceOne.setValleyMoney(map.get("money4"));
+                transOrderServiceOne.setDeepValleyElec(map.get("elec5"));
+                transOrderServiceOne.setDeepValleyMoney(map.get("money5"));
                 transOrderServiceOne.setElec(map.get("elec"));
                 transOrderServiceOne.setMoney(map.get("money"));
                 transOrderServiceOne.setReasonStopCharging(reason);

src/main/java/com/tmzn/devicelinkykc/message/DeviceMsgHandle.java

@@ -3,11 +3,9 @@ package com.tmzn.devicelinkykc.message;
 import com.alibaba.fastjson2.JSONArray;
 import com.alibaba.fastjson2.JSONObject;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
-import com.sun.org.apache.bcel.internal.generic.IF_ACMPEQ;
 import com.tmzn.devicelinkykc.constant.DeviceOnlineStatus;
 import com.tmzn.devicelinkykc.constant.PortStatusConstant;
 import com.tmzn.devicelinkykc.constant.RedisConstant;
-import com.tmzn.devicelinkykc.constant.ykc.BillingModelConst;
 import com.tmzn.devicelinkykc.constant.ykc.StatusConstant;
 import com.tmzn.devicelinkykc.constant.ykc.TransConstant;
 import com.tmzn.devicelinkykc.entity.*;
@@ -18,7 +16,6 @@ import com.tmzn.devicelinkykc.frameMsg.frameType.CharngingPushFrame;
 import com.tmzn.devicelinkykc.frameMsg.frameType.LoginFrame;
 import com.tmzn.devicelinkykc.frameMsg.frameType.RealTimeStatusPushFrame;
 import com.tmzn.devicelinkykc.frameMsg.frameType.TransactionFlowPushFrame;
-import com.tmzn.devicelinkykc.msgEnum.DeviceSendYkc;
 import com.tmzn.devicelinkykc.openfeign.transdata.RpcResult;
 import com.tmzn.devicelinkykc.redis.RedisCache;
 import com.tmzn.devicelinkykc.service.*;
@@ -35,10 +32,7 @@ import org.springframework.stereotype.Component;
 import java.io.IOException;
 import java.math.BigDecimal;
 import java.util.*;
-import java.util.concurrent.Executors;
-import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
-import java.util.stream.Collectors;
 
 
 /**
@@ -85,8 +79,6 @@ public class DeviceMsgHandle {
 
     public void deviceMsg(String msg)  throws Exception{
         //必须过滤调非云快充设备
-
-
         //logger.info("redis中msg>>>" + msg);
         msg = msg.substring(1, msg.length() - 1);
         msg = msg.replace("\\", "");
@@ -94,9 +86,7 @@ public class DeviceMsgHandle {
 
         JSONObject jsonObject = null;
         try {
-
             jsonObject = JSONObject.parseObject(msg);
-
         } catch (Exception e) {
             //这里正常格式才走,不正常的格式不打印报错了;可能有其他格式的数据过来;正常要解析的数据是能走到JSON中的
             logger.info("device msg conversion exception not processed!!!" + msg);
@@ -107,40 +97,20 @@ public class DeviceMsgHandle {
         if (!redisCache.hasKey(RedisConstant.DEVICE_INFO)) {
             return;
         }
-
         Set<String> setImei = redisCache.getCacheObject(RedisConstant.DEVICE_INFO);
         String imei = jsonObject.getString("imei");
         if (!(imei != null && setImei.contains(imei))) {
             return;
         }
-/*        JSONArray data = jsonObject.getJSONArray("data");
-        Integer[] a = new Integer[data.size()];
-        for (int i = 0; i < data.size(); i++) {
-            a[i] = data.getIntValue(i);
-        }
-        List<Integer> ints = Arrays.asList(a);
-        if (ints.contains(113)) {
-            //特殊情况113,{"port":1,"paytype":1,"reason":1,"balance":0,"elec":52},
-            //113的位置
-            System.out.println("113index>" + ints.indexOf(113));
-            int port = a[ints.indexOf(113) + 1];
-            int paytype = a[ints.indexOf(113) + 2];
-            int reason = a[ints.indexOf(113) + 3];
-            int elec1 = a[ints.indexOf(113) + 7];
-            int elec12 = a[ints.indexOf(113) + 8] << 8;
-            int elec = elec1 + elec12;
-            String aaa = "{\"real_data\":{\"port\":" + port + ",\"paytype\":" + paytype + ",\"reason\":" + reason + ",\"balance\":0,\"elec\":" + elec + "},\"type\":113}";
-            JSONObject realdata = JSONObject.parseObject(aaa);
-            System.out.println(realdata);
-//            jsonObject.remove("real_data");
-//            jsonObject.put("real_data");
-            jsonObject = realdata;
-        }*/
         logger.info("msg>>>" + msg);
         //设备状态更新,true:没有type不是设备上送类型不往云快充处理 false:需要根据设备消息类型往下处理是不是需要上报云快充
-        if (checkDeviceStatus(jsonObject)) {
-            return;
+        try{
+            handleDeviceMsg(jsonObject);
+        }catch (Exception e){
+            logger.error("处理消息失败{},{}",imei,e.getMessage());
+            e.printStackTrace();
         }
+       
     }
 
     public void testMsg(String msg) throws Exception {
@@ -148,9 +118,7 @@ public class DeviceMsgHandle {
         JSONObject jsonObject = null;
         jsonObject = JSONObject.parseObject(msg);
         //设备状态更新,true:没有type不是设备上送类型不往云快充处理 false:需要根据设备消息类型往下处理是不是需要上报云快充
-        if (checkDeviceStatus(jsonObject)) {
-            return;
-        }
+        handleDeviceMsg(jsonObject);
     }
 
     private void checkActive(String s) {
@@ -169,7 +137,7 @@ public class DeviceMsgHandle {
 
     //处理离线消息
     //查找所有端口状态置为下线 并推送状态给云快充
-    private void _handleDeviceOfflineMsg(String imei){
+    private void handleOffline(String imei){
         QueryWrapper<DeviceStatus> deviceStatusQueryWrapper = new QueryWrapper<>();
         deviceStatusQueryWrapper.eq("device_imei", imei);
         List<DeviceStatus> list = deviceStatusService.list(deviceStatusQueryWrapper);
@@ -196,7 +164,7 @@ public class DeviceMsgHandle {
         }
     }
 
-    private boolean checkAutoStop(int power,String imei,int portId){
+    private void checkAutoStop(int power, String imei, int portId){
 
         try{
             String hkey = imei+"_"+portId;
@@ -214,7 +182,7 @@ public class DeviceMsgHandle {
             redisCache.setCacheMapValue(RedisConstant.POWER_ZERO_TIMES,hkey,lastPower0Times);
 
             if(lastPower0Times<5){
-                return true;
+                return;
             }
 
             //查找订单开始时间 如果开始时间过过2分钟 且连续power为0 就需要停止充电
@@ -222,23 +190,20 @@ public class DeviceMsgHandle {
             orderStatusQueryWrapper.eq("device_imei", imei).eq("guns_code", portId).orderByDesc("create_time").last("limit 1");
             OrderStatus one = orderStatusService.getOne(orderStatusQueryWrapper);
             if(one.getNowOrderStatus()!=StatusConstant.NOW_ORDER_STATUS_CHARGING){
-                return true;
+                return;
             }
             if((System.currentTimeMillis()- one.getCreateTime())<120*1000){
-                return true;
+                return;
             }
 
             //连续3次功率0 就要停止充电
             RpcResult rpcResult = deviceControlerService.stopCharge(imei, imei, (int) portId);
             logger.info("{}-{}触发无功率自停{}",imei,portId,lastPower0Times);
-            return true;
         }catch (Exception e){
             logger.error("无功率检测异常{}",e.getMessage());
             e.printStackTrace();
         }
 
-        return false;
-
 
     }
 
@@ -246,9 +211,8 @@ public class DeviceMsgHandle {
      * 设备状态按照设备上报和设备心跳上送时间校验修改,这里就必须更新状态的修改时间;通过定时任务判断在线设备接收心跳包超10分钟改为离线
      *
      * @param jsonObject
-     * @return
      */
-    private boolean checkDeviceStatus(JSONObject jsonObject) throws Exception {
+    private void handleDeviceMsg(JSONObject jsonObject) throws Exception {
         String imei = jsonObject.getString("imei");
         Integer cmd = jsonObject.getInteger("cmd");
         if (!jsonObject.containsKey("type")) {
@@ -256,60 +220,178 @@ public class DeviceMsgHandle {
             //没有type但是cmd指令是离线时37896=========
             if (cmd == 37896) {
                 //处理离线消息
-                _handleDeviceOfflineMsg(imei);
+                handleOffline(imei);
             }
-            return true;
+            return;
         }
 
         Integer type = jsonObject.getInteger("type");
 
         if(!NormalChargeConstant.CMD_SET_MAINBOARD.equals(cmd)){
-            logger.error("不支持的命令");
-            return true;
+//            logger.error("不支持的命令");
+            return;
         }
 
+        //端口状态
         if(NormalChargeConstant.KEY_PORT_DETAIL.equals(type)){
-            //103状态是带电压功率等信息的,所以需要对该信息进行处理操作
-            JSONObject data = jsonObject.getJSONObject("real_data");
-            Integer port_first_status = data.getInteger("port_first_status");
-            Integer port_second_status = data.getInteger("port_second_status");
-            Integer power = data.getInteger("power");
-            //功率为0时,还是充电中状态,将状态转换成空闲,结束充电
-//              20240608现场使用时出现充电状态第一次103上来就是power是0情况
-//                if (port_first_status != null&&power==0&&port_first_status==PortStatusConstant.CHARGING){
-//                    port_first_status=PortStatusConstant.FREE;
-//                }
-//                if (port_second_status != null&&power==0&&port_second_status==PortStatusConstant.CHARGING){
-//                    port_second_status=PortStatusConstant.FREE;
-//                }
-
-            //判断连续无功率就自动停止
-
-            redisCache.setCacheObject(RedisConstant.DEVICE_PORT_STATUS + imei, data, 15, TimeUnit.MINUTES);
-            if (port_first_status != null) {
-                if(port_first_status==PortStatusConstant.CHARGING){
-                    checkAutoStop(power,imei,1);
-                }
-                checkPort(port_first_status, 1, imei, type);
-            }
-            if (port_second_status != null) {
-                if(port_second_status==PortStatusConstant.CHARGING){
-                    checkAutoStop(power,imei,2);
-                }
-                checkPort(port_second_status, 2, imei, type);
-            }
-            return true;
+            handle103(jsonObject, imei, type);
+            return;
         }
 
         if (NormalChargeConstant.PORT_STATUS.equals(type)) {
             //116端口详情也会变化
             JSONArray data = jsonObject.getJSONArray("data");
             checkPort(data.getInteger(4), data.getInteger(3), imei, type);
-            return true;
+            return;
         }
 
-
+        //指定端口状态
         if (NormalChargeConstant.KEY_PORT_STATUS.equals(type)) {
+            handle101(jsonObject, imei, type);
+            return;
+        }
+
+        //104消息启动充电
+        if (NormalChargeConstant.KEY_STARTCHARGE.equals(type)) {
+            handle104(jsonObject, imei);
+            return;
+        }
+
+        //结束充电
+        if (NormalChargeConstant.KEY_END_NOTICE.equals(type)) {
+            handle113(jsonObject, imei);
+            return;
+        }
+
+        //TODO:设备状态的修改这里进行监听变化 ,??
+        // 1.设备消息cmd:75960设备上报消息是的命令,只要设备报的不是离线当做设备在线
+        // 2.设备上报指令后根据type类型来分类处理消息包括:设备设为在线 是否插枪状态 枪状态(端口状态)
+        if (NormalChargeConstant.EMERGENCY_STOP_CHARGING.equals(type)) {
+            handleEmergency(jsonObject,imei);
+            return;
+        }
+
+         if (NormalChargeConstant.REPORT_PORT_STATUS.equals(type)) {
+                //114设备主动上报
+            JSONArray data = jsonObject.getJSONArray("data");
+            Integer integer = data.getInteger(2);
+            if (integer > 5) {
+                //双枪
+                checkPort(data.getInteger(7), 1, imei, type);
+                checkPort(data.getInteger(8), 2, imei, type);
+            } else {
+                checkPort(data.getInteger(7), 1, imei, type);
+            }
+
+         }
+    }
+
+
+    //生产上根本进不来 不考虑 临时调试ykc上报急停状态
+    private void handleEmergency(JSONObject jsonObject, String imei) throws Exception {
+        //急停停充
+        JSONArray data = jsonObject.getJSONArray("data");
+        int port = data.getInteger(2);
+        int status = data.getInteger(3);
+        //关闭急停和急停完,停止充电,获取设备状态
+        DeviceParam dataParam = new DeviceParam();
+        dataParam.setDeviceId(imei);
+        dataParam.setCcid(imei);
+        deviceControlerService.sendPortDetailCmd(dataParam);
+        deviceControlerService.stopCharge(imei, imei, port);
+        //查询计费模板
+        QueryWrapper<BillingModel> billingModelQueryWrapper = new QueryWrapper<>();
+        billingModelQueryWrapper.eq("device_imei", imei);
+        BillingModel model = billingModelService.getOne(billingModelQueryWrapper);
+        QueryWrapper<OrderStatus> orderStatusQueryWrapper = new QueryWrapper<>();
+        orderStatusQueryWrapper.eq("device_imei", imei)
+                .eq("guns_code", port)
+                .orderByDesc("create_time"
+                ).last("limit 1");
+        OrderStatus statusServiceOne = orderStatusService.getOne(orderStatusQueryWrapper);
+        statusServiceOne.setEndTime(System.currentTimeMillis());
+        DeviceConnectionMsg deviceConnection = socketHandle.getDeviceConnection(statusServiceOne.getPileCode());
+        if (status == 1) {
+            logger.info(statusServiceOne.getPileCode() + ":急停停充>>>上报交易记录>>>");
+            byte[] encrypt = new byte[0];
+            if (port == 1) {
+                //急停停充:急停状态下:1.向设备发起结束充电,结算交易订单(交给结束充电处理;但是要考虑是急停的原因),2.上报的充电结束的订单式
+
+                Map<String, BigDecimal> map = transMoney.compute(1, model, statusServiceOne.getCreateTime(), statusServiceOne.getEndTime());
+
+                encrypt = transactionFlowPushFrame.sendTrans(deviceConnection, statusServiceOne.getTransOrder(), statusServiceOne.getPileCode(), (byte) 1, statusServiceOne.getCreateTime(), statusServiceOne.getEndTime(), model, statusServiceOne.getCard(), map, TransConstant.EMERGENCY_STOP_EXCEPTION_STOP);
+            } else if (port == 2) {
+                //TODO:这里还是模拟数据上报
+
+                Map<String, BigDecimal> map = transMoney.compute(2, model, statusServiceOne.getCreateTime(), statusServiceOne.getEndTime());
+                //模拟3.5千瓦
+                encrypt = transactionFlowPushFrame.sendTrans(deviceConnection, statusServiceOne.getTransOrder(), statusServiceOne.getPileCode(), (byte) 2, statusServiceOne.getCreateTime(), statusServiceOne.getEndTime(), model, statusServiceOne.getCard(), map, TransConstant.EMERGENCY_STOP_EXCEPTION_STOP);
+            }
+            statusServiceOne.setOriginalText(encrypt);
+            statusServiceOne.setReasonStopCharging(TransConstant.EMERGENCY_STOP_EXCEPTION_STOP);
+            statusServiceOne.setStopChargingReply(StatusConstant.STOP_CHARGING_REPLY_OK);
+            statusServiceOne.setNowOrderStatus(StatusConstant.NOW_ORDER_STATUS_CHARGING_ENDING);
+            statusServiceOne.setTransactionOrderReportingActionStatus(StatusConstant.TRANSACTION_ORDER_REPORTING_ACTION_STATUS_OK);
+            orderStatusService.updateById(statusServiceOne);
+        }
+    }
+
+    //启动充电
+    private void handle104(JSONObject jsonObject, String imei){
+        //开启充电设备上报结果
+        JSONObject data = jsonObject.getJSONObject("real_data");
+        Integer result = data.getInteger("result");
+        Integer port = data.getInteger("port");
+
+        QueryWrapper<OrderStatus> orderStatusQueryWrapper = new QueryWrapper<>();
+        orderStatusQueryWrapper.eq("device_imei", imei).eq("guns_code", port).orderByDesc("create_time").last("limit 1");
+        OrderStatus statusServiceOne = orderStatusService.getOne(orderStatusQueryWrapper);
+        byte[] bytes = statusServiceOne.getTransOrder();
+        logger.info(statusServiceOne.getPileCode() + ":设备开启充电流水号:" + DataConversion.bytesToHexString(bytes));
+        DeviceConnectionMsg deviceConnection = socketHandle.getDeviceConnection(statusServiceOne.getPileCode());
+        int reson = 0x00;
+        if (result == 0x01) {
+            //启充成功上报充电开启成功
+            charngingPushFrame.startStatus(deviceConnection, bytes, port, result, 0x00);
+            logger.info("上报启动充电成功{},{}",statusServiceOne.getId(),statusServiceOne.getPileCode());
+        } else {
+            //启机不成功,根据设备状态判断,并且要结束充电并上报订单
+            String cacheKey;
+            if(port==1){
+                cacheKey = RedisConstant.ONLINE_DEVICE_ONE;
+            }else{
+                cacheKey = RedisConstant.ONLINE_DEVICE_TWO;
+            }
+            if (redisCache.hasKey(cacheKey)) {
+                DeviceStatus oneStatus = redisCache.getCacheMapValue(cacheKey, statusServiceOne.getPileCode());
+                if (StatusConstant.FAULT == oneStatus.getGunStatus()) {
+                    reson = 0x03;
+                } else if (StatusConstant.OFFLINE == oneStatus.getGunStatus()) {
+                    reson = 0x04;
+                } else if (StatusConstant.CHARGING == oneStatus.getGunStatus()) {
+                    reson = 0x02;
+                }
+                charngingPushFrame.startStatus(deviceConnection, bytes, port, result, reson);
+                logger.info("上报启动充电失败{},{}",statusServiceOne.getId(),statusServiceOne.getPileCode());
+            }
+        }
+        new Thread(() -> {
+            try {
+                Thread.sleep(5000); // 延迟 5 秒
+                DeviceParam dataParam = new DeviceParam();
+                dataParam.setDeviceId(imei);
+                dataParam.setCcid(imei);
+                deviceControlerService.sendPortDetailCmd(dataParam);
+                logger.info(statusServiceOne.getPileCode() + ":延迟主动下发103消息"+imei);
+            } catch (Exception e) {
+                logger.info(statusServiceOne.getPileCode() + ":延迟主动下发103消息异常" + e.getMessage()+imei);
+            }
+        }).start();
+    }
+
+    //单个端口状态
+    private void handle101(JSONObject jsonObject, String imei, int type) {
+        try{
             //状态查询101
             JSONObject data = jsonObject.getJSONObject("real_data");
             Integer port_first_status = data.getInteger("port_first_status");
@@ -320,263 +402,137 @@ public class DeviceMsgHandle {
             if (port_second_status != null) {
                 checkPort(port_second_status, 2, imei, type);
             }
-            return true;
+        }catch (Exception e){
+            logger.info("处理101失败{}",imei);
         }
 
-        //104消息
-        if (NormalChargeConstant.KEY_STARTCHARGE.equals(type)) {
-            //开启充电设备上报结果
-            JSONObject data = jsonObject.getJSONObject("real_data");
-            Integer result = data.getInteger("result");
-            Integer port = data.getInteger("port");
-            //TODO：上报云快充启动充电结果
-//                QueryWrapper<OrderStatus> orderStatusQueryWrapper = new QueryWrapper<>();
-//                orderStatusQueryWrapper.eq("imei",imei).eq("guns_code",port);
-//                OrderStatus one = orderStatusService.getOne(orderStatusQueryWrapper);
-//                List<OrderStatus> collect = orderStatuses.stream().filter(orderStatus -> orderStatus.getGunsCode() == port).collect(Collectors.toList());
-//                OrderStatus one = new OrderStatus();
-//                if (collect.size()>0){
-//                    one=collect.get(0);
-//                } else {
-//                    logger.info("开启充电未查到设备订单");
-//                    return false;
+    }
+
+    private void handle103(JSONObject jsonObject, String imei, int type) throws Exception {
+        //103状态是带电压功率等信息的,所以需要对该信息进行处理操作
+        JSONObject data = jsonObject.getJSONObject("real_data");
+        Integer port_first_status = data.getInteger("port_first_status");
+        Integer port_second_status = data.getInteger("port_second_status");
+        Integer power = data.getInteger("power");
+        //功率为0时,还是充电中状态,将状态转换成空闲,结束充电
+//              20240608现场使用时出现充电状态第一次103上来就是power是0情况
+//                if (port_first_status != null&&power==0&&port_first_status==PortStatusConstant.CHARGING){
+//                    port_first_status=PortStatusConstant.FREE;
+//                }
+//                if (port_second_status != null&&power==0&&port_second_status==PortStatusConstant.CHARGING){
+//                    port_second_status=PortStatusConstant.FREE;
 //                }
-            QueryWrapper<OrderStatus> orderStatusQueryWrapper = new QueryWrapper<>();
-            orderStatusQueryWrapper.eq("device_imei", imei).eq("guns_code", port).orderByDesc("create_time").last("limit 1");
-            OrderStatus statusServiceOne = orderStatusService.getOne(orderStatusQueryWrapper);
-            byte[] bytes = statusServiceOne.getTransOrder();
-            logger.info(statusServiceOne.getPileCode() + ":设备开启充电流水号:" + DataConversion.bytesToHexString(bytes));
-            DeviceConnectionMsg deviceConnection = socketHandle.getDeviceConnection(statusServiceOne.getPileCode());
-            int reson = 0x00;
-            if (result == 0x01) {
-                //启充成功上报充电开启成功
-                charngingPushFrame.startStatus(deviceConnection, bytes, port, result, 0x00);
 
-            } else {
-                //启机不成功,根据设备状态判断,并且要结束充电并上报订单
-                if (port == 1) {
-                    if (redisCache.hasKey(RedisConstant.ONLINE_DEVICE_ONE)) {
-                        DeviceStatus oneStatus = redisCache.getCacheMapValue(RedisConstant.ONLINE_DEVICE_ONE, statusServiceOne.getPileCode());
-                        if (StatusConstant.FAULT == oneStatus.getGunStatus()) {
-                            reson = 0x03;
-                        } else if (StatusConstant.OFFLINE == oneStatus.getGunStatus()) {
-                            reson = 0x04;
-                        } else if (StatusConstant.CHARGING == oneStatus.getGunStatus()) {
-                            reson = 0x02;
-                        }
-                        charngingPushFrame.startStatus(deviceConnection, bytes, port, result, reson);
-                    }
-                } else if (port == 2) {
-                    if (redisCache.hasKey(RedisConstant.ONLINE_DEVICE_TWO)) {
-                        DeviceStatus oneStatus = redisCache.getCacheMapValue(RedisConstant.ONLINE_DEVICE_TWO, statusServiceOne.getPileCode());
-                        if (StatusConstant.FAULT == oneStatus.getGunStatus()) {
-                            reson = 0x03;
-                        } else if (StatusConstant.OFFLINE == oneStatus.getGunStatus()) {
-                            reson = 0x04;
-                        } else if (StatusConstant.CHARGING == oneStatus.getGunStatus()) {
-                            reson = 0x02;
-                        }
-                        charngingPushFrame.startStatus(deviceConnection, bytes, port, result, reson);
-                    }
-                }
-            }
+        //判断连续无功率就自动停止
 
-            new Thread(() -> {
-                try {
-                    Thread.sleep(5000); // 延迟 5 秒
-                    DeviceParam dataParam = new DeviceParam();
-                    dataParam.setDeviceId(imei);
-                    dataParam.setCcid(imei);
-                    deviceControlerService.sendPortDetailCmd(dataParam);
-                    logger.info(statusServiceOne.getPileCode() + ":延迟主动下发103消息"+imei);
-                } catch (Exception e) {
-                    logger.info(statusServiceOne.getPileCode() + ":延迟主动下发103消息异常" + e.getMessage()+imei);
-                }
-            }).start();
-
-
-//            //发送一条103消息 等待状态上报
-//            try{
-//                DeviceParam dataParam = new DeviceParam();
-//                dataParam.setDeviceId(imei);
-//                dataParam.setCcid(imei);
-//                deviceControlerService.sendPortDetailCmd(dataParam);
-//                logger.info(statusServiceOne.getPileCode() + ":主动下发103消息");
-//            }catch (Exception e){
-//                logger.info(statusServiceOne.getPileCode() + ":主动下发103消息异常"+e.getMessage());
-//            }
-//            return true;
+        redisCache.setCacheObject(RedisConstant.DEVICE_PORT_STATUS + imei, data, 15, TimeUnit.MINUTES);
+        if (port_first_status != null) {
+            if(port_first_status==PortStatusConstant.CHARGING){
+                checkAutoStop(power,imei,1);
+            }
+            checkPort(port_first_status, 1, imei, type);
+        }
+        if (port_second_status != null) {
+            if(port_second_status==PortStatusConstant.CHARGING){
+                checkAutoStop(power,imei,2);
+            }
+            checkPort(port_second_status, 2, imei, type);
         }
 
-        if (NormalChargeConstant.KEY_END_NOTICE.equals(type)) {
-            //停止充电通知触发情况:1.急停,收到停充时主动要去发停充,所以这里不能处理急停的交易订单;2.手动停充,正常的远程停止指令
-            // 1.设备已经在接收到云快充指令的时候进行了停充操作,2.结算订单,上报云快充停止回复
+    }
 
-            try {
 
-                JSONObject data = jsonObject.getJSONObject("real_data");
-                logger.info("{}接收到设备上送113停止充电msg>>" + jsonObject.toString(),imei);
-                int port = data.getIntValue("port");
-                byte reson = data.getByte("reason");
-                QueryWrapper<OrderStatus> orderStatusQueryWrapper = new QueryWrapper<>();
-                orderStatusQueryWrapper.eq("device_imei", imei).eq("guns_code", port).orderByDesc("create_time").last("limit 1");
-                OrderStatus statusServiceOne = orderStatusService.getOne(orderStatusQueryWrapper);
-                if (statusServiceOne.getReasonStopCharging() != TransConstant.APP_REMOTE_STOP) {
-                    //不是远程停止的 就给设备发送消息获取端口状态
-                    DeviceParam dataParam = new DeviceParam();
-                    dataParam.setDeviceId(imei);
-                    dataParam.setCcid(imei);
-                    deviceControlerService.sendPortDetailCmd(dataParam);
-                    return false;
-                }
-                if (statusServiceOne.getTransactionOrderReportingActionStatus()==StatusConstant.TRANSACTION_ORDER_REPORTING_ACTION_STATUS_OK){
-                    //如果已上报停止状态就不再上报
-                    return false;
-                }
-                //远程停止
-                //查询计费模板
-                QueryWrapper<BillingModel> billingModelQueryWrapper = new QueryWrapper<>();
-                billingModelQueryWrapper.eq("device_imei", imei);
-                BillingModel model = billingModelService.getOne(billingModelQueryWrapper);
-                //收到停充回复
-                DeviceConnectionMsg deviceConnection = socketHandle.getDeviceConnection(statusServiceOne.getPileCode());
-                if (reson == 0x01) {
+    //处理停止充电情况
+    private void handle113(JSONObject jsonObject, String imei){
+        //停止充电通知触发情况:1.急停,收到停充时主动要去发停充,所以这里不能处理急停的交易订单;2.手动停充,正常的远程停止指令
+        // 1.设备已经在接收到云快充指令的时候进行了停充操作,2.结算订单,上报云快充停止回复
+        try {
+            JSONObject data = jsonObject.getJSONObject("real_data");
+            logger.info("{}接收到设备上送113停止充电msg>>" + jsonObject.toString(),imei);
+            int port = data.getIntValue("port");
+            byte reson = data.getByte("reason");
+            QueryWrapper<OrderStatus> orderStatusQueryWrapper = new QueryWrapper<>();
+            orderStatusQueryWrapper.eq("device_imei", imei).eq("guns_code", port).orderByDesc("create_time").last("limit 1");
+            OrderStatus statusServiceOne = orderStatusService.getOne(orderStatusQueryWrapper);
+            if(statusServiceOne==null){
+                logger.info("没有待处理订单{}",imei);
+                return;
+            }
+
+            if(statusServiceOne.getTransactionOrderReplyStatus() == StatusConstant.TRANSACTION_ORDER_REPLY_STATUS_SUCC){
+                logger.info("订单状态已上报成功{},id:{}",imei,statusServiceOne.getId());
+                return;
+            }
+
+            //如果是用户手动停止充电 则不处理状态
+            if(statusServiceOne.getReasonStopCharging()==TransConstant.APP_REMOTE_STOP){
+                logger.info(statusServiceOne.getPileCode() + ":云快充>>>>>>远程停充>>>>");
+            }else{
+                //不处理急停
+                if(reson == 0x01){
                     logger.info(statusServiceOne.getPileCode() + ":用户主动停充>>>>>>停充>>>>");
-                    //用户主动停止充电
-                    if (redisCache.hasKey(RedisConstant.DEVICE_PORT_STATUS + imei)) {
-                        //拿缓存的103状态看现在的端口状态是急停不处理113停止充电
-                        JSONObject dataJson = redisCache.getCacheObject(RedisConstant.DEVICE_PORT_STATUS + imei);
-                        Integer port_first_status = dataJson.getInteger("port_first_status");
-                        Integer port_second_status = dataJson.getInteger("port_second_status");
-                        if (port_first_status == PortStatusConstant.EMERGENCY_STOP || port_second_status == PortStatusConstant.EMERGENCY_STOP) {
-                            return false;
-                        }
-                    }
-                    if (statusServiceOne.getReasonStopCharging() == TransConstant.EMERGENCY_STOP_EXCEPTION_STOP || statusServiceOne.getStopChargingReply() == 1) {
-                        //1.急停停充的逻辑不处理停止充电记录  2.一个订单多次停止也不再次上报 3.充满不拔枪113结束通知会延迟所以充满时已经处理过交易上送
-                        return false;
-                    }
-                    //113进到这里说明需要记录结束时间(最优时间,尽量能让后台计费的103或113落库)
-                    statusServiceOne.setEndTime(System.currentTimeMillis());
-                    byte[] encrypt = new byte[0];
-                    //订单充电结束但是原因是0的一般是当手动停充处理
-                    if (statusServiceOne.getReasonStopCharging() == 0) {
-                        statusServiceOne.setReasonStopCharging(TransConstant.MANUAL_STOP);
-                    }
-                    ////计算电量费用后上报,手动停止和余额不足的情况
-                    // DeviceStatus deviceStatus = redisCache.getCacheMapValue(RedisConstant.ONLINE_DEVICE_ONE, statusServiceOne.getPileCode());
-                    Map<String, BigDecimal> map = transMoney.compute(port, model, statusServiceOne.getCreateTime(), statusServiceOne.getEndTime());
-                    logger.info(statusServiceOne.getPileCode() + ":停止充电上送交易记录" + DataConversion.bytesToHexString(statusServiceOne.getTransOrder()));
-                    encrypt = transactionFlowPushFrame.sendTrans(deviceConnection, statusServiceOne.getTransOrder(), statusServiceOne.getPileCode(), (byte) 1, statusServiceOne.getCreateTime(), statusServiceOne.getEndTime(), model, statusServiceOne.getCard(), map, statusServiceOne.getReasonStopCharging());
-                    statusServiceOne.setOriginalText(encrypt);
-                    statusServiceOne.setStopChargingReply(StatusConstant.STOP_CHARGING_REPLY_OK);
-                    statusServiceOne.setNowOrderStatus(StatusConstant.NOW_ORDER_STATUS_CHARGING_ENDING);
-                    statusServiceOne.setTransactionOrderReportingActionStatus(StatusConstant.TRANSACTION_ORDER_REPORTING_ACTION_STATUS_OK);
-                    //statusServiceOne.setEndTime(endTime);
-                    orderStatusService.updateById(statusServiceOne);
-                    charngingPushFrame.endStatus(deviceConnection, port, 0x01, 0x00);
-                } else if (reson == 0x00) {
-                    //余额用完停充
+                    statusServiceOne.setReasonStopCharging(TransConstant.APP_REMOTE_STOP);
+                }else if(reson==0x00){
                     logger.info(statusServiceOne.getPileCode() + ":设备余额不足>>>>>>停充>>>>");
-                    DeviceParam deviceParam = new DeviceParam();
-                    deviceParam.setDeviceId(statusServiceOne.getDeviceImei());
-                    deviceParam.setCcid(statusServiceOne.getDeviceImei());
-                    //deviceControlerService.sendPortDetailCmd(deviceParam);
-                    //deviceControlerService.stopCharge(statusServiceOne.getDeviceImei(), statusServiceOne.getDeviceImei(), 1);
-                    statusServiceOne.setEndTime(System.currentTimeMillis());
-                    byte[] encrypt = new byte[0];
                     statusServiceOne.setReasonStopCharging(TransConstant.INSUFFICIENT_BALANCE_EXCEPTION_STOP);
-                    //计算电量
-                    Map<String, BigDecimal> map = transMoney.compute(port, model, statusServiceOne.getCreateTime(), statusServiceOne.getEndTime());
-                    logger.info(statusServiceOne.getPileCode() + ":余额用完充电上送交易记录" + DataConversion.bytesToHexString(statusServiceOne.getTransOrder()));
-                    encrypt = transactionFlowPushFrame.sendTrans(deviceConnection, statusServiceOne.getTransOrder(), statusServiceOne.getPileCode(), (byte) 2, statusServiceOne.getCreateTime(), statusServiceOne.getEndTime(), model, statusServiceOne.getCard(), map, statusServiceOne.getReasonStopCharging());
-                    statusServiceOne.setOriginalText(encrypt);
-                    statusServiceOne.setStopChargingReply(StatusConstant.STOP_CHARGING_REPLY_OK);
-                    statusServiceOne.setNowOrderStatus(StatusConstant.NOW_ORDER_STATUS_CHARGING_ENDING);
-                    statusServiceOne.setTransactionOrderReportingActionStatus(StatusConstant.TRANSACTION_ORDER_REPORTING_ACTION_STATUS_OK);
-                    orderStatusService.updateById(statusServiceOne);
-                    //return false;
+                }else if(reson == 0x03){
+                    logger.info(statusServiceOne.getPileCode() + ":设备充电充满>>>>>>停充>>>>");
+                    statusServiceOne.setReasonStopCharging(TransConstant.SOC_FULL_OF_STOP);
+                }else{
+                    logger.info(statusServiceOne.getPileCode() + ":设备充电停止>>>>其他>>>");
+                    statusServiceOne.setReasonStopCharging(TransConstant.OTHER_STOP);
                 }
-                //deviceControlerService.reset(imei, imei);
-                DeviceParam dataParam = new DeviceParam();
-                dataParam.setDeviceId(imei);
-                dataParam.setCcid(imei);
-                deviceControlerService.sendPortDetailCmd(dataParam);
-            } catch (Exception e) {
-                //TODO:测试不上传订单,报个空闲设备状态
-                DeviceConnectionMsg deviceConnection = socketHandle.getDeviceConnection(imei);
-                realTimeStatusPushFrame.deviceStatusPush(deviceConnection, FrameDataSplicing.transactionNum(deviceConnection.getDeviceId(), deviceConnection.getMessageCount()), deviceConnection.getDeviceId(), (byte) 1, StatusConstant.FREE, StatusConstant.CHARGING_INIT_STATUS_OK, 0, 0, zero, zero, 0);
-                e.printStackTrace();
             }
-            return true;
-        }
 
-        //TODO:设备状态的修改这里进行监听变化 ,??
-        // 1.设备消息cmd:75960设备上报消息是的命令,只要设备报的不是离线当做设备在线
-        // 2.设备上报指令后根据type类型来分类处理消息包括:设备设为在线 是否插枪状态 枪状态(端口状态)
-        if (NormalChargeConstant.EMERGENCY_STOP_CHARGING.equals(type)) {
-            //急停停充
-            JSONArray data = jsonObject.getJSONArray("data");
-            int port = data.getInteger(2);
-            int status = data.getInteger(3);
-            //关闭急停和急停完,停止充电,获取设备状态
-            DeviceParam dataParam = new DeviceParam();
-            dataParam.setDeviceId(imei);
-            dataParam.setCcid(imei);
-            deviceControlerService.sendPortDetailCmd(dataParam);
-            deviceControlerService.stopCharge(imei, imei, port);
-            //查询计费模板
-            QueryWrapper<BillingModel> billingModelQueryWrapper = new QueryWrapper<>();
-            billingModelQueryWrapper.eq("device_imei", imei);
-            BillingModel model = billingModelService.getOne(billingModelQueryWrapper);
-            QueryWrapper<OrderStatus> orderStatusQueryWrapper = new QueryWrapper<>();
-            orderStatusQueryWrapper.eq("device_imei", imei)
-                    .eq("guns_code", port)
-                    .orderByDesc("create_time"
-                    ).last("limit 1");
-            OrderStatus statusServiceOne = orderStatusService.getOne(orderStatusQueryWrapper);
+            //设置订单已停止充电和结束时间
             statusServiceOne.setEndTime(System.currentTimeMillis());
+            statusServiceOne.setNowOrderStatus(StatusConstant.NOW_ORDER_STATUS_CHARGING_ENDING);
             DeviceConnectionMsg deviceConnection = socketHandle.getDeviceConnection(statusServiceOne.getPileCode());
-            if (status == 1) {
-                logger.info(statusServiceOne.getPileCode() + ":急停停充>>>上报交易记录>>>");
-                byte[] encrypt = new byte[0];
-                if (port == 1) {
-                    //急停停充:急停状态下:1.向设备发起结束充电,结算交易订单(交给结束充电处理;但是要考虑是急停的原因),2.上报的充电结束的订单式
 
-                    Map<String, BigDecimal> map = transMoney.compute(1, model, statusServiceOne.getCreateTime(), statusServiceOne.getEndTime());
+            if(deviceConnection==null || deviceConnection.getLoginStatus()!=1){
+                //未上报
+                statusServiceOne.setTransactionOrderReportingActionStatus(StatusConstant.TRANSACTION_ORDER_REPORTING_ACTION_STATUS_NO);
+                logger.info("socket 未连接 需要重新上报异常上报{}",statusServiceOne.getPileCode());
+                orderStatusService.updateById(statusServiceOne);
+                return;
+            }
 
-                    encrypt = transactionFlowPushFrame.sendTrans(deviceConnection, statusServiceOne.getTransOrder(), statusServiceOne.getPileCode(), (byte) 1, statusServiceOne.getCreateTime(), statusServiceOne.getEndTime(), model, statusServiceOne.getCard(), map, TransConstant.EMERGENCY_STOP_EXCEPTION_STOP);
-                } else if (port == 2) {
-                    //TODO:这里还是模拟数据上报
+            byte[] encrypt = new byte[0];
+            //查询计费模板
+            QueryWrapper<BillingModel> billingModelQueryWrapper = new QueryWrapper<>();
+            billingModelQueryWrapper.eq("device_imei", imei);
+            BillingModel model = billingModelService.getOne(billingModelQueryWrapper);
+            Map<String, BigDecimal> map = transMoney.compute(port, model, statusServiceOne.getCreateTime(), statusServiceOne.getEndTime());
+            logger.info(statusServiceOne.getPileCode() + "计算电费" + DataConversion.bytesToHexString(statusServiceOne.getTransOrder()));
+            encrypt = transactionFlowPushFrame.sendTrans(deviceConnection, statusServiceOne.getTransOrder(), statusServiceOne.getPileCode(), statusServiceOne.getGunsCode(), statusServiceOne.getCreateTime(), statusServiceOne.getEndTime(), model, statusServiceOne.getCard(), map, statusServiceOne.getReasonStopCharging());
 
-                    Map<String, BigDecimal> map = transMoney.compute(2, model, statusServiceOne.getCreateTime(), statusServiceOne.getEndTime());
-                    //模拟3.5千瓦
-                    encrypt = transactionFlowPushFrame.sendTrans(deviceConnection, statusServiceOne.getTransOrder(), statusServiceOne.getPileCode(), (byte) 2, statusServiceOne.getCreateTime(), statusServiceOne.getEndTime(), model, statusServiceOne.getCard(), map, TransConstant.EMERGENCY_STOP_EXCEPTION_STOP);
-                }
+            if(encrypt==null || encrypt.length<=0){
+                return;
+            }else{
+                statusServiceOne.setTransactionOrderReportingActionStatus(StatusConstant.TRANSACTION_ORDER_REPORTING_ACTION_STATUS_OK);
                 statusServiceOne.setOriginalText(encrypt);
-                statusServiceOne.setReasonStopCharging(TransConstant.EMERGENCY_STOP_EXCEPTION_STOP);
+            }
+            boolean res =charngingPushFrame.endStatus(deviceConnection, port, 0x01, 0x00);
+            if(res){
+                //更新远程停止充电
+                logger.info("停止充电回复成功{}",imei);
                 statusServiceOne.setStopChargingReply(StatusConstant.STOP_CHARGING_REPLY_OK);
-                statusServiceOne.setNowOrderStatus(StatusConstant.NOW_ORDER_STATUS_CHARGING_ENDING);
-                statusServiceOne.setTransactionOrderReportingActionStatus(StatusConstant.TRANSACTION_ORDER_REPORTING_ACTION_STATUS_OK);
-                orderStatusService.updateById(statusServiceOne);
+            }else{
+                logger.info("停止充电回复失败{}",imei);
             }
-            return true;
-        }
+            orderStatusService.updateById(statusServiceOne);
 
-         if (NormalChargeConstant.REPORT_PORT_STATUS.equals(type)) {
-                //114设备主动上报
-                JSONArray data = jsonObject.getJSONArray("data");
-                Integer integer = data.getInteger(2);
-                if (integer > 5) {
-                    //双枪
-                    checkPort(data.getInteger(7), 1, imei, type);
-                    checkPort(data.getInteger(8), 2, imei, type);
-                } else {
-                    checkPort(data.getInteger(7), 1, imei, type);
-                }
-
-            }
-        return false;
+            //获取一设备状态
+            DeviceParam dataParam = new DeviceParam();
+            dataParam.setDeviceId(imei);
+            dataParam.setCcid(imei);
+            deviceControlerService.sendPortDetailCmd(dataParam);
+        } catch (Exception e) {
+            logger.info("{}处理113消息异常{}",imei,e.getMessage());
+//            DeviceConnectionMsg deviceConnection = socketHandle.getDeviceConnection(imei);
+//            realTimeStatusPushFrame.deviceStatusPush(deviceConnection, FrameDataSplicing.transactionNum(deviceConnection.getDeviceId(), deviceConnection.getMessageCount()), deviceConnection.getDeviceId(), (byte) 1, StatusConstant.FREE, StatusConstant.CHARGING_INIT_STATUS_OK, 0, 0, zero, zero, 0);
+            e.printStackTrace();
+        }
     }
 
     /**

src/main/java/com/tmzn/devicelinkykc/message/YkcMsgHandle.java

@@ -189,6 +189,7 @@ public class YkcMsgHandle {
 
                     if (reason[0] == 0x00) {
                         one.setTransactionOrderReplyStatus(StatusConstant.TRANSACTION_ORDER_REPLY_STATUS_SUCC);
+
                         transOrderServiceOne.setFlage(StatusConstant.TRANSACTION_ORDER_REPLY_STATUS_SUCC);
                     } else if (reason[0] == 0x01) {
                         one.setTransactionOrderReplyStatus(StatusConstant.TRANSACTION_ORDER_REPLY_STATUS_FAIL);
@@ -196,7 +197,6 @@ public class YkcMsgHandle {
                         one.setTransactionOrderReplyStatus(StatusConstant.TRANSACTION_ORDER_REPLY_STATUS_ILLEGAL);
                     }
                     //接收到后将订单校验从redis剔除
-                    redisCache.deleteObject(RedisConstant.NO_RESPONSE_WAS_RECEIVED + one.getPileCode());
                     orderStatusService.updateById(one);
                     transOrderService.updateById(transOrderServiceOne);
                 } else if (framType == YkcSendDevice.DEVICE_STATUS_REQUEST.getFrameType()) {
@@ -452,26 +452,12 @@ public class YkcMsgHandle {
             statusServiceOne.setEndTime(System.currentTimeMillis());
             statusServiceOne.setReasonStopCharging(TransConstant.APP_REMOTE_STOP);
             orderStatusService.updateById(statusServiceOne);
-            if (guns[0] == 1) {
-                if (redisCache.hasKey(RedisConstant.ONLINE_DEVICE_ONE)) {
-                    DeviceStatus ds = redisCache.getCacheMapValue(RedisConstant.ONLINE_DEVICE_ONE, deviceStatus.getPileCode());
-                    if (ds != null) {
-                        redisCache.deleteCacheMapValue(RedisConstant.ONLINE_DEVICE_ONE, deviceStatus.getPileCode());
-                    }
-                }
-            } else if (guns[0] == 2) {
-                if (redisCache.hasKey(RedisConstant.ONLINE_DEVICE_TWO)) {
-                    DeviceStatus ds = redisCache.getCacheMapValue(RedisConstant.ONLINE_DEVICE_TWO, deviceStatus.getPileCode());
-                    if (ds != null) {
-                        redisCache.deleteCacheMapValue(RedisConstant.ONLINE_DEVICE_TWO, deviceStatus.getPileCode());
-                    }
-                }
-            }
+
             redisCache.setCacheMapValue(guns[0] == 1 ? RedisConstant.ONLINE_DEVICE_ONE : RedisConstant.ONLINE_DEVICE_TWO, deviceStatus.getPileCode(), deviceStatus);
         } else {
             logger.info("stop charging  device:" + deviceStatus.getDeviceSn() + ";port:" + guns[0] + "stop charnging fail");
         }
-        //发出结束充电指令
+        //获取端口状态
         DeviceParam deviceParam = new DeviceParam();
         deviceParam.setDeviceId(deviceStatus.getDeviceImei());
         deviceParam.setCcid(deviceStatus.getDeviceImei());