精华内容
下载资源
问答
  • 2.1无状态分组过滤器和有状态分组过滤器的区别: 状态分组过滤器:只根据单个IP分组携带的信息确定是否过滤掉该IP。(基于单个IP分组) 状态分组过滤器:不仅根据IP分组携带的信息,而且还根据IP分组所属的...

    一、防火墙概述

    1.1引出防火墙的原因:

    安全的网络系统既要保障正常的数据交换过程,又要能够检测用于实施攻击的数据交换过程。阻止用于实施攻击的数据交换过程需要做到以下两点:一是能够在网络间传输,或者用户终端输入输出的信息流中检测出用于实施攻击的信息流;二是能够丢弃检测出用于实施攻击的信息流。
    防火墙位于网络之间,或者用户终端与网络之间。具有以下功能:一是能够检测出用于实施攻击的信息流,并阻断这样的信息流;二是能够允许正常信息流通过。

    防火墙工作机制:依据配置的安全策略允许或阻断操作。

    1.2防火墙分类:

    个人防火墙
    只保护单台计算机,用于对进出计算机的信息流实施控制,因此,个人防火墙通常是分组过滤器。
    无状态分组过滤器:只根据单个IP分组携带的信息确定是否过滤掉该IP。
    有状态分组过滤器:不仅根据IP分组携带的信息,而且还根据IP分组所属的会话的状态确定是否过滤掉该IP分组。
    网络防火墙
    通常位于内网和外网之间的连接点,对内网中的资源实施保护。目前作为网络防火墙的主要是:分组过滤器、电路层代理、应用层网关。

    分组过滤器:根据用户指定的安全策略对内网和外网之间传输的信息流实施控制,它对信息流的发送端和接收端是透明的,所以分组过滤器的存在不需要改变终端访问网络的方式。

    电路层代理:终端先向电路代理层请求建立TCP连接,电路层代理在完成对终端用户的身份鉴别后,和服务器建立TCP连接,并将这两个TCP绑定在一起。

    应用层网关:对应用层数据进行内容安全检查,应用层各字段值是否正确?请求消息和响应消息是否匹配?文件内容是否包含进制传播的非法内容或病毒?

    防火墙功能—防火墙的功能主要包含以下几个:
    1.服务控制:只允网络间相互交换和特定服务相关的信息流
    2.方向控制:只允许网络之间交换与由属于某个特定网络的终端发起的3特定服务相关的信息流。
    3.用户控制:不同网络之间只允许传输与授权访问用户合法访问网络资源相关的信息流。
    4.行为控制:不同网络只允许传输与行为合理的网络资源访问过程相关的信息流。

    防火墙的局限性:
    1.无法防御网络内部终端发起的攻击。
    2.不能阻止病毒的传播。
    3.无法防御利用防火墙安全策略允许的信息传输过程实施的攻击

    二、分组过滤器

    2.1无状态分组过滤器和有状态分组过滤器的区别:

    无状态分组过滤器:只根据单个IP分组携带的信息确定是否过滤掉该IP。(基于单个IP分组)
    有状态分组过滤器:不仅根据IP分组携带的信息,而且还根据IP分组所属的会话的状态确定是否过滤掉该IP分组。(基于一个会话)
    分组过滤器一般指无状态分组过滤器,通过制定规则对每一个IP分组的单向传输过程独立进行控制,但实际应用中常常需要针对某个服务相关的一组IP分组的传输过程实施控制,这种控制过程一是双向的,完成服务过程中需要双向传输IP分组;二是相关性,同一传输方向,不同顺序的IP分组之间存在相关性,两个不同传输方向的IP分组之间存在相关性,这种情况下的IP分组传输过程需要有状态分组过滤器机制实施控制。

    判别是否是响应消息的依据:一是响应消息是属于终端A发起建立的与Web服务器之间的TCP连接的TCP报文,即TCP报文的源和目的IP地址、源和目的端口号等于标识该TCP连接的两端插口。二是响应消息和终端A发送给Web服务器的请求消息存在相关性,即如果终端A发送的是建立TCP连接请求报文,则响应消息是同意建立TCP连接的响应报文,如果终端A发送的是HTTP请求报文,则响应消息是HTTP响应报文。这就意味着终端A至Web服务器传输方向可以通过无状态分组过滤器实现允许与终端A访问Web服务器相关的TCP报文正常转发的访问控制,而Web服务器至终端A方向的过滤规则必须根据当前TCP连接状态和终端A刚发送给Web服务器的请求报文的内容动态设置,这就是有状态分组过滤器的本质含义。

    无分组状态过滤器
    过滤规则:由一组属性值(源IP地址、目的IP地址、源和目的端口号、协议类型)和操作组成,如果某个IP分组携带的信息和构成规则的一组属性值匹配,意味着该IP分组和规则匹配,对该IP分组实施规则制定的操作。
    过滤规则格式:
    协议类型= ,源IP地址= ,源端口号= ,目的IP地址= ,目的端口号= ;操作。
    两种过滤规则集设置方法:
    1)黑名单—是列出所有禁止传输的IP分组类型,没有明确禁止的IP分组类型都是允许传输的。
    2)白名单—是列出所有允许传输的IP分组类型,没有明确允许的IP分组类型都是禁止传播的。

    路由器R1接口1输入方向的过滤规则集如下:
    协议类型=TCP,源IP地址=192.1.1.1/32,源端口号=,目的IP地址=192.1.2.7/32,目的端口号=80;正常转发。
    协议类型=TCP,源IP地址=192.1.1.7/32,源端口号=21,目的IP地址=192.1.2.1/32,目的端口号=
    ;正常转发。
    协议类型=TCP,源IP地址=192.1.1.7/32,源端口号=20,目的IP地址=192.1.2.1/32,目的端口号=;正常转发。
    协议类型=
    ,源IP地址=any,目的IP地址=any;丢弃。
    路由器R2接口2输入方向的过滤规则集如下:
    协议类型=TCP,源IP地址=192.1.2.1/32,源端口号=,目的IP地址=192.1.1.7/32,目的端口号=21;正常转发。
    协议类型=TCP,源IP地址=192.1.2.1/32,源端口号=
    ,目的IP地址=192.1.2.1/32,目的端口号=20;正常转发。
    协议类型=TCP,源IP地址=192.1.2.7/32,源端口号=80,目的IP地址=192.1.2.1/32,目的端口号=;正常转发。
    协议类型=
    ,源IP地址=any,目的IP地址=any;丢弃。

    有状态分组过滤器:
    引出有状态分组过滤器的原因:
    但上述过滤规则中直接允许Web服务器发送的、源端口号为80的TCP报文沿着Web服务器至终端A方向传输
    一是只允许由终端A发起建立与Web服务器之间的TCP连接;
    二是没有规定这种传输过程必须在由终端A发起建立与Web服务器之间的TCP连接后进行,也就是没有作用顺序限制;
    三是由于需要用两端插口标识TCP连接,因此,上述过滤规则并没有明确指出只有属于由终端A发起建立与Web服务器之间的TCP连接的TCP报文才能沿着Web服务器至终端A方向传输。

    针对上述三点,有状态分组过滤器的工作原理如下:
    1.终端A至Web服务器传输方向上的过滤规则允许终端A传输与终端A发起访问Web服务器的操作有关的TCP报文;
    2.初始状态下,Web服务器至终端A传输方向上的过滤规则拒绝一切IP分组;
    3.只有当终端A至Web服务器传输方向上传输了与终端A发起访问Web服务器的操作相关的TCP报文之后,Web服务器至终端A传输方向才允许传输作为对应的响应报文的TCP报文。

    有状态分组过滤器根据功能分为会话层和应用层两种类型的有状态分组过滤器。这里的会话层是指分组过滤器检查信息的深度限于与会话相关的信息,与OSI体系结构的会话层没有关系。应用层是指分组过滤器检查信息的深度涉及应用层协议数据单元(PDU)中有关的字段。
    1)会话层有状态分组过滤器
    一个方向配置允许发起创建某个会话的IP分组传输的过滤规则集。创建会话之后,所有属于该会话的报文可以从两个方向传输。也就是说一旦终端A发出请求建立与Web服务器之间的TCP请求报文,路由器R1在会话表中创建一个会话;创建该会话之后,所有属于该会话的TCP报文允许经过路由器R1接口1输入输出。
    除了TCP会话(用TCP连接两端端口号标识会话),还可以是UDP会话(用报文两端端口号标识会话)、ICMP会话(用报文两端地址、请求报文标识符和序号标识会话)
    2)应用层有状态分组过滤器
    它与会话层分组过滤器有以下不同:
    1.应用层有状态分组过滤器需要分析应用层协议数据单元,所以过滤规则中要指定应用层协议。
    2.一个方向需要配置允许传输请求报文的过滤规则,另一个方向自动生成允许传输该请求报文对应响应报文的过滤规则。
    3.应用层检查响应报文与请求报文的相关性。

    展开全文
  • 如何获悉显示过滤器包含的参数:选中协议中的某个字段,对应过滤参数显示在底部状态栏 如何把数据包某个属性作为数据包列表新列:选中某个属性右键apply as column即可把数据包某个属性作为数据包列表新列 常见的IP...

    显示过滤表达式中操作符:


    ==eq等于
    !=ne不等于
    >gt高于
    <lt低于
    >=ge不高于
    <=le不低于
     contains包含某个字符
     match某串字符匹配某个条件
    &&and逻辑与
    ||or逻辑或
    not逻辑非



    如何设置显示过滤器:


    在显示过滤器工具条Filter输入框内直接输入显示过滤语句





    如何将数据包的某个属性指定为过滤条件:


    右键数据包的某个属性选择apply as filter(直接作为显示过滤器使用)或prepare a filter(作为有待应用的显示过滤器)即可应用显示过滤器



    如何获悉显示过滤器包含的参数:


    选中协议中的某个字段,对应过滤参数显示在底部状态栏




    如何把数据包某个属性作为数据包列表新列:


    选中某个属性右键apply as column即可把数据包某个属性作为数据包列表新列




    Ethernet过滤器

    eth.addr==<>   显示具有指定MAC地址的数据帧
    eth.src ==<>   显示具有指定源MAC地址的数据帧
    eth.dst==<>   显示具有指定目的MAC地址的数据帧
    eth.type==<>  显示指定以太网类型的流量
    eth.dst==ffff.ffff.ffff    显示以太网广播帧



    ARP过滤器

    arp.opcode==<>   显示指定类型的ARP帧
    arp.opcode==1 ARP请求帧
    arp.opcode==2 ARP应答帧
    arp.src.hw_mac==<> 只显示指定MAC地址主机发出的ARP帧

    以下附上ARP数据包包头格式以供参考:






    IP过滤器

    Ip.addr==<>   显示发往或源自指定IP地址的数据包
    ip.src==<>    显示指定源IP地址的数据包
    ip.dst==<>  显示指定目的IP地址的数据包
    ip.ttl==<value>   ip.ttl> <value>    显示IP包头中TTL字段值为指定值得数据包
    ip.len==<value> ip.len< <value>  显示指定长度的IP数据包
    ip.version==<4/6>  显示指定IP版本号的IP数据包
    ipv6.addr=<>  显示发往或源自指定IPv6地址的数据包

    以下附上IP数据包包头格式以供参考:






    复杂的过滤器

    以下是几个复杂一些的过滤语句:

    ip.src==10.0.0.0/24 and http.host contains "sohu"           显示10.0.0.0/24网络的主机,发送包含"sohu"字符串的所有流量
    ip.addr==10.0.0.0/24 and http.host matches "\.com$"       显示10.0.0.0/24网络的主机,访问域名以".com"结尾的网站的所有流量
    ip.src==10.0.0.0/24 and eth.dst==ffff.ffff.ffff                   显示源于10.0.0.0/24网络的的所有IP广播地址
    not arp and eth.dst==ffff.ffff.ffff                               显示 所有广播包,但ARP请求所触发的广播包除外
    not arp and not icmp                       显示除ARP和ICMP外的所有流量



    TCP/UDP过滤器

    tcp.port==<>       显示指定的TCP源,目的端口(比如:tcp.port==80)
    tcp.dstport==<>   显示指定的TCP目的端口
    tcp.srcport==<>    显示指定的TCP源端口
    tcp.analysis      分析TCP性能有关参数     
        tcp.analysis.retransmission 显示重传的tcp数据包
        tcp.analysis.duplicate_ack 显示确认多次的tcp数据包
        tcp.analysis.zero_windows 显示含零窗口通告信息的TCP数据包
    tcp.flags  检查数据包TCP头部中的标记位
       tcp.flags.syn==1   显示syn置1的数据包
       tcp.flags.reset==1   显示reset置1的数据包
       tcp.flags.fin==1    显示fin置1的数据包
    tcp.window_size_value < <>       显示tcp头部窗口大小字段低于指定值得数据包
    tcp.stream eq <>     显示某条TCP连接从建立到终结,回话双方生成的所有数据包(比如:tcp.stream eq 0)

    提示如何跟随一条TCP流:右键想要查看完整TCP数据流的TCP包,选择follow-tcp stream既可跟随tcp流


    以下附上TCP数据包包头格式以供参考:




    HTTP过滤器

    http.host==<>     显示访问指定主机名的HTTP协议数据包
    http.request.method=="GET"    显示包含HTTP GET方法的数据包
    http.request.uri==""       显示HTTP客户端发起的包含指定URI请求的HTTP数据包(比如:http.request.uri=="www.baidu.com")
    http.request.uri contains ""    显示HTTP客户端发起的包含某指定字符串的URI请求的HTTP数据包(比如:http.request.uri contains"baidu")
    http.cookie    显示网络中传播的所有包含cookie请求的HTTP数据包
    http.set_cookie   显示所有包含由HTTP服务器发送给HTTP客户端的cookie set命令的HTTP数据包



    DNS过滤器

    dns.flags.response==0    显示dns查询报文
    dns.flags.response==1     显示dns响应报文

    dns.count.answers>=4 显示answers字段大于或等于4的DNS响应报文



    FTP过滤器

    ftp.request.command==<> 显示包含特定请求的ftp数据包

    ftp  显示从TCP21端口传送的包含FTP命令的FTP数据包

    ftp-data   显示从TCP20端口或其他端口发出的包含实际FTP数据的FTP报文



    wireshark中常用的正则表达式含义

    wireshark显示过滤器所采用的正则表达式语法,等同于Perl语言所采用的正则表达式

    ^     匹配行的开头
    $    匹配行的结尾
    |     用来表示二者任选其一
    ()   起分组作用
    *    匹配0次或多次
    +   匹配1次或多次
    ?   匹配0次或1次
    {n} 精确匹配n次
    {n,} 至少n次
    {n,m} 匹配n次到m次之间




    字节偏移型过滤器

    显示过滤器中的字节偏移型过滤器与抓包过滤器中的用法相同在此不在赘述,详情请看我之前写的文章《Wireshark网络分析实战笔记(一)抓包过滤器

    eth.dst[0:2]==01:00:5e


    配置显示过滤器宏

    1.配置显示过滤器宏:依次点击analyze—display filter macros


    2.使用显示过滤器宏:在filter中输入 ${test1:192.168.1.1;80}

    其中test1是我要使用的显示过滤器宏的名称;

    第一个参数192.168.1.1传给表达式中$1;

    第二个参数80传给表达式中$2;






    展开全文
  • CAN控制器-配置过滤器

    千次阅读 2015-09-17 10:18:28
    首先简单介绍一下CAN总线,关于CAN总线是谁发明的,CAN总线的历史,CAN总线的发展,CAN总线的应用场合,这些,...然后每个节点都有过滤器,对网络上的传播的帧的标识符进行过滤,自己想要什么样的帧,可以设置自己的过

    首先简单介绍一下CAN总线,关于CAN总线是谁发明的,CAN总线的历史,CAN总线的发展,CAN总线的应用场合,这些,通通不说。这里只是以我个人理解,简单说说CAN通信。CAN总线的端点没有地址(除非自己在帧里定义地址),CAN总线通信不用地址,用标识符,不是单独的谁发给谁,而是,你总是发送给整个网络。然后每个节点都有过滤器,对网络上的传播的帧的标识符进行过滤,自己想要什么样的帧,可以设置自己的过滤器,接收相关的帧信息。如果两个节点同时发送怎么办?这个不用我们担心,CAN控制器会自己仲裁,让高优先级的帧先发。

             然后我们可以了解一下stm32的CAN控制器。


             如上图所示,stm32有两个can控制器,can1(主),和can2(从),其中过滤器的设置是通过can1来设置,其他工作模式,波特率等,可以各自设置。每个控制器有三个发送邮箱,两个fifo,每个fifo有三个接收邮箱。



             发送:选择一个空的发送邮箱,把帧信息写到该发送邮箱的寄存器里,请求发送,控制器就会根据标识符的优先级把帧先后发送出去。

             接收:如果接收到的帧的标识符能过过滤表的一系列过滤,该帧信息就会保存在fifo接收邮箱的寄存器里。

             过滤器:stm32f407共有28组过滤器,每组过滤器可以设置关联到fifo0或者fifo1,每组都包括两个32位存储器,可以配置成一个32位有位屏蔽功能的标识符过滤器,或者两个32位完全匹配的标识符过滤器,或者两个16位有位屏蔽功能的标识符过滤器,或者四个16位完全匹配的标识符过滤器。如下图所示:



    我所说的完全匹配的意思是,接收到的帧的标识符每一位都要跟过滤器对应的位一样,才能过得了这个过滤器。有位屏蔽功能的意思是一个寄存器放标识符,一个放屏蔽掩码,屏蔽掩码为1的位对应的接收到的帧的标识符的位与对应的放标识符的寄存器的位一致,就能通过。


    为了过滤出一组标识符,应该设置过滤器组工作在屏蔽位模式。 
    为了过滤出一个标识符,应该设置过滤器组工作在标识符列表模式。 
    应用程序不用的过滤器组,应该保持在禁用状态。 
    过滤器组中的每个过滤器,都被编号为(叫做过滤器号,图 32.1.11 中的 n)从 0 开始,到某
    最大数值-取决于过滤器组的模式和位宽的设置。 
    举个简单的例子,我们设置过滤器组 0 工作在:1 个 32 位过滤器-标识符屏蔽模式,然后
    置 CAN_F0R1=0XFFFF0000,CAN_F0R2=0XFF00FF00。其中存放到 CAN_F0R1 的值就是期
    收到的 ID,即我们希望收到的 ID(STID+EXTID+IDE+RTR)最好是:0XFFFF0000。而
    FF00FF00 就是设置我们需要必须关心的 ID,表示收到的 ID,其位[31:24]和位[15:8]这 16 个
    的必须和 CAN_F0R1 中对应的位一模一样,而另外的 16 个位则不关心,可以一样,也可以
    一样,都认为是正确的 ID,即收到的 ID必须是 0XFFxx00xx,才算是正确的(x 表示不关心)。




    传输一位的时间和波特率的计算:

     

             CAN控制器的波特率是由APB时钟线和CAN位时序寄存器CAN_BTR的TS2[3:0]、TS1[2:0]和BRP[9:0]确定的,其中,TS1[2:0]定义了时间段1占用多少个时间单元,TS2[3:0]定义了时间段2占用多少个时间单元,BRP[9:0]定义对APB1时钟的分频。

     

    PS:设置波特率为1M


    其中Tpclk为APB1的时钟周期,假设为

    Tpclk = 1/42M

    0≦TS1≦7

    0≦TS2≦15

    0≦BRP≦1021

    根据以上数据,有

    (TS2+TS1+3)(BRP+1)=42

    令BRP=2,有

    TS2+TS1=11

    令TS1=8,TS2=3

     

     



    设置步骤:

    1.     设置中断优先级分组(如果之前没有设置),这个最好一个程序里只在开头设置一次。

    2.     使能相关GPIO时钟。

    3.     选择相关GPIO引脚的复用功能。

    4.     设置相关GPIO引脚为复用模式。

    5.     设置相关GPIO引脚的速度,方式。

    6.     设置主控制寄存器MCR,进入初始化模式

    7.     等待进入初始化模式

    8.     设置波特率。

    9.     其他设置。

    10.  如果要用到中断,在中断使能寄存器IER中使能相关中断响应。

    11.  如果要用到中断,设置相关中断优先级(NVIC_IP)。

    12.  如果要用到中断,使能相关中断(NVIC_ISER)。

    13.  设置主控制寄存器MCR,进入正常工作模式。

    14.  设置FMR,使过滤器组工作在初始化模式。

    15.  设置FMR的CAN2SB,确定CAN2的过滤器组从哪一组开始。

    16.  设置用到的过滤器组的工作方式。

    17.  设置用到的过滤器组的位宽。

    18.  给fifo0和fifo2划分(关联)过滤组。

    19.  禁用用到的过滤器组。

    20.  设置过滤器组的标识符,帧类型等。

    21.  使能相关过滤器组。

    22.  设置FMR,使过滤器组工作在正常模式。

    23.  如果要用中断,编写中断服务函数(函数名是固定的)。

    24.  中断服务函数里检查是哪个中断。

    25.  编写相应服务程序。

     

    电路请参见本博客:小工具之——CAN收发器 


    程序:

    [plain]  view plain copy 在CODE上查看代码片 派生到我的代码片
    1. /************************************  
    2.     标题:操作CAN的练习  
    3.     软件平台:IAR for ARM6.21  
    4.     硬件平台:stm32f4-discovery  
    5.     主频:168M  
    6.       
    7.     描述:通过硬件收发器连接CAN1,CAN2  
    8.           组成一个两个端点的网络  
    9.   
    10.           CAN1循环发出数据帧  
    11.   
    12.           CAN2接收过滤数据帧  
    13.   
    14.           用uart把CAN2接收到  
    15.           的数据帧发到超级终端  
    16.   
    17.     author:小船  
    18.     data:2012-08-14  
    19. *************************************/  
    20.   
    21. #include <stm32f4xx.h>   
    22. #include "MyDebugger.h"  
    23.   
    24. #define RECEIVE_BUFFER_SIZE 20  
    25.   
    26. u32 CAN2_receive_buffer[RECEIVE_BUFFER_SIZE][4];  
    27. u8 UART_send_buffer[1800];  
    28. u8 Consumer = 0;  
    29. u8 Producer = 0;  
    30.   
    31. u32 Gb_TimingDelay;  
    32. void Delay(uint32_t nTime);  
    33. void TIM7_init();//定时1s  
    34. u32 get_rece_data();  
    35. void CAN_GPIO_config();  
    36.   
    37. void main ()  
    38. {     
    39.   
    40.   u32 empty_box;  
    41.   SysTick_Config(SystemCoreClock / 1000); //设置systemtick一毫秒中断  
    42.   SCB->AIRCR = 0x05FA0000 | 0x400;  //中断优先级分组 抢占:响应=3:1  
    43.    
    44.   MyDebugger_Init();  
    45.   TIM7_init();  
    46.   MyDebugger_Message( "\n\rtesting......\n\r" ,   
    47.                      sizeof("\n\rtesting......\n\r")/sizeof(char) );  
    48.     
    49.   CAN_GPIO_config();  
    50.     
    51.   RCC->APB1ENR |= ((1<<25)|(1<<26));//使能CAN1、CAN2时钟  
    52.     
    53.   CAN1->MCR = 0x00000000;  
    54.   /*  
    55.   请求进入初始化模式  
    56.   禁止报文自动重传  
    57.   自动唤醒模式  
    58.   */  
    59.   CAN1->MCR |= ((1<<0)|(1<<4)|(1<<5));  
    60.   CAN1->MCR &= ~(1<<16);//在调试时,CAN照常工作  
    61.     
    62.   while(!(CAN1->MSR & 0xfffffffe))  //等待进入初始化模式  
    63.   {  
    64.     MyDebugger_LEDs(orange, on);  
    65.   }  
    66.   MyDebugger_LEDs(orange, off);  
    67.     
    68.   /*  
    69.   正常模式  
    70.   重新同步跳跃宽度(1+1)tq  
    71.   TS2[2:0]=3  
    72.   TS1[3:0]=8  
    73.   BRP[9:0]=2  
    74.     
    75.   ps:  
    76.   tq = (BRP[9:0] + 1) x tPCLK,  
    77.   tBS2 = tq x (TS2[2:0] + 1),  
    78.   tBS1 = tq x (TS1[3:0] + 1),  
    79.   NominalBitTime = 1 × tq+tBS1+tBS2,  
    80.   BaudRate = 1 / NominalBitTime  
    81.     
    82.   波特率设为1M  
    83.   */  
    84.   CAN1->BTR = ((0<<30)|(0x01<<24)|(3<<20)|(8<<16)|(2<<0));  
    85.     
    86.   CAN1->MCR &= ~(0x00000001);//正常工作模式  
    87.     
    88.   CAN2->MCR = 0x00000000;  
    89.   /*  
    90.   请求进入初始化模式  
    91.   禁止报文自动重传  
    92.   自动唤醒模式  
    93.   */  
    94.   CAN2->MCR |= ((1<<0)|(1<<4)|(1<<5));  
    95.   CAN2->MCR &= ~(1<<16);//在调试时,CAN照常工作  
    96.     
    97.   while(!(CAN2->MSR & 0xfffffffe))  //等待进入初始化模式  
    98.   {  
    99.     MyDebugger_LEDs(orange, on);  
    100.   }  
    101.   MyDebugger_LEDs(orange, off);  
    102.     
    103.   /*  
    104.   正常模式  
    105.   重新同步跳跃宽度(1+1)tq  
    106.   TS2[2:0]=3  
    107.   TS1[3:0]=8  
    108.   BRP[9:0]=2  
    109.     
    110.   ps:  
    111.   tq = (BRP[9:0] + 1) x tPCLK,  
    112.   tBS2 = tq x (TS2[2:0] + 1),  
    113.   tBS1 = tq x (TS1[3:0] + 1),  
    114.   NominalBitTime = 1 × tq+tBS1+tBS2,  
    115.   BaudRate = 1 / NominalBitTime  
    116.     
    117.   波特率设为1M  
    118.   */  
    119.   CAN2->BTR = ((0<<30)|(0x01<<24)|(3<<20)|(8<<16)|(2<<0));  
    120.     
    121.   CAN2->IER &= 0x00000000;  
    122.   /*  
    123.   FIFO1消息挂号中断使能  
    124.   FIFO1满中断使能  
    125.   FIFO1溢出中断使能  
    126.   */  
    127.   CAN2->IER |= ((1<<4)|(1<<5)|(1<<6));  
    128.     
    129.     
    130.   NVIC->IP[65] = 0xa0;   //抢占优先级101,响应优先级0   
    131.   NVIC->ISER[2] |= (1<<1);  //使能中断线65,也就是can2_rx1中断  
    132.     
    133.   CAN2->MCR &= ~(0x00000001);//正常工作模式  
    134.     
    135.     
    136.   //总共有28组过滤器  
    137.   CAN1->FMR |= 1; //过滤器组工作在初始化模式  
    138.     
    139.   CAN1->FMR &= 0xffffc0ff;//CAN2的过滤器组从14开始  
    140.   CAN1->FMR |= (14<<8);  
    141.     
    142.   CAN1->FM1R |= (1<<14);//过滤器组14的寄存器工作在标识符列表模式  
    143.                          
    144.                         //位宽为16位,2个32位分为四个16位寄存器,过滤四个标识符  
    145.     
    146.   //CAN1->FS1R |= (1<<15);//过滤器组15为单个32位寄存器,用于扩展标识符  
    147.     
    148.   CAN1->FFA1R = 0x0fffc000;//0~13号过滤器组关联到fifo0,14~27号过滤器组关联到fifo1  
    149.     
    150.   CAN1->FA1R &= ~(1<<14);//禁用过滤器组14  
    151.     
    152.    /*  
    153.   过滤器组0寄存器分为4个十六位过滤器:  
    154.   标识符列表:  
    155.   过滤器编号        匹配标准标识符             RTR       IDE           EXID[17:15]  
    156.      0              0x7cb(111 1100 1011b)    数据帧    标准标识符     000b  
    157.      1              0x4ab(100 1010 1011b)    数据帧    标准标识符     000b  
    158.      2              0x7ab(111 1010 1011b)    数据帧    标准标识符     000b    
    159.      3              0x40b(100 0000 1011b)    数据帧    标准标识符     000b    
    160.   */  
    161.   CAN1->sFilterRegister[14].FR1 &= 0x00000000;  
    162.   CAN1->sFilterRegister[14].FR2 &= 0x00000000;  
    163.   CAN1->sFilterRegister[14].FR1 |= ((0x7cb<<5)|(0<<4)|(0<<3));  
    164.   CAN1->sFilterRegister[14].FR1 |= ((0x4ab<<21)|(0<<20)|(0<<19));  
    165.   CAN1->sFilterRegister[14].FR2 |= ((0x7ab<<5)|(0<<4)|(0<<3));  
    166.   CAN1->sFilterRegister[14].FR2 |= ((0x40b<<21)|(0<<20)|(0<<19));  
    167.     
    168.   CAN1->FA1R |= (1<<14);//使能过滤器组14  
    169.      
    170.   CAN1->FMR &= ~1; //过滤器组正常工作  
    171.     
    172.   while(1)  
    173.   {  
    174.     /*  
    175.     选择空的发送邮箱:  
    176.     标准标识符0x7ab(111 1010 1011b)  
    177.     数据帧  
    178.     不使用扩展标识符  
    179.     */  
    180.     if( CAN1->TSR & ((1<<26)|(1<<27)|(1<<28)) )  
    181.     {  
    182.       empty_box = ((CAN1->TSR>>24) & 0x00000003);   
    183.       CAN1->sTxMailBox[empty_box].TIR = (0x7ab<<21);    
    184.         
    185.       CAN1->sTxMailBox[empty_box].TDTR &= 0xfffffff0;  
    186.       CAN1->sTxMailBox[empty_box].TDTR |= 0x00000008;//发送数据长度为8  
    187.         
    188.       CAN1->sTxMailBox[empty_box].TDLR = 0x12345678;  
    189.         
    190.       CAN1->sTxMailBox[empty_box].TDHR = 0x9abcdef0;  
    191.         
    192.       CAN1->sTxMailBox[empty_box].TIR |= (1<<0);//请求发送  
    193.     }  
    194.     else  
    195.     {  
    196.       MyDebugger_LEDs(orange, on);  
    197.     }  
    198.     Delay(100);  
    199.       
    200.      /*  
    201.     选择空的发送邮箱:  
    202.     标准标识符0x4ab(100 1010 1011b)  
    203.     数据帧  
    204.     不使用扩展标识符  
    205.     */  
    206.     if( CAN1->TSR & ((1<<26)|(1<<27)|(1<<28)) )  
    207.     {  
    208.       empty_box = ((CAN1->TSR>>24) & 0x00000003);   
    209.       CAN1->sTxMailBox[empty_box].TIR = (0x4ab<<21);    
    210.         
    211.       CAN1->sTxMailBox[empty_box].TDTR &= 0xfffffff0;  
    212.       CAN1->sTxMailBox[empty_box].TDTR |= 0x00000008;//发送数据长度为8  
    213.         
    214.       CAN1->sTxMailBox[empty_box].TDLR = 0x56781234;  
    215.         
    216.       CAN1->sTxMailBox[empty_box].TDHR = 0x9abcdef0;  
    217.         
    218.       CAN1->sTxMailBox[empty_box].TIR |= (1<<0);//请求发送  
    219.     }  
    220.     else  
    221.     {  
    222.       MyDebugger_LEDs(orange, on);  
    223.     }  
    224.     Delay(100);  
    225.       
    226.      /*  
    227.     选择空的发送邮箱:  
    228.     标准标识符0x7cb(100 1010 1011b)  
    229.     数据帧  
    230.     不使用扩展标识符  
    231.     */  
    232.     if( CAN1->TSR & ((1<<26)|(1<<27)|(1<<28)) )  
    233.     {  
    234.       empty_box = ((CAN1->TSR>>24) & 0x00000003);   
    235.       CAN1->sTxMailBox[empty_box].TIR = (0x7cb<<21);    
    236.         
    237.       CAN1->sTxMailBox[empty_box].TDTR &= 0xfffffff0;  
    238.       CAN1->sTxMailBox[empty_box].TDTR |= 0x00000006;//发送数据长度为6  
    239.         
    240.       CAN1->sTxMailBox[empty_box].TDLR = 0x56781234;  
    241.         
    242.       CAN1->sTxMailBox[empty_box].TDHR = 0x00009abc;  
    243.         
    244.       CAN1->sTxMailBox[empty_box].TIR |= (1<<0);//请求发送  
    245.     }  
    246.     else  
    247.     {  
    248.       MyDebugger_LEDs(orange, on);  
    249.     }  
    250.     Delay(100);  
    251.       
    252.      /*  
    253.     选择空的发送邮箱:  
    254.     标准标识符0x40b(100 0000 1011b)  
    255.     数据帧  
    256.     不使用扩展标识符  
    257.     */  
    258.     if( CAN1->TSR & ((1<<26)|(1<<27)|(1<<28)) )  
    259.     {  
    260.       empty_box = ((CAN1->TSR>>24) & 0x00000003);   
    261.       CAN1->sTxMailBox[empty_box].TIR = (0x40b<<21);    
    262.         
    263.       CAN1->sTxMailBox[empty_box].TDTR &= 0xfffffff0;  
    264.       CAN1->sTxMailBox[empty_box].TDTR |= 0x00000004;//发送数据长度为4  
    265.         
    266.       CAN1->sTxMailBox[empty_box].TDLR = 0x56781234;  
    267.         
    268.       CAN1->sTxMailBox[empty_box].TDHR = 0x00000000;  
    269.         
    270.       CAN1->sTxMailBox[empty_box].TIR |= (1<<0);//请求发送  
    271.     }  
    272.     else  
    273.     {  
    274.       MyDebugger_LEDs(orange, on);  
    275.     }  
    276.     Delay(100);  
    277.       
    278.    }  
    279. }  
    280.   
    281. /****************************************  
    282.   函数名:CAN_GPIO_config  
    283.   参数:无  
    284.   返回值:无  
    285.   功能:设置CAN1,2控制器用到IO口  
    286.   CAN1_TX---------PD1  
    287.   CAN1_RX---------PB8  
    288.   CAN2_TX---------PB13  
    289.   CAN2_RX---------PB5  
    290. ****************************************/  
    291. void CAN_GPIO_config()  
    292. {  
    293.   RCC->AHB1ENR |= ((1<<1) | (1<<3));//使能GPIOB、D时钟  
    294.   GPIOB->AFR[0] |= 0x00900000;      //AF9  
    295.   GPIOB->AFR[1] |= 0x00900009;  
    296.   GPIOD->AFR[0] |= 0x00000090;  
    297.       
    298.   GPIOB->MODER &= 0xF3FCF3FF; //第二功能  
    299.   GPIOB->MODER |= 0x08020800;  
    300.   GPIOD->MODER &= 0xFFFFFFF3;   
    301.   GPIOD->MODER |= 0x00000008;  
    302.     
    303.   GPIOB->OSPEEDR &= 0xF3FCF3FF; //50M  
    304.   GPIOB->OSPEEDR |= 0x08020800;  
    305.   GPIOD->OSPEEDR &= 0xFFFFFFF3;   
    306.   GPIOD->OSPEEDR |= 0x00000008;  
    307.     
    308.   GPIOB->PUPDR &= 0xF3FCF3FF;   //上拉  
    309.   GPIOB->PUPDR |= 0x04010400;  
    310.   GPIOD->PUPDR &= 0xFFFFFFF3;   
    311.   GPIOD->PUPDR |= 0x00000004;   
    312. }  
    313.   
    314. /****************************************  
    315.   函数名:CAN2_RX1_IRQHandler  
    316.   参数:无  
    317.   返回值:无  
    318.   功能:CAN2fifo1接收中断处理  
    319.         把信息存进循环队列  
    320. ****************************************/  
    321. void CAN2_RX1_IRQHandler()  
    322. {  
    323.   if(CAN2->RF1R & (0x00000003))//接收到新的消息,fifo1非空  
    324.   {  
    325.     Producer++;  
    326.     if(Producer == RECEIVE_BUFFER_SIZE)Producer = 0;  
    327.     if(Producer != Consumer)  
    328.     {  
    329.       CAN2_receive_buffer[Producer][0] = CAN2->sFIFOMailBox[1].RIR;  
    330.       CAN2_receive_buffer[Producer][1] = CAN2->sFIFOMailBox[1].RDTR;  
    331.       CAN2_receive_buffer[Producer][2] = CAN2->sFIFOMailBox[1].RDLR;  
    332.       CAN2_receive_buffer[Producer][3] = CAN2->sFIFOMailBox[1].RDHR;  
    333.     }  
    334.     else  
    335.     {  
    336.       if(Producer == 0)Producer = RECEIVE_BUFFER_SIZE;  
    337.       Producer--;  
    338.       MyDebugger_LEDs(blue, on);  
    339.     }     
    340.     CAN2->RF1R |= (1<<5);//释放邮箱  
    341.   }  
    342.     
    343.   if(CAN2->RF1R & (1<<3))//fifo0满  
    344.   {  
    345.     MyDebugger_LEDs(red, on);  
    346.     CAN2->RF1R &= ~(1<<3);  
    347.   }  
    348.     
    349.   if(CAN2->RF1R & (1<<4))//fifo0溢出  
    350.   {  
    351.     MyDebugger_LEDs(red, on);  
    352.     CAN2->RF1R &= ~(1<<4);  
    353.   }  
    354. }  
    355.   
    356. /****************************************  
    357.   函数名:TIM7_init  
    358.   参数:无  
    359.   返回值:无  
    360.   功能:初始化定时器7  
    361.         作1s定时用  
    362. ****************************************/  
    363. void TIM7_init()  
    364. {  
    365.   RCC->APB1ENR |= (1<<5); //打开TIM7时钟  
    366.   TIM7->PSC = 8399; //对时钟84M进行8400分频,使得计数频率为10k  
    367.   TIM7->ARR = 10000;  //定时一秒  
    368.   TIM7->CNT = 0;  //清空计数器  
    369.   TIM7->CR1 |= (1<<7); //自动重装载预装载使能  
    370.   TIM7->DIER |= 1; //使能中断  
    371.     
    372.   NVIC->IP[55] = 0xe0;  
    373.   NVIC->ISER[1] |= (1<<(55-32));  
    374.     
    375.   TIM7->CR1 |= 1; //开始计时  
    376. }  
    377.   
    378. /****************************************  
    379.   函数名:TIM7_IRQHandler  
    380.   参数:无  
    381.   返回值:无  
    382.   功能:定时器7中断处理  
    383.         1s定时到  
    384.         把can2收到的信息转换格式  
    385.         用usrt发送到超级终端显示  
    386. ****************************************/  
    387. void TIM7_IRQHandler(void)  
    388. {  
    389.   u32 length;  
    390.   if(TIM7->SR)  
    391.   {  
    392.     length = get_rece_data();  
    393.     MyDebugger_Message( UART_send_buffer, length );  
    394.     TIM7->SR &= ~(0x0001);   
    395.   }  
    396. }  
    397.   
    398. /****************************************  
    399.   函数名:get_rece_data  
    400.   参数:无  
    401.   返回值:length 整理后要发送数据的长度  
    402.   功能:把循环队列的信息取出  
    403.         进行格式转换  
    404.         把信息存到uart发送缓冲区  
    405. ****************************************/  
    406. u32 get_rece_data()  
    407. {  
    408.   u8 filter_No;  
    409.   u8 Data_length;   
    410.   char i;  
    411.   u32 length = 0;  
    412.   const char ascii[16] = {'0', '1', '2', '3', '4', '5', '6', '7',  
    413.                           '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};  
    414.   while(1)  
    415.   {  
    416.     if(Producer != Consumer)  
    417.       {  
    418.         Consumer++;  
    419.         if(Consumer == RECEIVE_BUFFER_SIZE)Consumer=0;  
    420.           
    421.         UART_send_buffer[length++] = '\n';  
    422.         UART_send_buffer[length++] = '\r';  
    423.         //Filter No.xx  
    424.         UART_send_buffer[length++] = 'F';  
    425.         UART_send_buffer[length++] = 'i';   
    426.         UART_send_buffer[length++] = 'l';  
    427.         UART_send_buffer[length++] = 't';  
    428.         UART_send_buffer[length++] = 'e';  
    429.         UART_send_buffer[length++] = 'r';   
    430.         UART_send_buffer[length++] = ' ';  
    431.         UART_send_buffer[length++] = 'N';   
    432.         UART_send_buffer[length++] = 'o';  
    433.         UART_send_buffer[length++] = '.';  
    434.      
    435.         filter_No = (CAN2_receive_buffer[Consumer][1]>>8) & 0x000000ff;  
    436.         UART_send_buffer[length++] = filter_No%100/10 + '0';  
    437.         UART_send_buffer[length++] = filter_No%10 + '0';  
    438.         UART_send_buffer[length++] = '\n';  
    439.         UART_send_buffer[length++] = '\r';  
    440.           
    441.         //DataLength:x  
    442.         UART_send_buffer[length++] = 'D';   
    443.         UART_send_buffer[length++] = 'a';  
    444.         UART_send_buffer[length++] = 't';   
    445.         UART_send_buffer[length++] = 'a';  
    446.         UART_send_buffer[length++] = 'L';  
    447.         UART_send_buffer[length++] = 'e';   
    448.         UART_send_buffer[length++] = 'n';  
    449.         UART_send_buffer[length++] = 'g';   
    450.         UART_send_buffer[length++] = 't';  
    451.         UART_send_buffer[length++] = 'h';  
    452.         UART_send_buffer[length++] = ':';  
    453.         Data_length = CAN2_receive_buffer[Consumer][1] & 0x0000000f;  
    454.         UART_send_buffer[length++] = Data_length % 10 + '0';  
    455.         UART_send_buffer[length++] = '\n';  
    456.         UART_send_buffer[length++] = '\r';  
    457.           
    458.           
    459.         if(CAN2_receive_buffer[Consumer][0] & (1<<1))  
    460.         {  
    461.           UART_send_buffer[length++] = 'R';   
    462.           UART_send_buffer[length++] = 'e';  
    463.           UART_send_buffer[length++] = 'm';   
    464.           UART_send_buffer[length++] = 'o';  
    465.           UART_send_buffer[length++] = 't';  
    466.           UART_send_buffer[length++] = 'e';   
    467.           UART_send_buffer[length++] = 'F';  
    468.           UART_send_buffer[length++] = 'r';   
    469.           UART_send_buffer[length++] = 'a';  
    470.           UART_send_buffer[length++] = 'm';  
    471.           UART_send_buffer[length++] = 'e';  
    472.         }  
    473.         else  
    474.         {  
    475.           UART_send_buffer[length++] = 'D';   
    476.           UART_send_buffer[length++] = 'a';  
    477.           UART_send_buffer[length++] = 't';   
    478.           UART_send_buffer[length++] = 'a';   
    479.           UART_send_buffer[length++] = 'F';  
    480.           UART_send_buffer[length++] = 'r';   
    481.           UART_send_buffer[length++] = 'a';  
    482.           UART_send_buffer[length++] = 'm';  
    483.           UART_send_buffer[length++] = 'e';  
    484.         }  
    485.         UART_send_buffer[length++] = '\n';  
    486.         UART_send_buffer[length++] = '\r';          
    487.           
    488.           
    489.         if(CAN2_receive_buffer[Consumer][0] & (1<<2))  
    490.         {  
    491.           UART_send_buffer[length++] = 'e';   
    492.           UART_send_buffer[length++] = 'x';  
    493.           UART_send_buffer[length++] = 't';   
    494.           UART_send_buffer[length++] = ' ';  
    495.           UART_send_buffer[length++] = 'I';  
    496.           UART_send_buffer[length++] = 'D';  
    497.           UART_send_buffer[length++] = ':';  
    498.             
    499.           UART_send_buffer[length++] =   
    500.             ascii[CAN2_receive_buffer[Consumer][0] >> 31];  
    501.           UART_send_buffer[length++] =   
    502.             ascii[(CAN2_receive_buffer[Consumer][0] >> 27)& 0x0000000f];  
    503.           UART_send_buffer[length++] =   
    504.             ascii[(CAN2_receive_buffer[Consumer][0] >> 23)& 0x0000000f];  
    505.           UART_send_buffer[length++] =   
    506.             ascii[(CAN2_receive_buffer[Consumer][0] >> 19)& 0x0000000f];  
    507.           UART_send_buffer[length++] =   
    508.             ascii[(CAN2_receive_buffer[Consumer][0] >> 15)& 0x0000000f];  
    509.           UART_send_buffer[length++] =   
    510.             ascii[(CAN2_receive_buffer[Consumer][0] >> 11)& 0x0000000f];  
    511.           UART_send_buffer[length++] =   
    512.             ascii[(CAN2_receive_buffer[Consumer][0] >> 7)& 0x0000000f];  
    513.           UART_send_buffer[length++] =   
    514.             ascii[(CAN2_receive_buffer[Consumer][0] >> 3)& 0x0000000f];  
    515.         }  
    516.         else  
    517.         {  
    518.           UART_send_buffer[length++] = 's';   
    519.           UART_send_buffer[length++] = 't';  
    520.           UART_send_buffer[length++] = 'd';   
    521.           UART_send_buffer[length++] = ' ';  
    522.           UART_send_buffer[length++] = 'I';  
    523.           UART_send_buffer[length++] = 'D';  
    524.           UART_send_buffer[length++] = ':';  
    525.             
    526.           UART_send_buffer[length++] =   
    527.             ascii[CAN2_receive_buffer[Consumer][0] >> 29];  
    528.           UART_send_buffer[length++] =   
    529.             ascii[(CAN2_receive_buffer[Consumer][0] >> 25)& 0x0000000f];  
    530.           UART_send_buffer[length++] =   
    531.             ascii[(CAN2_receive_buffer[Consumer][0] >> 21)& 0x0000000f];          
    532.         }  
    533.         UART_send_buffer[length++] = '\n';  
    534.         UART_send_buffer[length++] = '\r';  
    535.           
    536.         UART_send_buffer[length++] = 'D';   
    537.         UART_send_buffer[length++] = 'a';  
    538.         UART_send_buffer[length++] = 't';  
    539.         UART_send_buffer[length++] = 'a';  
    540.         UART_send_buffer[length++] = ':';  
    541.         if(Data_length > 4)  
    542.         {  
    543.           for(i = 2*Data_length - 8; i > 0; i--)  
    544.             UART_send_buffer[length++] =   
    545.               ascii[(CAN2_receive_buffer[Consumer][3] >> ((i-1)*4))& 0x0000000f];  
    546.             
    547.           for(i = 8; i > 0; i--)  
    548.             UART_send_buffer[length++] =   
    549.               ascii[(CAN2_receive_buffer[Consumer][2] >> ((i-1)*4))& 0x0000000f];  
    550.         }  
    551.         else  
    552.         {  
    553.           for(i = 2*Data_length; i > 0; i--)  
    554.             UART_send_buffer[length++] =   
    555.               ascii[(CAN2_receive_buffer[Consumer][2] >> ((i-1)*4))& 0x0000000f];           
    556.         }  
    557.         UART_send_buffer[length++] = '\n';  
    558.         UART_send_buffer[length++] = '\r';  
    559.       }  
    560.     else  
    561.       break;  
    562.   }  
    563.   return length;  
    564. }  
    565.   
    566.   
    567. void Delay(uint32_t nTime)  
    568. {   
    569.   Gb_TimingDelay = nTime;  
    570.   
    571.   while(Gb_TimingDelay != 0);  
    572. }  
    573.   
    574. void SysTick_Handler(void)  
    575. {  
    576.   if (Gb_TimingDelay != 0x00)  
    577.   {   
    578.     Gb_TimingDelay--;  
    579.   }  
    580. }  




    运行结果:

    展开全文
  • web3j过滤器提供以太坊网络发生的某些事件的通知,对java和安卓程序员来说很有用。...块过滤器和未决交易过滤器提供了在网络上创建新交易或块的通知。 主题过滤器更灵活。允许根据提供的特定标准创建...

    web3j过滤器提供以太坊网络发生的某些事件的通知,对java和安卓程序员来说很有用。在Ethereum以太坊中支持三类过滤器:

    • 块滤波器(Block filters)
    • 未决交易过滤器(Pending transaction filters)
    • 主题过滤器(Topic filters)

    块过滤器和未决交易过滤器提供了在网络上创建新交易或块的通知。

    主题过滤器更灵活。允许根据提供的特定标准创建过滤器。

    不幸的是,除非你使用WebSocket连接到Geth,否则通过JSON-RPC API来处理过滤器是一个繁琐的过程,这里需要轮询以太坊客户端,以便了解HTTP和IPC所请求的实时同步特征,是否有任何新的更新到你的过滤器。此外,块和交易过滤器只提供交易或区块链hash值,因此需要进一步的请求来获得hash对应的实际交易或块。

    web3j的过滤器解决了这些问题,因此你有一个完全异步的基于事件的API来处理过滤器。它使用RXJava的可观测性Observables,它提供了与事件协同工作的一致API,这有助于通过功能组合将JSON-RPC调用链接在一起。

    注:Infura不支持过滤器。

    块和交易过滤器

    接收所有新块把它们添加到区块链(false参数指定我们只需要块就ok,而不需要嵌入交易):

    Subscription subscription = web3j.blockObservable(false).subscribe(block -> {
        ...
    });
    

    接收所有新交易,把它们添加到块链:

    Subscription subscription = web3j.transactionObservable().subscribe(tx -> {
        ...
    });
    

    接收所有待提交交易并提交到网络(即在它们被分组在一起之前):

    Subscription subscription = web3j.pendingTransactionObservable().subscribe(tx -> {
        ...
    });
    

    不再需要的时候取消订阅unsubscribe

    subscription.unsubscribe();
    

    另外还提供了其他回调,它们简单地提供了块或交易hash,这些细节涉及Web3JRX接口。

    再现过滤器

    webjs还提供用于再现块和交易历史的过滤器。

    从区块链再现一系列块:

    Subscription subscription = web3j.replayBlocksObservable(
            <startBlockNumber>, <endBlockNumber>, <fullTxObjects>)
            .subscribe(block -> {
                ...
    });
    

    再现包含在一个块范围内的单个交易:

    Subscription subscription = web3j.replayTransactionsObservable(
            <startBlockNumber>, <endBlockNumber>)
            .subscribe(tx -> {
                ...
    });
    

    也可以获得Web3J再现最新的块,并在你看过后提供通知(通过提交Observable):

    Subscription subscription = web3j.catchUpToLatestBlockObservable(
            <startBlockNumber>, <fullTxObjects>, <onCompleteObservable>)
            .subscribe(block -> {
                ...
    });
    

    或者,也可以在你再现最新的块后,通知新创建的后续块:

    Subscription subscription = web3j.catchUpToLatestAndSubscribeToNewBlocksObservable(
            <startBlockNumber>, <fullTxObjects>)
            .subscribe(block -> {
                ...
    });
    

    如上所述,并包含在块内的交易:

    Subscription subscription = web3j.catchUpToLatestAndSubscribeToNewTransactionsObservable(
            <startBlockNumber>)
            .subscribe(tx -> {
                ...
    });
    

    所有上述过滤器都是通过Web3JRX接口导出的。

    主题过滤器和EVM事件

    主题过滤器捕获在网络中发生的以太坊虚拟机(EVM)事件的细节。这些事件是由智能合约创建的,并存储在与智能合约相关联的交易日志中。

    solidity文档提供了EVM事件的良好概述。

    使用EthFilter类型指定希望应用于过滤器的主题。这可以包括希望应用过滤器的智能合约的地址。你还可以提供特定的主题进行筛选。其中单个主题表示智能合约上的索引参数:

    EthFilter filter = new EthFilter(DefaultBlockParameterName.EARLIEST,
            DefaultBlockParameterName.LATEST, <contract-address>)
                 [.addSingleTopic(...) | .addOptionalTopics(..., ...) | ...];
    

    然后可以使用类似于上面的块和交易过滤器的语法创建该过滤器:

    web3j.ethLogObservable(filter).subscribe(log -> {
        ...
    });
    

    过滤器主题只能引用索引的Solidity事件参数。不可能对非索引事件参数进行筛选。此外,对于可变长度数组类型(如字符串和字节)的任何索引事件参数,它们的值的Keccak-256 hash 存储在EVM日志上。不可能使用它们的全部值来存储或筛选。

    如果创建一个没有与之相关联的主题的过滤器实例,则在网络中发生的所有EVM事件都将由过滤器捕获。

    操作组合标注

    除了send()sendAsync之外,所有JSON-RPC方法在web3j中都实现了支持observable()方法来创建可观察的异步执行请求。这使得将JSON-RPC调用组合成新的函数是非常容易和直接的。

    例如, blockObservable本身由许多单独的JSON-RPC调用组成:

    public Observable<EthBlock> blockObservable(
            boolean fullTransactionObjects, long pollingInterval) {
        return this.ethBlockHashObservable(pollingInterval)
                .flatMap(blockHash ->
                        web3j.ethGetBlockByHash(blockHash, fullTransactionObjects).observable());
    }
    

    在这里,我们首先创建一个可观察的,它提供每个新创建的块的块哈希的通知。然后,我们使用flatMap调用ethGetBlockByHash,以获得完整的块细节,这是传递给可观察者的订阅服务器的细节。

    进一步的例子

    请参阅ObservableIT,进一步举例说明。

    对于使用手动筛选器API的演示,可以查看EventFilterIT

    • 以太坊入门教程,主要介绍智能合约与dapp应用开发,适合入门。
    • 以太坊开发进阶教程,主要是介绍使用node.js、mongodb、区块链、ipfs实现去中心化电商DApp实战,适合进阶。
    • java以太坊开发教程,主要是针对java和android程序员进行区块链以太坊开发的web3j详解。
    • python以太坊,主要是针对python工程师使用web3.py进行区块链以太坊开发的详解。
    • php以太坊,主要是介绍使用php进行智能合约开发交互,进行账号创建、交易、转账、代币开发以及过滤器和交易等内容。
    • C#以太坊,主要讲解如何使用C#开发基于.Net的以太坊应用,包括账户管理、状态与交易、智能合约开发与交互、过滤器和交易等。
    • php比特币开发教程,本课程面向初学者,内容即涵盖比特币的核心概念,例如区块链存储、去中心化共识机制、密钥与脚本、交易与UTXO等,同时也详细讲解如何在Php代码中集成比特币支持功能,例如创建地址、管理钱包、构造裸交易等,是Php工程师不可多得的比特币开发学习课程。
    • java比特币开发教程,本课程面向初学者,内容即涵盖比特币的核心概念,例如区块链存储、去中心化共识机制、密钥与脚本、交易与UTXO等,同时也详细讲解如何在Java代码中集成比特币支持功能,例如创建地址、管理钱包、构造裸交易等,是Java工程师不可多得的比特币开发学习课程。
    • EOS入门教程,本课程帮助你快速入门EOS区块链去中心化应用的开发,内容涵盖EOS工具链、账户与钱包、发行代币、智能合约开发与部署、使用代码与智能合约交互等核心知识点,最后综合运用各知识点完成一个便签DApp的开发。

    原文出处:web3j教程:过滤器(Filters)和事件(Events)

    展开全文
  • django 内置标签与过滤器

    千次阅读 2017-11-17 19:03:06
    本文档介绍了Django的内置模板标签和过滤器。 我们推荐尽可能使用 自动文档,同时也可以自行编辑任何已安装的自定义标签或过滤器的文档。 内置标记引用 autoescape 控制自动转义是否可用.这种标签带任何 on...
  • django 内建标签和过滤器参考

    千次阅读 2008-12-23 23:18:00
    下面的标签和过滤器参考就是为那些没有 admin 站点的可用的人准备的.由于 Django 是高度可定制的,你的 admin 里的关于标签和过滤器的参考可以认为是最可信的.内建标签参考block定义一个能被子模板覆盖的 块. 参阅 ...
  • 文章目录一、需求二、分析1、人数2、点击次数3、技术点三、代码实现1、数据的读取,做切割处理2、按照活动ID事件类型分组3、调用process,自定义ValueState,对数据进行统计 一、需求 以下数据: 用户ID,活动ID,...
  • 映射框层控制 ... 如果需要此功能,则最好先关闭所有图层(“可见性”:“”),然后让控件使用查询参数将其打开,因为此功能不会关闭最初可见的图层。 图例使用超棒的字体。 这是一个很大的发展中,可能会
  • 微信支付 - 微信支付SDK使用讲解 - 微信支付状态查询 - 内网穿透 花生壳 - 微信支付回调 - rabbitMQ 延时队列讲解 13.秒杀基础 - 秒杀需求分析 - 秒杀服务搭建 - 秒杀之Redis - 秒杀之多线程 14.秒杀核心...
  • 使用Redis,将实时系统每条数据都去 Redis 进行判断; 使用 HashSet,因为 HashSet 本身就是无序不重复的;         但是以上两个方案,都是存在缺陷的。如果使用 Redis...
  • 作者:金源 出处:http://blog.csdn.net/jinyuan0829 本文版权归作者CSDN共有,欢迎转载,但未经作者同意必须保留此段声明,且在文章页面
  • 在我们的项目开发过程中,经常会对用户的信息进行分组,即通过组来显示用户的信息,同时通过一定的查询条件来显示查询后的相关用户信息,并且通过颜色选择来设置列表信息的背景颜色,实现仿QQ分组列表显示以及查询...
  • 在任何类型的ORM中,聚合(aggregation)都是造成混乱的根源,而Django也是如此。该文档提供了各种示例,演示了如何使用Django的ORM对数据进行分组(group)聚合...
  • 之前做项目的时候遇到一个需求是实现品牌的字母排序功能,网上的资料很多,但是一部分bug,这篇文章是我学习解决部分bug之后的总结。今天带来的是RecyclerView的A-Z字母排序和过滤搜索功能。 首先上效果图: ...
  • PDP分组数据协议

    千次阅读 2013-03-20 11:36:57
    PDP(packet data protocol)分组数据协议,是外部PDN(PLMN外部包数据)网与GPRS接口所用的网络协议。它是GPRS连接的软硬件环境,指定GPRS连接的接入点APN,连接类型IP或PPP,还有其他可选选项。 一个PDP上下文...
  • 状态检测防火墙知识

    千次阅读 2011-07-31 01:21:58
     状态检测防火墙采用了状态检测包过滤的技术,是传统包过滤上的功能扩展。状态检测防火墙在网络层一个检查引擎截获数据包并抽取出与应用层状态有关的信息,并以此为依据决定对该连接是接受还是拒绝。这种技术提供...
  • SQL:分组查询&&聚合查询

    千次阅读 2019-01-12 14:13:13
    文章目录通用编辑配置SQL编辑配置SQL Editor主编辑配置查询编辑对象编辑SQL执行 菜单:file–&amp;amp;amp;amp;amp;amp;amp;amp;gt;preferences 通用编辑配置 SQL编辑配置 SQL Editor主编辑...
  • 防火墙 包过滤防火墙 代理防火墙 应用网关防火墙 HTTP代理 SOCKS协议
  • Stream 作为 Java 8 的一大亮点,它与 java.io 包里的 InputStream OutputStream 是完全不同的概念。 集合讲的是数据,流讲的是计算 Java 8 中的 Stream 是对集合(Collection)对象功能的增强,它专注于...
  • 测试cxGrid的cxGridDBBandTableView组件在排序或者过滤以后: FocusedRecordIndex没有反应,FocusedRowIndex正常。 cxgrdtvGrid1DBTableView1.DataController.FocusedRecordIndex := 0; //定位到第一行 ...
  • 1.无状态分组过滤器 典型部署在内部网络网络边缘路由器上的防火墙, 路由器逐个检查数据报,根据访问控制表(Access Control Lists ,ACL)实现防火墙规则。 2.有状态分组过滤器 跟踪每个TCP连接建立、 拆除, ...
  • 防火墙技术虽然出现了许多,但总体来讲可分为“包过滤型”“应用代理型”两大类。前者以以色列的Checkpoint防火墙美国Cisco公司的PIX防火墙为代表,后者以美国NAI公司的Gauntlet防火墙为代表。 (1). 包过滤...
  • GCT 英语单词分组记忆手册

    万次阅读 2008-01-22 10:25:00
    有利的,助的 adventure n.冒险,冒险活动 adverb n.副词 advertise vt.通知 vi.登广告 advertisement n.广告;公告;登广告 advice n.劝告;忠告;意见 ===================012========================== ...
  •  识别主机两种方式:主机名、IP地址。前者便于记忆(如www.yahoo.com),但路由器很难处理(主机名长度不定);后者定长、层次结构,便于路由器处理,但难以记忆。折中的办法就是建立IP地址与主机名间的映射,这...
  • 就像我虽然准确的知道自己写过多少篇文章,但不知道Wordpress程序通过分类,标签,日期搜索功能自动的生成了多少个页面一样。为了满足不同访问者的访问目的需求会产生大量各种各样的页面。有些页面承载了价值...
  • SQLSTATE各种状态

    万次阅读 2014-05-30 10:16:57
    根据 X/Open SQL Access Group SQL CAE规范 (1992) 所进行的定义,SQLERROR返回 SQLSTATE 值。SQLSTATE值是包含五个字符的字符串 。五个字符包含数值或者大写字母, 代表各种错误或者警告条件的代码。SQLSTATE ...
  • 效果: 这篇文章算是之前一篇的...《Android 使用RecyclerView实现(仿微信)的联系人A-Z字母排序和过滤搜索功能》 http://blog.csdn.net/silenceoo/article/details/75661590主界面布局代码:<?xml version="1.0"

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 37,228
精华内容 14,891
关键字:

无状态分组过滤器和有状态分组过滤器