rfid修改

增加重置球机垂直方向

web/pom.xml

@@ -85,6 +85,35 @@
             <scope>system</scope>
             <systemPath>${project.basedir}/src/main/resources/libs/rxtx-2.1.7.jar</systemPath>
         </dependency>
+
+        <dependency>
+            <groupId>com</groupId>
+            <artifactId>javaRFID-helloworld</artifactId>
+            <version>1.0</version>
+            <scope>system</scope>
+            <systemPath>${project.basedir}/src/main/resources/libs/javaRFID-helloworld.jar</systemPath>
+        </dependency>
+        <dependency>
+            <groupId>com.payne.connect</groupId>
+            <artifactId>payne</artifactId>
+            <version>1.0</version>
+            <scope>system</scope>
+            <systemPath>${project.basedir}/src/main/resources/libs/connect-lib.jar</systemPath>
+        </dependency>
+        <dependency>
+            <groupId>com.payne.reader</groupId>
+            <artifactId>payneReader</artifactId>
+            <version>1.0</version>
+            <scope>system</scope>
+            <systemPath>${project.basedir}/src/main/resources/libs/lib_reader.jar</systemPath>
+        </dependency>
+        <dependency>
+            <groupId>gnu.io</groupId>
+            <artifactId>rxtxcomm</artifactId>
+            <version>1.0</version>
+            <scope>system</scope>
+            <systemPath>${project.basedir}/src/main/resources/libs/RXTXcomm.jar</systemPath>
+        </dependency>
     </dependencies>
 
     <build>

web/src/main/java/com/zhehekeji/web/lib/CameraControlModule.java

@@ -1,5 +1,7 @@
 package com.zhehekeji.web.lib;
 
+import com.zhehekeji.web.pojo.CameraPtzPojo;
+
 import java.time.LocalDateTime;
 
 public interface CameraControlModule {
@@ -34,6 +36,7 @@ public interface CameraControlModule {
 
     boolean ptzControlRightEnd(Integer cameraId, int nChannelID);
 
+    CameraPtzPojo ptzGetDVRConfig(Integer    cameraId);
     /**
      * 向左上
      */

web/src/main/java/com/zhehekeji/web/lib/hik/HCNetSDK.java

@@ -3134,6 +3134,11 @@ DVR实现巡航数据结构
         public  short wPanPos;//水平参数
         public  short wTiltPos;//垂直参数
         public  short wZoomPos;//变倍参数
+        @Override
+        protected List getFieldOrder() {
+            // TODO Auto-generated method stub
+            return Arrays.asList("wAction","wPanPos","wTiltPos","wZoomPos"); //这里参数顺序和SDK开发包的C++定义必须完全一致
+        }
     }
 
     //球机范围信息

web/src/main/java/com/zhehekeji/web/lib/hik/HikCameraControlModuleImpl.java

@@ -1,12 +1,14 @@
 package com.zhehekeji.web.lib.hik;
 
 import com.sun.jna.NativeLong;
+import com.sun.jna.Pointer;
 import com.sun.jna.ptr.IntByReference;
 import com.zhehekeji.common.util.PathUtil;
 import com.zhehekeji.core.util.Assert;
 import com.zhehekeji.web.lib.CameraConnMap;
 import com.zhehekeji.web.lib.CameraControlModule;
 import com.zhehekeji.web.lib.joyware.NetSDKLib;
+import com.zhehekeji.web.pojo.CameraPtzPojo;
 import lombok.extern.slf4j.Slf4j;
 
 import java.io.*;
@@ -18,6 +20,8 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.Timer;
 
+import static com.zhehekeji.web.lib.hik.HCNetSDK.NET_DVR_GET_PTZPOS;
+
 /**
  * 云台控制接口实现
  * 主要有 ：八个方向控制、变倍、变焦、光圈功能
@@ -85,6 +89,36 @@ public class HikCameraControlModuleImpl implements CameraControlModule {
         return HikLoginModuleImpl.hcNetsdk.NET_DVR_PTZControl_Other(lUserId, 1, HCNetSDK.PAN_RIGHT, 0);
     }
 
+    @Override
+    public CameraPtzPojo ptzGetDVRConfig(Integer lUserID) {
+
+        CameraPtzPojo cameraPtzPojo = new CameraPtzPojo();
+        int lUserId = CameraConnMap.getConnId(lUserID).intValue();
+        HCNetSDK.NET_DVR_PTZPOS netDvrPtzpos = new HCNetSDK.NET_DVR_PTZPOS();
+        Pointer pointer = netDvrPtzpos.getPointer();
+        IntByReference intByReference = new IntByReference(1);
+        boolean b_GetPTZ = HikLoginModuleImpl.hcNetsdk.NET_DVR_GetDVRConfig(lUserId, NET_DVR_GET_PTZPOS,1,pointer,netDvrPtzpos.size(),intByReference);
+        if (b_GetPTZ == false) {
+            System.out.println("获取PTZ坐标信息失败，错误码：" +HikLoginModuleImpl.hcNetsdk.NET_DVR_GetLastError());
+            cameraPtzPojo.setGetSuccess(false);
+        }else {
+
+            cameraPtzPojo.setGetSuccess(true);
+            netDvrPtzpos.read();
+            cameraPtzPojo.setWPanPos(hexToDegree(netDvrPtzpos.wPanPos));
+            cameraPtzPojo.setWTiltPos(hexToDegree(netDvrPtzpos.wTiltPos));
+            cameraPtzPojo.setWZoomPos(hexToDegree(netDvrPtzpos.wZoomPos));
+        }
+        return cameraPtzPojo;
+    }
+
+    static double hexToDegree(short hex) {
+        String value = Integer.toHexString(hex);
+        Integer v = Integer.parseInt(value);
+        int integerPart = v / 10;
+        int decimalPart = v % 10;
+        return integerPart + decimalPart / 10.0;
+    }
     public boolean ptzControlRightEnd(Integer cameraId, int nChannelID)
     {
         int lUserId = CameraConnMap.getConnId(cameraId).intValue();

web/src/main/java/com/zhehekeji/web/lib/joyware/JoywareCameraControlModuleImpl.java

@@ -5,6 +5,7 @@ import com.zhehekeji.common.util.PathUtil;
 import com.zhehekeji.core.util.Assert;
 import com.zhehekeji.web.lib.CameraConnMap;
 import com.zhehekeji.web.lib.CameraControlModule;
+import com.zhehekeji.web.pojo.CameraPtzPojo;
 import lombok.extern.slf4j.Slf4j;
 
 import java.time.LocalDateTime;
@@ -93,6 +94,12 @@ public class JoywareCameraControlModuleImpl implements CameraControlModule {
                 0, 0, 0, 1);
     }
 
+    //暂未开发
+    @Override
+    public CameraPtzPojo ptzGetDVRConfig(Integer lUserID) {
+        return null;
+    }
+
     /**
      * 向左上
      */

web/src/main/java/com/zhehekeji/web/pojo/CameraPtzPojo.java

@@ -0,0 +1,13 @@
+package com.zhehekeji.web.pojo;
+
+
+import lombok.Data;
+
+@Data
+public class CameraPtzPojo {
+    short wAction;//获取时该字段无效
+    double wPanPos;//水平参数
+    double wTiltPos;//垂直参数
+    double wZoomPos;//变倍参数
+    boolean getSuccess;
+}

web/src/main/java/com/zhehekeji/web/service/PlcService.java

@@ -8,6 +8,7 @@ import com.zhehekeji.web.config.ConfigProperties;
 import com.zhehekeji.web.entity.*;
 import com.zhehekeji.web.lib.*;
 import com.zhehekeji.web.mapper.*;
+import com.zhehekeji.web.pojo.CameraPtzPojo;
 import com.zhehekeji.web.pojo.OrderVO;
 import com.zhehekeji.web.service.RFID.RFIDMap;
 import com.zhehekeji.web.service.RFID.RFIDSocket;
@@ -154,6 +155,45 @@ public class PlcService {
         return true;
     }
 
+    public void verticalAdjustmentByStreet(String SRMNumber){
+        Street street = streetService.getStreetByPlcId(SRMNumber);
+        if(street.getCamera1Id()!=null){
+            //重置垂直方向球机
+            verticalAdjustment(street.getCamera1Id());
+        }
+        if(street.getCamera2Id()!=null){
+            //重置垂直方向球机
+            verticalAdjustment(street.getCamera2Id());
+        }
+    }
+    public void verticalAdjustment(Integer cameraId){
+        log.info("球机"+cameraId+"重置垂直方向开始");
+        Double origin = null;
+        int i = 10 ;
+        while (i >=0){
+            i-- ;
+            CameraPtzPojo cameraPtzPojo =  cameraControlModule.ptzGetDVRConfig(cameraId);
+            if(cameraPtzPojo.isGetSuccess()) {
+                cameraControlModule.ptzControlDownStart(cameraId, 0, 0, 1);
+                log.info("球机控制向下");
+                System.out.println("获取的垂直位置"+cameraPtzPojo.getWTiltPos());
+                if (origin == null) {
+                    origin = cameraPtzPojo.getWTiltPos();
+                } else if (cameraPtzPojo.getWTiltPos() <= origin) {
+                    break;
+                }
+            }
+            try {
+                Thread.sleep(500);
+            } catch (InterruptedException e) {
+                throw new RuntimeException(e);
+            }
+        }
+        log.info("球机"+cameraId+"重置垂直方向成功");
+        cameraControlModule.ptzControlDownEnd(cameraId,0);
+        gyrateCameraByCode(cameraId,"C1");
+    }
+
     public boolean closeStreetLightSource( Integer streetId){
         List<LightSource> lightSources = lightSourceService.getLightSourceByStreetId(streetId);
         lightSources.forEach(lightSource -> {
@@ -723,31 +763,30 @@ public class PlcService {
         if(street != null){
             RFID rfid = rfidService.getRFIDByPlc(street.getId());
             if(rfid != null){
-                RFIDStart(rfid.getIp(),rfid.getPort(),street.getId());
+                RFIDStart(rfid.getIp(),rfid.getPort(),street.getId(),1);
             }
         }
     }
 
-    public void RFIDStart(String ip,Integer port,Integer streetId){
+    public void RFIDStart(String ip, Integer port, Integer streetId, Integer direction) {
-        RFIDSocket rfidSocket = new RFIDSocket(ip,port);
+        RFIDSocket rfidSocket = new RFIDSocket(ip, port);
-        rfidSocket.startCheck();
+        log.info("rfid调用，ip：" + ip + ";port:" + port);
-        rfidSocket.readData();
+        rfidSocket.startCheck(direction, true);
-        RFIDMap.put(streetId,rfidSocket);
+        RFIDMap.put(streetId, rfidSocket);
     }
 
-    public Set<String> RFIDStop(PlcCmdInfo plcCmdInfo){
+    public Set<String> RFIDStop(PlcCmdInfo plcCmdInfo) {
         Street street = streetService.getStreetByPlcId(plcCmdInfo.getPlcId());
         RFIDSocket rfidSocket = RFIDMap.get(street.getId());
         Set<String> tags = null;
-        if(rfidSocket != null){
+        if (rfidSocket != null) {
             tags = rfidSocket.getTags();
-            log.info("tags:{}",tags);
+            log.info("tags:{}", tags);
-            rfidSocket.close();
+            rfidSocket.stopCheck();
             RFIDMap.remove(street.getId());
         }
         return tags;
     }
-
     public ConfigProperties getConfigProperties(){
         return configProperties;
     }

web/src/main/java/com/zhehekeji/web/service/RFID/RFIDReader.java

@@ -0,0 +1,541 @@
+package com.zhehekeji.web.service.RFID;
+
+import com.payne.reader.Reader;
+import com.payne.reader.base.Consumer;
+import com.payne.reader.bean.config.*;
+import com.payne.reader.bean.receive.*;
+import com.payne.reader.bean.send.*;
+import com.payne.reader.communication.ConnectHandle;
+import com.payne.reader.communication.DataPacket;
+
+import java.security.InvalidParameterException;
+/**
+ * 读取器接口
+ */
+public interface RFIDReader extends Reader {
+    /**
+     * 连接读取器
+     *
+     * @param var1 连接处理回调
+     * @return 连接是否成功
+     */
+    boolean connect(ConnectHandle var1);
+
+    /**
+     * 连接读取器，并设置回调线程
+     *
+     * @param var1       连接处理回调
+     * @param var2       回调线程
+     * @return 连接是否成功
+     */
+    boolean connect(ConnectHandle var1, boolean var2);
+
+    /**
+     * 判断是否已连接
+     *
+     * @return 是否已连接
+     */
+    boolean isConnected();
+
+    /**
+     * 断开连接
+     */
+    void disconnect();
+
+    /**
+     * 获取读取器地址
+     *
+     * @return 读取器地址
+     */
+    byte getReaderAddress();
+
+    /**
+     * 获取天线数量
+     *
+     * @return 天线数量
+     */
+    AntennaCount getAntennaCount();
+
+    /**
+     * 切换天线数量
+     *
+     * @param var1 天线数量
+     */
+    void switchAntennaCount(AntennaCount var1);
+
+    /**
+     * 设置命令超时时间
+     *
+     * @param var1 超时时间
+     */
+    void setCmdTimeout(long var1);
+
+    /**
+     * 重置读取器
+     *
+     * @param var1 失败处理回调
+     */
+    void reset(Consumer<Failure> var1);
+
+    /**
+     * 设置波特率
+     *
+     * @param var1 波特率类型
+     * @param var2 成功处理回调
+     * @param var3 失败处理回调
+     */
+    void setBaudRate(BaudRate var1, Consumer<Success> var2, Consumer<Failure> var3);
+
+    /**
+     * 设置波特率
+     *
+     * @param var1 波特率类型
+     * @param var2 成功处理回调
+     * @param var3 失败处理回调
+     * @param var4 异常处理回调
+     */
+    void setBaudRate(BaudRate var1, Consumer<Success> var2, Consumer<Failure> var3, Consumer<Throwable> var4);
+
+    /**
+     * 设置读取器地址
+     *
+     * @param var1 读取器地址
+     * @param var2 成功处理回调
+     * @param var3 失败处理回调
+     */
+    void setReaderAddress(byte var1, Consumer<Success> var2, Consumer<Failure> var3);
+
+    /**
+     * 获取固件版本
+     *
+     * @param var1 版本获取成功处理回调
+     * @param var2 失败处理回调
+     */
+    void getFirmwareVersion(Consumer<Version> var1, Consumer<Failure> var2);
+
+    /**
+     * 设置蜂鸣器模式
+     *
+     * @param var1 蜂鸣器模式
+     * @param var2 成功处理回调
+     * @param var3 失败处理回调
+     */
+    void setBeeperMode(Beeper var1, Consumer<Success> var2, Consumer<Failure> var3);
+
+    /**
+     * 获取读取器温度
+     *
+     * @param var1 读取器温度获取成功处理回调
+     * @param var2 失败处理回调
+     */
+    void getReaderTemperature(Consumer<ReaderTemperature> var1, Consumer<Failure> var2);
+
+    /**
+     * 读取GPIO输出
+     *
+     * @param var1 GPIO输出获取成功处理回调
+     * @param var2 失败处理回调
+     */
+    void readGpio(Consumer<GpioOut> var1, Consumer<Failure> var2);
+
+    /**
+     * 写入GPIO输入
+     *
+     * @param var1 GPIO输入类型
+     * @param var2 输入值
+     * @param var3 成功处理回调
+     * @param var4 失败处理回调
+     */
+    void writeGpio(GpioInType var1, boolean var2, Consumer<Success> var3, Consumer<Failure> var4);
+
+    /**
+     * 设置天线连接探测器地址
+     *
+     * @param var1 探测器地址
+     * @param var2 成功处理回调
+     * @param var3 失败处理回调
+     */
+    void setAntConnectionDetector(byte var1, Consumer<Success> var2, Consumer<Failure> var3);
+
+    /**
+     * 获取天线连接探测器地址
+     *
+     * @param var1 探测器地址获取成功处理回调
+     * @param var2 失败处理回调
+     */
+    void getAntConnectionDetector(Consumer<AntConnectionDetector> var1, Consumer<Failure> var2);
+
+    /**
+     * 设置工作天线
+     *
+     * @param var1 工作天线
+     * @param var2 成功处理回调
+     * @param var3 失败处理回调
+     * @throws InvalidParameterException 参数无效异常
+     */
+    void setWorkAntenna(int var1, Consumer<Success> var2, Consumer<Failure> var3) throws InvalidParameterException;
+
+    /**
+     * 获取工作天线
+     *
+     * @param var1 工作天线获取成功处理回调
+     * @param var2 失败处理回调
+     */
+    void getWorkAntenna(Consumer<WorkAntenna> var1, Consumer<Failure> var2);
+
+    /**
+     * 获取缓存工作天线
+     *
+     * @return 缓存工作天线
+     */
+    int getCacheWorkAntenna();
+
+    /**
+     * 获取缓存天线组
+     *
+     * @return 缓存天线组
+     */
+    int getCacheAntennaGroup();
+
+    /**
+     * 设置输出功率
+     *
+     * @param var1 输出功率配置
+     * @param var2 成功处理回调
+     * @param var3 失败处理回调
+     * @throws InvalidParameterException 参数无效异常
+     */
+    void setOutputPower(OutputPowerConfig var1, Consumer<Success> var2, Consumer<Failure> var3) throws InvalidParameterException;
+
+    /**
+     * 获取输出功率
+     *
+     * @param var1 输出功率获取成功处理回调
+     * @param var2 失败处理回调
+     */
+    void getOutputPower(Consumer<OutputPower> var1, Consumer<Failure> var2);
+
+    /**
+     * 设置均匀输出功率
+     *
+     * @param var1 均匀输出功率
+     * @param var2 设置成功处理回调
+     * @param var3 失败处理回调
+     */
+    void setOutputPowerUniformly(byte var1, boolean var2, Consumer<Success> var3, Consumer<Failure> var4);
+
+    /**
+     * 设置频率区域
+     *
+     * @param var1 频率区域类型
+     * @param var2 成功处理回调
+     * @param var3 失败处理回调
+     */
+    void setFrequencyRegion(FreqNormal var1, Consumer<Success> var2, Consumer<Failure> var3);
+
+    /**
+     * 设置用户定义频率
+     *
+     * @param var1 用户定义频率类型
+     * @param var2 成功处理回调
+     * @param var3 失败处理回调
+     */
+    void setUserDefineFrequency(FreqUserDefine var1, Consumer<Success> var2, Consumer<Failure> var3);
+
+    /**
+     * 获取频率区域
+     *
+     * @param var1 频率区域获取成功处理回调
+     * @param var2 失败处理回调
+     */
+    void getFrequencyRegion(Consumer<FreqRegionResult> var1, Consumer<Failure> var2);
+
+    /**
+     * 设置读取器标识
+     *
+     * @param var1 读取器标识
+     * @param var2 成功处理回调
+     * @param var3 失败处理回调
+     */
+    void setReaderIdentifier(Identifier var1, Consumer<Success> var2, Consumer<Failure> var3);
+
+    /**
+     * 获取读取器标识
+     *
+     * @param var1 读取器标识获取成功处理回调
+     * @param var2 失败处理回调
+     */
+    void getReaderIdentifier(Consumer<ReaderIdentifier> var1, Consumer<Failure> var2);
+
+    /**
+     * 设置RF链接配置
+     *
+     * @param var1 链接配置
+     * @param var2 成功处理回调
+     * @param var3 失败处理回调
+     */
+    void setRfLinkProfile(ProfileId var1, Consumer<Success> var2, Consumer<Failure> var3);
+
+    /**
+     * 获取RF链接配置
+     *
+     * @param var1 RF链接配置获取成功处理回调
+     * @param var2 失败处理回调
+     */
+    void getRfLinkProfile(Consumer<RfLinkProfile> var1, Consumer<Failure> var2);
+
+    /**
+     * 设置E710链接配置
+     *
+     * @param var1 链接配置
+     * @param var2 配置类型
+     * @param var3 成功处理回调
+     * @param var4 失败处理回调
+     */
+    void setE710LinkProfile(ProfileId var1, byte var2, Consumer<Success> var3, Consumer<Failure> var4);
+
+    /**
+     * 获取E710链接配置
+     *
+     * @param var1 E710链接配置获取成功处理回调
+     * @param var2 失败处理回调
+     */
+    void getE710LinkProfile(Consumer<E710LinkProfile> var1, Consumer<Failure> var2);
+
+    /**
+     * 获取RF端口返回损耗
+     *
+     * @param var1 端口号
+     * @param var2 返回损耗获取成功处理回调
+     * @param var3 失败处理回调
+     */
+    void getRfPortReturnLoss(byte var1, Consumer<RfPortReturnLoss> var2, Consumer<Failure> var3);
+
+    /**
+     * 设置库存配置
+     *
+     * @param var1 库存配置
+     * @throws InvalidParameterException 参数无效异常
+     */
+    void setInventoryConfig(InventoryConfig var1) throws InvalidParameterException;
+
+    /**
+     * 开始库存盘点
+     *
+     * @param var1 是否开启多天线读取
+     */
+    void startInventory(boolean var1);
+
+    /**
+     * 停止盘点。
+     */
+    void stopInventory();
+
+    /**
+     * 停止盘点，参数为一个布尔值。
+     *
+     * @param var1 布尔值参数
+     */
+    void stopInventory(boolean var1);
+
+    /**
+     * 设置MultiAntReadTagConfig配置。
+     *
+     * @param var1 MultiAntReadTagConfig对象
+     */
+    void setMultiAntReadTagConfig(MultiAntReadTagConfig var1);
+
+    /**
+     * 启动MultiAntReadTag。
+     */
+    void startMultiAntReadTag();
+
+    /**
+     * 停止MultiAntReadTag。
+     */
+    void stopMultiAntReadTag();
+
+    /**
+     * 读取标签。
+     *
+     * @param var1 读取配置ReadConfig对象
+     * @param var2 操作标签回调函数
+     * @param var3 失败回调函数
+     */
+    void readTag(ReadConfig var1, Consumer<OperationTag> var2, Consumer<Failure> var3);
+
+    /**
+     * 读取标签。
+     *
+     * @param var1 自定义会话读取配置CustomSessionReadConfig对象
+     * @param var2 操作标签回调函数
+     * @param var3 失败回调函数
+     */
+    void readTag(CustomSessionReadConfig var1, Consumer<OperationTag> var2, Consumer<Failure> var3);
+
+    /**
+     * 写入标签。
+     *
+     * @param var1 写入配置WriteConfig对象
+     * @param var2 布尔值参数
+     * @param var3 操作标签回调函数
+     * @param var4 失败回调函数
+     */
+    void writeTag(WriteConfig var1, boolean var2, Consumer<OperationTag> var3, Consumer<Failure> var4);
+
+    /**
+     * 锁定标签。
+     *
+     * @param var1 锁定配置LockConfig对象
+     * @param var2 操作标签回调函数
+     * @param var3 失败回调函数
+     */
+    void lockTag(LockConfig var1, Consumer<OperationTag> var2, Consumer<Failure> var3);
+
+    /**
+     * 杀死标签。
+     *
+     * @param var1 杀死配置KillConfig对象
+     * @param var2 操作标签回调函数
+     * @param var3 失败回调函数
+     */
+    void killTag(KillConfig var1, Consumer<OperationTag> var2, Consumer<Failure> var3);
+
+    /**
+     * 设置ImpinjFastTid。
+     *
+     * @param var1 FastTidType对象
+     * @param var2 布尔值参数
+     * @param var3 成功回调函数
+     * @param var4 失败回调函数
+     */
+    void setImpinjFastTid(FastTidType var1, boolean var2, Consumer<Success> var3, Consumer<Failure> var4);
+
+    /**
+     * 获取ImpinjFastTid。
+     *
+     * @param var1 成功回调函数
+     * @param var2 失败回调函数
+     */
+    void getImpinjFastTid(Consumer<ImpinjFastTid> var1, Consumer<Failure> var2);
+
+    /**
+     * 设置EpcMatch。
+     *
+     * @param var1 匹配配置MatchConfig对象
+     * @param var2 成功回调函数
+     * @param var3 失败回调函数
+     */
+    void setEpcMatch(MatchConfig var1, Consumer<Success> var2, Consumer<Failure> var3);
+
+    /**
+     * 获取EpcMatch。
+     *
+     * @param var1 成功回调函数
+     * @param var2 失败回调函数
+     */
+    void getEpcMatch(Consumer<MatchInfo> var1, Consumer<Failure> var2);
+
+    /**
+     * 清除EpcMatch。
+     *
+     * @param var1 成功回调函数
+     * @param var2 失败回调函数
+     */
+    void clearEpcMatch(Consumer<Success> var1, Consumer<Failure> var2);
+
+    /**
+     * 设置TagMask。
+     *
+     * @param var1 掩码配置MaskConfig对象
+     * @param var2 成功回调函数
+     * @param var3 失败回调函数
+     */
+    void setTagMask(MaskConfig var1, Consumer<Success> var2, Consumer<Failure> var3);
+
+    /**
+     * 获取TagMask。
+     *
+     * @param var1 成功回调函数
+     * @param var2 失败回调函数
+     */
+    void getTagMask(Consumer<MaskInfo> var1, Consumer<Failure> var2);
+
+    /**
+     * 清除TagMask。
+     *
+     * @param var1 清除的TagMaskID
+     * @param var2 成功回调函数
+     * @param var3 失败回调函数
+     */
+    void clearTagMask(ClearMaskId var1, Consumer<Success> var2, Consumer<Failure> var3);
+
+    /**
+     * 设置ReaderStatus。
+     *
+     * @param var1 字节参数
+     * @param var2 成功回调函数
+     * @param var3 失败回调函数
+     */
+    void setReaderStatus(byte var1, Consumer<Success> var2, Consumer<Failure> var3);
+
+    /**
+     * 获取ReaderStatus。
+     *
+     * @param var1 成功回调函数
+     * @param var2 失败回调函数
+     */
+    void getReaderStatus(Consumer<ReaderStatus> var1, Consumer<Failure> var2);
+
+    /**
+     * 获取TempLabel2。
+     *
+     * @param var1 TempLabel2对象
+     * @param var2 失败回调函数
+     */
+    void measTempLabel2(TempLabel2Config var1, Consumer<TempLabel2> var2, Consumer<Failure> var3);
+
+    /**
+     * 设置CommandStatusCallback。
+     *
+     * @param var1 回调函数
+     */
+    void setCommandStatusCallback(Consumer<CmdStatus> var1);
+
+    /**
+     * 设置OriginalDataCallback。
+     *
+     * @param var1 原始数据回调函数
+     * @param var2 失败回调函数
+     */
+    void setOriginalDataCallback(Consumer<byte[]> var1, Consumer<byte[]> var2);
+
+    /**
+     * 设置UndefinedResultCallback。
+     *
+     * @param var1 未定义结果回调函数
+     */
+    void setUndefinedResultCallback(Consumer<ReceiveData> var1);
+
+    /**
+     * @deprecated 已过时，请勿使用
+     */
+    @Deprecated
+    void sendCustomRequest(byte var1, byte[] var2);
+
+    /**
+     * 发送自定义请求。
+     *
+     * @param var1 数据包对象
+     */
+    void sendCustomRequest(DataPacket var1);
+
+    /**
+     * 获取SdkBuildInfo。
+     *
+     * @return SdkBuildInfo信息
+     */
+    default String getSdkBuildInfo() {
+        return "add cmd:89, packaged at 2022-10-13 04.00";
+    }
+}

web/src/main/java/com/zhehekeji/web/service/RFID/RFIDSocket.java

@@ -1,238 +1,175 @@
 package com.zhehekeji.web.service.RFID;
 
-import lombok.SneakyThrows;
+import com.payne.connect.net.NetworkHandle;
-import lombok.extern.slf4j.Slf4j;
+import com.payne.reader.Reader;
-
+import com.payne.reader.base.Consumer;
-import java.io.*;
+import com.payne.reader.bean.config.AntennaCount;
-import java.net.InetSocketAddress;
+import com.payne.reader.bean.receive.*;
-import java.net.Socket;
+import com.payne.reader.bean.send.FastSwitchFourAntennaInventory;
-import java.util.*;
+import com.payne.reader.bean.send.InventoryConfig;
-
+import com.payne.reader.process.ReaderImpl;
-/**
+import com.zhehekeji.web.util.ToolUtil;
- * sick扫码枪
+
- */
+import java.util.HashSet;
-@Slf4j
+import java.util.Map;
-public class RFIDSocket {
+import java.util.Set;
-
+import java.util.concurrent.ConcurrentHashMap;
-    private Socket socket;
-
-    private OutputStream os;
-
-    private InputStream is;
-
-    private Queue<Byte> buffer;
 
+public class RFIDSocket {
+    private String ip;
+    private int port;
     private boolean running;
+    Reader mReader;
 
-    private int step;
-
-    private int length;
-
-    private int index;
-
-    /**
-     * 读到的所有code标签
-     */
     private Set<String> tags = new HashSet<>();
 
-    private List<Byte> byteList = new ArrayList<>(30);
+    private Map<String, Integer> tagsCount = new ConcurrentHashMap<>();
 
-    public Set<String> getTags(){
+    public Set<String> getTags() {
         return tags;
     }
+    public RFIDSocket(String ip, Integer port) {
+        this.ip = ip;
+        this.port = port;
 
-    public RFIDSocket(String ip,int port){
+        NetworkHandle handle = new NetworkHandle(ip, (port));
-        socket = new Socket();
+        mReader = ReaderImpl.create(AntennaCount.FOUR_CHANNELS);
-        os = null;
-        is = null;
-        try {
-            socket.connect(new InetSocketAddress(ip,port),3000);
-            os = socket.getOutputStream();
-            is = socket.getInputStream();
-        } catch (IOException e) {
-            log.error("RFIDSocket time out,ip:{},info:{}",ip,e);
-
-            close();
 
+        boolean linkSuccess =false;
+        try {
+            linkSuccess = mReader.connect(handle);
 
+        }catch (Exception e) {
+            e.printStackTrace();
+        }
+        if (linkSuccess) {
+            System.out.println("reader1 connect success");
+        } else {
+            throw new RuntimeException("reader1 connect fail");
         }
+
     }
 
-    public void readData(){
+    public void startCheck(Integer direction,boolean foreach) {
+//		Reader mReader = ReaderImpl.create(AntennaCount.SIXTEEN_CHANNELS);
+//		Reader mReader = ReaderImpl.create(AntennaCount.EIGHT_CHANNELS);
         running = true;
-        buffer = new LinkedList();
-
         Thread thread = new Thread(new Runnable() {
-
-            @SneakyThrows
-            @Override
             public void run() {
-                while (true){
+                mReader.setOriginalDataCallback(
-                    if(!running){
+                        new Consumer<byte[]>() {
-                        System.out.println("stop");
+                            @Override
-                        break;
+                            public void accept(byte[] onSend) throws Exception {
-                    }
+                                //System.out.println("---reader 1 send :" + ArrayUtils.bytesToHexString(onSend, 0, onSend.length));
-                    int i = 0;
+                            }
-                    try {
+                        },
-                        //读不到会阻塞 返回-1表示连接已断开
+                        new Consumer<byte[]>() {
-                        i = is.read();
+                            @Override
-                    } catch (IOException e) {
+                            public void accept(byte[] onReceive) throws Exception {
-                        log.error("disconnect");
+
-                    }
-                    if(i == -1){
 
-                        break;
+                            }
-                    }
+                        });
-                    int count = 0;
+                FastSwitchFourAntennaInventory inventory = new FastSwitchFourAntennaInventory.Builder().build();
-                    try {
+                InventoryConfig config = new InventoryConfig.Builder()
-                        count = is.available();
+                        .setInventory(inventory)
-                        if(count > 0){
+                        .setOnInventoryTagSuccess(new Consumer<InventoryTag>() {
-                            //把之前read的字节嫁过来
+
-                            byte[]readBytes = new byte[count+1];
+                            @Override
-                            readBytes[0] = (byte)i;
+                            public void accept(InventoryTag tag) throws Exception {
-                            is.read(readBytes,1,count);
+                                System.out.println("reader1 inventory tag :" + tag.getEpc());
-                            for(byte b:readBytes){
+                                String tagStr = tag.getEpc().replace(" ","");
-                                buffer.offer(b);
+                                System.out.println("tag: " + tag.getEpc());
+                                tagStr = tagStr.replace("0000000000","");
+                                tags.add(tagStr);
+                                if (ToolUtil.isNotEmpty(tagsCount.get(tagStr))) {
+                                    tagsCount.put(tagStr, tagsCount.get(tagStr) + 1);
+                                } else {
+                                    tagsCount.put(tagStr, 1);
+                                }
+                            }
+                        })
+                        .setOnInventoryTagEndSuccess(new Consumer<InventoryTagEnd>() {
+
+                            @Override
+                            public void accept(InventoryTagEnd arg0) throws Exception {
+//						System.out.println("reader1 InventoryTagEnd");
+                            }
+                        })
+                        .setOnFailure(new Consumer<InventoryFailure>() {
+
+                            @Override
+                            public void accept(InventoryFailure failure) throws Exception {
+                                System.out.println("reader1 inventory fail :" + (failure.getErrorCode() & 0xFF));
+                            }
+                        })
+                        .build();
+                mReader.setInventoryConfig(config);
+                mReader.startInventory(true);
+
+                mReader.setWorkAntenna(direction,
+                        new Consumer<Success>() {
+                            @Override
+                            public void accept(Success success) throws Exception {
+                                //切换天线
+                                //处理成功
+                            }
+                        }, new Consumer<Failure>() {
+                            @Override
+                            public void accept(Failure failure) throws Exception {
+                                //处理失败情况
                             }
                         }
-                    } catch (IOException e) {
+                );
-                        log.error("");
+                byte[] bytes = new byte[1];
-                    }
+                bytes[0] = 0x01;
-                    while (buffer.size()> 0){
+                while (running) {
-                        String code = readTag();
+                    try {
-                        if(code != null){
+                        bytes[0] = (byte) (bytes[0] == 0x01 ? 0x00 : 0x01);
-                            tags.add(code);
+                        Thread.sleep(1000);
+                        if(foreach){
+                            mReader.setWorkAntenna(bytes[0],(v)->{
+                                System.out.println("reader1 setWorkAntenna success");
+                            },(v)->{
+                                System.out.println("reader1 setWorkAntenna fail");
+                            });
                         }
+                    } catch (Exception e) {
+                        e.printStackTrace();
+                        stopCheck();
                     }
                 }
-
             }
+
         });
         thread.start();
-    }
-
-    private String readTag(){
-        String tag = null;
-        Byte b = buffer.poll();
-        if(b == null){
-            return tag;
-        }
-        if(step == 0){
-            //判断是否表示头
-            if(b == HEAD.HEAD){
-                step++;
-                byteList.add(b);
-            }
-        }else if(step == 1){
-            //读长度
-            length = b & 0xff;
-            step++;
-            byteList.add(b);
-        }else if(step == 2){
-            byteList.add(b);
-            index++;
-            if(index == length-1){
-                step++;
-            }
-        }else if(step == 3){
-            byteList.add(b);
-            byte[]bytes = new byte[byteList.size()];
-            for(int i = 0;i<byteList.size();i++){
-                bytes[i] = byteList.get(i);
-            }
-            MessageTran messageTran = new MessageTran(bytes);
-            if(messageTran != null){
-                if(messageTran.getAryData().length == 9){
-                    //只能根据长度判断返回的包是标签内容还是其他
-                    //9个字节，第一个字节是指哪个天线，暂时不用管，只需关注什么标签
-                    StringBuffer sb = new StringBuffer();
-                    log.debug("antId:{}",String.format("%02X",messageTran.getAryData()[0]));
-                    for(int i = 1;i<messageTran.getAryData().length;i++){
-                        sb.append(String.format("%02X",messageTran.getAryData()[i]));
-                    }
-                    tag = sb.toString();
-                }
-            }
-            clear();
-        }
-        return tag;
-    }
 
-    private void clear(){
-        byteList.clear();
-        step = 0;
-        length = 0;
-        index = 0;
     }
 
-    public void close() {
+    public void stopCheck() {
         running = false;
-        try {
+        System.out.println("reader1 stop");
-            is.close();
+        if (mReader != null) {
-            socket.close();
+            mReader.stopInventory();
-            os.close();
+            mReader.disconnect();
-        } catch (IOException e) {
-            e.printStackTrace();
-            log.error("warn rfid close:{}",e);
         }
 
     }
 
-    public void startCheck(){
+    public String getTag() {
-        Thread thread = new Thread(new Runnable() {
+        if (ToolUtil.isNotEmpty(tagsCount)) {
-            @Override
+            int i = 0;
-            public void run() {
+            String tag = "";
-                int i = 0;
+            for (String t : tagsCount.keySet()) {
-                while (true){
+                if (i < tagsCount.get(t)) {
-                    if(!running){
+                    tag = t;
-                        break;
+                    i = tagsCount.get(t);
-                    }
-                    byte []antChanges =  new byte[6];
-                    antChanges[0] = (byte)0xa0;
-                    antChanges[1] = (byte)0x04;
-                    antChanges[2] = (byte)0x01;
-                    antChanges[3] = (byte)0x74;
-                    if(i % 2 == 0){
-                        //切换天线 使用天线0
-                        antChanges[4] = (byte)0x00;
-                        antChanges[5] = (byte)0xe7;
-                    }else {
-                        //切换天线 使用天线1
-                        antChanges[4] = (byte)0x01;
-                        antChanges[5] = (byte)0xe6;
-                    }
-                    i++;
-                    try {
-                        os.write(antChanges);
-                        Thread.sleep(10);
-                    } catch (InterruptedException | IOException e) {
-                        log.error("send cmd error:{}",e);
-                    }
-                    byte[]bytes = new byte[5];
-                    bytes[0] = (byte)0xa0;
-                    bytes[1] = (byte)0x03;
-                    bytes[2] = (byte)0x01;
-                    bytes[3] = (byte)0xb0;
-                    bytes[4] = (byte)0xac;
-                    try {
-                        os.write(bytes);
-                        Thread.sleep(70);
-                    } catch (InterruptedException | IOException e) {
-                        log.warn("send rfid cmd error:{}",e);
-                    }
                 }
             }
-        });
+            return tag;
-        thread.start();
+        }
-
+        return "";
     }
 
-    public static void main(String[] args) throws IOException, InterruptedException {
+
-        RFIDSocket rfid = new RFIDSocket("172.16.0.220",4001);
-        rfid.startCheck();
-        rfid.readData();
-        Thread.sleep(30000);
-        rfid.close();
-        System.out.println(rfid.getTags());
-    }
 }

web/src/main/java/com/zhehekeji/web/service/RFID/RFIDSocketOld.java

@@ -0,0 +1,163 @@
+package com.zhehekeji.web.service.RFID;
+
+import com.module.interaction.RXTXListener;
+import com.module.interaction.ReaderHelper;
+import com.rfid.RFIDReaderHelper;
+import com.rfid.ReaderConnector;
+import com.rfid.rxobserver.RXObserver;
+import com.rfid.rxobserver.bean.RXInventoryTag;
+import com.util.StringTool;
+import com.zhehekeji.web.util.ToolUtil;
+
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Observer;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class RFIDSocketOld {
+    private String ip;
+    private int port;
+    private ReaderHelper mReaderHelper;
+    private ReaderConnector mReaderConnector;
+    private boolean running;
+
+    private Set<String> tags = new HashSet<>();
+
+    private Map<String,Integer> tagsCount = new ConcurrentHashMap<>();
+    public Set<String> getTags(){
+        return tags;
+    }
+
+
+    private Observer mObserver = new RXObserver() {
+        @Override
+        protected void onInventoryTag(RXInventoryTag tag) {
+            System.out.println("EPC data:" + tag.strEPC);
+        }
+
+        @Override
+        protected void onInventoryTagEnd(RXInventoryTag.RXInventoryTagEnd endTag) {
+            System.out.println("inventory end:" + endTag.mTotalRead);
+            ((RFIDReaderHelper) mReaderHelper).realTimeInventory((byte) 0xff,(byte)0x01);
+        }
+
+        @Override
+        protected void onExeCMDStatus(byte cmd,byte status) {
+            System.out.format("CDM:%s  Execute status:%S\n",
+                    String.format("%02X",cmd),String.format("%02x", status));
+        }
+    };
+    private RXTXListener mListener = new RXTXListener() {
+        @Override
+        //获取接收器返回的数据
+        public void reciveData(byte[] btAryReceiveData) {
+            // TODO Auto-generated method stub
+            System.out.println("reciveData: " + StringTool.byteArrayToString(btAryReceiveData, 0, btAryReceiveData.length));
+            MessageTran messageTran = new MessageTran(btAryReceiveData);
+            if (messageTran != null){
+                System.out.println("ary data length: " + messageTran.getAryData().length);
+                System.out.println("artData: " + StringTool.byteArrayToString(messageTran.getAryData(), 0, messageTran.getAryData().length));
+                StringBuffer sb = new StringBuffer();
+                int aryDataLength = messageTran.getAryData().length;
+                if (aryDataLength > 8){
+                    for (int i = 0; i < aryDataLength; ++i){
+                        sb.append(String.format("%02X",messageTran.getAryData()[i]));
+                    }
+                    
+                    String tag = sb.toString();
+                    //int index = st.indexOf("E");
+                    //String tag = st.substring(index, index+16);
+                    System.out.println("tag: "+tag);
+                    tags.add(tag);
+                    if(ToolUtil.isNotEmpty(tagsCount.get(tag))){
+                        tagsCount.put(tag, tagsCount.get(tag)+1);
+                    }else{
+                        tagsCount.put(tag, 1);
+                    }
+                }
+            }
+        }
+
+        @Override
+        public void sendData(byte[] btArySendData) {
+            // TODO Auto-generated method stub
+            System.out.println("sendData: " + StringTool.byteArrayToString(btArySendData, 0, btArySendData.length));
+        }
+
+        @Override
+        public void onLostConnect() {
+            // TODO Auto-generated method stub
+        }
+
+    };
+    public RFIDSocketOld(String ip, Integer port){
+        mReaderConnector = new ReaderConnector();
+        mReaderHelper = mReaderConnector.connectNet(ip, port);
+    }
+    public void startCheck(Integer direction){
+        running = true;
+        Thread thread = new Thread(new Runnable() {
+            public void run() {
+
+                if (mReaderHelper != null) {
+                    System.out.println("Connect success!");
+                    try {
+                        mReaderHelper.registerObserver(mObserver);
+                        mReaderHelper.setRXTXListener(mListener);
+
+                        Thread.sleep(500);
+                        //start to find the tags
+//				((RFIDReaderHelper) mReaderHelper).realTimeInventory((byte) 0xff,(byte)0x01);
+                        while (true) {
+//                    if (i%2==0){
+                            if (!running){
+                                break;
+                            }
+                            if (direction == 1) {
+                                //切换天线 0x00：天线1；0x01：天线2
+                                ((RFIDReaderHelper) mReaderHelper).setWorkAntenna((byte) 0xFF, (byte) 0x00);
+                            } else {
+                                ((RFIDReaderHelper) mReaderHelper).setWorkAntenna((byte) 0xFF, (byte) 0x01);
+                            }
+                            //开始盘存180006B
+                            //((RFIDReaderHelper) mReaderHelper).iso180006BInventory((byte) 0xFF);
+                            ((RFIDReaderHelper) mReaderHelper).inventory((byte) 0xFF, (byte) 0x0A);
+//                    i++;
+                            Thread.sleep(70);
+                        }
+                    } catch (Exception e) {
+                        // TODO Auto-generated catch block
+                        e.printStackTrace();
+                    }
+                } else {
+                    System.out.println("Connect faild!");
+                    mReaderConnector.disConnect();
+                }
+            }
+        });
+        thread.start();
+    }
+
+    public void stopCheck(){
+        running = false;
+        if (mReaderConnector.isConnected()){
+            mReaderConnector.disConnect();
+        }
+    }
+    public String getTag(){
+        if(ToolUtil.isNotEmpty(tagsCount)){
+            int i = 0;
+            String tag = "" ;
+            for (String t : tagsCount.keySet()){
+                if (i<tagsCount.get(t)) {
+                    tag = t;
+                    i = tagsCount.get(t);
+                }
+            }
+            return tag;
+        }return "";
+    }
+
+
+}

web/src/main/java/com/zhehekeji/web/service/ksec/KsecDecoder.java

@@ -139,6 +139,8 @@ public class KsecDecoder extends DelimiterBasedFrameDecoder {
                         plcService.gyrateCamera(plcCmdInfo,Cmd.C5.name());
                         plcService.orderStop(plcCmdInfo);
                         plcService.closeStreetLightSource(plcCmdInfo.getStreetId());
+                        //重置相机水平方向
+                        plcService.verticalAdjustmentByStreet( dataInfo.getSRMNumber());
 
                     }
                 } else if (Cmd.C.name().equals(ksecInfo.getType())) {

web/src/main/java/com/zhehekeji/web/service/sick/SickSocket.java

@@ -7,6 +7,7 @@ import org.slf4j.LoggerFactory;
 import java.io.*;
 import java.net.InetSocketAddress;
 import java.net.Socket;
+import java.net.SocketTimeoutException;
 import java.nio.charset.StandardCharsets;
 
 /**
@@ -16,44 +17,69 @@ import java.nio.charset.StandardCharsets;
 public class SickSocket {
 
     private static final Logger tcpLogger = LoggerFactory.getLogger("sick");
+
     public static void main(String[] args) {
-        String code = readOCR("192.168.8.236", 2002);
+        String code = readOCR("192.168.5.10", 2002);
         System.out.println(code);
     }
 
-    public static String readOCR(String ip,int port){
+    /**
+     * 读取OCR的结果
+     *
+     * @param ip   目标服务器的IP地址
+     * @param port 目标服务器的端口号
+     * @return OCR的结果
+     */
+    public static String readOCR(String ip, int port) {
+        // 创建Socket对象
         Socket socket = new Socket();
+        // 定义变量code，并赋值为"NoRead"
         String code = "NoRead";
+        // 创建OutputStream对象os，并赋值为null
         OutputStream os = null;
+        // 创建InputStream对象is，并赋值为null
         InputStream is = null;
+
         try {
-            socket.connect(new InetSocketAddress(ip,port),3000);
+            // 连接服务器，指定服务器的IP地址和端口号，并设置连接超时时间为3000毫秒
+            socket.connect(new InetSocketAddress(ip, port), 3000);
+            socket.setSoTimeout(3000);
+            // 获取socket的输出流对象
             os = socket.getOutputStream();
+            // 获取socket的输入流对象
             is = socket.getInputStream();
+            // 定义变量i，并赋值为0
             int i = 0;
-            while ("NoRead".equals(code) && i <= 4){
+            // 当code等于"NoRead"且i小于等于4且socket未关闭时，执行以下循环
+            while ("NoRead".equals(code) && i <= 4 && !socket.isClosed()) {
+                // 调用writeCmd方法，将数据写入socket的输出流
                 writeCmd(os);
+                // 从socket的输入流中读取数据，并赋值给code
                 code = read(is);
-                tcpLogger.info("count:{},ip:{},code:{}",i,ip,code);
+                // 打印日志信息，包括计数器i、服务器的IP地址和读取到的数据code
-                if(code!= null){
+                tcpLogger.info("count:{},ip:{},code:{}", i, ip, code);
-                    code = code.replace("\\n","");
+                // 如果code不为null，则将code中的\n替换为空字符串
+                if (code != null) {
+                    code = code.replace("\\n", "");
                 }
+                // i自增1
                 i++;
             }
-
+        } catch (SocketTimeoutException socketTimeoutException) {
-
+            tcpLogger.error("sick响应超时,ip:{},info:{}", ip, socketTimeoutException);
+            log.error("sick响应超时,ip:{},info:{}", ip, socketTimeoutException);
         } catch (IOException e) {
-            tcpLogger.error("sick time out,ip:{},info:{}",ip,e);
+            tcpLogger.error("sick time out,ip:{},info:{}", ip, e);
-            log.error("sick time out,ip:{},info:{}",ip,e);
+            log.error("sick time out,ip:{},info:{}", ip, e);
-        }finally {
+        } finally {
-            if(os != null){
+            if (os != null) {
                 try {
                     os.close();
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
-            if(is != null){
+            if (is != null) {
                 try {
                     is.close();
                 } catch (IOException e) {
@@ -72,7 +98,7 @@ public class SickSocket {
 
     private static void writeCmd(OutputStream os) throws IOException {
         String startCmd = "start";
-        byte[]bytes = startCmd.getBytes(StandardCharsets.UTF_8);
+        byte[] bytes = startCmd.getBytes(StandardCharsets.UTF_8);
         os.write(bytes);
     }
 

web/src/main/java/com/zhehekeji/web/util/ToolUtil.java

@@ -0,0 +1,30 @@
+package com.zhehekeji.web.util;
+
+import java.lang.reflect.Array;
+import java.util.Collection;
+import java.util.Map;
+
+public class ToolUtil {
+    public static boolean isEmpty(Object o) {
+        if (o == null) {
+            return true;
+        }
+        if (o instanceof String) {
+            return ((String) o).isEmpty();
+        }
+        if (o instanceof Collection) {
+            return ((Collection<?>) o).isEmpty();
+        }
+        if (o instanceof Map) {
+            return ((Map<?, ?>) o).isEmpty();
+        }
+        if (o.getClass().isArray()) {
+            return Array.getLength(o) == 0;
+        }
+        return "".equals(o.toString());
+    }
+
+    public static boolean isNotEmpty(Object o) {
+        return !isEmpty(o);
+    }
+}