00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044 #ifndef _GEAR_HH_
00045 #define _GEAR_HH_
00046
00047 #ifdef HAVE_CONFIG_H
00048 #include "config.h"
00049 #endif // HAVE_CONFIG_H
00050
00051 #include <list>
00052
00053 #ifdef HAVE_HASH_MAP
00054 #include <hash_map>
00055 #else
00056 #ifdef HAVE_EXT_HASH_MAP
00057 #include <ext/hash_map>
00058 #endif // HAVE_EXT_HASH_MAP
00059 #endif // HAVE_HASH_MAP
00060
00061 #ifdef NS_DIFFUSION
00062 #include <mobilenode.h>
00063 #endif // NS_DIFFUSION
00064
00065 #include "gear_attr.hh"
00066 #include "gear_tools.hh"
00067
00068 #include "diffapp.hh"
00069
00070
00071
00072
00073 #define GEOROUTING_PRE_FILTER_PRIORITY 170
00074 #define GEOROUTING_POST_FILTER_PRIORITY 20
00075
00076
00077 #define BEACON_REQUEST_TIMER 150
00078 #define NEIGHBOR_TIMER 151
00079
00080
00081 #define GEO_INITIAL_ENERGY 1
00082 #define GEO_UNIT_ENERGY_FOR_SEND 0.001
00083 #define GEO_UNIT_ENERGY_FOR_RECV 0.001
00084
00085
00086 enum geo_beacons {
00087 GEO_REQUEST = 1,
00088
00089 GEO_REPLY,
00090
00091
00092 GEO_UPDATE
00093
00094
00095
00096 };
00097
00098
00099 enum geo_actions {
00100 BROADCAST = 0,
00101
00102 BROADCAST_SUPPRESS,
00103
00104
00105 OUTSIDE_REGION
00106
00107
00108 };
00109
00110 #define GEO_BEACON_REPLY_PERIOD 100 // Sends at most one
00111
00112
00113
00114 #define GEO_NEIGHBOR_DELAY 30000 // In milli-seconds
00115
00116 #define GEO_BEACON_REQUEST_CHECK_PERIOD 100000 // In milli-seconds
00117 #define GEO_NEIGHBOR_UPDATE 300 // In seconds
00118 #define GEO_NEIGHBOR_REQUEST_PERIOD (10 * GEO_NEIGHBOR_UPDATE) // In seconds
00119
00120 #define GEO_NEIGHBOR_EXPIRED (5 * GEO_NEIGHBOR_UPDATE) // In seconds,
00121
00122
00123
00124
00125
00126
00127
00128
00129
00130
00131 #define GEO_BEACON_REPLY_DELAY 1500 // (msec) between receive and forward
00132 #define GEO_BEACON_REPLY_JITTER 1000 // (msec) jitter
00133
00134
00135
00136 #define GEO_BEACON_DELAY 400 // (msec) between receive and forward
00137 #define GEO_BEACON_JITTER 200 // (msec) jitter
00138
00139 #define INITIAL_ENERGY 1
00140 #define DEFAULT_VALID_PERIOD 10
00141
00142 #define UNICAST_ORIGINAL 1
00143 #define BROADCAST_TYPE 2
00144 #define MAX_INT 10000
00145
00146 #define MAX_PATH_LEN 200
00147
00148 class Region {
00149 public:
00150 void operator= (Region p) {center_ = p.center_; radius_ = p.radius_;}
00151 void output()
00152 {
00153 center_.output();
00154 DiffPrint(DEBUG_IMPORTANT, "-%f", radius_);
00155 }
00156
00157 GeoLocation center_;
00158 double radius_;
00159 };
00160
00161 class GeoHeader {
00162 public:
00163 int16_t pkt_type_;
00164 int16_t path_len_;
00165 Region dst_region_;
00166 };
00167
00168 class PktHeader {
00169 public:
00170 int32_t pkt_num_;
00171 int32_t rdm_id_;
00172 int32_t prev_hop_;
00173 int pkt_type_;
00174 int path_len_;
00175 Region dst_region_;
00176 };
00177
00178 class NeighborEntry {
00179 public:
00180 NeighborEntry(int32_t id, double longitude, double latitude,
00181 double remaining_energy) :
00182 id_(id), longitude_(longitude), latitude_(latitude),
00183 remaining_energy_(remaining_energy){
00184 valid_period_ = DEFAULT_VALID_PERIOD;
00185 GetTime(&tv_);
00186 }
00187
00188 int32_t id_;
00189 double longitude_;
00190 double latitude_;
00191 double remaining_energy_;
00192 struct timeval tv_;
00193 double valid_period_;
00194 };
00195
00196 class GeoRoutingFilter;
00197
00198 typedef list<NeighborEntry *> NeighborList;
00199 typedef list<PktHeader *> PacketList;
00200
00201 class GeoFilterReceive : public FilterCallback {
00202 public:
00203 GeoFilterReceive(GeoRoutingFilter *app) : app_(app) {};
00204 void recv(Message *msg, handle h);
00205
00206 GeoRoutingFilter *app_;
00207 };
00208
00209 class GeoRoutingFilter : public DiffApp {
00210 public:
00211 #ifdef NS_DIFFUSION
00212 GeoRoutingFilter(const char *diffrtg);
00213 int command(int argc, const char*const* argv);
00214 #else
00215 GeoRoutingFilter(int argc, char **argv);
00216 #endif // NS_DIFFUSION
00217
00218 virtual ~GeoRoutingFilter()
00219 {
00220
00221 };
00222
00223 void run();
00224 void recv(Message *msg, handle h);
00225
00226
00227 void messageTimeout(Message *msg);
00228 void beaconTimeout();
00229 void neighborTimeout();
00230
00231 protected:
00232
00233 handle pre_filter_handle_;
00234 handle post_filter_handle_;
00235 int pkt_count_;
00236 int rdm_id_;
00237
00238
00239 struct timeval last_beacon_reply_tv_;
00240
00241
00242 struct timeval last_neighbor_request_tv_;
00243
00244
00245 double geo_longitude_;
00246 double geo_latitude_;
00247 int num_pkt_sent_;
00248 int num_pkt_recv_;
00249 double initial_energy_;
00250 double unit_energy_for_send_;
00251 double unit_energy_for_recv_;
00252
00253
00254
00255 NeighborList neighbors_list_;
00256
00257
00258 PacketList message_list_;
00259
00260
00261 HeuristicValueTable h_value_table_;
00262 LearnedCostTable learned_cost_table_;
00263
00264
00265 GeoFilterReceive *filter_callback_;
00266
00267
00268 handle setupPostFilter();
00269 handle setupPreFilter();
00270
00271
00272 void preProcessFilter(Message *msg);
00273 void postProcessFilter(Message *msg);
00274
00275
00276 PktHeader * preProcessMessage(Message *msg);
00277 PktHeader * stripOutHeader(Message *msg);
00278 PktHeader * retrievePacketHeader(Message *msg);
00279 bool extractLocation(Message *msg,
00280 float *longitude_min, float *longitude_max,
00281 float *latitude_min, float *latitude_max);
00282 GeoHeader * restoreGeoHeader(PktHeader *pkt_header, Message *msg);
00283 void takeOutAttr(NRAttrVec *attrs, int32_t key);
00284
00285
00286 NeighborEntry * findNeighbor(int32_t neighbor_id);
00287 void updateNeighbor(int32_t neighbor_id, double neighbor_longitude,
00288 double neighbor_latitude, double neighbor_energy);
00289 bool checkNeighbors();
00290 void sendNeighborRequest();
00291
00292
00293 double remainingEnergy() {return INITIAL_ENERGY;}
00294
00295
00296 double retrieveLearnedCost(int neighbor_id, GeoLocation dst);
00297 double estimateCost(int neighbor_id, GeoLocation dst);
00298
00299
00300 int32_t findNextHop(GeoHeader *geo_header, bool greedy);
00301 int floodInsideRegion(GeoHeader *geo_header);
00302
00303 double retrieveHeuristicValue(GeoLocation dst);
00304 void broadcastHeuristicValue(GeoLocation dst, double new_heuristic_value);
00305
00306
00307 void getNodeLocation(double *longitude, double *latitude);
00308 };
00309
00310 class GeoMessageSendTimer : public TimerCallback {
00311 public:
00312 GeoMessageSendTimer(GeoRoutingFilter *agent, Message *msg) :
00313 agent_(agent), msg_(msg) {};
00314 ~GeoMessageSendTimer()
00315 {
00316 delete msg_;
00317 };
00318 int expire();
00319
00320 GeoRoutingFilter *agent_;
00321 Message *msg_;
00322 };
00323
00324 class GeoNeighborsTimer : public TimerCallback {
00325 public:
00326 GeoNeighborsTimer(GeoRoutingFilter *agent) : agent_(agent) {};
00327 ~GeoNeighborsTimer() {};
00328 int expire();
00329
00330 GeoRoutingFilter *agent_;
00331 };
00332
00333 class GeoBeaconRequestTimer : public TimerCallback {
00334 public:
00335 GeoBeaconRequestTimer(GeoRoutingFilter *agent) : agent_(agent) {};
00336 ~GeoBeaconRequestTimer() {};
00337 int expire();
00338
00339 GeoRoutingFilter *agent_;
00340 };
00341
00342 #endif // !_GEAR_HH_