开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 通讯编程 > 查看源码
mobilenode.cc
资源名称：ns-allinone-2.33.tar.gz　[点击查看]
上传用户：rrhhcc
上传日期：2015-12-11
资源大小：54129k
文件大小：15k
源码类别：

通讯编程

开发平台：

Visual C++

mobilenode.cc：源码内容
  1. /*-*- Mode:C++; c-basic-offset:8; tab-width:8; indent-tabs-mode:t -*- 
  2.  *
  3.  * Copyright (c) 1997 Regents of the University of California.
  4.  * All rights reserved.
  5.  *
  6.  * Redistribution and use in source and binary forms, with or without
  7.  * modification, are permitted provided that the following conditions
  8.  * are met:
  9.  * 1. Redistributions of source code must retain the above copyright
  10.  *    notice, this list of conditions and the following disclaimer.
  11.  * 2. Redistributions in binary form must reproduce the above copyright
  12.  *    notice, this list of conditions and the following disclaimer in the
  13.  *    documentation and/or other materials provided with the distribution.
  14.  * 3. All advertising materials mentioning features or use of this software
  15.  *    must display the following acknowledgement:
  16.  * This product includes software developed by the Computer Systems
  17.  * Engineering Group at Lawrence Berkeley Laboratory.
  18.  * 4. Neither the name of the University nor of the Laboratory may be used
  19.  *    to endorse or promote products derived from this software without
  20.  *    specific prior written permission.
  21.  *
  22.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  23.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  26.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32.  * SUCH DAMAGE.
  33.  *
  34.  * $Header: /cvsroot/nsnam/ns-2/common/mobilenode.cc,v 1.36 2006/02/22 13:21:52 mahrenho Exp $
  35.  *
  36.  * Code in this file will be changed in the near future. From now on it 
  37.  * should be treated as for backward compatibility only, although it is in
  38.  * active use by many other code in ns. - Aug 29, 2000
  39.  */
  41. /* 
  42.  * CMU-Monarch project's Mobility extensions ported by Padma Haldar, 
  43.  * 11/98.
  44.  */
  47. #include <math.h>
  48. #include <stdlib.h>
  50. #include "connector.h"
  51. #include "delay.h"
  52. #include "packet.h"
  53. #include "random.h"
  54. #include "trace.h"
  55. #include "address.h"
  57. #include "arp.h"
  58. #include "topography.h"
  59. #include "ll.h"
  60. #include "mac.h"
  61. #include "propagation.h"
  62. #include "mobilenode.h"
  63. #include "phy.h"
  64. #include "wired-phy.h"
  65. #include "god.h"
  67. // XXX Must supply the first parameter in the macro otherwise msvc
  68. // is unhappy. 
  69. static LIST_HEAD(_dummy_MobileNodeList, MobileNode) nodehead = { 0 };
  71. static class MobileNodeClass : public TclClass {
  72. public:
  73.         MobileNodeClass() : TclClass("Node/MobileNode") {}
  74.         TclObject* create(int, const char*const*) {
  75.                 return (new MobileNode);
  76.         }
  77. } class_mobilenode;
  79. /*
  80.  *  PositionHandler()
  81.  *
  82.  *  Updates the position of a mobile node every N seconds, where N is
  83.  *  based upon the speed of the mobile and the resolution of the topography.
  84.  *
  85.  */
  86. void
  87. PositionHandler::handle(Event*)
  88. {
  89. Scheduler& s = Scheduler::instance();
  91. #if 0
  92. fprintf(stderr, "*** POSITION HANDLER for node %d (time: %f) ***n",
  93. node->address(), s.clock());
  94. #endif
  95. /*
  96.  * Update current location
  97.  */
  98. node->update_position();
  100. /*
  101.  * Choose a new random speed and direction
  102.  */
  103. #ifdef DEBUG
  104.         fprintf(stderr, "%d - %s: calling random_destination()n",
  105.                 node->address_, __PRETTY_FUNCTION__);
  106. #endif
  107. node->random_destination();
  109. s.schedule(&node->pos_handle_, &node->pos_intr_,
  110.    node->position_update_interval_);
  111. }
  114. /* ======================================================================
  115.    Mobile Node
  116.    ====================================================================== */
  118. MobileNode::MobileNode(void) : 
  119. pos_handle_(this)
  120. {
  121. X_ = Y_ = Z_ = speed_ = 0.0;
  122. dX_ = dY_ = dZ_ = 0.0;
  123. destX_ = destY_ = 0.0;
  125. random_motion_ = 0;
  126. base_stn_ = -1;
  127. T_ = 0;
  129. log_target_ = 0;
  130. next_ = 0;
  131. radius_ = 0;
  133. position_update_interval_ = MN_POSITION_UPDATE_INTERVAL;
  134. position_update_time_ = 0.0;
  137. LIST_INSERT_HEAD(&nodehead, this, link_); // node list
  138. LIST_INIT(&ifhead_); // interface list
  139. bind("X_", &X_);
  140. bind("Y_", &Y_);
  141. bind("Z_", &Z_);
  142. bind("speed_", &speed_);
  144. }
  146. int
  147. MobileNode::command(int argc, const char*const* argv)
  148. {
  149. Tcl& tcl = Tcl::instance();
  150. if(argc == 2) {
  151. if(strcmp(argv[1], "start") == 0) {
  152.         start();
  153. return TCL_OK;
  154. } else if(strcmp(argv[1], "log-movement") == 0) {
  155. #ifdef DEBUG
  156.                         fprintf(stderr,
  157.                                 "%d - %s: calling update_position()n",
  158.                                 address_, __PRETTY_FUNCTION__);
  159. #endif
  160.         update_position();
  161.         log_movement();
  162. return TCL_OK;
  163. } else if(strcmp(argv[1], "log-energy") == 0) {
  164. log_energy(1);
  165. return TCL_OK;
  166. } else if(strcmp(argv[1], "powersaving") == 0) {
  167. energy_model()->powersavingflag() = 1;
  168. energy_model()->start_powersaving();
  169. return TCL_OK;
  170. } else if(strcmp(argv[1], "adaptivefidelity") == 0) {
  171. energy_model()->adaptivefidelity() = 1;
  172. energy_model()->powersavingflag() = 1;
  173. energy_model()->start_powersaving();
  174. return TCL_OK;
  175. } else if (strcmp(argv[1], "energy") == 0) {
  176. Tcl& tcl = Tcl::instance();
  177. tcl.resultf("%f", energy_model()->energy());
  178. return TCL_OK;
  179. } else if (strcmp(argv[1], "adjustenergy") == 0) {
  180. // assume every 10 sec schedule and 1.15 W 
  181. // idle energy consumption. needs to be
  182. // parameterized.
  183. idle_energy_patch(10, 1.15);
  184. energy_model()->total_sndtime() = 0;
  185. energy_model()->total_rcvtime() = 0;
  186. energy_model()->total_sleeptime() = 0;
  187. return TCL_OK;
  188. } else if (strcmp(argv[1], "on") == 0) {
  189. energy_model()->node_on() = true;
  190. tcl.evalf("%s set netif_(0)", name_);
  191. const char *str = tcl.result();
  192. tcl.evalf("%s NodeOn", str);
  193. God::instance()->ComputeRoute();
  194. return TCL_OK;
  195. } else if (strcmp(argv[1], "off") == 0) {
  196. energy_model()->node_on() = false;
  197. tcl.evalf("%s set netif_(0)", name_);
  198. const char *str = tcl.result();
  199. tcl.evalf("%s NodeOff", str);
  200. tcl.evalf("%s set ragent_", name_);
  201. str = tcl.result();
  202. tcl.evalf("%s reset-state", str);
  203. God::instance()->ComputeRoute();
  204.       return TCL_OK;
  205. } else if (strcmp(argv[1], "shutdown") == 0) {
  206. // set node state
  207. //Phy *p;
  208. energy_model()->node_on() = false;
  210. //p = ifhead().lh_first;
  211. //if (p) ((WirelessPhy *)p)->node_off();
  212. return TCL_OK;
  213. } else if (strcmp(argv[1], "startup") == 0) {
  214. energy_model()->node_on() = true;
  215. return TCL_OK;
  216. }
  218. } else if(argc == 3) {
  219. if(strcmp(argv[1], "addif") == 0) {
  220. WiredPhy* phyp = (WiredPhy*)TclObject::lookup(argv[2]);
  221. if(phyp == 0)
  222. return TCL_ERROR;
  223. phyp->insertnode(&ifhead_);
  224. phyp->setnode(this);
  225. return TCL_OK;
  226. } else if (strcmp(argv[1], "setsleeptime") == 0) {
  227. energy_model()->afe()->set_sleeptime(atof(argv[2]));
  228. energy_model()->afe()->set_sleepseed(atof(argv[2]));
  229. return TCL_OK;
  230. } else if (strcmp(argv[1], "setenergy") == 0) {
  231. energy_model()->setenergy(atof(argv[2]));
  232. return TCL_OK;
  233. } else if (strcmp(argv[1], "settalive") == 0) {
  234. energy_model()->max_inroute_time() = atof(argv[2]);
  235. return TCL_OK;
  236. } else if (strcmp(argv[1], "maxttl") == 0) {
  237. energy_model()->maxttl() = atoi(argv[2]);
  238. return TCL_OK;
  239. } else if(strcmp(argv[1], "radius") == 0) {
  240.                         radius_ = strtod(argv[2],NULL);
  241.                         return TCL_OK;
  242.                 } else if(strcmp(argv[1], "random-motion") == 0) {
  243. random_motion_ = atoi(argv[2]);
  244. return TCL_OK;
  245. } else if(strcmp(argv[1], "addif") == 0) {
  246. WirelessPhy *n = (WirelessPhy*)
  247. TclObject::lookup(argv[2]);
  248. if(n == 0)
  249. return TCL_ERROR;
  250. n->insertnode(&ifhead_);
  251. n->setnode(this);
  252. return TCL_OK;
  253. } else if(strcmp(argv[1], "topography") == 0) {
  254. T_ = (Topography*) TclObject::lookup(argv[2]);
  255. if (T_ == 0)
  256. return TCL_ERROR;
  257. return TCL_OK;
  258. } else if(strcmp(argv[1], "log-target") == 0) {
  259. log_target_ = (Trace*) TclObject::lookup(argv[2]);
  260. if (log_target_ == 0)
  261. return TCL_ERROR;
  262. return TCL_OK;
  263. } else if (strcmp(argv[1],"base-station") == 0) {
  264. base_stn_ = atoi(argv[2]);
  265. if(base_stn_ == -1)
  266. return TCL_ERROR;
  267. return TCL_OK;
  268. } 
  269. } else if (argc == 4) {
  270. if (strcmp(argv[1], "idleenergy") == 0) {
  271. idle_energy_patch(atof(argv[2]),atof(argv[3]));
  272. return TCL_OK;
  273. }
  274. } else if (argc == 5) {
  275. if (strcmp(argv[1], "setdest") == 0) { 
  276. /* <mobilenode> setdest <X> <Y> <speed> */
  277. #ifdef DEBUG
  278. fprintf(stderr, "%d - %s: calling set_destination()n",
  279. address_, __FUNCTION__);
  280. #endif
  281.   
  282. if (set_destination(atof(argv[2]), atof(argv[3]), 
  283.     atof(argv[4])) < 0)
  284. return TCL_ERROR;
  285. return TCL_OK;
  286. }
  287. }
  288. return Node::command(argc, argv);
  289. }
  292. /* ======================================================================
  293.    Other class functions
  294.    ====================================================================== */
  295. void
  296. MobileNode::dump(void)
  297. {
  298. Phy *n;
  299. fprintf(stdout, "Index: %dn", address_);
  300. fprintf(stdout, "Network Interface Listn");
  301.   for(n = ifhead_.lh_first; n; n = n->nextnode() )
  302. n->dump();
  303. fprintf(stdout, "--------------------------------------------------n");
  304. }
  306. /* ======================================================================
  307.    Position Functions
  308.    ====================================================================== */
  309. void 
  310. MobileNode::start()
  311. {
  312. Scheduler& s = Scheduler::instance();
  314. if(random_motion_ == 0) {
  315. log_movement();
  316. return;
  317. }
  319. assert(initialized());
  321. random_position();
  322. #ifdef DEBUG
  323.         fprintf(stderr, "%d - %s: calling random_destination()n",
  324.                 address_, __PRETTY_FUNCTION__);
  325. #endif
  326. random_destination();
  327. s.schedule(&pos_handle_, &pos_intr_, position_update_interval_);
  328. }
  330. void 
  331. MobileNode::log_movement()
  332. {
  333.         if (!log_target_) 
  334. return;
  336. Scheduler& s = Scheduler::instance();
  337. sprintf(log_target_->pt_->buffer(),
  338. "M %.5f %d (%.2f, %.2f, %.2f), (%.2f, %.2f), %.2f",
  339. s.clock(), address_, X_, Y_, Z_, destX_, destY_, speed_);
  340. log_target_->pt_->dump();
  341. }
  344. void
  345. MobileNode::log_energy(int flag)
  346. {
  347. if (!log_target_) 
  348. return;
  349. Scheduler &s = Scheduler::instance();
  350. if (flag) {
  351. sprintf(log_target_->pt_->buffer(),"N -t %f -n %d -e %f", s.clock(),
  352. address_, energy_model_->energy()); 
  353. } else {
  354. sprintf(log_target_->pt_->buffer(),"N -t %f -n %d -e 0 ", s.clock(),
  355. address_); 
  356. }
  357. log_target_->pt_->dump();
  358. }
  360. //void
  361. //MobileNode::logrttime(double t)
  362. //{
  363. // last_rt_time_ = (int)t;
  364. //}
  366. void
  367. MobileNode::bound_position()
  368. {
  369. double minX;
  370. double maxX;
  371. double minY;
  372. double maxY;
  373. int recheck = 1;
  375. assert(T_ != 0);
  377. minX = T_->lowerX();
  378. maxX = T_->upperX();
  379. minY = T_->lowerY();
  380. maxY = T_->upperY();
  382. while (recheck) {
  383. recheck = 0;
  384. if (X_ < minX) {
  385. X_ = minX + (minX - X_);
  386. recheck = 1;
  387. }
  388. if (X_ > maxX) {
  389. X_ = maxX - (X_ - maxX);
  390. recheck = 1;
  391. }
  392. if (Y_ < minY) {
  393. Y_ = minY + (minY - Y_);
  394. recheck = 1;
  395. }
  396. if (Y_ > maxY) {
  397. Y_ = maxY- (Y_ - maxY);
  398. recheck = 1;
  399. }
  400. if (recheck) {
  401. fprintf(stderr, "Adjust position of node %dn",address_);
  402. }
  403. }
  404. }
  406. int
  407. MobileNode::set_destination(double x, double y, double s)
  408. {
  409. assert(initialized());
  411. if(x >= T_->upperX() || x <= T_->lowerX())
  412. return -1;
  413. if(y >= T_->upperY() || y <= T_->lowerY())
  414. return -1;
  416. update_position(); // figure out where we are now
  418. destX_ = x;
  419. destY_ = y;
  420. speed_ = s;
  422. dX_ = destX_ - X_;
  423. dY_ = destY_ - Y_;
  424. dZ_ = 0.0; // this isn't used, since flying isn't allowed
  426. double len;
  428. if (destX_ != X_ || destY_ != Y_) {
  429. // normalize dx, dy to unit len
  430. len = sqrt( (dX_ * dX_) + (dY_ * dY_) );
  431. dX_ /= len;
  432. dY_ /= len;
  433. }
  434.   
  435. position_update_time_ = Scheduler::instance().clock();
  437. #ifdef DEBUG
  438. fprintf(stderr, "%d - %s: calling log_movement()n", 
  439. address_, __FUNCTION__);
  440. #endif
  441. log_movement();
  443. /* update gridkeeper */
  444. if (GridKeeper::instance()){
  445. GridKeeper* gp =  GridKeeper::instance();
  446. gp-> new_moves(this);
  447. }                     
  449. if (namChan_ != 0) {
  451. double v = speed_ * sqrt( (dX_ * dX_) + (dY_ * dY_)); 
  453. sprintf(nwrk_,     
  454. "n -t %f -s %d -x %f -y %f -U %f -V %f -T %f",
  455. Scheduler::instance().clock(),
  456. nodeid_,
  457. X_, Y_,
  458. speed_ * dX_, speed_ * dY_,
  459. ( v != 0) ? len / v : 0. );   
  460. namdump();         
  461. }
  462. return 0;
  463. }
  467. void 
  468. MobileNode::update_position()
  469. {
  470. double now = Scheduler::instance().clock();
  471. double interval = now - position_update_time_;
  472. double oldX = X_;
  473. //double oldY = Y_;
  475. if ((interval == 0.0)&&(position_update_time_!=0))
  476. return;         // ^^^ for list-based imprvmnt 
  479. // CHECK, IF THE SPEED IS 0, THEN SKIP, but usually it's not 0
  480. X_ += dX_ * (speed_ * interval);
  481. Y_ += dY_ * (speed_ * interval);
  483. if ((dX_ > 0 && X_ > destX_) || (dX_ < 0 && X_ < destX_))
  484.   X_ = destX_; // correct overshoot (slow? XXX)
  485. if ((dY_ > 0 && Y_ > destY_) || (dY_ < 0 && Y_ < destY_))
  486.   Y_ = destY_; // correct overshoot (slow? XXX)
  488. /* list based improvement */
  489. if(oldX != X_)// || oldY != Y_)
  490. T_->updateNodesList(this, oldX);//, oldY);
  491. // COMMENTED BY -VAL- // bound_position();
  493. // COMMENTED BY -VAL- // Z_ = T_->height(X_, Y_);
  495. #if 0
  496. fprintf(stderr, "Node: %d, X: %6.2f, Y: %6.2f, Z: %6.2f, time: %fn",
  497. address_, X_, Y_, Z_, now);
  498. #endif
  499. position_update_time_ = now;
  500. }
  503. void
  504. MobileNode::random_position()
  505. {
  506. if (T_ == 0) {
  507. fprintf(stderr, "No TOPOLOGY assignedn");
  508. exit(1);
  509. }
  511. X_ = Random::uniform() * T_->upperX();
  512. Y_ = Random::uniform() * T_->upperY();
  513. Z_ = T_->height(X_, Y_);
  515. position_update_time_ = 0.0;
  516. }
  518. void
  519. MobileNode::random_destination()
  520. {
  521. if (T_ == 0) {
  522. fprintf(stderr, "No TOPOLOGY assignedn");
  523. exit(1);
  524. }
  526. random_speed();
  527. #ifdef DEBUG
  528.         fprintf(stderr, "%d - %s: calling set_destination()n",
  529.                 address_, __FUNCTION__);
  530. #endif
  531. (void) set_destination(Random::uniform() * T_->upperX(),
  532.                                Random::uniform() * T_->upperY(),
  533.                                speed_);
  534. }
  536. void
  537. MobileNode::random_direction()
  538. {
  539. /* this code isn't used anymore -dam 1/22/98 */
  540. double len;
  542. dX_ = (double) Random::random();
  543. dY_ = (double) Random::random();
  545. len = sqrt( (dX_ * dX_) + (dY_ * dY_) );
  547. dX_ /= len;
  548. dY_ /= len;
  549. dZ_ = 0.0; // we're not flying...
  551. /*
  552.  * Determine the sign of each component of the
  553.  * direction vector.
  554.  */
  555. if (X_ > (T_->upperX() - 2*T_->resol())) {
  556. if (dX_ > 0) 
  557. dX_ = -dX_;
  558. } else if (X_ < (T_->lowerX() + 2*T_->resol())) {
  559. if (dX_ < 0) 
  560. dX_ = -dX_;
  561. } else if (Random::uniform() <= 0.5) {
  562. dX_ = -dX_;
  563. }
  565. if (Y_ > (T_->upperY() - 2*T_->resol())) {
  566. if (dY_ > 0) 
  567. dY_ = -dY_;
  568. } else if (Y_ < (T_->lowerY() + 2*T_->resol())) {
  569. if (dY_ < 0) 
  570. dY_ = -dY_;
  571. } else if(Random::uniform() <= 0.5) {
  572. dY_ = -dY_;
  573. }
  574. #if 0
  575. fprintf(stderr, "Location: (%f, %f), Direction: (%f, %f)n",
  576. X_, Y_, dX_, dY_);
  577. #endif
  578. }
  580. void
  581. MobileNode::random_speed()
  582. {
  583. speed_ = Random::uniform() * MAX_SPEED;
  584. }
  586. double
  587. MobileNode::distance(MobileNode *m)
  588. {
  589. update_position(); // update my position
  590. m->update_position(); // update m's position
  592.         double Xpos = (X_ - m->X_) * (X_ - m->X_);
  593.         double Ypos = (Y_ - m->Y_) * (Y_ - m->Y_);
  594. double Zpos = (Z_ - m->Z_) * (Z_ - m->Z_);
  596.         return sqrt(Xpos + Ypos + Zpos);
  597. }
  599. double
  600. MobileNode::propdelay(MobileNode *m)
  601. {
  602. return distance(m) / SPEED_OF_LIGHT;
  603. }
  605. void 
  606. MobileNode::idle_energy_patch(float /*total*/, float /*P_idle*/)
  607. {
  608. }