leach和leach-c协议仿真

http://blog.csdn.net/codingkid/article/details/7215216

1.复制leach_test为leach-c_test，修改里面的文件夹和输出文件名。并且手动建立相应的文件夹。

很多教程说只修改文件名，没提到修改文件夹，如果同时运行两个协议会覆盖一部分实验结果的，而且是并行的就更难分解出是哪个协议的实验数据了。所以还是分开较好。

2.添加到test文件最后，后台运行的，需要等待。

3.写脚本分析实验数据。

1. #计算不同时间剩余节点的数量
2. BEGIN {
3. countcyl=0;
4. totalleft=0;
5. lasttime=0;
6. time[0]=0;
7. node=0;
8. total[0]=100;
9. }
10. {
11. simtime              = $1;
12. nodeid               = $2;
13. statenode            = $3;
14. if (simtime>lasttime ) {
15. countcyl++;
16. lasttime=simtime;
17. time[countcyl]=simtime;
18. totalleft=0;
19. }
20. if (statenode==1)
21. totalleft++;
22. total[countcyl]=totalleft;
23. }
24. END {
25. for(i=0;i<=countcyl;i++)
26. printf( "%f %d\n",time[i],total[i]);
27. }

1. BEGIN {
2. countcyl=0;
3. packetsum=0;                       #当前时间发包且接收的总数
4. lasttime=0;
5. time[0]=0;
6. sum[0]=0;
7. }
8. {
9. simtime              = $1;
10. nodeid               = $2;
11. packet               = $3;             #读取当前时间，当前节点的发包且被成功接收的数目
12. if (simtime>lasttime ) {                                #具体算法
13. packtsum=0;
14. countcyl++;
15. lasttime=simtime;
16. time[countcyl]=simtime;
17. }
18. if (simtime==lasttime ) {
19. packetsum=packetsum+packet;
20. sum[countcyl]=packetsum;
21. }
22. }
23. END {                                                        #对应时段，打印发包总量。
24. for(i=0;i<=countcyl;i++)
25. printf ( "%f %f\n",time[i],sum[i]);
26. }

1. BEGIN {
2. countcyl=0;                           #计数器，用来记录当前的轮数 或者当前的时段数
3. energysum=0;                      #用来暂时储存当前时段的节点消耗能量总和
4. lasttime=0;                           #记录当前最后的时间
5. time[0]=0;                             #存储各（轮）分段的时间
6. sum[0]=0;                             #存储各分段时间对应的消耗的能量
7. }
8. {
9. simtime              = $1;                      #文件中第一字段的值，当前时间
10. nodeid               = $2;                      #。。。第二字段的值，节点ID
11. nodeenergy            = $3;               #。。。第三字段的值，当前节点使用的能量
12. if (simtime>lasttime ) {     #这里就是一个简单的方法来提取每个时间段，节点总共消耗了多少能量
13. energysum=0;
14. countcyl++;
15. lasttime=simtime;
16. time[countcyl]=simtime;
17. }
18. if (simtime==lasttime ) {
19. if (nodeenergy<2.0) {
20. energysum=energysum+nodeenergy;
21. sum[countcyl]=energysum;
22. }
23. else if (nodeenergy>=2.0) {         #节点初始的总能量为2
24. energysum=energysum+2.0;
25. sum[countcyl]=energysum;
26. }
27. }
28. }
29. END {                                          #对应时间段，得出能量消耗量并打印
30. for(i=0;i<=countcyl;i++)
31. printf ( "%f %f\n",time[i],sum[i]);
32. }

4.gnuplot来画图

1. set multiplot
2. set origin 0.0,0.5
3. set size 0.5,0.5
4. plot 'leach.alive.rst' with linespoint,'leach-c.alive.rst' with linespoint
5. set origin 0.5,0.5
6. set size 0.5,0.5
7. plot 'leach.data.rst' with linespoint,'leach-c.data.rst' with linespoint
8. set origin 0.33,0.0
9. set size 0.5,0.5
10. plot 'leach.energy.rst' with linespoint,'leach-c.energy.rst' with linespoint

得到如下图：

明显实验结果说明leach-c死亡节点比较早，虽然bs收到数据量大，但是能量消耗是leach协议更关心的问题。

修改bs坐标为(0,0)，再次计算得到如下结果：

从各方面来说c都比leach更优，有人说若bs在节点区域内部，则leach更优，若在外部则leach-c更优！

想知道为什么还需要看懂这两个协议喽。

接下来代码和理论分析。

 

顶

0

踩