#include "..\include\aodv\aodv.h"
#include "..\include\datalink_rf\rf.h"
#include "..\include\constant.h"
#include "..\include\hal\hal.h"
#include "..\include\drivers\uartint.h"
#include "..\include\drivers\rs485.h"
#include "..\include\drivers\hdwint.h"
aodv_table_list table_list;
application_data_list data_list;
bid_cache_list bid_list;
ntid_cache_list nt_id;
struct npdu npdu_aodv;
unsigned char npdu_send_flag;
unsigned char LOCAL_ID;
unsigned char busy = 0;
void aodv_init(void)
{
unsigned char i;
LOCAL_ID = BOMA_RF();
//路由表的初始化
table_list.table[0].rt_flags=1;//每个节点的路由表的第一项，存储自己的信息，主要是本节点维护的自身的序列号（当它是源节点是就是源节点序列号etc）
table_list.table[0].dest=LOCAL_ID; //LOCAL_MAC
table_list.table[0].rt_seqno=2;
for(i=1;i { table_list.table[i].rt_flags=0;// bug? } //广播报文的初始化 bid_list.bid_cache[0].flag=1; //每个节点的报文表的第一项，存储自己的广播报文信息，主要是广播号 bid_list.bid_cache[0].broad_id=1; //每发起一次广播bid自加 bid_list.bid_cache[0].src=LOCAL_ID; for(i=1;i { bid_list.bid_cache[i].flag=0; bid_list.bid_cache[0].broad_id=0; // Hz } //数据队列的初始化 for(i=0;i { data_list.buffer_data[i].buffer_status=0; } //计时器的初始化 nt_id.ntid_cache[0].flag = 1; nt_id.ntid_cache[0].node_id = LOCAL_ID; } //网络层状态机 NetLayer_State_Machine() { unsigned char tmp_num; unsigned char i,j; unsigned char temp_id; // unsigned char xx; if(npdu_send_flag==1) { busy = 1; npdu_send_flag=0; if ( (tmp_num=lookup_table(npdu_aodv.send_dest) )!=0xff) { npdu_send(npdu_aodv.base,npdu_aodv.base_len,npdu_aodv.send_src,npdu_aodv.send_dest, table_list.table[tmp_num].rt_nexthop); } else { // xx=enque(npdu_aodv.base_out,npdu_aodv.base_len,npdu_aodv.send_src,npdu_aodv.send_dest);//最好少走这条路线，否则后果严重 enque(npdu_aodv.base,npdu_aodv.base_len,npdu_aodv.send_src,npdu_aodv.send_dest); // H // SendChar(0xA0+xx); table_list.table[0].rt_seqno+=2; if(table_list.table[0].rt_seqno%2)table_list.table[0].rt_seqno++; sendRequest( bid_list.bid_cache[0].broad_id++,LOCAL_ID,table_list.table[0].rt_seqno,npdu_aod v.send_dest,FIRST_SEQNO, TTL_DIAMETER,1,BROADCAST_ID,LOCAL_ID); //LOCAL_MAC FIRST_SEQNO // } busy = 0; } if(datalink_received_flag==1) //npdu_aodv好像还没有赋值。。这里有错 { busy = 1; SendChar(0x10+npdu_aodv.base_in[0]); datalink_received_flag=0; if (npdu_aodv.base_in[0]==1)//数据报文 { SendChar(0x13); if(npdu_aodv.base_in[1]==LOCAL_ID) return; //接收到本节点发出数据报文，丢包LOCAL_MAC if(npdu_aodv.base_in[2]==LOCAL_ID) // LOCAL_MAC { app_received_flag=1; //接收到传给本节点的数据报文，交给上层处理 SendChar(0x33); Uart0_Send(npdu_aodv.base_in,npdu_aodv.base_in_len); } if(npdu_aodv.base_in[2]!=LOCAL_ID) //接收到的数据既不是本节点发出的， 也不是传给本节点的，只是转发数据分组LOCAL_MAC { npdu_aodv.send_src=npdu_aodv.base_in[1]; npdu_aodv.send_dest=npdu_aodv.base_in[2]; for(i=0;i { npdu_aodv.base[i]=npdu_aodv.base_in[i+3]; // 不能用base_out 会与npdu_send中的base_out冲突 } npdu_aodv.base_len=npdu_aodv.base_in_len-3; if ( (tmp_num=lookup_table(npdu_aodv.base_in[2]) )!=0xff) //基本会走这条路线 { SendChar(0x14); npdu_send(npdu_aodv.base,npdu_aodv.base_len,npdu_aodv.send_src,npdu_aodv.send_dest, table_list.table[tmp_num].rt_nexthop); } else //因为本节点是数据转发的中间节点，不是源节点，路由发起早在源节点就完成了，所以没有到目的节点的路由表的可能性不大 { SendChar(0x15); // enque(npdu_aodv.base_in,npdu_aodv.base_in_len,npdu_aodv.receive_src,npdu_aodv.receive_dest ); // broadcast_id enque(npdu_aodv.base,npdu_aodv.base_len,npdu_aodv.send_src,npdu_aodv.send_dest); // H //这个地方发送请求还是不发送请求？挖掘中... 突发的链路失效 sendRequest( bid_list.bid_cache[0].broad_id++,LOCAL_ID,table_list.table[0].rt_seqno,npdu_aod v.base_in[2],FIRST_SEQNO, TTL_DIAMETER,1,BROADCAST_ID,rf_port.receive_src); //由中间节点启动路由发现过程LOCAL_MAC table_list.table[0].rt_seqno ？ } } } if(npdu_aodv.base_in[0]==0) //协议报文 { SendChar(0x12); aodv_resolve(); } busy = 0; } //================================================ if(nt_id.ntid_cache[0].rt_timer > 500000 && busy == 0) //本节点隔一定时间发送hello 报文 { nt_id.ntid_cache[0].rt_timer = 0; sendHello(); } for(j=1;j { if(nt_id.ntid_cache[j].rt_timer > 600000 && busy == 0 && nt_id.ntid_cache[j].flag == 1) //nt_id.ntid_cache[j].flag == 1 可以不要 { nt_id.ntid_cache[j].flag = 0; nt_id.ntid_cache[j].rt_timer = 0; temp_id = nt_id.ntid_cache[j].node_id; // nt_id.ntid_cache[j].node_id = 0; if(delete_table(temp_id) == 0xff); if(id_lookup(temp_id) != 0xff) bid_list.bid_cache[temp_id].flag=0; // delete broad id sendError(LOCAL_ID,temp_id,1); // ttl = 1 只传一跳 } } //==============================================*/ } //aodv协议模块 aodv_resolve() { static unsigned char aodv_type; busy = 1; aodv_type=npdu_aodv.base_in[1]; SendChar(0x40+npdu_aodv.base_in[1]); switch ( aodv_type ) { recvRequest(); break; case 2: recvReply(); break; case 3: recvError(); break; case 4: recvHello(); break; default: break; } busy = 0; } sendRequest(unsigned char bid,unsigned char src,unsigned char src_seq_no,unsigned char dest,unsigned char dest_seq_no, unsigned char ttl,unsigned char hops,unsigned char mac_dest,unsigned char last_hop) { busy = 1; // unsigned char rt_num; npdu_aodv.base_out[0]=0;//0协议报文1数据报文 npdu_aodv.base_out[1]=1;//报文类型1 request 2 reply 3 error 4 hello // npdu_aodv.base_out[2]=1; //此报文经过的跳数 npdu_aodv.base_out[2]=hops; //此报文经过的跳数 npdu_aodv.base_out[3]=bid;//broadcast_id npdu_aodv.base_out[4]=src; // src // table_list.table[0].rt_seqno+=2; // npdu_aodv.base_out[5]=table_list.table[0].rt_seqno;//src sequence number npdu_aodv.base_out[5]=src_seq_no; npdu_aodv.base_out[6]=dest; // rt_num=lookup_table(dest); // if(rt_num==0xff) npdu_aodv.base_out[7]=0; // else npdu_aodv.base_out[7]=table_list.table[rt_num].rt_seqno; //dest sequence number npdu_aodv.base_out[7]=dest_seq_no; npdu_aodv.base_out[8]=ttl; //ttl npdu_aodv.base_out[9]=last_hop; // H 发送自己上一跳地址，让路由表里可以存两跳 npdu_aodv.base_out_len=10; rf_port.send_dest=mac_dest; //此时应为广播地址 nt_id.ntid_cache[0].rt_timer = 0; // H Wireless_Send_Flag=1; SendChar(0xa1); } sendReply(unsigned char src,unsigned char hop,unsigned char dest,unsigned char dest_seqno,unsigned char ttl,unsigned char mac_dest,unsigned char last_hop) { busy = 1; npdu_aodv.base_out[0]=0;//0协议报文1数据报文 npdu_aodv.base_out[1]=2;//报文类型1 request 2 reply 3 error 4 hello npdu_aodv.base_out[2]=hop; //此报文经过的跳数 npdu_aodv.base_out[3]=src; // src npdu_aodv.base_out[4]=dest; npdu_aodv.base_out[5]=dest_seqno;//dest sequence number ?? src_seqno npdu_aodv.base_out[6]=ttl; npdu_aodv.base_out[7]=last_hop; // H npdu_aodv.base_out_len=8; rf_port.send_dest=mac_dest; // nt_id.ntid_cache[0].rt_timer = 0; // H Wireless_Send_Flag=1; SendChar(0xa2); } sendHello(void) { // busy = 1; npdu_aodv.base_out[0]=0;//0协议报文1数据报文 npdu_aodv.base_out[1]=4;//报文类型1 request 2 reply 3 error 4 hello npdu_aodv.base_out[2]=LOCAL_ID; // src npdu_aodv.base_out[3]=1; // ttl npdu_aodv.base_out_len=4; rf_port.send_dest=BROADCAST_ID; Wireless_Send_Flag=1; SendChar(0xa4); } sendError(unsigned char node, unsigned char node_,unsigned char ttl) { // busy = 1; npdu_aodv.base_out[0]=0; npdu_aodv.base_out[1]=3; npdu_aodv.base_out[2]=ttl;// ttl npdu_aodv.base_out[3]=node; npdu_aodv.base_out[4]=node_; npdu_aodv.base_out_len=5; rf_port.send_dest=BROADCAST_ID; nt_id.ntid_cache[0].rt_timer = 0; // H Wireless_Send_Flag=1; SendChar(0xa3); } void recvRequest(void) { unsigned char i; unsigned char rq_hop=npdu_aodv.base_in[2]; unsigned char rq_bid=npdu_aodv.base_in[3]; unsigned char rq_src=npdu_aodv.base_in[4]; unsigned char rq_src_no=npdu_aodv.base_in[5]; unsigned char rq_dest=npdu_aodv.base_in[6]; unsigned char rq_dest_no=npdu_aodv.base_in[7]; unsigned char rq_last_ttl=npdu_aodv.base_in[8]; unsigned char rq_nn_hop=npdu_aodv.base_in[9]; unsigned char tmp_src_rt_table_num; unsigned char tmp_dest_rt_table_num; unsigned char tmp_id_num; unsigned char tmp_broad_id=0; //广播序列号循环标志 SendChar(0x00); SendChar(0x00+npdu_aodv.base_in[2]); SendChar(0x00+npdu_aodv.base_in[3]); SendChar(0x00+npdu_aodv.base_in[4]); SendChar(0x00+npdu_aodv.base_in[5]); SendChar(0x00+npdu_aodv.base_in[6]); SendChar(0x00+npdu_aodv.base_in[7]); SendChar(0x00+npdu_aodv.base_in[8]); SendChar(0x00+npdu_aodv.base_in[9]); SendChar(0x00); //Uart0_Send(npdu_aodv.base_in,9); busy = 1; // if (rq_src == BOMA_RF()) drop(); //don't work // else { //加上就过不了。。 tmp_id_num=id_lookup(rq_src); if(tmp_id_num==0xff) id_add(rq_src,rq_bid); //第一次收到该源节点发来的请求报文if( (tmp_id_num=id_lookup(rq_src) )!=0xff ) { if(bid_list.bid_cache[tmp_id_num].broad_id >= 0xfc) tmp_broad_id = 1; if( rq_bid > bid_list.bid_cache[tmp_id_num].broad_id || (tmp_broad_id == 1 && rq_bid < bid_list.bid_cache[tmp_id_num].broad_id)) id_updata(tmp_id_num,rq_src, rq_bid); //源节点发来的新的请求报文else return; //已经收到过该请求报文，丢弃，防止循环传递 } tmp_src_rt_table_num=lookup_table(rq_src); if(tmp_src_rt_table_num==0xff) //有没有到源节点的路由表项 { tmp_src_rt_table_num=add_table(rq_src,rq_src_no,rf_port.receive_src,rq_nn_hop,rq_hop); //rq_src_no //================================================================= ========= for(i=0;i { if( (data_list.buffer_data[i].buffer_status==1)&& (data_list.buffer_data[i].dest==rq_src) ) { npdu_send(data_list.buffer_data[i].app_buffer_data,data_list.buffer_data[i].length, data_list.buffer_data[i].src,rq_src,table_list.table[tmp_src_rt_table_num].rt_nexthop); //转发数据分组 deque(i); } } } else if (tmp_src_rt_table_num == 0) {SendChar(0xD0);return;} // H 收到本节点发出去的请求报文，丢弃 else { // Hz if ( (rq_src_no > table_list.table[tmp_src_rt_table_num].rt_seqno ) || ((rq_src_no == table_list.table[tmp_src_rt_table_num].rt_seqno) && (rq_hop< table_list.table[tmp_src_rt_table_num].rt_hops)) ) { rt_update(tmp_src_rt_table_num, rq_src_no, rq_hop, rf_port.receive_src,rq_nn_hop );// mac_src是下一跳更新路由 //错的，应该是等待一段时间，看有没有更好的路由请求报文（所以要写成状态机的形式） //这里就是收到的第一个请求报文 for(i=0;i { if( (data_list.buffer_data[i].buffer_status==1)&& (data_list.buffer_data[i].dest==rq_src) ) { npdu_send(data_list.buffer_data[i].app_buffer_data,data_list.buffer_data[i].length, data_list.buffer_data[i].src,rq_src,table_list.table[tmp_src_rt_table_num].rt_nexthop); //转发数据分组 deque(i); } } } } if(rq_dest== LOCAL_ID) //本节点就是寻路的目的节点，发送Hz modify LOCAL_MAC use BOMA_RF() { //H if(table_list.table[0].rt_seqno>=rq_dest_no) table_list.table[0].rt_seqno++; // if(table_list.table[0].rt_seqno>=rq_src_no) drop(); // else table_list.table[0].rt_seqno=rq_dest_no+1; // if (table_list.table[0].rt_seqno%2) table_list.table[0].rt_seqno++; table_list.table[0].rt_seqno+=2; if(table_list.table[0].rt_seqno%2)table_list.table[0].rt_seqno++; SendChar(0x50);SendChar(rf_port.receive_src);SendChar(rq_nn_hop); sendReply(LOCAL_ID,1,rq_src,table_list.table[0].rt_seqno, TTL_DIAMETER,rf_port.receive_src,rq_nn_hop); //LOCAL_MAC // if (rq_hop >= 2) hop_flag = 0x02; //Hz } else if (tmp_src_rt_table_num == 0) //本节点是中间节点，且源节点是本节点{SendChar(0xD1);return;} else { SendChar(0x56); tmp_dest_rt_table_num=lookup_table(rq_dest); //有没有到源节点的路由表项 if( (tmp_dest_rt_table_num!=0xff)) // &&(table_list.table[tmp_dest_rt_table_num].rt_seqno >= rq_src_no) )//如果本节点已经有一个足够新的到目的节点的路由表项rq_dest_no { SendChar(0x57); sendReply(rq_dest, table_list.table[tmp_dest_rt_table_num].rt_hops+rq_hop ,rq_src, table_list.table[tmp_dest_rt_table_num].rt_seqno,10,table_list.table[tmp_src_rt_table_num].rt_ne xthop,rq_nn_hop); //跳数应该两段相加H table_list.table[tmp_dest_rt_table_num].rt_hops++ table_list.table[tmp_dest_rt_table_num].rt_nexthop } else { if(rq_last_ttl>0) // { rq_hop++; rq_last_ttl--; sendRequest(rq_bid,rq_src,rq_src_no,rq_dest,rq_dest_no,rq_last_ttl,rq_hop,BROADCAST_ID,rf_ port.receive_src);//转发请求协议报文forward() SendChar(0x58); } else return; } } // } busy = 0; } void recvReply(void) { unsigned char rp_hop=npdu_aodv.base_in[2]; unsigned char rp_src=npdu_aodv.base_in[3]; unsigned char rp_dest=npdu_aodv.base_in[4]; unsigned char rp_dest_no=npdu_aodv.base_in[5]; // unsigned char rp_last_ttl=npdu_aodv.base_in[6]; unsigned char rp_nn_hop=npdu_aodv.base_in[7]; unsigned char i; unsigned char suppress_reply = 0; unsigned char tmp_dest_rt_table_num; unsigned char tmp_src_rt_table_num; busy = 1; SendChar(0x83); tmp_src_rt_table_num=lookup_table(rp_src); //有没有到目的节点的路由表项 if(tmp_src_rt_table_num==0xff) { tmp_src_rt_table_num=add_table(rp_src,rp_dest_no,rf_port.receive_src,rp_nn_hop,rp_hop); SendChar(0x80); //should be src_seqno for(i=0;i { if( (data_list.buffer_data[i].buffer_status==1)&& (data_list.buffer_data[i].dest==rp_src) ) // H rp_dest { npdu_send(data_list.buffer_data[i].app_buffer_data,data_list.buffer_data[i].length, data_list.buffer_data[i].src,data_list.buffer_data[i].dest,table_list.table[tmp_src_rt_table_num].rt_ nexthop); //rp_dest 转发数据分组tmp_src_rt_table_num deque(i); } } } else { // Hz if ( (table_list.table[tmp_src_rt_table_num].rt_seqno < rp_dest_no) || // newer route ((table_list.table[tmp_src_rt_table_num].rt_seqno == rp_dest_no) && (table_list.table[tmp_src_rt_table_num].rt_hops > rp_hop)) ) // shorter or better route { rt_update(tmp_src_rt_table_num, rp_dest_no, rp_hop,rf_port.receive_src,rp_nn_hop); // Update the rt entry // H SendChar(0x81);SendChar(0x00+rp_src); SendChar(0x00+rp_nn_hop); for(i=0;i { if( (data_list.buffer_data[i].buffer_status==1)&& (data_list.buffer_data[i].dest==rp_src) ) // H rp_dest { npdu_send(data_list.buffer_data[i].app_buffer_data,data_list.buffer_data[i].length, data_list.buffer_data[i].src,data_list.buffer_data[i].dest,table_list.table[tmp_src_rt_table_num].rt_ nexthop); //rp_dest 转发数据分组tmp_src_rt_table_num deque(i); SendChar(0x71); SendChar(0x00+table_list.table[tmp_src_rt_table_num].rt_nexthop); } } } else { suppress_reply = 1; //i表示没有足够新的路由表项0表示有足够新的路由表项 } } if(rp_dest==LOCAL_ID) {return; //LOCAL_MAC 本节点是Reply的目的节点或者没有足够新的路由表项提供若是目的节点那么路由表中有到自己的信息（初始化） // npdu_send_flag = 1; } else //中间节点并且提供足够新的路由表项则转发此报文 { SendChar(0x82); if(rp_last_ttl>=0) { rp_hop += 1; rp_last_ttl--; tmp_dest_rt_table_num=lookup_table(rp_dest); sendReply(rp_src,rp_hop, rp_dest,rp_dest_no,rp_last_ttl,table_list.table[tmp_dest_rt_table_num].rt_nexthop,rf_port.receive_ src);//转发此报文 SendChar(0x70+table_list.table[tmp_dest_rt_table_num].rt_nexthop); } else return; } busy = 0; } void recvHello(void ) { unsigned char rh_node = npdu_aodv.base_in[2]; unsigned char temp_num; // busy = 1; SendChar(0xbb); SendChar(npdu_aodv.base_in[2]); temp_num = lookup_table(rh_node); if(temp_num == 0xff) temp_num = add_table(rh_node,0,rh_node,rh_node,1); //seq_no = 0 else return; /* for(i=1;i<5;i++) if(nt_id.ntid_cache[i].node_id == rh_node) { nt_id.ntid_cache[i].flag = 1; nt_id.ntid_cache[i].rt_timer = 0; j = 1; //完成了重置计时器 // SendChar(0xb0+i); } if(j == 0) //没找到对应的计时器，新添一个 { for(i=1;i<5;i++) if(nt_id.ntid_cache[i].flag == 0) { nt_id.ntid_cache[i].flag = 1; nt_id.ntid_cache[i].node_id = rh_node; nt_id.ntid_cache[i].rt_timer = 0; // SendChar(0xc0+i); return; } } busy = 0; */ } void recvError(void) { unsigned char re_ttl=npdu_aodv.base_in[2]; unsigned char re_node_f=npdu_aodv.base_in[3]; //first node id unsigned char re_node_s=npdu_aodv.base_in[4]; //secend node id unsigned char i; unsigned char temp_dest; busy = 1; SendChar(re_node_f);SendChar(re_node_s); if(re_ttl>1) // 1作为分隔点 { re_ttl--; sendError(re_node_f,re_node_s,re_ttl);//转发此报文 } else //符合条件的节点（发现断链节点的上一跳节点）收到error报文后进行本地修复{ for(i=0;i { if((table_list.table[i].rt_nexthop==re_node_f)&&(table_list.table[i].rt_nn_hop==re_node_s) &&(table_list.table[i].rt_flags==1)) { table_list.table[i].rt_flags=0; temp_dest=table_list.table[i].dest; table_list.table[0].rt_seqno+=2; if(table_list.table[0].rt_seqno%2) table_list.table[0].rt_seqno++; sendRequest( bid_list.bid_cache[0].broad_id++,LOCAL_ID,table_list.table[0].rt_seqno,temp _dest,FIRST_SEQNO, TTL_DIAMETER,1,BROADCAST_ID,LOCAL_ID); //此处待改进，修复后的路由表中下两跳地址有问题 } } } busy = 0; } //forward(npdu_aodv.base_out,len,net_src,net_dest,mac_dest) //传送数据报文Reply报文用路由表项中的mac_dest（next_hop） //传送Request报文用mac_dest（广播） //{ //unsigned char i; //datalink.base_out[0]=1; //datalink.base_out[1]=src; //datalink.base_out[2]=dest; //datalink.base_out // for(i=0;i // { // datalink.base_out[2+i]=npdu_aodv.base_out[i]; // } // datalink.base_len=len+3; // datalink_send(datalink.base_out[],datalink.base_len,LOCAL_MAC,mac_dest); //} npdu_send(unsigned char *buffer,unsigned char len,unsigned char src,unsigned char dest,unsigned char mac_dest) { unsigned char i; busy = 1; npdu_aodv.base_out[0]=1; npdu_aodv.base_out[1]=src; npdu_aodv.base_out[2]=dest; for(i=0;i { npdu_aodv.base_out[3+i]=*buffer; buffer++; } npdu_aodv.base_out_len=len+3; rf_port.send_dest=mac_dest; nt_id.ntid_cache[0].rt_timer = 0;// H Wireless_Send_Flag=1; SendChar(0x35); // SendChar(0xAA); SendChar(0x00+npdu_aodv.base_out[1]); SendChar(0x00+npdu_aodv.base_out[2]); // busy = 0; } /* drop() // H 无用 { return; } */ //路由表模块 unsigned char lookup_table(unsigned char dest_id) { unsigned char i; for(i=0;i { if ( (table_list.table[i].dest==dest_id)&&( table_list.table[i].rt_flags==1 ) ) return i; } if(i>=MAX_TABLE_ENTRY) return 0xff; } unsigned char add_table( unsigned char dest_id, unsigned char seqno, unsigned char next_hop, unsigned char nn_hop, unsigned char hops) { unsigned char i; for(i=0;i { if ( table_list.table[i].rt_flags==0 ) { table_list.table[i].rt_flags=1; table_list.table[i].dest=dest_id; table_list.table[i].rt_nexthop=next_hop; table_list.table[i].rt_nn_hop=nn_hop; table_list.table[i].rt_hops=hops; table_list.table[i].rt_seqno=seqno; return i; } } if(i>=MAX_TABLE_ENTRY) return 0xff; } unsigned char delete_table(unsigned char dest_id) { unsigned char i; for(i=0;i { if ( (table_list.table[i].rt_flags==1 )&&(table_list.table[i].dest==dest_id)) { table_list.table[i].rt_flags=0; return i; } } if(i>=MAX_TABLE_ENTRY) return 0xff; } unsigned char rt_update(unsigned char num, unsigned char dest_no,unsigned char rp_hop,unsigned char next_hop, unsigned char nn_hop) { unsigned char i; if( (num<=MAX_TABLE_ENTRY)&&(table_list.table[num].rt_flags==1) ) { table_list.table[i].rt_seqno=dest_no; table_list.table[i].rt_hops=rp_hop; table_list.table[i].rt_nexthop=next_hop; // H table_list.table[i].dest=dest; 没必要 table_list.table[i].rt_nn_hop=nn_hop; // H return 1; } else return 0xff; } //数据队列模块 unsigned char enque(unsigned char *buffer,unsigned char len,unsigned char src,unsigned char dest) { unsigned char i; unsigned char j; for(i=0;i { if(data_list.buffer_data[i].buffer_status==0) { data_list.buffer_data[i].buffer_status=1; data_list.buffer_data[i].src=src; data_list.buffer_data[i].dest=dest; data_list.buffer_data[i].length=len; for(j=0;j { data_list.buffer_data[i].app_buffer_data[j]=*buffer; buffer++; } return i; } } if(i>=MAX_BUFFER_NUM) return 0xff; } deque(unsigned char num) { data_list.buffer_data[num].buffer_status=0; } //广播ID管理模块 void id_updata(unsigned char num,unsigned char src, unsigned char bid) { bid_list.bid_cache[num].flag=1; bid_list.bid_cache[num].broad_id=bid; bid_list.bid_cache[num].src=src; //这个没必要 } unsigned char id_lookup(unsigned char src) { unsigned char i; for(i=0;i { if( (bid_list.bid_cache[i].flag==1) &&(bid_list.bid_cache[i].src==src)) return i;//表示该请求广播报文（对于中间转发节点）已经受到过（旧报文），不做处理，防止不停处理 } if(i>=MAX_BROADCAST_ID) return 0xff; //表示没有收到过源节点发送的任何请求广播报文 } unsigned char id_add(unsigned char src, unsigned char bid) { unsigned char i; for(i=0;i { if(bid_list.bid_cache[i].flag==0) { bid_list.bid_cache[i].flag=1; bid_list.bid_cache[i].broad_id=bid; bid_list.bid_cache[i].src=src; AODV相关路由协议学习 1：AODV路由协议工作原理 AODV路由协议是一种经典的按需路由协议，它只在两个节点需要进行通信且源节点没有到达目的节点的路由时，才会进行路由发现过程。AODV采用的是广播式路由发现机制，当源节点想与另一节点进行通信时，源节点会首先查询自己的路由表中是否存在有到达目的节点的路由有效信息。如果包含有目的节点的有效信息，则源节点就会将数据包传送到目的节点的下一跳节点;如果缺失目的节点的有效的信息，则源节点会启动路径请求程序，同时广播RREQ控制包。 而下一跳节点在接收到RREQ报文时，如果该节点是目的节点，又或者该节点路由表中存放有到达目的节点的可行路径信息，则会向源节点回复路由响应报文CRREP。否则就记录相关信息，用于建立一个反向路径，让目的节点的RREP遵循此路径返回源节点，同时将RREQ报文中的跳数字段值加1，并向该节点的邻居节点转发RREQ报文。这样经过若干中间节点转发最后到达目的节点，确认路由建立。 路由表项建立以后，路由中的每个节点都要执行路由维持和管理路由表的任务。如果由于中间节点的移动而导致路由失效，则检测到路由断链的节点就会向上游节点发送路由出错报文RRER，而收到出错报文RRER的节点则会直接发出RREQ来进行路径请求，如果能在规定好的时间找到目的节点的路径，则表示路由成功 1.2存在的问题 传统的AODV采用基本的路由发现算法来建立从源节点到目的节 点的路由时，路由选择是选择最短路径路由，即选择最小跳数的路由，这样就忽略了每两点之间的传输能力，从而导致产生整条链路吞吐量低、路由不稳定、线路拥塞、延迟甚至数据丢失等严重问题。 2最大路由速率的AODV协议的提出【基于最大路由速率的AODV协议优化研究与实现---罗泽、吴谨绎、吴舒辞】 2.1基本思想 针对传统AODV路由协存在的问题，提出了一种基于最大传输速率（路由速率=路由速率之和/路由跳数）的改进方案，其基本思想是:用户确定一个期望速率，源节点在进行路由发现时比较收到的各条路由的实测速率，选择一条速率最大的路由作为路由，在源节点使用当前路由发送数据的过程中，源节点每隔一段时间发出RREQ报文，以便查找到可能存在的更好的路由，如果发现一条速率更高的路由且该路由速率大于期望速率，则执行路由切换，改用新路由。 AODV协议详解 1 AODV 报文格式 AODV 有三种基本的协议报文类型：RREQ 报文、RREP 报文和RRER 报文。 1.1 RREQ 报文 a. 对RREQ 的处理 接收到RREQ 的结点做如下处理： （1）创建一个表项，先不分配有效序列号，用于记录反向路径。 （2）如果在“路由发现定时”内已收到一个具有相同标识的RREQ 报文，则抛弃该报文，不做任何处理;否则，对该表项进行更新如下： I.下一跳结点=广播RREQ 的邻居。 II.跳数=RREQ 报文的“跳计数”字段值。 III.设置表项的“过时计时器”。 （3）如果满足以下条件，则结点产生“路由回答报文”RREP，并发送到信源；否则更新RREQ 报文并广播更新后的RREQ 报文。 I.该结点是信宿。 II.结点的路由表中有到信宿的活动表项，且表项的信宿序列号大于RREQ中的信宿序列号。 （4）更新RREQ 报文并广播更新后的RREQ 报文 I.信宿序列号=本结点收到的信宿相关的最大序列号。 II.跳计数加1。 1.2 RREP 报文 （1）信宿结点产生RREP 执行如下操作： I.如果收到相应的RREQ 的信宿序列号与信宿维护的当前序列号相等，则信宿将自己维护的序列号加1，否则不变。 II.跳计数=0。 III.定时器值。 （2）中间结点产生的RREP 执行如下操作： I.本结点获取的该信宿的最大序列号。 II.跳计数=本结点到信宿的跳数（查相应表项即可得到）。 III.更新本结点维护的“前向路由表项”的下一跳和“反向路由表项”的前一跳 b. 对RREP 的处理 结点对接收到的RREP 作如下处理。 （1）如果没有与RREP 报文中的信宿相匹配的表项，则先创建一个“前向路表”空表项。 （2）否则，满足如下条件对已有表项进行更新。 条件： I.现有表项的信宿序列号小于RREP 报文中的序列号。 II.现有的表项没有激活。 III.信宿序列号相同，但RREP 报文的“跳计数”值小于表项相对应的值；通过更新或创建，产生一个新的前向路由。 西南交通大学 本科毕业设计（论文） AD HOC网络中AOD\路由协议分析THEANAL YSISOFAODXROUTINGPROTOCOL IN AD HOC NETWORK 年级2008 级 学号__________________ 姓名__________________ 专业通信工程 指导老师___________________ 2012年6月 承诺 本人郑重承诺：所呈交的设计（论文）是本人在导师的指导下独立进行设计（研究）所取得的成果，除文中特别加以标注引用的内容外，本文不包含任何其他个人或集体已经发表或撰写的设计（研究）成果。对本设计（研究）做出贡献的个人和集体，均已在文中以明确方式标明' 如被发现设计（论文）中存在抄袭、造假等学术不端行为，本人愿承担—切后果。 学生签名： 年月日 院系计算机与通信工程系_________ 专业通信工程 ____________________ 年级2008 级 ________________________ 姓名____________________________________ 题目Ad hoc 网络中AODV路由协议分析______________________________ 指导教师 评语 ________________________________________________________________________ 指导教师（签章） 评阅人 评语 评阅人（签章）成绩____________________________ 答辩委员会主任_______ （____ 签章） 内容目录 1导言 (3) 2概述 (4) 3AODV术语 (5) 4适用性综述 (7) 5消息格式 (8) 6AODV操作 (13) 管理序列号 (13) 路由表项和先驱列表 (15) 生成路由请求 (16) 控制路由请求消息的传播 (17) 处理和转发路由请求 (18) 生成路由回复 (20) 接受和转发路由回复 (22) 对单向连接的操作 (23) Hello消息 (24) 维护本地连接 (25) 路由错误，路由超时和路由删除 (26) 本地修复 (28) 重启后的操作 (30) 接口 (31) 7AODV和集群网络 (31) 8AODV在其他网络中的应用 (32) 9扩展 (34) 10参数配置 (35) 网络组诺基亚研发中心 C. Perkins RFC：3561加州大学圣芭芭拉分校 E. Belding-Royer 类别：试验版辛辛那提大学 S. Das 2003年7月 Ad hoc网络中基于距离数组的按需(AODV)路由协议 本备忘状态 本备忘定义的只是一个试验性质的网络社区协议而已，它不是任何一种类型的网络标准。我们非常需要各种讨论和建议用于改进这个协议。本备忘录的分发不受任何限制。 版权声明 复制权属于整个因特网社区，保留所有权利。 摘要 本协议用于特定网络中的可移动节点。它能在动态变化的点对点网络中确定一条到目的地的路由，并且具有接入速度快，计算量小，内存占用低，网络负荷轻等特点。它采用目的序列号来确保在任何时候都不会出现回环（甚至在路由控制信息出现异常的时候也是如此），避免了传统的距离数组协议中会出现的很多问题（比如无穷计数问题）。 目录 AODV相关路由协议学习 1: AODV路由协议工作原理 AODV路由协议是一种经典的按需路由协议，它只在两个节点需要进行通信且源节点没有到达目的节点的路由时，才会进行路由发现过程。AODV 采用的是广播式路由发现机制，当源节点想与另一节点进行通信时，源节点会首先查询自己的路由表中是否存在有到达目的节点的路由有效信息。如果包含有目的节点的有效信息，则源节点就会将数据包传送到目的节点的下一跳节点；如果缺失目的节点的有效的信息，则源节点会启动路径请求程序，同时广播RREQ空制包。 而下一跳节点在接收到RREC报报文时，如果该节点是目的节点，又或者该节点路由表中存放有到达目的节点的可行路径信息，贝S会向源节点回复路由响应报文CRREP否则就记录相关信息，用于建立一个反向路径，让目的节点的RREP遵循此路径返回源节点，同时将RREC报文中的跳数字段值加1,并向该节点的邻居节点转发RREC报 文。这样经过若干中间节点转发最后到达目的节点，确认路由建立。 路由表项建立以后，路由中的每个节点都要执行路由维持和管理路由表的任务。如果由于中间节点的移动而导致路由失效，则检测到路由断链的节点就会向上游节点发送路由出错报文RRER而收到出错报文RRER的节点则会直接发出RREQ来进行路径请求，如果能在规定好的时间内找到目的节点的路径，则表示路由成功 1.2存在的问题 传统的AODV采用基本的路由发现算法来建立从源节点到目的节 点的路由时，路由选择是选择最短路径路由，即选择最小跳数的路由，这样就忽略了每两点之间的传输能力，从而导致产生整条链路吞吐量低、路由不稳定、线路拥塞、延迟甚至数据丢失等严重问题。 2最大路由速率的AODV协议的提出【基于最大路由速率的AODV协议优化研究与实现---罗泽、吴谨绎、吴舒辞】 2.1基本思想 针对传统AODV路由协存在的问题，提出了一种基于最大传输速率（路由速率二路由速率之和/路由跳数）的改进方案，其基本思想是:用户确定一个期望速率，源节点在进行路由发现时比较收到的各条路由的实测速率，选择一条速率最大的路由作为路由，在源节点使用当前路由发送数据的过程中，源节点每隔一段时间发出RREQ报文，以便查找到可能存在的更好的路由，如果发现一条速率更高的路由且该路由速率大于期望速率，则执行路由切换，改用新路由。 分类：ns仿真2012-04-23 10:52 171人阅读评论(0) 收藏举报delete脚本活动工作 1 AODV 报文格式 AODV 有三种基本的协议报文类型：RREQ 报文、RREP 报文和RRER 报文。 1.1 RREQ 报文 a. 对RREQ 的处理 接收到RREQ 的结点做如下处理： （1）创建一个表项，先不分配有效序列号，用于记录反向路径。 （2）如果在“路由发现定时”内已收到一个具有相同标识的RREQ 报文，则抛弃该报文，不做任何处理;否则，对该表项进行更新如下： I.下一跳结点=广播RREQ 的邻居。 II.跳数=RREQ 报文的“跳计数”字段值。 III.设置表项的“过时计时器”。 （3）如果满足以下条件，则结点产生“路由回答报文”RREP，并发送到信源；否则更新RREQ 报文并广播更新后的RREQ 报文。 I.该结点是信宿。 II.结点的路由表中有到信宿的活动表项，且表项的信宿序列号大于RREQ中的信宿序列号。 （4）更新RREQ 报文并广播更新后的RREQ 报文 I.信宿序列号=本结点收到的信宿相关的最大序列号。 II.跳计数加1。 1.2 RREP 报文 （1）信宿结点产生RREP 执行如下操作： I.如果收到相应的RREQ 的信宿序列号与信宿维护的当前序列号相等，则信宿将自己维护的序列号加1，否则不变。 II.跳计数=0。 III.定时器值。 （2）中间结点产生的RREP 执行如下操作： I.本结点获取的该信宿的最大序列号。 II.跳计数=本结点到信宿的跳数（查相应表项即可得到）。 III.更新本结点维护的“前向路由表项”的下一跳和“反向路由表项”的前一跳 路由协议DSR_AODV_DSDV [Dynamic Source Routing，动态源路由协议] ●当节点S需要向节点D发送数据的时候，而此时节点S并不知道通往节点D的路径， 此时，节点S便启动路由发现过程 ——DSR协议为反应式（Reactive）路由协议 ●源节点广播Route Request路由请求消息（RREQ消息） ●每个节点均在其向前发送的RREQ消息上附加自己唯一的标识符 [动态源路由协议的路由发现过程] [X,Y]表示附加到RREQ消息上的标识符列表 ●如图，节点H同时接收到来自两个相邻节点的RREQ消息：有潜在消息冲突的可能 ●节点C收到来自G和H两个相邻节点发送来的RREQ消息，但C并不再向前发送该消息， 因为节点C已经向前发送过一次RREQ消息 ●节点J与节点K均向节点D发送了RREQ消息 ●由于J和K均不知道对方存在，彼此之间是隐藏的，因此这两个节点所发送的消息存 在冲突的可能 ●节点D不再向前发送RREQ消息，因为节点D便是整个路由发现过程的终点目标 ●当目的节点D接到第一个RREQ消息的时候，便往回发送一个Route Reply路由应答消 息（RREP消息） ●RREP消息经由反向路径回传，（反向路径就是和RREQ消息到达路径相反的路径） ●RREP消息当中包含了由S到D的路径，而这条路径就是源节点S所发送的RREQ消息所 确定的 [动态源路由协议的路由应答过程] ●当源节点S接收到RREP消息的时候，它便将RREP消息中所记录的路径缓存起来 ●当源节点S发送数据到目的节点D时，数据分组的首部将包含整个路径的信息，这也是 该算法命名为“源路由”的缘由 ●中间节点使用数据分组中首部包含的“源路由”信息了来决定抵达该节点的数据应该转 发的方向 [动态源路由协议的数据投递过程] [动态源路由协议优化——路径缓存] ●每个节点将通过任何可能的方式所获得的新路径缓存起来 ●当节点S发现一条可以通往节点D的路径[S,E,F,J,D]时，它同样知道有一条可以到达 节点F的路径[S,E,F] ●当节点K接收到路由请求消息Route Request RREQ[S,C,G]后，节点K则同样知道经过 路径[K,G,C,S]可以到达节点S ●当节点F向前传递路由应答消息Route Reply RREP[S,E,F,J,D]时，节点F则可以知道 经过路径[F,J,D]可以到达节点D ●当节点E经过路径Data [S,E,F,J,D]发送数据分组的时候，它则知道它自身可通过路 径[E,F,J,D]可以到达节点D ●一个节点无意中听到其他节点的通信消息的时候，它则将缓存其中它自己所不知道的路 由 ●存在问题：一些陈旧的路由缓存对于系统的开销是一种负担 [动态源路由协议的优点] ●只维持需要通信节点之间的路径——可以减少路由保持对于系统的开销 ●路由缓存机制可进一步减少路由发现过程的开销 ●一次简单的路由发现过程可能产生许多通往同一节点的路径，由于中间很可能用以前的 缓存记录对路由发现消息进行应答AODV相关路由协议详情学习
AODV协议详解
AODV路由协议分析研究
AODV路由协议中文说明
AODV相关路由协议学习
aodv路由协议分析
路由协议
相关主题
文本预览