精华内容
下载资源
问答
  • 本文提出了两种降维和预测分位数方法(即分位数组套索和分位数组SCAD模型)来预测碳期货收益,并研究包括市场基本变量和技术变量在内的一组综合因素的可预测性。 在预测性能方面,这两个提出的模型优于一系列流行的...
  • 英特尔中国研究院院长宋继强率领团队集体亮相,共同分享了英特尔中国研究院的整体定位、研究方向和创新机制,并展示了在人工智能、机器人、5G、虚拟现实等一系列前瞻科技领域的最新研究成果。作为英特尔研究院在海外...

    记者 | 谷磊

    近日,“英特尔中国研究院媒体开放日”在北京举行,CSDN记者受邀出席。英特尔中国研究院院长宋继强率领团队集体亮相,共同分享了英特尔中国研究院的整体定位、研究方向和创新机制,并展示了在人工智能、机器人、5G、虚拟现实等一系列前瞻科技领域的最新研究成果。

    作为英特尔研究院在海外设立的三个“地区性的研究机构”之一,英特尔中国研究院目前主要聚焦于研究与未来自主系统相关的关键技术,包括以下三大部分:

    • 人工智能算法

    • 自主系统平台

    • 智能基础设施

    图片描述

    图1 英特尔中国研究院院长宋继强

    关于英特尔中国研究院的定位和使命,院长宋继强表示,“我们致力于打造世界一流的工业研究院,通过突破性的成果打造英特尔的创新引擎,保持英特尔的技术领先性。它不仅着眼于未来革命性的科技研究,还承载着将研究成果转化至全球及中国本土创新产品的使命。工业研究院实际上是以产业化为目的,我们看的是三到五年可以产业化的技术,五年以外的通常靠大学去探索。”

    在demo互动体验环节,英特尔中国研究员为媒体详细展示诸多前沿技术:

    图片描述

    图2 机械手抓取操控系统

    机械手抓取操控系统:该平台包含了Eagle Shoal机械手、机械臂、以及感知硬件技术和软硬件集成的一整套方案 ,主要用于机器人抓取操控的相关研究。Eagle Shoal 机械手由英特尔中国研究院自主研发原型,包含8个主动自由度,16个力传感器,能够满足日常生活中遇到的大部分抓取需求,有效降低抓取操控研究领域所需的机械手硬件成本。

    图片描述

    图3 睿宝机器人

    睿宝机器人:想象有一天,你身边的机器人伙伴能够快速识别你的脸,能够清晰分辨出你的声音,还能猜透你的心… 这一切要如何实现?

    • 通过基于置信度的多模态融合技术,配合摄像头和麦克风等多个传感器,英特尔中国研究院自主研发的睿宝机器人能够在线自主学习,采集和标注每个用户在不同时间、地点和场景下的数据。

    • 利用个性化知识图谱,通过多模态交互,睿宝还能构建针对每个用户的知识图谱,支持个性化交互。

    这些技术都可以广泛应用于家用服务机器人、智能家居等需要与用户互动、提供个性化服务、情感陪伴等场景。

    图片描述

    图4 HERO平台

    HERO平台:HERO平台采用了英特尔酷睿系列CPU,并搭载英特尔Arria10 GX系列FPGA作为异构加速器,“用武之地”非常广泛,尤其是在智能机器人方面。基于HERO平台,英特尔中国研究院开发了多种基于FPGA加速的机器人算法。

    • 定位与导航:利用FPGA的超强计算力,即使采用低成本的激光雷达,也能为机器人提供稳定的定位与导航能力。
    • 高精度运动规划:双臂机器人可以通过图形界面设置双臂的目标位置实现运动路径规划与执行。
    • 雷达感知:通过雷达感知扩展机器人的视野,睿宝能够发现身后的人,也可以在光线暗淡或有遮挡的情况下感受到人。
    • 自主避障:持续运动中的机器人凡遇到障碍即转向。

    此外,该平台基于英特尔SGX技术构建了机器人的物理和信息安全系统,针对攸关物理安全的算法模块和IO通道提供芯片级安全保障。

    图片描述

    图5 无线3D VR全景视频采集播放系统

    无线3D VR全景视频采集播放系统:无线3D VR视频和游戏系统包括超高分辨率全景视频采集合成和无线VR传输,在5G时代通信与计算融合的助力下,采用边缘计算加速端到端的海量数据的可靠传输,实现远程沉浸式互动,用户可以身临其境地观赏全景视频,或者参与移动端VR游戏互动。它使用了ISP总线同步相机快门,通过分布式构架加速全景图像拼接和压缩,利用光流算法去除鬼影效应,并能在任意角度插值生成3D立体信息。

    图片描述

    图6 实时人像风格迁移

    人工智能算法,实时人像风格迁移:你相信吗?凭借一个摄像头,就能够实时在镜头中看到具备不同艺术风格的面部特效。基于深度神经网络人像风格迁移系统,英特尔中国研究院将多种艺术人像风格实时迁移到静态的目标图像以及动态的目标视频中。不仅限于目前的成果,随后该技术还可以广泛普及在AR/VR、在线直播、影视、多媒体社交等更多领域。

    图片描述

    图7 实时3D面部表情捕捉与特效渲染

    实时3D面部表情捕捉与特效渲染:前不久,著名艺人、时尚偶像、唱作歌手李宇春推出她的首支人工智能MV——《今天雨,可是我们在一起》。这首MV成为了科技赋能音乐和娱乐的跨界创新范例,搭载的技术就是来自英特尔中国研究院的3D人脸面部表情捕捉技术。

    基于机器学习和深度学习算法,英特尔的研究员们从数十万人脸图片数据中,训练出多个人脸识别模型,用于对视频图像进行智能分析与3D建模,不仅可以检测与识别人脸,还能精准重建3D人脸,并实时跟踪面部表情变化,将预先设计好的特效素材附着在3D人脸上,叠加到视频中,从而实现逼真炫酷的脸部特效。

    展开全文
  • 然后,我们说明了在Mechanical Turk上放置任务的机制包括招募主题,执行任务以及审查提交的工作。 我们还为研究人员在此平台上执行研究时可能遇到的常见问题提供解决方案,包括进行同步实验的技术,确保高质量...
  • 我们的分析最终在一项研究议程中得以探讨,该议程探讨了区块链如何改变组织协作的方式,包括以下问题:可能出现哪些不同类型的区块链,谁参与了区块链治理并受到其影响,参与者为何想要区块链,何时何地需要区块链...
  • 前面我们已经基于不同维度介绍关于Netty的很多知识了,包括通信原理、框架工作机制、核心组件、应用实战,以及不同场景对不同方案的选择等等。那么我们这次就研究一下我们项目中基于Netty端对端开发中如何搭建一个...

    前言

    前面我们已经基于不同维度介绍关于Netty的很多知识了,包括通信原理、框架工作机制、核心组件、应用实战,以及不同场景对不同方案的选择等等。那么我们这次就研究一下我们项目中基于Netty端对端开发中如何搭建一个完整的应用框架,以供开发人员嵌入他们关注的各种应用部件等。

     

    实现Netty应用级框架需要考虑哪些因素

    image.png

    很多人问,我们在基于某种网络通信框架构建我们自己的应用框架的时候,究竟需要考虑到哪些方面?我们如何构建一个与业务解耦的应用基础设施、定制协议格式、健壮性的机制等来支撑我们的开发呢?大家也可以在下方的留言讨论,而就个人的理解和相关实践经验,我认为至少应考虑到以下的问题:

    1. 网络通信协议的选择,方案的比较, 我们应基于TCP?UDP?还是应用层的一些成熟协议?...

    2. 网络I/O模型该采用何种?BIO?NIO?IO复用?AIO?还是信号驱动IO呢?

    3. 底层通信框架我们要定制,还是沿用已有的成熟框架?

    4. 我们场景是否需要统一定制全局可复用的交互协议、报文等?

    5. 是否应该建设一种高效可靠的消息编解码机制支撑快速通信?

    6. 来自客户端的连接、业务请求等是否需要有认证和鉴权?

    7. 当业务通信发生异常了,能否方便看到和追踪通信报文细节(更便于我们一步一步查找问题原因)??

    8. 当服务端因为非预期原因断开或崩溃,然后发现修复重启后是否每个客户端都要手动再连接一下??

    9. 当服务器空闲一段时间后,是否该有一种机制自动触发心跳检测网络的健康状况??

       ... ...

      还有很多本文就不一一列举。那我们今天就以上考虑到的问题点来手写实现一个基于Netty通信框架的应用级框架,然后验证我们的问题是否能得以圆满解决。

     

    应用框架实战

      在以下应用框架中我们将给出以上问题的解决方案

    1. 网络通信协议的选择,方案的比较, 我们应基于TCP?UDP?还是应用层的一些成熟协议? 采用TCP/IP

    2. 网络I/O模型该采用何种?BIO?NIO?IO复用?AIO?还是信号驱动IO呢?采用NIO非阻塞模型

    3. 底层通信框架我们要定制,还是沿用已有的成熟框架? 基于Netty框架

    4. 我们场景是否需要统一定制全局可复用的交互协议、报文等? 私有协议定义和交互约定方式

    5. 是否应该建设一种高效可靠的消息编解码机制支撑快速通信?采用ByteToMessage/MessageToByte/Kryo

    6. 来自客户端的连接、业务请求等服务端是否需要有认证和鉴权?采用服务端白名单

    7. 当业务通信发生异常了,能否方便看到和追踪通信报文细节(更便于我们一步一步查找问题原因)??采用Netty内置Logging机制

    8. 当服务端因为非预期原因断开或崩溃,然后发现修复重启后是否每个客户端都要手动再连接一下?? 设计断线自动尝试重连

    9. 当服务器空闲一段时间后,是否该有一种机制自动触发心跳检测网络的健康状况??采用IdleState和自动触发机制

     

    一、基础设施部分

    /**
    * @author andychen https://blog.51cto.com/14815984
    * @description:Kryo序列化器单例
    */
    public class KryoBuilder {
       private KryoBuilder(){}
    
       /**
        * 获取单例
        * @return
        */
       public static Kryo getInstance(){
           return SingleKryo.builder;
       }
       private static class SingleKryo{
           private static Kryo builder = new Kryo();
       }
    
       /**
        * 构建kryo对象和注册
        * @return
        */
       public static Kryo build(){
           Kryo kryo = getInstance();
           kryo.setRegistrationRequired(false);
           kryo.register(Arrays.asList("").getClass(), new ArraysAsListSerializer());
           kryo.register(GregorianCalendar.class, new GregorianCalendarSerializer());
           kryo.register(InvocationHandler.class, new JdkProxySerializer());
           kryo.register(BigDecimal.class, new DefaultSerializers.BigDecimalSerializer());
           kryo.register(BigInteger.class, new DefaultSerializers.BigIntegerSerializer());
           kryo.register(Pattern.class, new RegexSerializer());
           kryo.register(BitSet.class, new BitSetSerializer());
           kryo.register(URI.class, new URISerializer());
           kryo.register(UUID.class, new UUIDSerializer());
           UnmodifiableCollectionsSerializer.registerSerializers(kryo);
           SynchronizedCollectionsSerializer.registerSerializers(kryo);
    
           kryo.register(HashMap.class);
           kryo.register(ArrayList.class);
           kryo.register(LinkedList.class);
           kryo.register(HashSet.class);
           kryo.register(TreeSet.class);
           kryo.register(Hashtable.class);
           kryo.register(Date.class);
           kryo.register(Calendar.class);
           kryo.register(ConcurrentHashMap.class);
           kryo.register(SimpleDateFormat.class);
           kryo.register(GregorianCalendar.class);
           kryo.register(Vector.class);
           kryo.register(BitSet.class);
           kryo.register(StringBuffer.class);
           kryo.register(StringBuilder.class);
           kryo.register(Object.class);
           kryo.register(Object[].class);
           kryo.register(String[].class);
           kryo.register(byte[].class);
           kryo.register(char[].class);
           kryo.register(int[].class);
           kryo.register(float[].class);
           kryo.register(double[].class);
    
           return kryo;
       }
    }
    /**
    * @author andychen https://blog.51cto.com/14815984
    * @description:Kryo序列化器
    */
    public class KryoSerializer {
       private static final Kryo kryo = KryoBuilder.build();
    
       /**
        * 序列化
        *
        * @param object
        * @param buf
        */
       public static void serialize(Object object, ByteBuf buf) {
           ByteArrayOutputStream stream = new ByteArrayOutputStream();
           try{
               Output out = new Output(stream);
               kryo.writeClassAndObject(out, object);
               out.flush();
               out.close();
    
               byte[] bytes = stream.toByteArray();
               stream.flush();
               stream.close();
               /**
                * 写入buffer
                */
               buf.writeBytes(bytes);
           } catch (Exception e) {
               e.printStackTrace();
           }
       }
    
       /**
        * 反序列化
        * @param buf 数据缓冲
        * @return
        */
       public static Object deserialize(ByteBuf buf) {
           try(ByteBufInputStream stream = new ByteBufInputStream(buf)) {
               Input input = new Input(stream);
               return kryo.readClassAndObject(input);
           } catch (Exception e) {
               e.printStackTrace();
           }
           return null;
       }
    }
    /**
    * @author andychen https://blog.51cto.com/14815984
    * @description:Kryo编码器
    */
    public class KryoEncoder extends MessageToByteEncoder<Message> {
       /**
        * 编码实现
        * @param channelHandlerContext 处理器上下文
        * @param message 报文
        * @param byteBuf 对端数据缓冲
        * @throws Exception
        */
       @Override
       protected void encode(ChannelHandlerContext channelHandlerContext, Message message, ByteBuf byteBuf) throws Exception {
           KryoSerializer.serialize(message, byteBuf);
           channelHandlerContext.flush();
       }
    }
    /**
    * @author andychen https://blog.51cto.com/14815984
    * @description:Kryo解码器
    */
    public class KryoDecoder extends ByteToMessageDecoder {
       /**
        * 解码实现
        * @param channelHandlerContext 处理器上下文
        * @param byteBuf 对端缓冲
        * @param list 反序列化列表
        * @throws Exception
        */
       @Override
       protected void decode(ChannelHandlerContext channelHandlerContext, ByteBuf byteBuf, List<Object> list) throws Exception {
           Object object = KryoSerializer.deserialize(byteBuf);
           list.add(object);
       }
    }
    /**
    * @author andychen https://blog.51cto.com/14815984
    * @description:系统快捷工具类
    */
    public final class Utility {
       /**
        * 构建报文
        * @param sessionId 会话Id
        * @param msg 主体
        * @return
        */
       public static Message buildMessage(int sessionId, Object msg, byte type){
           //获取校验码
           final int OFFSET = 9;
           int seed = sessionId+(sessionId > OFFSET ? sessionId : sessionId+OFFSET);
           String crc = CRC.getCRC16(seed);
           MessageHeader header = new MessageHeader();
           header.setCrc(crc);
           header.setLength(calcBufferLen(msg));
           header.setSessionId(sessionId);
           header.setType(type);
    
           Message message = new Message();
           message.setHeader(header);
           message.setBody(msg);
    
           return message;
       }
    
       /**
        * 是否IP认证通过
        * @return
        */
       public static boolean isIPPassed(String ip){
           for (String p : Constant.WHITELIST){
               if(ip.equals(p)){
                   return true;
               }
           }
           return false;
       }
    
       /**
        * 计算报文长度
        * @param msg 报文对象
        * @return int
        */
       private static int calcBufferLen(Object msg){
           try(ByteArrayOutputStream stream = new ByteArrayOutputStream();
               ObjectOutputStream output = new ObjectOutputStream(stream)){
               output.writeObject(msg);
               return stream.toByteArray().length;
           }catch (IOException e){
               e.printStackTrace();
           }
           return 0;
       }
    }
    /**
    * @author andychen https://blog.51cto.com/14815984
    * @description:私有报文
    */
    public final class Message {//<T extends Object>
       /**
        * 报文头
        */
       private MessageHeader header;
       /**
        * 报文主体
        */
       private Object body;
       public MessageHeader getHeader() {
           return header;
       }
    
       public void setHeader(MessageHeader header) {
           this.header = header;
       }
    
       public Object getBody() {
           return body;
       }
    
       public void setBody(Object body) {
           this.body = body;
       }
    
       @Override
       public String toString() {
           return "Message [header=" + this.header + "][body="+this.body+"]";
       }
    }
    /**
    * @author andychen https://blog.51cto.com/14815984
    * @description:报文头
    */
    public final class MessageHeader {
       /**
        * CRC校验码
        */
       private String crc;
       /**
        * 会话id
        */
       private int sessionId;
       /**
        * 报文长度
        */
       private int length;
       /**
        * 报文类型码
        */
       private byte type;
       /**
        * 报文优先级
        */
       private int priority;
       /**
        * 报文附件
        */
       private Map<String,Object> attachment = new HashMap<>();
    
       public String getCrc() {
           return crc;
       }
    
       public void setCrc(String crc) {this.crc = crc;}
    
       public int getSessionId() {
           return sessionId;
       }
    
       public void setSessionId(int sessionId) {
           this.sessionId = sessionId;
       }
    
       public int getLength() {
           return length;
       }
    
       public void setLength(int length) {
           this.length = length;
       }
    
       public byte getType() {
           return type;
       }
    
       public void setType(byte type) {
           this.type = type;
       }
    
       public int getPriority() {
           return priority;
       }
    
       public void setPriority(int priority) {
           this.priority = priority;
       }
    
       public Map<String, Object> getAttachment() {
           return attachment;
       }
    
       public void setAttachment(Map<String, Object> attachment) {
           this.attachment = attachment;
       }
       @Override
       public String toString() {
           return "MessageHeader [crc=" + this.crc + ", length=" + this.length
                   + ", sessionId=" + this.sessionId + ", type=" + this.type + ", priority="
                   + this.priority + ", attachment=" + this.attachment + "]";
       }
    }
    /**
    * @author andychen https://blog.51cto.com/14815984
    * @description:数据报文类型
    */
    public enum MessageType {
       /**
        * 认证请求
        */
       AUTH_REQUEST((byte)0),
       /**
        * 认证应答
        */
       AUTH_REPLY((byte)1),
       /**
        * 心跳请求
        */
       HEARTBEAT_REQUEST((byte)2),
       /**
        * 心跳应答
        */
       HEARTBEAT_REPLY((byte)3),
       /**
        * 普通请求
        */
       REQUEST((byte)4),
       /**
        * 普通应答
        */
       REPLY((byte)5);
    
       public byte getValue() {
           return value;
       }
    
       private final byte value;
       MessageType(byte b) {
           this.value = b;
       };
    }

    二、客户端部分

    /**
    * @author andychen https://blog.51cto.com/14815984
    * @description:框架客户端启动器类
    */
    public class ClientStarter {
       /**
        * 日志处理
        */
       private static final Log log = LogFactory.getLog(ClientStarter.class);
    
       /**
        * 客户端启动
        * @param args
        */
       public static void main(String[] args) throws Exception {
           ClientTask client = new ClientTask(Constant.SERV_HOST, Constant.SERV_PORT);
           new Thread(client).start();
           while (!client.isConnected()){
               synchronized (client){
                   client.wait();
               }
           }
           log.info("与服务器连接已建立,准备通信...");
           /**
            * 采用在控制台适时输入消息主体的方式,发送报文
            */
           Scanner scanner = new Scanner(System.in);
           for (;;){
               String body = scanner.next();
               if(null != body && !"".equals(body)){
                   if(!body.equalsIgnoreCase("exit")){
                       client.send(body);
                   }else{
                       client.close();
                       /**
                        * 等待连接正常关闭通知
                        */
                       while (client.isConnected()){
                           synchronized(client){
                               client.wait();
                           }
                       }
                       scanner.close();
                       System.exit(0);//提示正常退出
                   }
               }
           }
       }
    }
    /**
    * @author andychen https://blog.51cto.com/14815984
    * @description:客户端封装
    */
    public class ClientTask implements Runnable {
       private final String host;
       private final int port;
       public ClientTask(String host, int port) {
           this.host = host;
           this.port = port;
       }
       /**
        * 日志处理
        */
       private static final Log log = LogFactory.getLog(ClientTask.class);
       /**
        * 报文计数器
        */
       public final static AtomicInteger counter = new AtomicInteger(0);
       /**
        * 这里用1个后台线程,定时执行检测客户端连接是否断开,若非用户断开则自动尝试重连
        */
       private final ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
       /**
        * 客户端连接通道
        */
       private Channel channel;
       /**
        * 工作线程池组
        */
       private EventLoopGroup group = new NioEventLoopGroup();
       /**
        * 是否意外关闭:出异常或网络断开(区别于人为主动关闭)
        */
       private volatile boolean except_closed = true;
       /**
        * 是否连接成功
        */
       private volatile boolean connected = false;
       private static Object _obj = new Object();
    
       /**
        * 是否连接
        * @return
        */
       public boolean isConnected(){
           return this.connected;
       }
    
       /**
        * 执行客户端
        */
       @Override
       public void run() {
           try {
               this.connect();
           } catch (Exception e) {
               e.printStackTrace();
           }
       }
       /**
        * 连接服务器端
        */
       public void connect() throws Exception{
           try {
               Bootstrap bootstrap = new Bootstrap();
               bootstrap.group(group)
                        .channel(NioSocketChannel.class)
                        //设置TCP底层保温发送不延迟
                        .option(ChannelOption.TCP_NODELAY, true)
                        .handler(new ChannelInitializerExt());
    
               //(1)异步连接服务器端,等待发送和接收报文
               ChannelFuture future = bootstrap.connect(new InetSocketAddress(this.host, this.port)).sync();
               this.channel = future.sync().channel();
               //(2)通知其他等待线程,连接已建立
               synchronized(this){
                   this.connected = true;
                   this.notifyAll();
               }
               this.channel.closeFuture().sync();
           } finally {
               //检测并执行重连接
               this.reconnect();
           }
       }
    
       /**
        * 关闭连接:非正常关闭
        */
       public void close(){
           this.except_closed = false;
           this.channel.close();
       }
    
       /**
        * 发送报文
        * @param body 报文主体
        */
       public void send(String body){
           if(null != this.channel && this.channel.isActive()){
               Message message = Utility.buildMessage(counter.incrementAndGet(), body, MessageType.REQUEST.getValue());
               this.channel.writeAndFlush(message);
               return;
           }
           log.info("通信尚未建立,请稍后再试...");
       }
       /**
        * 执行重连接
        * @throws Exception
        */
       private void reconnect() throws Exception{
           //主动关闭被检测到
           if(this.except_closed){
               log.info("连接非正常关闭,准备尝试重连...");
               this.executor.execute(new ReconnectTask(this.host, this.port));
           }else{
               //主动关闭连接:释放资源
               this.relese();
           }
       }
    
       /**
        * 关闭连接释放资源,通知其它等待的线程
        * @throws Exception
        */
       private void relese() throws Exception{
           this.channel = null;
           this.group.shutdownGracefully().sync();
           synchronized (this){
               this.connected = false;
               this.notifyAll();
           }
       }
    
       /**
        * 尝试重连服务器任务
        */
       private class ReconnectTask implements Runnable{
           private final String h;
           private final int p;
           public ReconnectTask(String h, int p) {
               this.h = h;
               this.p = p;
           }
           /**
            * 尝试重连
            */
           @Override
           public void run() {
               try {
                   //间隔1秒重试一次
                   Thread.sleep(1000);
                   connect();
               } catch (Exception e) {
                   e.printStackTrace();
               }
           }
       }
    }
    /**
    * @author andychen https://blog.51cto.com/14815984
    * @description:客户端通道初始化器扩展
    */
    public class ChannelInitializerExt extends ChannelInitializer<SocketChannel> {
       /**
        * 初始化通道
        * @param channel 通道
        * @throws Exception 异常
        */
       @Override
       protected void initChannel(SocketChannel channel) throws Exception {
           ChannelPipeline pipeline = channel.pipeline();
           //(1)报文粘包处理
           pipeline.addLast(new LengthFieldBasedFrameDecoder(Constant.MAX_MSG_LEN,0,2,0,2));
           //(2)给报文增加分割长度
           pipeline.addLast(new LengthFieldPrepender(2));
           //(3)报文解码器
           pipeline.addLast(new KryoDecoder());
           //(4)报文编码器
           pipeline.addLast(new KryoEncoder());
           //(5)连接超时检测
           pipeline.addLast(new ReadTimeoutHandler(Constant.TIMEOUT_SECONDS));
           //(6)认证请求
           pipeline.addLast(new AuthenticationHandler());
           //(7)心跳处理:发送心跳
           pipeline.addLast(new HeartbeatHandler());
       }
    }
    /**
    * @author andychen https://blog.51cto.com/14815984
    * @description:客户端认证请求
    */
    public class AuthenticationHandler extends ChannelInboundHandlerAdapter {
       /**
        * 日志处理
        */
       private static final Log log = LogFactory.getLog(AuthenticationHandler.class);
       /**
        * 全局计数器
        */
       private final static AtomicInteger counter = new AtomicInteger(0);
       /**
        * 通道开启事件
        * @param ctx 处理器上下文
        * @throws Exception
        */
       @Override
       public void channelActive(ChannelHandlerContext ctx) throws Exception {
           /**
            * 发起认证请求
            */
           Message message = Utility.buildMessage(counter.incrementAndGet(), "Auth Request",
                   MessageType.AUTH_REQUEST.getValue());
           ctx.writeAndFlush(message);
       }
    
       /**
        * 处理网络读取事件
        * @param ctx 处理器上下文
        * @param msg 报文
        * @throws Exception
        */
       @Override
       public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
           Message message = (Message)msg;
           if(null != message){
               MessageHeader header = message.getHeader();
               //处理认证应答
               if(null != header && header.getType() == MessageType.AUTH_REPLY.getValue()){
                   String body = message.getBody().toString();
                   if(body.equals(AuthenticationResult.FAILED)){
                       log.info("Authentication failed, channel close..");
                       ctx.close();
                       return;
                   }
                   log.info("Authentication is ok: "+message);
               }
           }
           ctx.fireChannelRead(msg);
       }
    
       /**
        * 客户端认证异常处理
        * @param ctx
        * @param cause
        * @throws Exception
        */
       @Override
       public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
           cause.printStackTrace();
           ctx.fireExceptionCaught(cause);
       }
    }
    /**
    * @author andychen https://blog.51cto.com/14815984
    * @description:客户端心跳处理器
    */
    public class HeartbeatHandler extends ChannelInboundHandlerAdapter {
       /**
        * 日志处理
        */
       private static final Log log = LogFactory.getLog(AuthenticationHandler.class);
       /**
        * 心跳定时任务
        */
       private volatile ScheduledFuture<?> scheduleHeartbeat;
       /**
        * 处理客户端心跳请求报文
        * @param ctx 处理器上下文
        * @param msg 消息对象
        * @throws Exception
        */
       @Override
       public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
           Message message = (Message)msg;
           if(null != message){
               MessageHeader header = message.getHeader();
               //处理认证应答
               if(header.getType() == MessageType.AUTH_REPLY.getValue()){
                   //登录完成后,开启客户端对服务端心跳
                   this.scheduleHeartbeat = ctx.executor().scheduleAtFixedRate(new HeartbeatTask(ctx),
                           0, Constant.HEARTBEAT_TIMEOUT,
                           TimeUnit.MILLISECONDS);
                   return;
               }
               //处理心跳应答
               if(header.getType() == MessageType.HEARTBEAT_REPLY.getValue()){
                   log.info("Client recevied server heartbeat: "+message);
                   ReferenceCountUtil.release(msg);
                   return;
               }
           }
           ctx.fireChannelRead(msg);
       }
    
       /**
        * 客户端捕获心跳异常
        * @param ctx 处理器上下文
        * @param cause 异常
        * @throws Exception
        */
       @Override
       public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
           cause.printStackTrace();
           if(null != this.scheduleHeartbeat){
               this.scheduleHeartbeat.cancel(true);
               this.scheduleHeartbeat = null;
           }
           //传递给TailHandler处理
           ctx.fireExceptionCaught(cause);
       }
    
       /**
        * 定义心跳任务
        */
       private class HeartbeatTask implements Runnable{
           /**
            * 心跳计数器
            */
           private final AtomicInteger counter = new AtomicInteger(0);
           private final ChannelHandlerContext ctx;
           public HeartbeatTask(ChannelHandlerContext ctx) {
               this.ctx = ctx;
           }
           /**
            * 心跳任务执行
            */
           @Override
           public void run() {
               //客户端心跳报文
               Message heartbeat = Utility.buildMessage(this.counter.incrementAndGet(), Constant.HEARTBEAT_ACK,
                       MessageType.HEARTBEAT_REQUEST.getValue());
               this.ctx.writeAndFlush(heartbeat);
           }
       }
    }

    三、服务器部分

    /**
    * @author andychen https://blog.51cto.com/14815984
    * @description:框架服务端启动器类
    */
    public class ServerStarter {
       /**
        * 日志处理
        */
       private static final Log log = LogFactory.getLog(ServerStarter.class);
       /**
        * 服务端启动
        * @param args
        */
       public static void main(String[] args) throws Exception {
           //主线程池组:负责处理连接
           EventLoopGroup main = new NioEventLoopGroup();
           //工作线程池组:负责请求对应的业务Handler处理
           EventLoopGroup work = new NioEventLoopGroup();
    
           ServerBootstrap bootstrap = new ServerBootstrap();
           bootstrap.group(main, work)
                    .channel(NioServerSocketChannel.class)
                    //设置底层协议接收缓存队列最大长度
                    .option(ChannelOption.SO_BACKLOG, Constant.TCP_MAX_QUEUE_SIZE)
                    .childHandler(new ChannelInitializerExt());
           //绑定端口,等待同步报文
           bootstrap.bind(Constant.SERV_PORT).sync();
           log.info("Server started and listen port: "+Constant.SERV_PORT+"...");
       }
    }
    /**
    * @author andychen https://blog.51cto.com/14815984
    * @description:服务器通道初始化器
    */
    public class ChannelInitializerExt extends ChannelInitializer<SocketChannel> {
       /**
        * 初始化处理器
        * @param channel 连接通道
        * @throws Exception 异常
        */
       @Override
       protected void initChannel(SocketChannel channel) throws Exception {
           ChannelPipeline pipeline = channel.pipeline();
           //(1)日志打印处理:可以打印报文字节码
           pipeline.addLast(new LoggingHandler(LogLevel.INFO));
           //(2)处理粘包问题:带长度
           pipeline.addLast(new LengthFieldBasedFrameDecoder(Constant.MAX_MSG_LEN,0,2,0,2));
           //(3)报文编码器:消息发送增加分隔符
           pipeline.addLast(new LengthFieldPrepender(2));
           //(4)私有报文解码
           pipeline.addLast(new KryoDecoder());
           //(5)私有报文编码
           pipeline.addLast(new KryoEncoder());
           //(6)通道连接超时检测,发送心跳
           pipeline.addLast(new ReadTimeoutHandler(Constant.TIMEOUT_SECONDS));
           //(7)身份认证应答
           pipeline.addLast(new AuthenticationHandler());
           //(8)心跳应答
           pipeline.addLast(new HeartbeatHandler());
           //(9)其他业务处理...
           pipeline.addLast(new OtherServiceHandler());
       }
    }
    /**
    * @author andychen https://blog.51cto.com/14815984
    * @description:服务端身份认证处理器
    */
    public class AuthenticationHandler extends ChannelInboundHandlerAdapter {
       /**
        * 日志处理
        */
       private static final Log log = LogFactory.getLog(AuthenticationHandler.class);
       /**
        * 定义认证业务计数器
        */
       private static final AtomicInteger counter = new AtomicInteger(0);
       /**
        * 缓存已认证ip列表
        */
       private static final List<String>  authedIPList = new LinkedList<>();
       /**
        * 认证业务处理
        * @param ctx
        * @param msg
        * @throws Exception
        */
       @Override
       public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
           Message message = (Message)msg;
           Message authMessage;
           if(null != message){
               MessageHeader header = message.getHeader();
               //处理认证请求
               if(null != header && header.getType() == MessageType.AUTH_REQUEST.getValue()){
                   String ip = ctx.channel().remoteAddress().toString();
                   String result;
                   //重复登录
                   if(authedIPList.contains(ip)){
                       result = AuthenticationResult.REPEAT_AUTH.toString();
                   }else{
                       //是否ip认证通过
                       if(Utility.isIPPassed(ip)){
                           authedIPList.add(ip);
                           result = AuthenticationResult.SUCCESS.toString();
                       }else{
                           result = AuthenticationResult.FAILED.toString();
                       }
                   }
                   authMessage = Utility.buildMessage(counter.incrementAndGet(), result, MessageType.AUTH_REPLY.getValue());
                   ctx.writeAndFlush(authMessage);
                   //释放对象,不再向后传递
                   ReferenceCountUtil.release(msg);
                   log.info("Server reply client auth request:"+authMessage);
                   return;
               }
           }
           ctx.fireChannelRead(msg);
       }
    
       /**
        * 认证处理器捕获异常处理
        * @param ctx 处理器上下文
        * @param cause 异常
        * @throws Exception
        */
       @Override
       public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
           cause.printStackTrace();
           authedIPList.remove(ctx.channel().remoteAddress().toString());
           ctx.close();
           ctx.fireExceptionCaught(cause);
       }
    }
    /**
    * @author andychen https://blog.51cto.com/14815984
    * @description:服务器端心跳包处理器
    */
    public class HeartbeatHandler extends ChannelInboundHandlerAdapter {
       /**
        * 日志处理
        */
       private static final Log log = LogFactory.getLog(HeartbeatHandler.class);
       /**
        * 会话计数器
        */
       private final AtomicInteger counter = new AtomicInteger(0);
       /**
        * 处理心跳报文
        * @param ctx 处理器上下文
        * @param msg 消息报文
        * @throws Exception
        */
       @Override
       public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
           Message message = (Message)msg;
           if(null != message){
               MessageHeader header = message.getHeader();
               /**
                * 处理心跳请求
                */
               if(null != header && header.getType() == MessageType.HEARTBEAT_REQUEST.getValue()){
                   log.info("Server recevied client heartbeat: "+message);
                   //应答报文
                   Message heartbeat = Utility.buildMessage(counter.incrementAndGet(), Constant.HEARTBEAT_ACK,
                           MessageType.HEARTBEAT_REPLY.getValue());
                   ctx.writeAndFlush(heartbeat);
                   //引用计数器释放对象
                   ReferenceCountUtil.release(msg);
                   return;
               }
           }
           ctx.fireChannelRead(msg);
       }
    }
    /**
    * @author andychen https://blog.51cto.com/14815984
    * @description:其它业务处理
    */
    public class OtherServiceHandler extends SimpleChannelInboundHandler<Message> {
       /**
        * 日志处理
        */
       private static final Log log = LogFactory.getLog(OtherServiceHandler.class);
       /**
        * 读取对端发送的报文
        * @param ctx 处理器上下文
        * @param message 报文
        * @throws Exception
        */
       @Override
       protected void channelRead0(ChannelHandlerContext ctx, Message message) throws Exception {
           log.info(message);
       }
       /**
        * 连接断开事件
        * @param ctx 上下文
        * @throws Exception
        */
       @Override
       public void channelInactive(ChannelHandlerContext ctx) throws Exception {
           log.info("["+ctx.channel().remoteAddress()+"]断开了连接...");
       }
    }

     

    运行检验

    image.png

    image.png

    image.png

    image.png

    image.png

    开发小结

    以上就是我们基于Netty实现的一整套通信应用框架的和核心代码。所有的业务开发都可定制和构建类似此的基础应用框架,开发Handler处理器的业务人员可任意嵌入被解耦化的业务领域Handler。可采用Handler自动注入Netty管道的方式零侵入框架,支持更多更复杂的业务!希望本文能给大家提供靠谱和一站式的借鉴。大家有任何关于Netty的问题可以在下方留言,谢谢关注!

    展开全文
  • 为支持该文章的研究而编制的数据集包括所有联邦集体诉讼投诉,指控在过去十年中提出的在线隐私侵犯以及联邦贸易委员会针对在线隐私的投诉和和解。 本文接下来讨论管辖权和权限在构成索赔方面的作用,并确定消费者所...
  • 然后,第2部分研究了在下游最终用户市场中,一般而言首先获得频谱然后获得特定频率对于提供特定服务必不可少的程度。 该文件所涉及的活动产生了电子通信服务,包括移动和无线语音和数据服务(大部分分析针对的是该...
  • 用户研究和经济分析提高了我们对隐私体验的理解,包括期望与现实之间的差距(Acquisti & Grossklags;McDonald & Cranor;Jolls、Sunstein & Thaler)。 计算机科学和信息理论帮助我们量化我们称为隐私的一些要素...
  • 在为 LHCS 提出的伦理框架中,所有医疗保健利益相关者都有责任为学习做出贡献,包括患者,他们将主要通过允许他们的健康数据用于研究来履行这一义务。 虽然患者最终将从 LHCS 中受益,但要求个人在建立互惠利益之前...
  • 图书馆包括 128 种法律期刊(大多数回到它们的第一期),以及法学院研究资料库、司法奖学金数据库、历史法律专着、来自开放内容出版商的法律文本、法律改革报告和法律论文摘要。 该图书馆还与 AustLII 的 LawCite ...
  • 信息技术的使用改变了投诉处理系统和争议解决机制的几个方面。 本文通过关注两个特定方面来回顾其中的一些修改:投诉提交流程和在线争议解决系统。 论据如下。 消费者投诉提交流程可以作为解决消费者纠纷的第一步。 ...
  • 首先评估技术变革如何塑造行业监管,然后讨论为什么物联网设备会对隐私产生负面影响,以及新监管机制应对“永远在线”时代挑战的潜在适用性。 在得出当前监管框架在保护个人隐私方面受到严重限制的结论后,第三部分...
  • 尽管当前的一些隐私制度提供了与严格定义的数据类型相关的名义上类似正当程序的机制,但这些机制很少包含所有保证公平结果的必要组成部分,并且可以说不适用于多种大数据系统(Terry 2012)。 需要一个更严格的框架...
  • 药物的不良反应主要包括哪些类型?请举例说明。 (1)副反应:如氯苯那敏(扑尔敏)治疗皮肤过敏时可引起中枢抑制。(2)毒性反应:如尼可刹米过量可引起惊厥,甲氨蝶呤可引起畸胎。(3)后遗效应:如苯巴比妥治疗...

    药理学研究的主要内容包括哪几个方面?
    (1)药物效应动力学(药效学):研究药物对机体的作用,包括药物的作用、作用机制等。(2)药物代谢动力学(药动学):研究机体对药物的作用,包括药物在体内的吸收、分布、生物转化和排泄过程,特别是血药浓度随时间变化的规律。(3)影响药效学和药动学的因素。
     

    药物的不良反应主要包括哪些类型?请举例说明。
    (1)副反应:如氯苯那敏(扑尔敏)治疗皮肤过敏时可引起中枢抑制。(2)毒性反应:如尼可刹米过量可引起惊厥,甲氨蝶呤可引起畸胎。(3)后遗效应:如苯巴比妥治疗失眠,引起次日的中枢抑制。(4)停药反应:长期应用某些药物,突然停药后原有疾病加剧,如抗癫痫药突然停药可使癫痫复发,甚至可导致癫痫持续状态。(5)变态反应:如青霉素G可引起过敏性休克。(6)特异质反应:少数红细胞缺乏G-6-PD的特异体质病人使用伯氨喹后可以引起溶血性贫血或高铁血红蛋白血症。
     

    何谓药物的效应、最大效能和效应强度?
    (1)效应:是指药物与机体组织间相互作用而引起机体在功能或形态上的改变。(2)最大效能:是指在量效曲线上,随药物浓度或剂量的增加,效应强度也增加,直至达到最大效应(即为最大效能)。(3)效应强度:是指在量效曲线上达到一定效应时所需的剂量(等效剂量)大小。

     

    文章剩余内容<<<<<

     

    展开全文
  • 故障诊断学基础知识

    2021-03-04 21:59:46
    因此包括信号获取与传感技术、故障机理与征兆联系、信号处理与特征提取、识别分类与智能决策等方面的研究,根据基础和关键科学问题又可细分为机械系统运行状态下故障动态演化机理、机械系统动态信号处理的内积匹配...

    1. 机械故障诊断涉及哪些学科?做哪方面的科学研究?包含了哪些技术?形成了哪些方法?解决什么工程问题?

    (1) 涉及的学科有:机械、力学、电子、计算机、信号处理、人工智能等。

    (2) 机械故障诊断是研究机器或机组运行状态的变化在诊断信息中的反映,因此包括信号获取与传感技术、故障机理与征兆联系、信号处理与特征提取、识别分类与智能决策等方面的研究,根据基础和关键科学问题又可细分为机械系统运行状态下故障动态演化机理、机械系统动态信号处理的内积匹配原理与微弱信号特征增强机制、故障定量识别和剩余寿命预测原理、人工智能诊断与机械故障预示方法等方面。

    (3) 在故障机理方面,一般分析流程是根据研究对象的物理特点,建立相应的数学力学模型(正问题-有限元建模与动力学分析),通过仿真研究获得其响应特征,再结合实验修正模型(反问题-动态信号特征准确提取),因此包含的技术主要集中在有限元和动力学原理方面,对于常见的机械基础零部件转子、齿轮、轴承等形成了较为完善的基于动力学机理的故障诊断方法;

    在信号处理方面,包含时频域分析、小波分析、循环平稳信号分析、经验模式分解、时间序列、随机共振、盲源分离、卡尔曼滤波、混沌分叉等技术,形成了基于全息谱、多种小波函数、时间序列模型、隐式马可夫模型、自适应随机共振、总体经验模式分解的故障诊断方法;

    在智能诊断方面,一方面传统的机器学习理论为故障诊断带来了专家系统、遗传算法、神经网络、模糊理论、故障树、决策树、粗糙集理论、支持向量机、PCA、ICA、ANN、KNN、PGM等技术,另一方面随着现代深度学习理论的逐步完善,形成了例如基于CNN、DBN、RestNet等一批目前较为流行的故障诊断方法,并且为了对接工程实际的运用,未来智能诊断会向着转移学习理论方面深入。

    其它,除上述方法外,还有油液分析、红外热成像、无损检测、热工参量、电工参量等诊断方法。

    (4) 随着科学技术和现代化工业的飞速发展,关键机械设备一旦出现事故,将会带来巨大的经济损失和人员伤亡,因此故障诊断被广泛的应用于解决多种多样的工程问题,其中机械系统早期故障、微弱故障和复合故障的定量诊断与预示、剩余寿命预测更具有工程意义。目前各种诊断方法的常见研究对象为机械系统中三大基础零部件轴承、齿轮、转子,主要是由于这些零部件往往是旋转机械系统发生故障的主要原因。

    2. 诊断对象有哪些(轴承、齿轮、转子、以及往复机械)?每种对象的故障特征是?针对不同诊断对象,有哪些适用方法?

    (1) 转子:

    不平衡–振动频谱能量集中于基频,轴心轨迹为椭圆,转子相位稳定,为同步正进动

    在这里插入图片描述
    碰磨–转子失稳后波形严重畸变或削波,轴心轨迹发散,反进动;轻微碰摩时同频幅值波动,轴心轨迹带有小圆环内圈;随着碰摩严重程度的增加,内圈小圆环增多,且形状变化不定;轨迹图上键相位置不稳定,出现快速跳动现象;碰摩严重时,出现(1/2)X频率成分,其轴心轨迹形状为“8”字形;
    在这里插入图片描述

    裂纹–各阶临界转速较正常时要小,尤其在裂纹严重时;由于裂纹造成刚度变化且不对称,转子的共振转速扩展为一个区,振动带有非线性,特征,出现旋转频率的2X、3X…等高倍频分量。裂纹扩展时,刚度进一步降低,1X.2X…等频率的幅值也随之增大;裂纹转子轴系在强迫响应时,一-次分量的分散度比无裂纹时大;转速超过临界转速后,一般各高阶谐波振幅较未超过时小;裂纹引起刚度不对称,使转子动平衡发生困难,往往多次试验也达不到所要求的平衡精度;机器开机或停机,工作转速通过1/2临界转速或1/3临界转速时,振幅响应有共振峰值;轴上出现裂纹时,初期扩展速度很慢,径向振幅的增长也很慢,但裂纹的扩展会随着裂纹深度的增大而加速,相应地也会出现1X和2X的振幅迅速增大,相位角也出现异常的波动。
    在这里插入图片描述

    松动–松动故障会引起转子的(1/2)X、(1/3)X等分数次谐波频率;松动的另一特征是振动的方向性,特别是松动方向上的振动。由于约束力的下降,将引起振动的加大。松动使转子系统在水平方向和垂直方向具有不同的临界转速,因此分数次谐波共振现象有可能发生在水平方向,也有可能发生在垂直方向;在松动情况下,振动形态会发生“跳跃"现象。当转速增加或减小时,振动会突然增大或减小;松动部件的振动具有不连续性,有时用手触摸也能感觉到;松动除产生上述低频振动外,还存在同频或倍频振动。
    在这里插入图片描述

    (2) 轴承:

    在这里插入图片描述
    滚动轴承信号的特性是它们不是周期性的而是随机的,轴承故障通常从小凹坑或剥落开始,并在覆盖非常宽的频率范围的早期给出尖锐的脉冲,这一事实使它们可以与确定性信号(例如齿轮)分开。出于某些目的,可以将它们建模为循环平稳的,但实际上并不是严格循环平稳的(至少对于局部缺陷而言),因此已创造了术语“伪循环平稳”,此外原始信号的频谱通常很少包含有关轴承故障的诊断信息。

    当滚动轴承的某一元件表面存在局部故障时,在轴承的旋转过程中,故障表面会周期性地撞击滚动轴承其他元件表面,从而会产生周期性的脉冲力。由这种脉冲力引起的高频冲击振动,不但会激起轴承系统中各个元件的固有频率振动,而且各个固有频率振动的幅值和频率,还会受到脉冲力的调制,且在轴承系统中,各个元件又有各自的固有频率。因此.滚动轴承故障振动信号具有多载波.多调制的特性

    当滚动轴承发生点蚀.磨损、裂纹等局部损伤类故障时,通常会激起轴承系统的高频固有振动,其振动信号表现为以系统固有频率为载波,故障特征频率为调制波的调制特征。要从此类信号中提取故障特征信息,包络分析法是目前公认的最有效的方法。其基本原理是.先通过以载波频率为中心频率的带通滤波器,将振动信号中的高频固有振动成分分离出来,然后通过包络检波器检波.得到只包含故障特征信息的低频包络信号,再对包络信号进行频谱分析,便可诊断出故障来。然而,传统的包络分析法在实际应用中,由于轴承故障振动信号的载波频率成分的多少和载波频率的大小很难确定,故在进行带通滤波时滤波器的中心频率和带宽的选择会具有很大的主观性。这样便会带来解调误差,不能有效地提取滚动轴承故障振动信号的特征,针对以上情况,本章提出了基于LMD和谱峭度的包络分析方法,应用于滚动轴承的故障诊断。先采用LMD方法对轴承振动信号进行分解.以起到自适应分离固有振动成分和初步降噪的作用;然后对含有高频固有振动成分的PF分量进行谱峭度分析,便能确定带通滤波器的中心频率和带宽;最后对滤波后的信号进行包络谱分析,即可实现滚动轴承的故障诊断。
    在这里插入图片描述
    在这里插入图片描述

    结合轴承振动信号特点,最强大的轴承诊断技术取决于检测和增强信号的脉冲性,下图针对工程信号给出了一个半自动轴承诊断程序:

    在这里插入图片描述

    DRS–discrete/random separation 离散随机分离

    SANC-- self-adaptive noise cancellation 自适应降噪

    MED–minimum entropy deconvolution最小熵反卷积

    SK-- spectral kurtosis谱峰度

    Envelope—包络谱

    其它常用基于振动信号诊断方法:
    在这里插入图片描述

    (3) 齿轮:

    齿轮齿上存在的缺陷会导致振幅和频率调制,并且与齿轮的旋转频率成周期性,其中载波频率是啮合频率,该啮合频率由故障齿轮的旋转频率调制,作为调制的结果,诸如齿轮旋转频率,小齿轮旋转频率,齿轮啮合频率,齿轮旋转频率围绕啮合频率形成的边带都可能会出现频谱中。

    齿轮在运行时,由于齿与齿的相互啮合会激起以啮合频率及其倍频为特征频率的啮合振动,故齿轮无论处于什么状态,其振动信号通常都具有多分量的特点。当齿轮存在裂纹、断齿等故障时,由于故障齿在啮合时,不但会引起振动信号的幅值和相位发生变化,而且振动信号的能量也会发生改变,从而相比于正常状态,齿轮的故障振动信号会出现幅值和相位调制现象,且能量也会呈现出周期性变化的特征。于是,可以通过提取齿轮故障振动信号的幅值和相位调制信息.或者是能量的周期性变化信息来对齿轮进行故障诊断。包络分析方法,可以提取幅值调制信息。因此,被广泛应用于齿轮的故障诊断,但通过提取相位调制信息来进行齿轮故障诊断的研究还较少。LMD方法,不但能将具有多分量调幅一调频特点的齿轮故障振动信号,分解为–系列的单分量调幅一调频信号,且能够同时得到各单分量信号的幅值调制信息(瞬时幅值)和相位调制信息(瞬时频率)。因此,LMD方法是适合于处理齿轮故障振动信号的。本章先从齿轮故障振动信号的相位调制信息人手,并根据齿轮振动信号具有多分量的特点,提出了基于LMD的瞬时频率谱方法,来提取齿轮的故障特征信息;然后,根据齿轮故障时振动信号的能量会发生变化的特点,提出了基于LMD的局部能量谱方法,来描述齿轮振动信号能量的周期性变化特征,以此对齿轮进行故障诊断。
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 酵母孢子形成是研究囊泡融合机制包括SNARE蛋白的理想模型系统。在该过程中涉及t-SNARE蛋白Sso1,它是突触囊泡融合所需蛋白syntaxin 1A的同源物.两者SNARE区域有51%的同源性。尽管如此,将SSO1的SNARE区域完全替换...
  • latex如何使节标题居左 ... 确定哪些组件构成了控制平面,包括后备存储,服务发现API,安全组件等。 等 建立最适合您的用例和组织的任何特定于域的配置对象和API (此条目) 考虑如何最好地使控制平面可在需要的...
  • 确定哪些组件构成了控制平面,包括后备存储,服务发现API,安全组件等。 等 建立最适合您的用例和组织的任何特定于域的配置对象和API (此条目) 考虑如何最好地使控制平面可在需要的地方插入 部署各种控制.....
  • 确定哪些组件构成了控制平面,包括后备存储,服务发现API,安全组件等。 等 (此条目) 建立最适合您的用例和组织的任何特定于域的配置对象和API 考虑如何最好地使控制平面可在需要的地方插入 部署各种控制.....
  • TCGA是研究肿瘤相关机制的重要资源。在线数据库更新改版都比较快,使用时需要参照最新的线上数据教程。不过癌症相关的数据库操作起来也都比较类似,输入一个或多个关注的目的基因,查看基因的功能注释,基因在哪些...
  • 该压缩包中包括中英文两个版本。 ...正因为Tanenbaum教授自己设计开发了一个小型、真实的操作系统MINIX,所以通过他在教材中的讲述,读者可以了解实现操作系统时应该考虑哪些问题、注重哪些细节。
  • 包括检查与衰老,受伤或疾病相关的可塑性和认知功能下降相关的机制,并确定我们如何进行干预以改善性能和生活质量。 为了研究可塑性,我们对人们如何学习新技能和能力以及影响学习和保持力的生活方式因素感兴趣。 ...
  • 本课程将全面介绍Windows内部内存管理机制包括寻址原理、进程内存空间分布、核心态用户态内存管理原理以及虚拟内存管理原理等。同时将讨论应用程序中内存的使用问题,内存泄露的发生以及排除方法。 深入研究...
  • 本课程将全面介绍Windows内部内存管理机制包括寻址原理、进程内存空间分布、核心态用户态内存管理原理以及虚拟内存管理原理等。同时将讨论应用程序中内存的使用问题,内存泄露的发生以及排除方法。 深入研究...
  • 本课程将全面介绍Windows内部内存管理机制包括寻址原理、进程内存空间分布、核心态用户态内存管理原理以及虚拟内存管理原理等。同时将讨论应用程序中内存的使用问题,内存泄露的发生以及排除方法。 深入研究...
  • 本课程将全面介绍Windows内部内存管理机制包括寻址原理、进程内存空间分布、核心态用户态内存管理原理以及虚拟内存管理原理等。同时将讨论应用程序中内存的使用问题,内存泄露的发生以及排除方法。 深入研究...

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 128
精华内容 51
关键字:

机制研究包括哪些