精华内容
下载资源
问答
  • 针对 RFID 阅读过程中的标签碰撞问题,在二进制树型搜索算法的基础上提出了一种优化的反碰撞算法.该算法通过构建新的请求建立方式,采用两位数仲裁碰撞进行逐位的识别,大大减少了碰撞检测时相应标签的数量,从而减少了...
  • 在RFID系统中,为解决碰撞问题,必须采用一定的防碰撞算法,时分多址算法中的二进制搜索算法识别率较高,是RFID系统中最常用的防碰撞算法。介绍了常用防碰撞算法的原理,并详细分析了二进制搜索算法的原理和实现过程,最后...
  • 传统蛙跳算法采用整数编码和相关的搜索方法,新算法采用种群文化倾向性,在二进制编码条件下实现了最优或次优解搜索.依据模式理论,以海明距为数学工具,定义了种群多样性参量作为早熟判别指标,当出现早熟时,在保留精英...
  • 模拟自然界优胜劣汰的进化现象,把搜索空间映射为遗传空间,把可能的解编码成一个向量——染色体,向量的每个元素称为基因。 通过不断计算各染色体的适应值,选择最好的染色体,获得最优解。 基本算法 选择运算 ...

    遗传算法

    基本概念

    模拟自然界优胜劣汰的进化现象,把搜索空间映射为遗传空间,把可能的解编码成一个向量——染色体,向量的每个元素称为基因。
    通过不断计算各染色体的适应值,选择最好的染色体,获得最优解。

    基本算法

    • 选择运算
    • 交换操作
    • 变异

    选择运算

    从旧的种群中选择适应度高的染色体,放入匹配集(缓冲区),为以后染色体交换、变异,产生新的染色体作准备。
    选择方法——适应度比例法(转轮法)
    按各染色体适应度大小比例来决定其被选择数目的多少。
    某染色体被选的概率: p c p_c pc
    P c = f ( x i ) ∑ f ( x i ) P_c= \frac{f(x_i)}{\sum f(x_i) } Pc=f(xi)f(xi)
    x i x_i xi 为种群中第 i i i个染色体值
    f ( x i ) f(x_i) f(xi)种群中所有染色体适应度值之和。
    ∑ f ( x i ) \sum f(x_i) f(xi) 种群中所有染色体适应度值之和。

    具体步骤

    1)计算各染色体适应度值
    2)累计所有染色体适应度值,记录中间累加值S - mid 和最
    后累加值 s u m = ∑ f ( x i ) sum=\sum f(x_i) sum=f(xi)
    3) 产生一个随机数 N , 0 < N < s u m N,0<N<sum N,0<N<sum
    4) 选择对应中间累加值S - mid 的第一个染色体进入交换集
    5) 重复(3)和(4),直到获得足够的染色体。

    GA的流程图

    在这里插入图片描述

    GA的基本参数

    1. 种群规模P: 参与进化的染色体数。
    2. 代购G: 二代之间不相同的染色体数目,无重叠G = 1;有重叠0 < G < 1。
    3. 选择方法:转轮法精英选择法,竞争法。
    4. 交换率: P c P_c Pc 一般为60~ 100%。
    5. 变异率: P m P_m Pm 一般为0.1~10% 。

    GA 代码

    % 下面举例说明遗传算法 %
    % 求下列函数的最大值 %
    % f(x)=x+10*sin(5x)+7*cos(4x) x∈[0,10] %
    % 将 x 的值用一个10位的二值形式表示为二值问题,一个10位的二值数提供的分辨率是每为 (10-0)/(2^10-1)≈0.01 
    % 将变量域 [0,10] 离散化为二值域 [0,1023], x=0+10*b/1023, 其中 b 是 [0,1023] 中的一个二值数。 %
    % %
    %--------------------------------------------------------------------------------------------------------------%
    %--------------------------------------------------------------------------------------------------------------
    
    
    % 2.0 主程序
    %遗传算法主程序
    %Name:genmain05.m
    %要求精度不大于0.01,
    clear
    clc
    popsize=20;                         %群体大小
    chromlength=10;                  %字符串长度(个体长度)
    pc=0.6;                                %交叉概率,只有在随机数小于pc时,才会产生交叉
    pm=0.001;                           %变异概率
    
    
    pop=initpop(popsize,chromlength);               %随机产生初始群体
    for i=1:2000                                                        %2000为遗传代数
            [objvalue]=calobjvalue(pop);                  %计算目标函数
            fitvalue=calfitvalue(objvalue);                 %计算群体中每个个体的适应度
    
            [newpop]=selection(pop,fitvalue);                 %复制
            [newpop1]=crossover(newpop,pc);               %交叉
            [newpop2]=mutation(newpop1,pm);               %变异
            
            [objvalue]=calobjvalue(newpop2);                 %计算目标函数
            fitvalue=calfitvalue(objvalue);                       %计算群体中每个个体的适应度
            
            [bestindividual,bestfit]=best(newpop2,fitvalue);     %求出群体中适应值最大的个体及其适应值
            y(i)=bestfit;                                                              %返回的 y 是自适应度值,而非函数值
            x(i)=decodechrom(bestindividual,1,chromlength)*10/1023;      %将自变量解码成十进制
            pop=newpop2;
    end
    fplot('x+10*sin(5*x)+7*cos(4*x)',[0 10])
    hold on
    plot(x,y,'r*')                                          
    hold on
    
    [z ,index]=max(y);             %计算最大值及其位置
    x5=x(index)                     %计算最大值对应的x值
    ymax=z
    

    完整代码外加PPT
    github地址

    批注

    x可以取值为浮点数时,可以根据精度设置二进制的长度,二进制转十进制,十进制除以 1 0 n 10^n 10n。获得小数
    比如:x∈[0,10] 如果设置二进制的长度为10,这二进制最大可以表示1023,若要取10则,1023只可以除以100。则10位二进制可以提供的精度为0.01。

    展开全文
  • 首先,采用经典的二进制代码变换公式构建了二进制布谷鸟搜索(BCS)算法。其次,引入病毒生物进化机制和病毒感染操作,一方面赋予布谷鸟鸟巢位置自变异机制增加种群多样性;一方面将布谷鸟鸟巢位置所组成的主群体的...
  • 采用一种可行和声初始化方式, 保证初始和声都是可行的, 整个搜索过程完全采用0-1 二进制模式, 对14 个0-1 背包问题进行测试. 将所提出算法与其他算法进行比较, 结果验证了所提出算法的有效性.</p>
  • RFID-二进制搜索

    千次阅读 热门讨论 2019-06-16 22:28:22
    MATLAB编程实现二进制搜索与二分支搜索

    说明

    MATLAB编程实现二进制树搜索与二分支搜索。

    二进制树搜索

    原理

    二进制搜索技术以唯一的序列号来识别射频电子标签为基础。为了从一簇射频电子标签中选择其中之一, 射频读写器发出一个读命令, 将射频电子标签序列号传输时的数据碰撞引导到射频读写器, 即由射频读写器判断是否有碰撞发生。 如果有, 则进一步搜索。在二进制算法的实现中, 起决定作用的是射频读写器所使用的信号编码必须能够确定碰撞发生的准确位置。
    二进制树搜索算法是由在一个射频读写器和多个射频电子标签之间规定的相互作用(命令和应答)顺序(规则)构成的,目的在于从较大的一组中选出一个标签。算法规定,射频电子标签之间要严格同步,以便准确地监测碰撞位的发生,并且要求能辨认出读写器中数据碰撞的比特位的准确位置,一般采用曼切斯特编码。
    为了实现这种算法,就需要一组命令,这组命令由射频读写器发出,可由射频电子标签处理,命令如下:
    REQUEST:此命令发送一序列号作为参数给射频电子标签。射频电子标签把自己的序列号与接收的序列号比较。如果小于或等于请求序列号,则此射频电子标签回送其序列号给射频读写器。这样就可以缩小预选的射频电子标签的范围请求;
    SELECT:用某个事先确定的序列号作为参数发送给射频电子标签。具有相同序列号的射频电子标签将此作为执行其他命令(例如读出和写入数据)的切入开关, 选择这个射频电子标签。具有其他序列号的射频电子标签只对REQUEST命令应答;
    READ-DATA:选中的射频电子标签将其存储的数据发送给射频读写器;
    UNSELECT:取消一个选中的射频电子标签,使射频电子标签进入“静默”状态, 这种状态中电于标签完全是非撤活的,对收到的REQUEST命令不作应答。为了更新激活射频电子标签,暂时离开射频读写器的作用范围(等于没有供应电压),以实现复位。

    代码

    • request
    %request函数
    %射频电子标签把自己的序列号与接收的序列号比较。如果小于或等于,返回。
    function [bit,D_max]=request(new_label,new_n)
    bit=ones(1,8);           %81
    for k=1:8
        sum=0;
        for j=1:new_n
            sum=sum+new_label(j,k);    
        end
        if sum==0           %即对应位全为0
            bit(1,k)=0;
        elseif sum==new_n   %对应为全为1
            bit(1,k)=1;
        else
            D_max=k;        %碰撞位,且设为0
            bit(1,k)=0;
            break;
        end
    end
    end
    
    • select
    %select函数
    %用某个事先确定的序列号作为参数发送给射频电子标签
    function [new_label2,new_n]=select(new_label,new_bit,new_max,n)
    new_n=0;
    for a=1:n
        if new_label(a,new_max)==new_bit(new_max)
            new_n=new_n+1;
            new_label2(new_n,:)=new_label(a,:);
        else
        end
    end
    end    
    
    • unselect
    %unselect函数
    function [h,nlabel]= unselect(new_label,nlabel,h)
    for nn=1:h
        result = isequal(new_label,nlabel(nn,:));
        if result 
            nlabel(nn,:)=[];  
            h=h-1;
            break;
        end
    end        
    end
    
    • 界面核心代码
    %主要代码位于pushbutton1_Callback
    
    % --- Executes on button press in pushbutton1.
    function pushbutton1_Callback(hObject, eventdata, handles)
    % hObject    handle to pushbutton1 (see GCBO)
    % eventdata  reserved - to be defined in a future version of MATLAB
    % handles    structure with handles and user data (see GUIDATA)
    tic
    tag_count1=get(handles.edit1,'String');  %获取输入的标签总数
    ctag=str2num(tag_count1);              
    rand1=rand(ctag,1)*256;                  %随机生成标签
    rand2=dec2bin(rand1);                       
    tgrand=num2str(rand2);
    rand3=sort(rand1);                       
    rand4=dec2bin(rand3);                  
    rand5=num2str(rand4);
    toc                                      %记录程序运行时间
    set(handles.listbox1,'String',tgrand);   %输出
    set(handles.listbox2,'String',rand5);
    set(handles.edit2,'String',num2str(toc));
    

    界面结果

    在这里插入图片描述

    二分支

    原理

    该方法采用递归的工作方式,遇到碰撞就随机地进行分支,成为多个子集。在接下来的时隙中,主要解决信息包所发生的碰撞。如果再次发生碰撞,就继续随机地分为多个分支。然后依次进行查询,标签被分支后,由于响应的标签数量减少,再次发生碰撞的概率降低,通过不断的分支,减少响应标签的数量,直至分支内没有或仅有一个标签响应。

    1. 先随机生成16位的标签号,定义标签的左右子树;
    2. 先找出标签碰撞的位数,若得到碰撞的位,根据碰撞的位将标签号分为左右两子树(定义左子树位1,右子树位0);
    3. 判断左子树是否只有一个标签或无标签,若是,则该次调用结束,判断上步的右子树是否只有一个标签或无标签,若不是,则进入该右子树的左子树进行查验,以此循环。

    我们定义每一个左右子树都要进行一次查询和一次响应,因为可以计算出操作次数,并定义吞吐量等于标签数目除以总的操作次数。

    代码

    • pick函数
    %定义pick函数:碰撞算法
    function c=pick(A,tag_count,b,len)  %A为标签数组,tag_count为标签数目,b已经使用的时隙数,len为标签长度
    A
    tag_count
    m=1;                                %左子树标签数目
    n=1;                                %右子树标签数目
    b=b+2;                              %查询、响应
    D_max=len;                          %初始化最高碰撞位
    x=0;
    len_l=len;                          %初始化标签长度
    
    if tag_count==1                     %若标签数目为1,直接返回
        c=b;
        return;
    end
    
    for j=1:1:len_l                     %对标签每一位进行判断是否碰撞
        sum=0;
        for k=1:1:tag_count             %所有标签对应为求和
            x=A(k,j);
            sum=sum+x;
        end
        if sum==0                       %即对应为全为0,无碰撞
            ;     
        elseif sum==tag_count           %即对应为全为1,无碰撞
            ;
        else                            %碰撞
            D_max=j;                    %最高碰撞位
            break;
        end
    end
    for i=1:tag_count                   %把标签分成左、右子树
       x=A(i,D_max);
        if x==1                         %左子树为1
            left_tag(m,:)=A(i,:);
            m=m+1;                      %左子树+1
        else
            right_tag(n,:)=A(i,:);
            n=n+1;
        end
    end
    if m==2||m==1                      %左子树有一个标签或无标签则响应完毕
        b=b+2;
        c=b;
    else
        b=pick(left_tag,m-1,b,len);    %如果标签数大于2,则递归调用
    end
    
    if n==2||n==1                      %同上
        b=b+2;
        c=b;   
    else
        b=pick(right_tag,n-1,b,len);
    end
    c=b;                               %返回操作总的次数
    return;
    
    • 主函数核心代码
    %主要代码位于pushbutton1_Callback
    % --- Executes on button press in pushbutton1.
    function pushbutton1_Callback(hObject, eventdata, handles)
    % hObject    handle to pushbutton1 (see GCBO)
    % eventdata  reserved - to be defined in a future version of MATLAB
    % handles    structure with handles and user data (see GUIDATA)
    ctag=str2num(get(handles.edit1,'String'));       %获取输入的标签总数
    ID_length=str2num(get(handles.edit2,'String'));  %获取输入的标签长度
    for i=1:ctag
        tagg(i,:)=randi([0,1],1,ID_length);          %随机生成tagcount个长为ID_length的标签
    end
    tag1 = unique(tagg,'rows');                      %去除重复
    tag_count=size(tag1,1);                          %计算不重复的标签总数
    r = randperm(tag_count);                         %打乱
    tag=tag1(r,:);
    tag;
    sum=0;a=0;
    a=pick(tag,tag_count,0,ID_length)                %调用pick函数
    sum=sum+a;                                       %计算操作次数
    cc=sum;
    tuntu=tag_count/cc;                              %计算吞吐量
    set(handles.edit4,'String',cc);                  %输出操作次数
    set(handles.edit5,'String',tuntu);               %输出吞吐量
    tag = num2str(tag); 
    tag;
    set(handles.listbox2,'String',tag);              %输出待识别的标签
    guidata(hObject,handles);
    
    % --- Executes on button press in pushbutton2.
    function pushbutton2_Callback(hObject, eventdata, handles)
    % hObject    handle to pushbutton2 (see GCBO)
    % eventdata  reserved - to be defined in a future version of MATLAB
    % handles    structure with handles and user data (see GUIDATA)
    close;                                            %关闭窗口
    
    

    结果界面

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 这里写自定义目录标题原理: 实现语言:python 实验要求: (1)普通二进制树搜索: 设计一个1、11、21…标签数目 ...1.普通二进制搜索算法 二进制搜索技术以唯一的序列号来识别射频电子标签为基础。

    实现语言:python

    实验要求:
    (1)普通二进制树搜索:
    设计一个1、11、21…标签数目
    ①先设计一个GUI界面,得到8位二进制数的随机序列,分成256份。
    ②先对每一次都找出碰撞的最高位;
    ③选择比碰撞位小的二进制数,然后继续进行第②步骤,直至选择出最小的那一个;
    ④去除最小的那一行,在进行第二三四步的循环,并记下用时;
    ⑤画出每一次找到一个标签的运行用时曲线图。
    (2)二分支搜索…

    原理:

    1.普通二进制搜索算法
    二进制搜索技术以唯一的序列号来识别射频电子标签为基础。为了从一簇射频电子标签中选择其中之一,射频读写器发出一个读命令,将射频电子标签序列号传输时的数据碰撞引导到射频读写器,即由射频读写器判断是否有碰撞发生。如果有,则进一步搜索。在二进制算法的实现中,起决定作用的是射频读写器所使用的信号编码必须能够确定碰撞发生的准确位置。因此,一般使用可以进行位碰撞检测的曼彻斯特编码发送数据。

    前提,读写器并不知道各个标签各自的ID号,只能根据曼彻斯特编码判断有没有碰撞。
    在普通二进制算法中,根据所给标签数生成对应的唯一标签ID,并进行普通二进制搜索算法:选取标签的第1位字符,与所假定标签“11111111”的第一位字符进行匹配,如果匹配数为1,则读写器确定匹配,直接和这个标签进行通信,并将其从标签从数组中删去,将匹配字符串和索引index初始化,重新匹配;若匹配到的标签数为0,就将所假定标签“11111111”的第1(n)位取反,然后继续重新匹配;若匹配到的标签数为2,就将需要匹配的字符数+1(本来匹配前n位,现在匹配前n+1位),再次匹配;不断循环,直到标签集合中无标签为止。
    在这里插入图片描述
    流程图如下:
    在这里插入图片描述
    2.二分支搜索
    二分支搜索方法采用递归的工作方式,遇到碰撞就随机地进行分支,成为多个子集。在接下来的时隙中,主要解决信息包所发生的碰撞。如果再次发生碰撞,就继续随机地分为多个分支。然后依次进行查询,标签被分支后,由于响应的标签数量减少,再次发生碰撞的概率降低,通过不断的分支,减少响应标签的数量,直至分支内没有或仅有一个标签响应。

    在二分支搜索中,不可避免的每一次都要搜索0,1。如果返回的标签数大于2,就进一步递归,将前缀的字符串加上0、1两种方式分别再次递归搜索;如果等于1就被被选中,直接进行通信,如果等于0就直接返回不操作。
    在这里插入图片描述
    普通二进制搜索的python代码如下

    import math
    import random
    import time
    from tkinter import *
    
    #tkinter界面设计 
    root = Tk()
    Label(root,text='二进制树仿真').grid(row = 0, column = 1)
    Label(root,text = '显示n个标签的识别').grid(row = 1, column = 0, padx = 10, pady = 5)
    entry1= Entry(root)
    entry1.grid(row = 1, column = 1, padx = 10, pady = 5)
    
    #回调函数
    def callback():
        n = int(entry1.get())
        listbox1.delete(0,END)
        listbox2.delete(0,END)
        text1.delete(1.0,END)
        w.delete(ALL)
        #初始化
        tags=[]
        print(n)
        list1=random.sample(range(256),n) #使用sample产生一个不重复的数组
        for i in range(n):
            tags.append('{:08b}'.format( list1[i])) #'{:08b}'.format( list1[i])  08b将list1转化为二进制且高位补零
        for i in range(n):
            listbox1.insert(END,str(tags[i]))
        print(tags)
    
    
        react_num=0
        request = '11111111'
        index = 0
        #初始化结束
        def search(react_num,request,index):
            global a                                     #a 必须声明为全局变量,原因我也不太清楚
            global n
            for i in range(len(tags)):              #对每一个标签进行匹配
                if tags[i][0:index]==request[0:index]:
                    react_num += 1
                    a = i
            return react_num, a                       #这样可以返回多个值,保存于一个元组之中
    
        start = time.time()
        react_num = search(0, request, index)[0] #搜索到的响应个数
        b = search(0, request, index)[1] #搜索到的下标,由于request和 index都没有变,所以还是一样的结果
        while (len(tags)):  
            if react_num == 1:
                    print(tags[b])
                    listbox2.insert(END,str(tags[b])) #将其表现在框中
                    mid_end = time.time() #将其表现在画布上
                    w.create_oval((5*(n-len(tags))-1), (200-100*(mid_end - start)-1),\
                                  (5*(n-len(tags))+1), (200-100*(mid_end - start)+1), fill="red")
                    index = 0
                    del tags[b]          #如果为1,则将其输出,并从列表中删去
                    request = '11111111'
                    react_num = search(0, request, index)[0]
                    b = search(0, request, index)[1]
            elif react_num >1:
                    index += 1          #如果大于2个,就将索引加一重新查找
                    react_num = search(0, request, index)[0]
                    b = search(0, request, index)[1]
            elif react_num < 1:
                    temp = request[0:index-1]+str(1-int(request[index])) #如果react_num<1, 则无, 就要改变request
                    request = temp + request[index:]  #改变request
                    react_num = search(0, request, index)[0] 
                    b = search(0, request, index)[1]
    
        end = time.time()
        print(end - start)
        text1.insert(INSERT,str(end-start))
    
        
    B = Button(root,text = '确定', width=10, command = callback)
    B.grid(row = 1, column = 2, padx=10, pady=5)
    
    group1 = LabelFrame(root, text="标签")
    group2 = LabelFrame(root, text="识别后")
    group1.grid(row = 2, column = 0, padx=10, pady=5)
    group2.grid(row = 2, column = 2, padx=10, pady=5)
    scrollbar1 = Scrollbar(group1)
    scrollbar2 = Scrollbar(group2)
    scrollbar1.pack(side=RIGHT, fill=Y)
    scrollbar2.pack(side=RIGHT, fill=Y)
    listbox1 = Listbox(group1, yscrollcommand=scrollbar1.set)
    listbox1.pack(anchor = W)
    listbox2 = Listbox(group2, yscrollcommand=scrollbar2.set)
    listbox2.pack(anchor = W)
    scrollbar1.config(command=listbox1.yview)
    scrollbar2.config(command=listbox2.yview)
    Label(root,text = '程序运行时间 :').grid(row = 3, column = 0, padx = 10, pady = 5)
    text1 = Text(root, width=20, height=1)
    text1.grid(row = 3, column = 1, padx = 10, pady = 5)
    group3 = LabelFrame(root, text="曲线")
    group3.grid(row = 4, column = 0, columnspan = 3, padx = 10, pady = 5)
    w = Canvas(group3, width=400, height=200)
    w.pack()
    
    mainloop()
    

    实验结果图
    在这里插入图片描述
    由于能力有限,曲线是使用tkinter的canvas组件画的,后期也可以改成用matplotlib

    上图实验结果显示
    在最开始的时候,列表中有128个标签,要得到唯一的一个标签ID,需要迭代8次,时间比较长,可以看出,曲线刚开始的时候斜率较大,一个标签识别需要运行时间长(需要迭代八次);后来曲线的斜率较小,因为前面的标签找到后就从列表中删除了,列表小了,标签数少了,要找到一个唯一的标签时间变短了(需要迭代的次数少了)。
    二分支算法使用递归实现,做法类似

    最后实验结果:
    普通二进制搜索算法每一次查找都是从头开始,这就导致了效率的低下,为了从较大量的电子标签中发现一个单独的电子标签,需要重复操作。其平均次数L取决于读写器作用范围内电子标签总数N;当标签总数为32时,平均需要6次迭代才能找出唯一标签;当标签总数为64时,平均7次;当标签总数为128时,平均需要8次,效率较低。

    而二分支搜索算法由于每一次不需要从头开始,并且使用递归搜索,不计算递归所带来的资源成本的话,就吞吐量来说,该算法是比较优秀的,找到唯一的解所需的平均查找操作次数大约为4次,即使标签数目不断增大,二分支树的深度也不会超过16层,而由于不需要重复查找,吞吐量和效率就比较高。

    展开全文
  •  二进制搜索算法的基本思路是,多个标签进入读写器工作场后,读写器发送带限制条件的询问命令,满足限制条件的标签回答,如果发生碰撞,则根据发生错误的位修改限制条件,再一次发送询问命令,直到找到一个正确的...

           二进制树型搜索算法由读写器控制,基本思想是不断的将导致碰撞的电子标签进行划分,缩小下一步搜索的标签数量,直到只有一个电子标签进行回应。

           二进制搜索算法的基本思路是,多个标签进入读写器工作场后,读写器发送带限制条件的询问命令,满足限制条件的标签回答,如果发生碰撞,则根据发生错误的位修改限制条件,再一次发送询问命令,直到找到一个正确的回答,并完成对该标签的读写操作。对剩余的标签重复以上操作,直到完成对所有标签的读写操作。      

            为了实现二进制搜索算法,就要选用曼彻斯特编码,因为这种编码可以检测出碰撞位。    为了实现这个算法,引入以下4种命令。

    1.冲突位检测

            实现该算法系统的必要前提是能够辨认出在读写器中数据冲突位的准确位置。为此,必须有合适的位编码法。如图对NRZ编码和曼彻斯特编码的冲突状况作一比较。

    1)NRZ编码

            如果两个电子标签之一发送了副载波信号,那么,这个信号由读写器译码为“高”电平,就被认定为逻辑“1”。但读写器不能确定读入的某位究竟是若干个电子标签发送的数据相互重叠的结果,还是某个电子标签单独发送的信号。

    2)曼彻斯特编码

           如果两个或多个电子标签同时发送的数位有不同值,则接收的上升沿和下降沿互相抵消,“没有变化”的状态是不允许的,将作为错误被识别。用这种方法可以按位追溯跟踪冲突的出现。

    2.用于“二进制树搜索”算法命令

    1)REQUEST 请求系列号

        发送一序列号作为参数给区域内标签。序列号小于或者等于的标签,回送其序列号给阅读器。(缩小范围)

    2)SELECT  选择系列号

        用某个(事先确定的)序列号作为参数发送给标签。具有相同的序列号的标签将以此作为执行其他命令(读出和写入)的切入开关,即选择了标签。

    3)READDATA  读出数据

         选中的标签将存储的数据发送给阅读器。

    4)UNSELECT   退出选择

         取消一个事先选中的标签,标签进入无声状态,这样标签对REQUEST命令不作应答。

    3.二进制树型搜索算法过程

        基本思想是将处于冲突的标签分成左右两个子集0和1,先查询子集0,若没有冲突,则正确识别标签,若仍有冲突则再分裂,把子集0分成00和01两个子集,依次类推,直到识别出子集0中所有标签,再按此步骤查询子集1。

        因此,标签的序列号是处理碰撞的基础。



    展开全文
  • 基于量子进化理论以及蚂蚁群体的寻优策略,结合一种二进制量子蚁群算法,...通过标准测试函数对其优化性能进行研究,该算法在函数优化的全局寻优能力和快速搜索能力上,均优于二进制量子蚁群算法和连续量子蚁群算法
  • 从硬件电路设计和软件设计实现方面阐述了RFID定位系统设计的基本流程,并在CC2500的硬件功能基础之上,采用二进制搜索法有效地解决了多标签识别防碰撞的问题。通过接收标签的RSSI值,采用LANDMARC定位算法实现精确...
  • [Matlab]离散二进制粒子群算法(BPSO )解决背包问题什么是离散二进制粒子群算法(BPSO )描述离散二进制粒子群算法(BPSO )步骤背包问题描述解决思路函数设计targetPackage.mpsoForBackpack.m图像 什么是离散...
  • 二进制搜索防碰撞算法中用的主要命令有: 1、Request(请求):阅读器向其识别区中的标签发送带有标签序列号的请求命令,标签接到命令后,其自身序列号小于或者等于该序列号的标签会将自己的序列号发送给阅读器,...
  • 多标签防碰撞技术是射频识别系统中的关键技术和研究热点,文章在对现有防碰撞算法的分析基础上,提出一种改进的基于后退式二进制搜索的防碰撞算法。该算法能够动态地调整发送指令的长度,从而有效减少搜索次数和传输...
  • 回溯算法(十进制转二进制

    千次阅读 2018-09-28 16:19:29
    回溯算法实际上一个类似枚举的搜索尝试过程,主要是在搜索尝试过程中寻找问题的解,当发现已不满足求解条件时,就“回溯”返回,尝试别的路径。回溯法是一种选优搜索法,按选优条件向前搜索,以达到目标。但当探索到...
  • 但是我不会逐步解释算法,而是会深入了解二进制搜索的工作原理和使用方式。 如果您不知道Binary Search,请查看: geeksforgeeks.org/binary-search 。 给定一个已排序的数组,我们找到最中间的元素并使用键...
  • 假设四个电子标签的序列号分别为 标签1:10110010; 标签2:10100011; 标签3:10110011; 标签4:11100011. ...1)读写器设置筛选条件(11111111),向标签发送请求。...2)阅读范围内的所有标签均符合条件,响应请求...
  • 采用一种改进的二进制微分进化算法对第一阶段的机组启停计划目标进行求解,对每个代表机组启停状态的个体编码采用机组最小启停时间约束、旋转备用约束、机组去组合等处理机制,有效保证了每个解的有效性并缩小了算法...
  • 遗传算法 二进制编码 matlab实现

    千次阅读 2020-03-31 18:17:09
    问题1:遗传算法第一步就是要解决编码问题,常用二进制编码,用过matlab的都知道有自带的十进制转换二进制的API,但是生成的char类型变量却不方便完成后续计算适应度、交叉、变异等操作; 问题2:常见实现编码方式为...
  • 1. 什么是离散粒子群算法? 普通粒子群算法(Particle Swarm Optimization Algorithm,PSO)的粒子初始位置、更新速度都是连续函数,与之对应,位置和速度更新均为离散值的算法是离散PSO算法(Discrete Particle ...
  • 采用典型的非线性0-1规划测试问题进行数值实验,并将算法二进制粒子群优化算法二进制引力搜索算法进行比较。实验结果表明,在解的稳定性和计算精度两个方面给出的算法具有显著优势,为非线性0-1规划问题的求解...
  • 算法简化了初始化的过程,采用单维求反的邻域搜索策略,计算量与最优多用户检测相比明显降低。仿真结果表明,提出的多用户检测方案在抗多址干扰和抗“远近”效应能力方面与传统检测方案相比,都有显著提高
  • Binary multi‑verse optimization algorithm for global ...最后与其他二进制优化算法,如二进制蝙蝠算法二进制粒子群优化,二进制算法,和二进制灰狼优化器进行了比较。 2.介绍 MVO的灵感来自于物理学中的
  • 针对基本二进制人工蜂群算法开采能力弱、收敛速度慢的缺点,提出一种全局最优引导的差分二进制人工蜂群算法算法仿照粒子群优化,将全局最优参数引入二进制人工蜂群算法中以提高开采能力;同时受差分演化算法中...
  • 斑点检测中提到的SIFT和SURF算法均包含了特征描述过程,它们采用梯度统计直方图的描述子,属于浮点型特征描述子,计算复杂,效率较低,二进制字符串特征描述子则改进了这一限制。 1、BRIEF BRIEF算法特征检测部分与...
  • 二进制是计算技术中广泛采用的一种数制。二进制数据是用0和1两个数码来表示的数。它的基数为2,进位规则是“逢二进一”,借位规则是“借一当二”,由18世纪德国数理哲学大师莱布尼兹发现。—— 百度百科二进制数据...
  • 两个n位二进制数分别存储在两个n元数组A和B中,这两个整数的和存在一个n+1元的数组C中答:此问题主要是考察相加进位的问题,元素1+1 =0 并且往前进一位ADD-BINARY(A,B)C=new integer[A.length+1]carry=0for i=A....
  • 并且将数据聚类作为一个优化问题的解,采用基于聚类中心的二进制编码,使用BFA算法搜索空间内搜索最优聚类中心。实验结果表明,提出的BFA算法能够有效应用于数据聚类问题,不仅总体精度优于其他聚类算法,而且具有良好...
  • 《高中信息技术《二进制及其转换》教学设计 人教版》由会员分享,可在线阅读,更多相关《高中信息技术《二进制及其转换》教学设计 人教版(3页珍藏版)》请在人人文库网上搜索。1、江苏省泰州二中高中信息技术二进制...
  • 电子标签1:10110010 电子标签2:10100011 电子标签3:10110011 电子标签4:11100011 迭带过程示意图: 

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 59,503
精华内容 23,801
关键字:

二进制搜索算法采用的是