DESERT 3.5.1
Loading...
Searching...
No Matches
uwUFetch_NODE_SENSOR.cpp
Go to the documentation of this file.
1//
2// Copyright (c) 2017 Regents of the SIGNET lab, University of Padova.
3// All rights reserved.
4//
5// Redistribution and use in source and binary forms, with or without
6// modification, are permitted provided that the following conditions
7// are met:
8// 1. Redistributions of source code must retain the above copyright
9// notice, this list of conditions and the following disclaimer.
10// 2. Redistributions in binary form must reproduce the above copyright
11// notice, this list of conditions and the following disclaimer in the
12// documentation and/or other materials provided with the distribution.
13// 3. Neither the name of the University of Padova (SIGNET lab) nor the
14// names of its contributors may be used to endorse or promote products
15// derived from this software without specific prior written permission.
16//
17// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
19// TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
20// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
21// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
22// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
23// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
24// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
25// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
26// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
27// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28
38#include "mac.h"
39#include "mmac.h"
40#include "uwUFetch_NODE.h"
41#include "uwUFetch_cmn_hdr.h"
42//#include "uwmphy_modem_cmn_hdr.h"
43#include "uwcbr-module.h"
44#include <sstream>
45#include <time.h>
46#include "rng.h"
47
49static class uwUFetchNODEModuleClass : public TclClass
50{
51public:
55 uwUFetchNODEModuleClass()
56 : TclClass("Module/UW/UFETCH/NODE")
57 {
58 }
59
60 TclObject *
61 create(int, const char *const *)
62 {
63 return (new uwUFetch_NODE());
64 }
65} class_module_uwufetchnode;
66
67bool uwUFetch_NODE::initialized = false;
68
69std::map<uwUFetch_NODE::UWUFETCH_NODE_STATUS, std::string>
70 uwUFetch_NODE::statusInfo;
71std::map<uwUFetch_NODE::UWUFETCH_NODE_STATUS_CHANGE, std::string>
72 uwUFetch_NODE::statusChange;
73std::map<uwUFetch_NODE::UWUFETCH_NODE_PACKET_TYPE, std::string>
74 uwUFetch_NODE::packetType;
75std::map<uwUFetch_NODE::UWUFETCH_TIMER_STATUS, std::string>
76 uwUFetch_NODE::statusTimer;
77
81uwUFetch_NODE::uwUFetch_NODE()
82 : /***SENSOR NODE***/
83 // timers
84 BCK_timer_rts(this)
85 , CTS_timer(this)
86 , BCK_timer_data(this)
87 , BCK_timer_probe(this)
88 , POLL_timer(this)
89 , DATA_BEFORE_TX_timer(this)
90 , CBEACON_timer(this)
91 ,
92 // Global Variables that should be never reset
93 rx_BEACON_start_time(0)
94 , rx_BEACON_finish_time(0)
95 , tx_PROBE_start_time(0)
96 , tx_PROBE_finish_time(0)
97 , rx_POLL_start_time(0)
98 , rx_POLL_finish_time(0)
99 , tx_DATA_start_time(0)
100 , tx_DATA_finish_time(0)
101 , rx_CBEACON_start_time(0)
102 , rx_CBEACON_finish_time(0)
103 , n_tot_BEACON_pck_rx_by_NODE(0)
104 , n_tot_BEACON_pck_rx_corr_by_NODE(0)
105 , n_tot_PROBE_pck_tx_by_NODE(0)
106 , n_tot_POLL_pck_rx_by_NODE(0)
107 , n_tot_POLL_pck_rx_corr_by_NODE(0)
108 , n_tot_DATA_pck_tx_by_NODE(0)
109 , n_tot_CBEACON_pck_rx_by_NODE(0)
110 , n_tot_CBEACON_pck_rx_corr_by_NODE(0)
111 , T_min_bck_probe_node(0)
112 , T_max_bck_probe_node(0)
113 , num_cbeacon_node_rx(0)
114 , mac_addr_HN_in_beacon(0)
115 , bck_before_tx_probe(0)
116 , Tprobe(0)
117 , Tdata_NODE(0)
118 , RTT(0)
119 , mac_addr_HN_in_poll(0)
120 , num_pck_to_tx_by_NODE(0)
121 , num_cbeacon_at_now_HN_tx(0)
122 , mac_addr_HN_in_cbeacon(0)
123 ,
124 // Variables that should be reseted when a cycle is end
125 n_BEACON_pck_rx_by_NODE(0)
126 , n_PROBE_pck_tx_by_NODE(0)
127 , n_POLL_pck_rx_by_NODE(0)
128 , n_DATA_pck_tx_by_NODE(0)
129 , n_CBEACON_pck_rx_by_NODE(0)
130 , dataAlreadyTransmitted(false)
131 ,
132 // Variables that enable or not an operation
133 rxBEACONEnabled(false)
134 , txPROBEEnabled(false)
135 , rxPOLLEnabled(false)
136 , txDATAEnabled(false)
137 , rxCBEACONEnabled(false)
138 , curr_BEACON_NODE_pck_rx(NULL)
139 , curr_PROBE_NODE_pck_tx(NULL)
140 , curr_POLL_NODE_pck_rx(NULL)
141 , curr_DATA_NODE_pck_tx(NULL)
142 , curr_CBEACON_NODE_pck_rx(NULL)
143 ,
144 /***HEAD NODE***/
145 // Timers
146 BeaconBeforeTx_timer(this)
147 , PROBE_timer(this)
148 , DATA_timer(this)
149 ,
150 // Global Variables that should be never reset
151 tx_BEACON_start_HN_time(0)
152 , tx_BEACON_finish_HN_time(0)
153 , rx_PROBE_start_HN_time(0)
154 , rx_PROBE_finish_HN_time(0)
155 , tx_POLL_start_HN_time(0)
156 , tx_POLL_finish_HN_time(0)
157 , rx_DATA_start_HN_time(0)
158 , rx_DATA_finish_HN_time(0)
159 , tx_CBEACON_start_HN_time(0)
160 , tx_CBEACON_finish_HN_time(0)
161 , rx_TRIGGER_start_HN_time(0)
162 , rx_TRIGGER_finish_HN_time(0)
163 , tx_RTS_start_HN_time(0)
164 , tx_RTS_finish_HN_time(0)
165 , rx_CTS_start_HN_time(0)
166 , rx_CTS_finish_HN_time(0)
167 , tx_DATA_start_HN_time(0)
168 , tx_DATA_finish_HN_time(0)
169 , n_tot_BEACON_pck_tx_by_HN(0)
170 , n_tot_PROBE_pck_rx_by_HN(0)
171 , n_tot_PROBE_pck_corr_rx_by_HN(0)
172 , n_tot_POLL_pck_tx_by_HN(0)
173 , n_tot_DATA_pck_rx_by_HN(0)
174 , n_tot_DATA_pck_rx_corr_by_HN(0)
175 , n_tot_CBEACON_pck_tx_by_HN(0)
176 , n_tot_TRIGGER_pck_rx_by_HN(0)
177 , n_tot_TRIGGER_pck_rx_corr_by_HN(0)
178 , n_tot_DATA_pck_tx_by_HN(0)
179 , mac_addr_NODE_polled(0)
180 , number_data_pck_HN_rx_exact(0)
181 , pck_number_id(1)
182 , data_timeout(0)
183 , Tbeacon(0)
184 , Tpoll(0)
185 , Tdata_HN(0)
186 , mac_addr_NODE_in_data(0)
187 , T_min_bck_RTS(0)
188 , T_max_bck_RTS(0)
189 , T_min_bck_DATA(0)
190 , T_max_bck_DATA(0)
191 , bck_before_tx_data(0)
192 , mac_addr_AUV_in_trigger(0)
193 , mac_addr_AUV_in_CTS(0)
194 , bck_before_tx_RTS(0)
195 , max_data_HN_can_tx(0)
196 , max_pck_HN_can_tx(0)
197 , Tdata_HN_pck(0)
198 , CTSrx(false)
199 , txRTSbeforeCBEACON(false)
200 , sectionCBeacon(false)
201 ,
202 // Variables that should be reseted when a cycle is end
203 n_BEACON_pck_tx_by_HN(0)
204 , n_PROBE_pck_rx_by_HN(0)
205 , n_POLL_pck_tx_by_HN(0)
206 , n_DATA_pck_rx_by_HN(0)
207 , n_CBEACON_pck_tx_by_HN(0)
208 , n_TRIGGER_pck_rx_by_HN(0)
209 , n_RTS_pck_tx_by_HN(0)
210 , n_CTS_pck_rx_by_HN(0)
211 , n_DATA_pck_tx_by_HN(0)
212 ,
213 // Variables that enable or not an operation
214 txBEACONEnabled(false)
215 , rxPROBEEnabled(false)
216 , txPOLLEnabled(false)
217 , rxDATAEnabled(false)
218 , txCBEACONEnabled(false)
219 , rxTRIGGEREnabled(false)
220 , txRTSEnabled(false)
221 , rxCTSEnabled(false)
222 , txDATAEnabledHN(false)
223 ,
224 // PACKETS create
225 curr_BEACON_HN_pck_tx(NULL)
226 , curr_PROBE_HN_pck_rx(NULL)
227 , curr_POLL_HN_pck_tx(NULL)
228 , curr_DATA_HN_pck_rx(NULL)
229 , curr_CBEACON_HN_pck_tx(NULL)
230 , curr_TRIGGER_HN_pck_rx(NULL)
231 , curr_RTS_HN_pck_tx(NULL)
232 , curr_CTS_HN_pck_rx(NULL)
233 , curr_DATA_HN_pck_tx(NULL)
234 , curr_DATA_NODE_pck_tx_HN(NULL)
235{
236 // variable binding
237 mac2phy_delay_ = 1e-19;
238 bind("TIME_BEFORE_START_COMU_HN_NODE_",
239 (double *) &T_START_PROCEDURE_HN_NODE);
240 bind("MAXIMUM_VALUE_BACKOFF_PROBE_", (double *) &T_MAX_BACKOFF_PROBE);
241 bind("MINIMUM_VALUE_BACKOFF_PROBE_", (double *) &T_MIN_BACKOFF_PROBE);
242 bind("MAXIMUM_NODE_POLLED_", (int *) &MAX_POLLED_NODE);
243 bind("MAXIMUM_PAYLOAD_SIZE_", (int *) &MAX_PAYLOAD);
244 bind("TIME_TO_WAIT_PROBES_PCK_", (double *) &T_PROBE);
245 bind("TIME_TO_WAIT_POLL_PCK_", (double *) &T_POLL);
246 bind("TIME_BETWEEN_2_DATA_TX_HN_",
247 (double *) &TIME_BETWEEN_2_TX_DATA_HN_AUV);
248 bind("TIME_BETWEEN_2_DATA_TX_NODE_",
249 (double *) &TIME_BETWEEN_2_TX_DATA_NODE_HN);
250 bind("SEE_THE_TRANSITIONS_STATE_", (int *) &PRINT_TRANSITIONS_INT);
251 bind("GUARD_INTERVAL_", (double *) &T_GUARD);
252 bind("MAXIMUM_BUFFER_SIZE_", (int *) &MAXIMUM_BUFFER_DATA_PCK_NODE);
253 bind("MAXIMUM_CBEACON_TRANSMISSIONS_", (int *) &MAX_ALLOWED_CBEACON_TX);
254 bind("MAXIMUM_PCK_WANT_RX_HN_FROM_NODE_",
255 (int *) &MAX_PCK_HN_WANT_RX_FROM_NODE);
256 bind("MY_DEBUG_", (int *) &debugMio_);
257 bind("NUMBER_OF_RUN_", (int *) &N_RUN);
258 bind("TIME_TO_WAIT_CTS_", (double *) &T_CTS);
259 bind("MODE_COMM_", (int *) &MODE_COMM_HN_AUV);
260 bind("BURST_DATA_", (int *) &MODE_BURST_DATA);
261} // end uwUFetch_NODE()
262
263int
264uwUFetch_NODE::crLayCommand(ClMessage *m)
265{
266 switch (m->type()) {
267 default:
268 return MMac::crLayCommand(m);
269 }
270} // end crLCommand()
271
272uwUFetch_NODE::~uwUFetch_NODE()
273{
274 // nothing to do
275} // end ~uwUFetch_NODE()
276
277int
278uwUFetch_NODE::command(int argc, const char *const *argv)
279{
280 Tcl &tcl = Tcl::instance();
281
282 if (argc == 2) {
283 if (strcasecmp(argv[1], "initialize") == 0) {
284 if (initialized == false)
285 initInfo();
286 if (debug_)
287 fout.open("/tmp/uwUFetch_AUV_stateTransitions.txt",
288 std::ios_base::app);
289 if (debugMio_) {
290 std::stringstream file_logging;
291 file_logging << "uwUFetch_NODE_" << addr << "_N_RUN_" << N_RUN
292 << ".out";
293 out_file_logging.open(
294 file_logging.str().c_str(), std::ios_base::app);
295 }
296 return TCL_OK;
297
298 } else if (strcasecmp(argv[1], "printTransitions") == 0) {
299 print_transitions = true;
300
301 return TCL_OK;
302 } else if (strcasecmp(argv[1], "getDataQueueSize") == 0) {
303
304 return TCL_OK;
305
306 } else if (strcasecmp(argv[1], "getBEACONrxByNODE") == 0) {
307 tcl.resultf("%d", getTotalBeaconPckRx_by_NODE());
308 return TCL_OK;
309
310 } else if (strcasecmp(argv[1], "getBEACONrxCorruptedByNODE") == 0) {
311 tcl.resultf("%d", getTotalBeaconPckRx_corrupted_by_NODE());
312 return TCL_OK;
313
314 } else if (strcasecmp(argv[1], "getPROBEtxByNODE") == 0) {
315 tcl.resultf("%d", getTotalProbePckTx_by_NODE());
316 return TCL_OK;
317
318 } else if (strcasecmp(argv[1], "getPOLLrxByNODE") == 0) {
319 tcl.resultf("%d", getTotalPollPckRx_by_NODE());
320 return TCL_OK;
321
322 } else if (strcasecmp(argv[1], "getPOLLrxCorruptedByNODE") == 0) {
323 tcl.resultf("%d", getTotalPollPckRx_corrupted_by_NODE());
324 return TCL_OK;
325
326 } else if (strcasecmp(argv[1], "getDATAtxByNODE") == 0) {
327 tcl.resultf("%d", getTotalDataPckTx_by_NODE());
328 return TCL_OK;
329
330 } else if (strcasecmp(argv[1], "getCBEACONrxByNODE") == 0) {
331 tcl.resultf("%d", getTotalCBeaconPckRx_by_NODE());
332 return TCL_OK;
333
334 } else if (strcasecmp(argv[1], "getCBEACONrxCorruptedByNODE") == 0) {
335 tcl.resultf("%d", getTotalCBeaconPckRx_corrupted_by_NODE());
336 return TCL_OK;
337
338 } else if (strcasecmp(argv[1], "SimpleNodeStart") == 0) {
339 stateIdle_NODE();
340 return TCL_OK;
341
342 } else if (strcasecmp(argv[1], "getBEACONtxByHN") == 0) {
343 tcl.resultf("%d", getTotalBeaconTx_by_HN());
344 return TCL_OK;
345
346 } else if (strcasecmp(argv[1], "getPROBErxByHN") == 0) {
347 tcl.resultf("%d", getTotalProbePckRx_HN());
348 return TCL_OK;
349
350 } else if (strcasecmp(argv[1], "getPROBErxCorruptedByHN") == 0) {
351 tcl.resultf("%d", getTotalProbePckRx_corrupted_HN());
352 return TCL_OK;
353
354 } else if (strcasecmp(argv[1], "getPOLLtxByHN") == 0) {
355 tcl.resultf("%d", getTotalPollPckTx_by_HN());
356 return TCL_OK;
357
358 } else if (strcasecmp(argv[1], "getDATArxByHN") == 0) {
359 tcl.resultf("%d", getTotalDataPckRx_by_HN());
360 return TCL_OK;
361
362 } else if (strcasecmp(argv[1], "getDATArxCorruptedByHN") == 0) {
363 tcl.resultf("%d", getTotalDataPckRx_corrupted_by_HN());
364 return TCL_OK;
365
366 } else if (strcasecmp(argv[1], "getCBEACONtxbyHN") == 0) {
367 tcl.resultf("%d", getTotalCBeaconPckTx_by_HN());
368 return TCL_OK;
369
370 } else if (strcasecmp(argv[1], "getTRIGGERrxByHN") == 0) {
371 tcl.resultf("%d", getTotalTriggerPckRx_HN());
372 return TCL_OK;
373
374 } else if (strcasecmp(argv[1], "getTRIGGERrxCorrupteByHN") == 0) {
375 tcl.resultf("%d", getTotalTriggerPckRx_corrupted_HN());
376 return TCL_OK;
377
378 } else if (strcasecmp(argv[1], "getRTStxByHN") == 0) {
379 tcl.resultf("%d", getTotalRtsPckTx_by_HN());
380 return TCL_OK;
381
382 } else if (strcasecmp(argv[1], "getCTSrxByHN") == 0) {
383 tcl.resultf("%d", getTotalCtsPckRx_HN());
384 return TCL_OK;
385
386 } else if (strcasecmp(argv[1], "getCTSrxCorrupteByHN") == 0) {
387 tcl.resultf("%d", getTotalCtsPckRx_corrupted_HN());
388 return TCL_OK;
389
390 } else if (strcasecmp(argv[1], "getDATAtxByHN") == 0) {
391 tcl.resultf("%d", getTotalDataPckTx_by_HN());
392 return TCL_OK;
393
394 } else if (strcasecmp(argv[1], "HeadNodeStart") == 0) {
395 stateIdle_HN();
396 return TCL_OK;
397
398 } else if (strcasecmp(argv[1], "BeHeadNode") == 0) {
399 HEADNODE = 1;
400 return TCL_OK;
401 }
402 } else if (argc == 3) {
403 if (strcasecmp(argv[1], "setMacAddr") == 0) {
404 addr = atoi(argv[2]);
405 if (debug_)
406 std::cout << "UWFETCH_NODE MAC address is:" << addr
407 << std::endl;
408 return TCL_OK;
409 }
410 }
411 return MMac::command(argc, argv);
412} // end command
413
414void
415uwUFetch_NODE::initInfo()
416{
417 initialized = true;
418
419 if ((print_transitions) && (system(NULL))) {
420 system("rm -f /tmp/uwUFetch_NODE_stateTransitions.txt");
421 system("touch /tmp/uwUFetch_NODE_stateTransitions.txt");
422 }
423 // State in which the NODE may be
424 statusInfo[UWUFETCH_NODE_STATUS_IDLE] = "Node is in IDLE state";
425 statusInfo[UWUFETCH_NODE_STATUS_BEACON_RECEIVE] =
426 "NODE has received a BEACON packet from HN";
427 statusInfo[UWUFETCH_NODE_STATUS_TRANSMIT_PROBE] =
428 "NODE is transmitting PROBE packet to HN";
429 statusInfo[UWUFETCH_NODE_STATUS_WAIT_POLL_PACKET] =
430 "NODE is waiting for POLL packet from HN";
431 statusInfo[UWUFETCH_NODE_STATUS_POLL_RECEIVE] =
432 "NODE has received a POLL packet from HN";
433 statusInfo[UWUFETCH_NODE_STATUS_TRANSMIT_DATA] =
434 "NODE is transmitting DATA packet to HN";
435 statusInfo[UWUFETCH_NODE_STATUS_TRIGGER_RECEIVE] =
436 "HN has received a TRIGGER packet from the AUV";
437 statusInfo[UWUFETCH_NODE_STATUS_RTS_TRANSMIT] =
438 "HN has transmitted a RTS packet to the AUV";
439 statusInfo[UWUFETCH_NODE_STATUS_WAIT_CTS_PACKET] =
440 "HN is waiting to the CTS packet from the AUV";
441 statusInfo[UWUFETCH_NODE_STATUS_CTS_RECEIVE] =
442 " HN has received a CTS packet from the AUV";
443 statusInfo[UWUFETCH_NODE_STATUS_TRANSMIT_BEACON] =
444 "HN is transmitting the BEACON packet to the NODE";
445 statusInfo[UWUFETCH_NODE_STATUS_WAIT_PROBE_PACKET] =
446 "HN is waiting to receive a PROBE packet from the NODE";
447 statusInfo[UWUFETCH_NODE_STATUS_PROBE_RX] =
448 "HN has received a PROBE packet from the NODE";
449 statusInfo[UWUFETCH_NODE_STATUS_POLL_TX] =
450 "HN is transmitting the POLL packet to the NODE";
451 statusInfo[UWUFETCH_NODE_STATUS_WAIT_DATA_NODE] =
452 "HN is waiting a DATA packet from the NODE";
453 statusInfo[UWUFETCH_NODE_STATUS_DATA_RX] =
454 "HN has received a DATA packet from the NODE";
455 statusInfo[UWUFETCH_NODE_STATUS_WAIT_CBEACON_PACKET] =
456 "NODE is waiting to receive a CBEACON packet from the HN";
457 statusInfo[UWUFETCH_NODE_STATUS_CBEACON_RECEIVE] =
458 "NODE has received a CBEACON packet from the HN";
459 // Reason for which the NODE change his state
460 statusChange[UWFETCH_NODE_STATUS_CHANGE_STATE_IDLE] =
461 "NODE is in IDLE STATE";
462 statusChange[UWFETCH_NODE_STATUS_CHANGE_PACKET_ERROR] =
463 "NODE has receive a packet that is corrupted";
464 statusChange[UWFETCH_NODE_STATUS_CHANGE_PACKET_FOR_ANOTHER_NODE] =
465 "NODE has received a packet that is addressed for another node";
466 statusChange[UWFETCH_NODE_STATUS_CHANGE_PACKET_UNKNOWN_TYPE] =
467 "NODE has received a packet that the type is unknown";
468 statusChange[UWUFETCH_NODE_STATUS_CHANGE_BEACON_RX] =
469 "NODE has received a BEACON packet";
470 statusChange[UWUFETCH_NODE_STATUS_CHANGE_PROBE_TX] =
471 "NODE has transmitted a PROBE packet";
472 statusChange[UWUFETCH_NODE_STATUS_CHANGE_TO_WAIT_POLL_EXPIRED] =
473 "POLL timeout is expired";
474 statusChange[UWUFETCH_NODE_STATUS_CHANGE_POLL_RX] =
475 "NODE has received a POLL packet";
476 statusChange[UWFETCH_NODE_STATUS_CHANGE_CBEACON_RX_DATA_ALREADY_TX] =
477 "NODE has received a CBEACON packet but it has already transmit "
478 "its DATA packets";
479 statusChange[UWUFETCH_NODE_STATUS_CHANGE_MAX_DATA_PCK_TX] =
480 "NODE has transmitted the maximum number of packets";
481 statusChange[UWUFETCH_NODE_STATUS_CHANGE_DATA_PCK_TX] =
482 "NODE has transmitted a DATA packets";
483 statusChange[UWUFETCH_NODE_STATUS_CHANGE_TRIGGER_RX] =
484 "HN has received a TRIGGER packet";
485 statusChange[UWUFETCH_NODE_STATUS_CHANGE_RTS_TX] =
486 "HN has transmitted a RTS packet to tha AUV";
487 statusChange[UWUFETCH_NODE_STATUS_CHANGE_TO_WAIT_CTS_EXPIRED] =
488 "CTS timeout expired";
489 statusChange[UWUFETCH_NODE_STATUS_CHANGE_CTS_RX] =
490 "HN has received a CTS packet from the AUV";
491 statusChange[UWUFETCH_NODE_STATUS_CHANGE_BEACON_TX] =
492 "HN has transmitted a BEACON packet to the NODE";
493 statusChange[UWUFETCH_NODE_STATUS_CHANGE_CBEACON_TX] =
494 "HN has transmitted a CBEACON packet to the NODe";
495 statusChange[UWUFETCH_NODE_STATUS_CHANGE_PROBE_RX] =
496 "HN has received a BEACON packet from the NODE";
497 statusChange
498 [UWUFETCH_NODE_STATUS_CHANGE_CBEACON_MAX_ALLOWED_TX_0_PROBE_RX] =
499 "HN has 0 NODE to poll and maximum number of CBEACON has "
500 "been transmitted";
501 statusChange[UWUFETCH_NODE_STATUS_CHANGE_CBEACON_ALLOWED_TX_0_PROBE_RX] =
502 "HN has 0 NODE to poll and another CBEACON can be transmitted";
503 statusChange
504 [UWUFETCH_NODE_STATUS_CHANGE_MAX_PROBE_RX_PROBE_TO_NOT_EXPIRED] =
505 "HN has received the maximum number of PROBE allowed and "
506 "the PROBE timeout is not still expired";
507 statusChange[UWUFETCH_NODE_STATUS_CHANGE_TO_EXPIRED_AT_LEAST_1_PROBE_RX] =
508 "PROBE timeout is expired and at least 1 node can be polled by the "
509 "HN";
510 statusChange[UWUFETCH_NODE_STATUS_CHANGE_POLL_TX] =
511 "HN has transmitted a POLL packet to the NODE";
512 statusChange[UWUFETCH_NODE_STATUS_CHANGE_DATA_TO_EXPIRED] =
513 "DATA timeout is expire";
514 statusChange
515 [UWUFETCH_NODE_STATUS_CHANGE_DATA_TO_EXPIRED_0_NODE_TO_POLL_NO_OTHER_CBEACON] =
516 "DATA timeout is expire and there are 0 node to poll and "
517 "other CBEACONS can not be transmitted";
518 statusChange
519 [UWUFETCH_NODE_STATUS_CHANGE_DATA_TO_EXPIRED_0_NODE_TO_POLL_YES_OTHER_CBEACON] =
520 "DATA timeout is expire and there are 0 node to poll and "
521 "at least one CBEACON can be transmitted";
522 statusChange
523 [UWUFETCH_NODE_STATUS_CHANGE_DATA_TO_EXPIRED_ANOTHER_NODE_TO_POLL] =
524 "DATA timeout is expire and at least 1 node can be polled";
525 statusChange[UWUFETCH_NODE_STATUS_CHANGE_DATA_RX] =
526 "HN has received a DATA packet from the NODE";
527 statusChange[UWUFETCH_NODE_STATUS_CHANGE_LAST_DATA_PCK_RX] =
528 "HN has received the last DATA packet from the NODE";
529 statusChange
530 [UWUFETCH_NODE_STATUS_CHANGE_DATA_MAX_ALLOWED_PCK_RX_0_NODE_TO_POLL_NO_OTHER_CBEACON] =
531 "HN has received all the packet from the NODE, there are 0 "
532 "node to polled and it's not possible to transmit other "
533 "CBEACON";
534 statusChange
535 [UWUFETCH_NODE_STATUS_CHANGE_DATA_MAX_ALLOWED_PCK_RX_0_NODE_TO_POLL_YES_OTHER_CBEACON] =
536 "HN has received all the packet from the NODE, there are 0 "
537 "node to polled and it's possible to transmit other "
538 "CBEACON";
539 statusChange
540 [UWUFETCH_NODE_STATUS_CHANGE_DATA_MAX_ALLOWED_PCK_RX_YES_NODE_TO_POLL] =
541 "HN has received all the packet from the NODE, there are "
542 "at least one node that can be polled";
543 statusChange[UWUFETCH_NODE_STATUS_CHANGE_CBEACON_MAX_ALLOWED_TX] =
544 "HN has transmit the maximum number of CBEACON packets";
545 statusChange[UWUFETCH_NODE_STATUS_CHANGE_BEACON_TO_EXPIRED] =
546 "BEACON timeout is expired";
547 statusChange[UWUFETCH_NODE_STATUS_CHANGE_TRIGGER_RX_BUT_HN_NO_DATA_TO_TX] =
548 "Trigger received by the HN, but HN has no DATA available to "
549 "transmit to the AUV";
550 statusChange[UWUFETCH_NODE_STATUS_CHANGE_HN_TX_ALL_DATA_TO_AUV] =
551 "HN has transmitted all his DATA packet to the AUV";
552 statusChange[UWUFETCH_NODE_STATUS_CHANGE_HN_RX_TRIGGER_FROM_AUV_CORRUPTED] =
553 "HN has received a TRIGGER from AUV that is corrupted by the "
554 "channel";
555 statusChange
556 [UWUFETCH_NODE_STATUS_CHANGE_HN_FINISH_TX_DATA_PCK_TO_AUV_RETURN_CBEACON_TX] =
557 "HN has finished to transmit a DATA packets to the AUV, "
558 "and now continue"
559 " with the transmission of CBEACON packet";
560 // Type of packets
561 packetType[UWUFETCH_NODE_PACKET_TYPE_DATA] = "DATA packet";
562 packetType[UWUFETCH_NODE_PACKET_TYPE_PROBE] = "PROBE packet";
563 packetType[UWUFETCH_NODE_PACKET_TYPE_POLL] = "POLL packet";
564 packetType[UWUFETCH_NODE_PACKET_TYPE_BEACON] = "BEACON packet";
565 packetType[UWUFETCH_NODE_PACKET_TYPE_TRIGGER] = "TRIGGER packet";
566 packetType[UWUFETCH_NODE_PACKET_TYPE_RTS] = "RTS packet";
567 packetType[UWUFETCH_NODE_PACKET_TYPE_CTS] = "CTS packet";
568 // Possible status in which NODE can be found
569 statusTimer[UWUFETCH_TIMER_STATUS_IDLE] = "NODE is in IDLE";
570 statusTimer[UWUFETCH_TIMER_STATUS_RUNNING] = "NODE is RUNNING";
571 statusTimer[UWUFETCH_TIMER_STATUS_FROZEN] = "NODE is FREEZING";
572 statusTimer[UWUFETCH_TIMER_STATUS_EXPIRED] = "NODE timeout is EXPIRED";
573} // end initInfo();
574
575/*******************************************************************************
576 * GENERAL METHODS *
577 *******************************************************************************/
578
579void
580uwUFetch_NODE::Phy2MacStartRx(const Packet *p)
581{
582
583 if (isHeadNode()) {
584 /****************************
585 * I'm the HEAD NODE *
586 ******************************/
587 uwUFetch_NODE::Phy2MacStartRx_HN(p);
588
589 } else {
590 /****************************
591 * I'm the SENSOR NODE *
592 ****************************/
593
594 hdr_cmn *cmh = hdr_cmn::access(p);
595 hdr_mac *mach = HDR_MAC(p);
596 int src_mac_addr = mach->macSA();
597
598 if (cmh->ptype() == PT_BEACON_UFETCH) {
599 // BEACON section
600 if (debugMio_)
601 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
602 << ")::Phy2MacStartRx()_________________Start_"
603 "to_rx_BEACON_pck_"
604 << "from_HN(" << src_mac_addr << ")."
605 << std::endl;
606
607 if (rxBEACONEnabled) {
608 // Node is enabled to receive BEACON
609 if (debug_)
610 std::cout << NOW << " uwUFetch_NODE (" << addr
611 << ") ::Phy2MacStartRx() ---->NODE is starting "
612 "to receive a "
613 << " BEACON packet from the HN with MAC address: "
614 << src_mac_addr << std::endl;
615
616 rx_BEACON_start_time = NOW;
617
618 } else {
619 // Node is not enabled to receive BEACON
620 if (debug_)
621 std::cout << NOW << " uwUFetch_NODE (" << addr
622 << ") ::Phy2MacStartRx() ---->NODE is not "
623 "enabled to receive a "
624 << "BEACON packet from the HN with MAC address: "
625 << src_mac_addr << ", so wait"
626 << " the end of the reception of the packet and "
627 "after DROP IT"
628 << std::endl;
629 }
630 } else if (cmh->ptype() == PT_POLL_UFETCH) {
631 // POLL section
632 if (debug_)
633 std::cout << NOW << " uwUFetch_NODE (" << addr
634 << ") ::Phy2MacStartRx() ---->NODE is starting to "
635 "receive a "
636 << " POLL packet from the HN with MAC address: "
637 << src_mac_addr << std::endl;
638 if (debugMio_)
639 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
640 << ")::Phy2MacStartRx()_________________Start_"
641 "to_rx_POLL_pck"
642 << "_from HN(" << src_mac_addr << ")."
643 << std::endl;
644
645 rx_POLL_start_time = NOW;
646
647 } else if (cmh->ptype() == PT_CBEACON_UFETCH) {
648 // CBEACON section
649 if (debug_)
650 std::cout << NOW << " uwUFetch_NODE (" << addr
651 << ") ::Phy2MacStartRx() ---->NODE is starting to "
652 "receive a "
653 << " CBEACON packet from the HN with MAC address: "
654 << src_mac_addr << std::endl;
655 if (debugMio_)
656 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
657 << ")::Phy2MacStartRx()_________________Start_"
658 "to_rx_CBEACON_pck"
659 << "_from HN(" << src_mac_addr << ")."
660 << std::endl;
661
662 rx_CBEACON_start_time = NOW;
663
664 } else if (cmh->ptype() == PT_PROBE_UFETCH) {
665 // PROBE section
666 if (debug_)
667 std::cout << NOW << " uwUFetch_NODE (" << addr
668 << ") ::Phy2MacStartRx() ---->NODE is starting to "
669 "receive a "
670 << " PROBE packet from the NODE with MAC address: "
671 << src_mac_addr << std::endl;
672
673 } else if (cmh->ptype() == PT_TRIGGER_UFETCH) {
674 // TRIGGER section
675 if (debug_)
676 std::cout << NOW << " uwUFetch_NODE (" << addr
677 << ") ::Phy2MacStartRx() ---->NODE is starting to "
678 "receive a "
679 << " TRIGGER packet from the AUV with MAC address: "
680 << src_mac_addr << std::endl;
681
682 } else {
683 // DATA section
684 if (debug_)
685 std::cout
686 << NOW << " uwUFetch_NODE (" << addr
687 << ") ::Phy2MacStartRx() ---->NODE is starting to "
688 "receive a "
689 << " DATA packet from the HN or NODE with MAC address: "
690 << src_mac_addr << std::endl;
691 }
692 }
693} // end Phy2MacStartRx();
694
695void
696uwUFetch_NODE::Phy2MacEndRx(Packet *p)
697{
698
699 if (isHeadNode()) {
700 /*********************
701 * I'm the HEAD NODE *
702 *********************/
703 uwUFetch_NODE::Phy2MacEndRx_HN(p);
704
705 } else {
706 /****************************
707 * I'm the SENSOR NODE *
708 *****************************/
709 hdr_cmn *cmh = hdr_cmn::access(p);
710 hdr_mac *mach = HDR_MAC(p);
711 int src_mac_addr = mach->macSA();
712 int dest_mac_addr = mach->macDA(); // Destination MAC address, the
713 // address to which the packet is
714 // addressed
715 hdr_MPhy *ph = HDR_MPHY(p);
716 double gen_time = ph->txtime;
717 double received_time = ph->rxtime;
718 double diff_time = received_time - gen_time;
719 double distance = diff_time * v_speed_sound;
720
721 // Control if the packet that the HN has received is really for him
722 if ((dest_mac_addr == addr) || (dest_mac_addr == MAC_BROADCAST)) {
723 // Packet is addressed to me NODE
724
725 if (cmh->ptype() == PT_BEACON_UFETCH) {
726 // BEACON section
727 if (debugMio_)
728 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
729 << ")::Phy2MacEndRx()___________________"
730 "Finished_to_rx_BEACON"
731 << "_pck_from_HN(" << src_mac_addr << ")"
732 << std::endl;
733
734 if (((cmh->error()) || (!rxBEACONEnabled))) {
735 if ((cmh->error()) && (rxBEACONEnabled)) {
736 // BEACON is corrupted by the channel
737 if (debug_)
738 std::cout << NOW << " uwUFetch_NODE (" << addr
739 << ") ::Phy2MacEndRx() ---->Node is "
740 "enabled to rx BEACON packet, but the "
741 "packet received"
742 << " is corrupted: DROP IT and return in "
743 "IDLE STATE."
744 << std::endl;
745
746 if (debugMio_)
747 out_file_logging
748 << NOW << "uwUFetch_SENSOR_NODE(" << addr
749 << ")::Phy2MacEndRx()___________________"
750 "ENABLED_to_rx_BEACON_pck_from_HN("
751 << mach->macSA() << ")_"
752 << "but_pck_It_s_in_ERROR." << std::endl;
753
754 rx_BEACON_finish_time = NOW;
755
756 incrTotalBeaconPckRx_by_NODE();
757 incrTotalBeaconPckRx_corrupted_by_NODE();
758
759 rxBEACONEnabled = true;
760 n_BEACON_pck_rx_by_NODE = 0;
761
762 stateIdle_NODE();
763 } else if ((cmh->error()) && (!rxBEACONEnabled)) {
764 // Node is not enabled to receive BEACON and packet it's
765 // in error
766
767 if (debug_)
768 std::cout << NOW << " uwUFetch_NODE (" << addr
769 << ") ::Phy2MacEndRx() ---->NODE has "
770 "finished to receive a "
771 << "BEACON packet from the HN with MAC "
772 "address: "
773 << src_mac_addr << " and it's not enabled"
774 << " to receive It, so DROP IT."
775 << std::endl;
776 if (debugMio_)
777 out_file_logging
778 << NOW << "uwUFetch_SENSOR_NODE(" << addr
779 << ")::Phy2MacEndRx()___________________"
780 "NOT_ENABLED_to_rx_BEACON_pck_from_HN("
781 << mach->macSA() << ")"
782 << "_and_pck_It_s_in_ERROR." << std::endl;
783
789 incrTotalBeaconPckRx_by_NODE();
790 incrTotalBeaconPckRx_corrupted_by_NODE();
791
792 if (mach->macSA() == mac_addr_HN_in_beacon) {
793 if (rxPOLLEnabled) {
794 if (debug_)
795 std::cout << NOW << " uwUFetch_NODE ("
796 << addr
797 << ") ::Phy2MacEndRx() ---->NODE "
798 "has finished to receive a "
799 << "BEACON packet from the HN "
800 "with MAC address: "
801 << src_mac_addr
802 << " and it's not enabled to rx "
803 "It, but SN it's waiting a "
804 "POLL packet"
805 << " from this HN, so return in "
806 "IDLE state and wait a BEACON "
807 "from another node."
808 << std::endl;
809 if (debugMio_)
810 out_file_logging
811 << NOW << "uwUFetch_SENSOR_NODE("
812 << addr << ")::Phy2MacEndRx()______"
813 "_____________SN("
814 << addr
815 << ")_is_waiting_a_POLL_from_HN("
816 << mach->macSA() << ")"
817 << ":return_in_IDLE_STATE."
818 << std::endl;
819
820 if (debugMio_)
821 out_file_logging
822 << NOW << "uwUFetch_SENSOR_NODE("
823 << addr
824 << ")::Phy2MacEndRx()______________"
825 "_____RESET_POLL_timeout."
826 << std::endl;
827
828 rxPOLLEnabled = false;
829 POLL_timer.force_cancel();
830
831 rxBEACONEnabled = true;
832 n_BEACON_pck_rx_by_NODE = 0;
833
834 n_BEACON_pck_rx_by_NODE = 0;
835 n_PROBE_pck_tx_by_NODE = 0;
836 n_POLL_pck_rx_by_NODE = 0;
837 n_DATA_pck_tx_by_NODE = 0;
838 n_CBEACON_pck_rx_by_NODE = 0;
839
840 rxBEACONEnabled = true;
841 txPROBEEnabled = false;
842 rxPOLLEnabled = false;
843 txDATAEnabled = false;
844 rxCBEACONEnabled = false;
845
846 dataAlreadyTransmitted = false;
847 stateIdle_NODE();
848 } else if (rxCBEACONEnabled) {
849 if (debug_)
850 std::cout << NOW << " uwUFetch_NODE ("
851 << addr
852 << ") ::Phy2MacEndRx() ---->NODE "
853 "has finished to receive a "
854 << "BEACON packet from the HN "
855 "with MAC address: "
856 << src_mac_addr
857 << " and it's not enabled to rx "
858 "It, but SN it's waiting a "
859 "CBEACON packet"
860 << " from this HN, so return in "
861 "IDLE state and wait a BEACON "
862 "from another node."
863 << std::endl;
864
865 if (debugMio_)
866 out_file_logging
867 << NOW << "uwUFetch_SENSOR_NODE("
868 << addr << ")::Phy2MacEndRx()______"
869 "_____________SN("
870 << addr << ")_is_waiting_a_CBEACON_"
871 "pck_from_HN("
872 << mach->macSA() << ")_"
873 << ":return_in_IDLE_STATE."
874 << std::endl;
875
876 if (debugMio_)
877 out_file_logging
878 << NOW << "uwUFetch_SENSOR_NODE("
879 << addr
880 << ")::Phy2MacEndRx()______________"
881 "_____RESET_CBEACON_timeout."
882 << std::endl;
883
884 rxPOLLEnabled = false;
885 rxCBEACONEnabled = false;
886 POLL_timer.force_cancel();
887 CBEACON_timer.force_cancel();
888
889 rxBEACONEnabled = true;
890 n_BEACON_pck_rx_by_NODE = 0;
891
892 n_BEACON_pck_rx_by_NODE = 0;
893 n_PROBE_pck_tx_by_NODE = 0;
894 n_POLL_pck_rx_by_NODE = 0;
895 n_DATA_pck_tx_by_NODE = 0;
896 n_CBEACON_pck_rx_by_NODE = 0;
897
898 rxBEACONEnabled = true;
899 txPROBEEnabled = false;
900 rxPOLLEnabled = false;
901 txDATAEnabled = false;
902 rxCBEACONEnabled = false;
903
904 dataAlreadyTransmitted = false;
905 stateIdle_NODE();
906 }
907 }
908 drop(p, 1, UWUFETCH_NODE_DROP_REASON_NOT_ENABLE);
909 } else if (!(cmh->error()) && (!rxBEACONEnabled)) {
910 // Node is not enabled to receive BEACON and Beacon it's
911 // not in error
912 if (debug_)
913 std::cout << NOW << " uwUFetch_NODE (" << addr
914 << ") ::Phy2MacEndRx() ---->NODE has "
915 "finished to receive a "
916 << "BEACON packet from the HN with MAC "
917 "address: "
918 << src_mac_addr << " and it's not enabled"
919 << " to receive It, so DROP IT."
920 << std::endl;
921 if (debugMio_)
922 out_file_logging
923 << NOW << "uwUFetch_SENSOR_NODE(" << addr
924 << ")::Phy2MacEndRx()___________________"
925 "NOT_ENABLED_to_rx_BEACON_pck_from_HN("
926 << mach->macSA() << ")_"
927 << "_and_BEACON_It_s_CORRECT:IGNORE_IT."
928 << std::endl;
929
930 incrTotalBeaconPckRx_by_NODE();
931
932 if (mach->macSA() == mac_addr_HN_in_beacon) {
933 if (rxPOLLEnabled) {
934 if (debug_)
935 std::cout << NOW << " uwUFetch_NODE ("
936 << addr
937 << ") ::Phy2MacEndRx() ---->NODE "
938 "has finished to receive a "
939 << "BEACON packet from the HN "
940 "with MAC address: "
941 << src_mac_addr
942 << " and it's not enabled to rx "
943 "It, but SN it's waiting a "
944 "POLL packet"
945 << " from this HN, so return in "
946 "IDLE state and wait a BEACON "
947 "from another node."
948 << std::endl;
949
950 if (debugMio_)
951 out_file_logging
952 << NOW << "uwUFetch_SENSOR_NODE("
953 << addr << ")::Phy2MacEndRx()______"
954 "_____________SN("
955 << addr << ")_is_waiting_a_POLL_"
956 "pck_from_HN("
957 << mach->macSA() << ")_"
958 << ":return_in_IDLE_STATE."
959 << std::endl;
960 if (debugMio_)
961 out_file_logging
962 << NOW << "uwUFetch_SENSOR_NODE("
963 << addr
964 << ")::Phy2MacEndRx()______________"
965 "_____RESET_POLL_timeout."
966 << std::endl;
967
968 rxPOLLEnabled = false;
969 POLL_timer.force_cancel();
970
971 rxBEACONEnabled = true;
972 n_BEACON_pck_rx_by_NODE = 0;
973
974 n_BEACON_pck_rx_by_NODE = 0;
975 n_PROBE_pck_tx_by_NODE = 0;
976 n_POLL_pck_rx_by_NODE = 0;
977 n_DATA_pck_tx_by_NODE = 0;
978 n_CBEACON_pck_rx_by_NODE = 0;
979
980 rxBEACONEnabled = true;
981 txPROBEEnabled = false;
982 rxPOLLEnabled = false;
983 txDATAEnabled = false;
984 rxCBEACONEnabled = false;
985
986 dataAlreadyTransmitted = false;
987 stateIdle_NODE();
988 } else if (rxCBEACONEnabled) {
989
990 if (debug_)
991 std::cout << NOW << " uwUFetch_NODE ("
992 << addr
993 << ") ::Phy2MacEndRx() ---->NODE "
994 "has finished to receive a "
995 << "BEACON packet from the HN "
996 "with MAC address: "
997 << src_mac_addr
998 << " and it's not enabled to rx "
999 "It, but SN it's waiting a "
1000 "CBEACON packet"
1001 << " from this HN, so return in "
1002 "IDLE state and wait a BEACON "
1003 "from another node."
1004 << std::endl;
1005 if (debugMio_)
1006 out_file_logging
1007 << NOW << "uwUFetch_SENSOR_NODE("
1008 << addr << ")::Phy2MacEndRx()______"
1009 "_____________SN("
1010 << addr << ")_is_waiting_a_CBEACON_"
1011 "pck_from_HN("
1012 << mach->macSA() << ")"
1013 << ":return in IDLE STATE."
1014 << std::endl;
1015 if (debugMio_)
1016 out_file_logging
1017 << NOW << "uwUFetch_SENSOR_NODE("
1018 << addr
1019 << ")::Phy2MacEndRx()______________"
1020 "_____RESET_CBEACON_timeout."
1021 << std::endl;
1022
1023 rxPOLLEnabled = false;
1024 POLL_timer.force_cancel();
1025
1026 rxCBEACONEnabled = false;
1027 CBEACON_timer.force_cancel();
1028
1029 rxBEACONEnabled = true;
1030 n_BEACON_pck_rx_by_NODE = 0;
1031
1032 n_BEACON_pck_rx_by_NODE = 0;
1033 n_PROBE_pck_tx_by_NODE = 0;
1034 n_POLL_pck_rx_by_NODE = 0;
1035 n_DATA_pck_tx_by_NODE = 0;
1036 n_CBEACON_pck_rx_by_NODE = 0;
1037
1038 rxBEACONEnabled = true;
1039 txPROBEEnabled = false;
1040 rxPOLLEnabled = false;
1041 txDATAEnabled = false;
1042 rxCBEACONEnabled = false;
1043
1044 dataAlreadyTransmitted = false;
1045 stateIdle_NODE();
1046 }
1047 }
1048 drop(p, 1, UWUFETCH_NODE_DROP_REASON_NOT_ENABLE);
1049 }
1050 } else {
1051 // Node is enabled to receive BEACON
1052 if (debug_)
1053 std::cout << NOW << " uwUFetch_NODE (" << addr
1054 << ") ::Phy2MacEndRx() ---->NODE has "
1055 "finished to receive a "
1056 << "BEACON packet from the HN with MAC "
1057 "address: "
1058 << src_mac_addr << " and it's enabled"
1059 << " to receive It." << std::endl;
1060 rxBEACONEnabled = false;
1061
1062 if (debug_)
1063 std::cout << NOW << " uwUFetch_NODE( " << addr
1064 << ") ::Phy2MacEndRx() ---->BEACON packet "
1065 "received by the NODE"
1066 << " is CORRECT, so COMPUTE IT" << std::endl;
1067
1068 rx_BEACON_finish_time = NOW;
1069
1070 if (debugMio_)
1071 out_file_logging << NOW << "uwUFetch_SENSOR_NODE("
1072 << addr
1073 << ")::Phy2MacEndRx()_________________"
1074 "__BEACON_rx_from_HN("
1075 << mach->macSA() << ")_:It_s_CORRECT."
1076 << std::endl;
1077
1078 incrBeaconPckRx_by_NODE();
1079 incrTotalBeaconPckRx_by_NODE();
1080
1081 curr_BEACON_NODE_pck_rx = p->copy();
1082
1083 Packet::free(p);
1084 refreshReason(UWUFETCH_NODE_STATUS_CHANGE_BEACON_RX);
1085
1086 BEACON_rx();
1087 }
1088 } else if (cmh->ptype() == PT_POLL_UFETCH) {
1089 // POLL section
1090 if (debug_)
1091 std::cout << NOW << " uwUFetch_NODE (" << addr
1092 << ") ::Phy2MacEndRx() ---->NODE has finished to "
1093 "receive a"
1094 << " POLL packet from the HN with MAC address: "
1095 << src_mac_addr << std::endl;
1096
1097 if (debugMio_)
1098 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
1099 << ")::Phy2MacEndRx()___________________"
1100 "Finished_to_rx_POLL_pck"
1101 << "_from_HN(" << src_mac_addr << ")."
1102 << std::endl;
1103
1104 if ((src_mac_addr == mac_addr_HN_in_beacon)) {
1105 if (cmh->error()) {
1106 // POLL is corrupted
1107 if (debug_)
1108 std::cout << NOW << " uwUFetch_NODE( " << addr
1109 << ") ::Phy2MacEndRx() ---->POLL packet "
1110 "received by the NODE"
1111 << " is corrupted: DROP IT." << std::endl;
1112 if (debugMio_)
1113 out_file_logging
1114 << NOW << "uwUFetch_SENSOR_NODE(" << addr
1115 << ")::Phy2MacEndRx()___________________"
1116 "POLL_pck_rx_from_HN("
1117 << src_mac_addr << ")_It_s_in_ERROR."
1118 << std::endl;
1119
1120 rx_POLL_finish_time = NOW;
1121
1122 incrTotalPollPckRx_by_NODE();
1123 incrTotalPollPckRx_corrupted_by_NODE(); // increment the
1124 // number of
1125 // packets in
1126 // error
1127
1128 drop(p, 1, UWFETCH_NODE_DROP_REASON_ERROR); // drop the
1129 // packet
1130 refreshReason(UWFETCH_NODE_STATUS_CHANGE_PACKET_ERROR);
1131
1132 n_PROBE_pck_tx_by_NODE = 0;
1133 n_POLL_pck_rx_by_NODE = 0;
1134 n_DATA_pck_tx_by_NODE = 0;
1135
1136 rxPOLLEnabled = false;
1137 dataAlreadyTransmitted = false;
1138
1139 } else {
1140 // POLL is not corrupted
1141 if (debug_)
1142 std::cout << NOW << " uwUFetch_NODE (" << addr
1143 << ") ::Phy2MacEndRx() ---->POLL packet "
1144 "received by the NODE"
1145 << " is CORRECT." << std::endl;
1146
1147 if (debugMio_)
1148 out_file_logging
1149 << NOW << "uwUFetch_SENSOR_NODE(" << addr
1150 << ")::Phy2MacEndRx()___________________"
1151 "POLL_pck_rx_from_HN("
1152 << src_mac_addr << ")_It_s_CORRECT."
1153 << std::endl;
1154
1155 rx_POLL_finish_time = NOW;
1156
1157 if (debug_)
1158 std::cout << NOW << " uwUFetch_NODE (" << addr
1159 << ") ::Phy2MacEndRx() ---->POLL timer "
1160 "is resetted."
1161 << std::endl;
1162 POLL_timer.force_cancel();
1163
1164 incrPollPckRx_by_NODE();
1165 incrTotalPollPckRx_by_NODE();
1166
1167 curr_POLL_NODE_pck_rx = p->copy();
1168
1169 Packet::free(p);
1170 refreshReason(UWUFETCH_NODE_STATUS_CHANGE_BEACON_RX);
1171
1172 POLL_rx();
1173 }
1174 } else {
1175 if (debug_)
1176 std::cout << NOW << " uwUFetch_NODE (" << addr
1177 << ") ::Phy2MacEndRx() ---->NODE has "
1178 "received a POLL packet"
1179 << " from the HN from which it's not waiting "
1180 "a POLL, so DROP IT."
1181 << std::endl;
1182 if (debugMio_)
1183 out_file_logging
1184 << NOW << "uwUFetch_SENSOR_NODE(" << addr
1185 << ")::Phy2MacEndRx()___________________POLL_"
1186 "pck_rx_from_HN("
1187 << src_mac_addr
1188 << ")_It_s_not_addressed_to_me:_DROP_IT."
1189 << std::endl;
1190
1191 drop(p,
1192 1,
1193 UWFETCH_NODE_DROP_REASON_ERROR); // drop the packet
1194 refreshReason(UWFETCH_NODE_STATUS_CHANGE_PACKET_ERROR);
1195 }
1196 } else if (cmh->ptype() == PT_CBEACON_UFETCH) {
1197 // CBEACON section
1198 if (debug_)
1199 std::cout
1200 << NOW << " uwUFetch_NODE (" << addr
1201 << ") ::Phy2MacEndRx() ---->NODE has finished to "
1202 "receive a"
1203 << " CBEACON packet from the HN with MAC address: "
1204 << src_mac_addr << std::endl;
1205
1206 if (debugMio_)
1207 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
1208 << ")::Phy2MacEndRx()___________________"
1209 "NODE_has_finished_to_rx_CBEACON_packet"
1210 << "_from HN(" << src_mac_addr << ")."
1211 << std::endl;
1212
1213 mac_addr_HN_in_cbeacon = mach->macSA();
1214
1215 if (mac_addr_HN_in_cbeacon == mac_addr_HN_in_beacon) {
1216 // CBEACON is received from the HN from which I have
1217 // received the BEACON
1218 if (debug_)
1219 std::cout << NOW << " uwUFetch_NODE (" << addr
1220 << ") ::Phy2MacEndRx() ---->CBEACON rx from "
1221 "the correct HN"
1222 << std::endl;
1223 if (debugMio_)
1224 out_file_logging << NOW << "uwUFetch_SENSOR_NODE("
1225 << addr
1226 << ")::Phy2MacEndRx()_________________"
1227 "__CBEACON_rx_from_the_correct_HN("
1228 << src_mac_addr << ")." << std::endl;
1229
1230 incrTotalCBeaconPckRx_by_NODE(); // increment the total
1231 // number of CBEACON
1232 // packets received.
1233 CBEACON_timer.force_cancel();
1234 if (cmh->error()) {
1235 // The CBEACON is corrupted
1236 if (debug_)
1237 std::cout << NOW << " uwUFetch_NODE (" << addr
1238 << ") ::Phy2MacEndRx() ---->CBEACON "
1239 "received by the NODE"
1240 << " is corrupted: DROP IT." << std::endl;
1241 if (debugMio_)
1242 out_file_logging
1243 << NOW << "uwUFetch_SENSOR_NODE(" << addr
1244 << ")::Phy2MacEndRx()___________________"
1245 "CBEACON_rx_from_HN("
1246 << mach->macSA() << ")_It_s_in_ERROR."
1247 << std::endl;
1248
1249 incrCBeaconPckRx_by_NODE();
1250 incrTotalCBeaconPckRx_corrupted_by_NODE();
1251
1252 if (debug_)
1253 std::cout << NOW << " uwUFetch_NODE (" << addr
1254 << ") ::Phy2MacEndRx() ---->CBEACON "
1255 "reset the timer"
1256 << std::endl;
1257 CBEACON_timer.force_cancel();
1258
1259 if (getCBeaconPckRx_by_NODE() == num_cbeacon_node_rx) {
1260 // Node has received the maximum number of CBEACON
1261 if (debug_)
1262 std::cout << NOW << " uwUFetch_NODE (" << addr
1263 << ") ::Phy2MacEndRx() ---->NODE has "
1264 "received the maximum"
1265 << " number of CBEACON packet from "
1266 "the HN with MAC address: "
1267 << mac_addr_HN_in_beacon << ", so"
1268 << " return in IDLE STATE."
1269 << std::endl;
1270 if (debugMio_)
1271 out_file_logging
1272 << NOW << "uwUFetch_SENSOR_NODE("
1273 << addr
1274 << ")::Phy2MacEndRx()__________________"
1275 "_MAX_number_of_CBEACON_received."
1276 << std::endl;
1277
1278 n_BEACON_pck_rx_by_NODE = 0;
1279 n_PROBE_pck_tx_by_NODE = 0;
1280 n_POLL_pck_rx_by_NODE = 0;
1281 n_DATA_pck_tx_by_NODE = 0;
1282 n_CBEACON_pck_rx_by_NODE = 0;
1283
1284 rxBEACONEnabled = true;
1285 txPROBEEnabled = false;
1286 rxPOLLEnabled = false;
1287 txDATAEnabled = false;
1288 rxCBEACONEnabled = false;
1289 POLL_timer.force_cancel();
1290
1291 dataAlreadyTransmitted = false;
1292 stateIdle_NODE();
1293 } else {
1294 // Node can receive another CBEACON packet
1295 if (debug_)
1296 std::cout << NOW << " uwUFetch_NODE (" << addr
1297 << ") ::Phy2MacEndRx() ---->NODE has "
1298 "not received the maximum"
1299 << " number of CBEACON packet from "
1300 "the HN with MAC address: "
1301 << mac_addr_HN_in_beacon << ", so"
1302 << " wait other CBEACON packets."
1303 << std::endl;
1304 if (debugMio_)
1305 out_file_logging
1306 << NOW << "uwUFetch_SENSOR_NODE("
1307 << addr
1308 << ")::Phy2MacEndRx()__________________"
1309 "_Other_CBEACON_can_be_rx."
1310 << std::endl;
1311
1312 n_PROBE_pck_tx_by_NODE = 0;
1313 n_POLL_pck_rx_by_NODE = 0;
1314 rxPOLLEnabled = false;
1315 POLL_timer.force_cancel();
1316 CBEACON_timer.force_cancel();
1317
1318 state_wait_CBEACON();
1319 }
1320 } else {
1321 // The CBEACON is not corrupted
1322 if (debug_)
1323 std::cout << NOW << " uwUFetch_NODE (" << addr
1324 << ") ::Phy2MacEndRx() ---->CBEACON "
1325 "packet received by the NODE"
1326 << " is CORRECT." << std::endl;
1327 if (debug_)
1328 std::cout << NOW << " uwUFetch_NODE (" << addr
1329 << ") ::Phy2MacEndRx() ---->CBEACON "
1330 "received is the number: "
1331 << getCBeaconPckRx_by_NODE() + 1
1332 << std::endl;
1333 if (debugMio_)
1334 out_file_logging
1335 << NOW << "uwUFetch_SENSOR_NODE(" << addr
1336 << ")::Phy2MacEndRx()___________________"
1337 "CBECON_rx_from_HN("
1338 << mach->macSA() << ")_It_s_CORRECT."
1339 << std::endl;
1340
1341 curr_CBEACON_NODE_pck_rx = p->copy();
1342
1343 Packet::free(p);
1344 refreshReason(UWUFETCH_NODE_STATUS_CHANGE_BEACON_RX);
1345
1346 CBEACON_rx();
1347 }
1348 } else {
1349 // CBEACON is received from the HN from which I don't never
1350 // received the BEACON
1351 if (debug_)
1352 std::cout << NOW << " uwUFetch_NODE (" << addr
1353 << ") ::Phy2MacEndRx() ---->CBEACON packet "
1354 "received by the NODE"
1355 << " is received from the HN from which I "
1356 "never received the BEACON: IGNORE IT"
1357 << std::endl;
1358 if (debugMio_)
1359 out_file_logging
1360 << NOW << "uwUFetch_SENSOR_NODE(" << addr
1361 << ")::Phy2MacEndRx()___________________"
1362 "CBEACON_rx_It_s_not_for_me_SENSOR_NODE."
1363 << std::endl;
1364
1365 incrTotalCBeaconPckRx_by_NODE(); // increment the number of
1366 // packets in error
1367 }
1368 } else if (cmh->ptype() == PT_PROBE_UFETCH) {
1369 // PROBE section
1370 if (debug_)
1371 std::cout
1372 << NOW << " uwUFetch_NODE (" << addr
1373 << ") ::Phy2MacEndRx() ---->NODE has finished to "
1374 "receive a"
1375 << " PROBE packet from the NODE with MAC address: "
1376 << src_mac_addr << ". DROP IT" << std::endl;
1377
1378 drop(p, 1, UWUFETCH_NODE_DROP_CAN_NOT_RX_THIS_PCK);
1379
1380 } else if (cmh->ptype() == PT_TRIGGER_UFETCH) {
1381 // TRIGGER section
1382 if (debug_)
1383 std::cout
1384 << NOW << " uwUFetch_NODE (" << addr
1385 << ") ::Phy2MacEndRx() ---->NODE has finished to "
1386 "receive a"
1387 << " TRIGGER packet from the AUV with MAC address: "
1388 << src_mac_addr << std::endl;
1389
1390 drop(p, 1, UWUFETCH_NODE_DROP_CAN_NOT_RX_THIS_PCK);
1391 } else {
1392 // DATA section
1393 if (debug_)
1394 std::cout << NOW << " uwUFetch_NODE (" << addr
1395 << ") ::Phy2MacEndRx() ---->NODE has finished to "
1396 "receive a"
1397 << " DATA packet from the HN or NODE with MAC "
1398 "address: "
1399 << src_mac_addr << " .DROP IT" << std::endl;
1400
1401 if (mach->macSA() == mac_addr_HN_in_beacon) {
1402 if (rxPOLLEnabled) {
1403 if (debug_)
1404 std::cout
1405 << NOW << " uwUFetch_NODE (" << addr
1406 << ") ::Phy2MacEndRx() ---->NODE has "
1407 "finished to receive a "
1408 << "DATA packet from the HN with MAC "
1409 "address: "
1410 << src_mac_addr
1411 << " and it's not enabled to rx It, but SN "
1412 "it's waiting a POLL packet"
1413 << " from this HN, so return in IDLE state "
1414 "and wait a BEACON from another node."
1415 << std::endl;
1416
1417 if (debugMio_)
1418 out_file_logging
1419 << NOW << "uwUFetch_SENSOR_NODE(" << addr
1420 << ")::Phy2MacEndRx()___________________"
1421 "Received_DATA_from_HN_from_which_"
1422 << "SN(" << addr << ")_is_waiting_a_POLL."
1423 << std::endl;
1424 if (debugMio_)
1425 out_file_logging << NOW << "uwUFetch_SENSOR_NODE("
1426 << addr
1427 << ")::Phy2MacEndRx()_____________"
1428 "______RESET_POLL_timeout_and_"
1429 "return_in_IDLE_STATE."
1430 << std::endl;
1431
1432 rxPOLLEnabled = false;
1433 POLL_timer.force_cancel();
1434
1435 rxBEACONEnabled = true;
1436 n_BEACON_pck_rx_by_NODE = 0;
1437
1438 n_BEACON_pck_rx_by_NODE = 0;
1439 n_PROBE_pck_tx_by_NODE = 0;
1440 n_POLL_pck_rx_by_NODE = 0;
1441 n_DATA_pck_tx_by_NODE = 0;
1442 n_CBEACON_pck_rx_by_NODE = 0;
1443
1444 rxBEACONEnabled = true;
1445 txPROBEEnabled = false;
1446 rxPOLLEnabled = false;
1447 txDATAEnabled = false;
1448 rxCBEACONEnabled = false;
1449
1450 dataAlreadyTransmitted = false;
1451 stateIdle_NODE();
1452
1453 } else if (rxCBEACONEnabled) {
1454
1455 if (debug_)
1456 std::cout
1457 << NOW << " uwUFetch_NODE (" << addr
1458 << ") ::Phy2MacEndRx() ---->NODE has "
1459 "finished to receive a "
1460 << "DATA packet from the HN with MAC "
1461 "address: "
1462 << src_mac_addr
1463 << " and it's not enabled to rx It, but SN "
1464 "it's waiting a CBEACON packet"
1465 << " from this HN, so return in IDLE state "
1466 "and wait a BEACON from another node."
1467 << std::endl;
1468 if (debugMio_)
1469 out_file_logging
1470 << NOW << "uwUFetch_SENSOR_NODE(" << addr
1471 << ")::Phy2MacEndRx()___________________"
1472 "Received_DATA_from_HN_from_which_"
1473 << "SN(" << addr
1474 << ")_is_waiting_a_CBEACON." << std::endl;
1475 if (debugMio_)
1476 out_file_logging << NOW << "uwUFetch_SENSOR_NODE("
1477 << addr
1478 << ")::Phy2MacEndRx()_____________"
1479 "______RESET_CBEACON_timeout_"
1480 "and_return_in_IDLE_STATE."
1481 << std::endl;
1482
1483 rxPOLLEnabled = false;
1484 POLL_timer.force_cancel();
1485
1486 rxCBEACONEnabled = false;
1487 CBEACON_timer.force_cancel();
1488
1489 rxBEACONEnabled = true;
1490 n_BEACON_pck_rx_by_NODE = 0;
1491
1492 n_BEACON_pck_rx_by_NODE = 0;
1493 n_PROBE_pck_tx_by_NODE = 0;
1494 n_POLL_pck_rx_by_NODE = 0;
1495 n_DATA_pck_tx_by_NODE = 0;
1496 n_CBEACON_pck_rx_by_NODE = 0;
1497
1498 rxBEACONEnabled = true;
1499 txPROBEEnabled = false;
1500 rxPOLLEnabled = false;
1501 txDATAEnabled = false;
1502 rxCBEACONEnabled = false;
1503
1504 dataAlreadyTransmitted = false;
1505 stateIdle_NODE();
1506 }
1507 }
1508 drop(p, 1, UWUFETCH_NODE_DROP_CAN_NOT_RX_THIS_PCK);
1509 }
1510 } else {
1511 // Packet not addressed to the exactly sensor node
1512 if (cmh->ptype() == PT_TRIGGER_UFETCH) {
1513
1514 drop(p, 1, UWUFETCH_NODE_DROP_CAN_NOT_RX_THIS_PCK);
1515
1516 } else if (cmh->ptype() == PT_PROBE_UFETCH) {
1517
1518 drop(p, 1, UWUFETCH_NODE_DROP_CAN_NOT_RX_THIS_PCK);
1519
1520 } else if (cmh->ptype() == PT_POLL_UFETCH) {
1521 if (debugMio_)
1522 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
1523 << ")::Phy2MacEndRx()___________________"
1524 "Finished_to_rx_POLL"
1525 << "_pck_from_HN(" << src_mac_addr << ")"
1526 << std::endl;
1527 if ((cmh->ptype() == PT_POLL_UFETCH) &&
1528 (src_mac_addr == mac_addr_HN_in_beacon) &&
1529 (getProbePckTx_by_NODE() >= 1)) {
1530 if (debug_)
1531 std::cout << NOW << " uwUFetch_NODE (" << addr
1532 << ") ::Phy2MacEndRx() ---->NODE has "
1533 "received a POLL packet"
1534 << " from the HN from which it waiting a "
1535 "POLL, but it's not my turn, so reset the "
1536 "POLL timer and"
1537 << " restart to waiting a POLL." << std::endl;
1538 if (debugMio_)
1539 out_file_logging
1540 << NOW << "uwUFetch_SENSOR_NODE(" << addr
1541 << ")::Phy2MacEndRx()___________________SN("
1542 << addr << ")_is_waiting_a_POLL_from"
1543 << "_HN(" << src_mac_addr
1544 << ")_but_It_s_NOT_ITS_TURN." << std::endl;
1545 if (debugMio_)
1546 out_file_logging << NOW << "uwUFetch_SENSOR_NODE("
1547 << addr
1548 << ")::Phy2MacEndRx()_________________"
1549 "__RESET_and_RESTART_POLL_timeout."
1550 << std::endl;
1551
1552 // POLL_timer.force_cancel();
1553 hdr_mac *mach = HDR_MAC(p);
1554 hdr_POLL_UFETCH *pollh = HDR_POLL_UFETCH(p);
1555
1559 num_pck_to_tx_by_NODE =
1560 pollh->num_DATA_pcks_MAX_rx(); // Number of DATA
1561 // packets that the
1562 // node will transmit
1563 // to the HN
1564 double poll_waiting_time =
1565 num_pck_to_tx_by_NODE * (T_GUARD) + T_POLL;
1566 if (debug_)
1567 std::cout << NOW << " uwUFetch_NODE (" << addr
1568 << ") ::Phy2MacEndRx() ---->The new waiting "
1569 "time is:"
1570 << poll_waiting_time << std::endl;
1571 if (debugMio_)
1572 out_file_logging
1573 << NOW << "uwUFetch_SENSOR_NODE(" << addr
1574 << ")::Phy2MacEndRx()___________________POLL_"
1575 "waiting_time_is:_"
1576 << poll_waiting_time << "_[s]." << std::endl;
1577
1578 drop(p, 1, UWFETCH_NODE_DROP_REASON_WRONG_RECEIVER);
1579
1580 POLL_timer.schedule(poll_waiting_time);
1581
1582 } else {
1583 // Packet is not addressed to me NODE
1584 if (debug_)
1585 std::cout << NOW << " uwUFetch_NODE (" << addr
1586 << ") ::Phy2MacEndRx() ---->The packet "
1587 "received is not for me NODE:"
1588 << " DROP IT." << std::endl;
1589
1590 drop(p, 1, UWFETCH_NODE_DROP_REASON_WRONG_RECEIVER);
1591 refreshReason(
1592 UWFETCH_NODE_STATUS_CHANGE_PACKET_FOR_ANOTHER_NODE);
1593 }
1594 } else {
1595
1596 drop(p, 1, UWFETCH_NODE_DROP_REASON_WRONG_RECEIVER);
1597 }
1598 }
1599 }
1600} // end Phy2MacEndRx();
1601
1602void
1603uwUFetch_NODE::Mac2PhyStartTx(Packet *p)
1604{
1605
1606 if (isHeadNode()) {
1607 /*********************
1608 * I'm the HEAD NODE *
1609 *********************/
1610 uwUFetch_NODE::Mac2PhyStartTx_HN(p);
1611 } else {
1612 /****************************
1613 * I'm the SENSOR NODE *
1614 ****************************/
1615 hdr_cmn *cmh = hdr_cmn::access(p);
1616 hdr_mac *mach = HDR_MAC(p);
1617
1618 if (cmh->ptype() == PT_PROBE_UFETCH) {
1619 // PROBE section
1620 if (debug_)
1621 std::cout << NOW << " uwUFetch_NODE (" << addr
1622 << ") ::Mac2PhyStartTx() ---->MAC layer of the NODE "
1623 "passes the PROBE"
1624 << " packet to its physical layer." << std::endl;
1625 if (debugMio_)
1626 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
1627 << ")::Mac2PhyStartTx()_________________Start_"
1628 "tx_PROBE_pck"
1629 << "_to_the_HN(" << mac_addr_HN_in_beacon
1630 << ")." << std::endl;
1631
1632 tx_PROBE_start_time = NOW;
1633
1634 MMac::Mac2PhyStartTx(p);
1635 } else {
1636 // DATA section
1637
1638 if (debug_)
1639 std::cout << NOW << " uwUFetch_NODE (" << addr
1640 << ") ::Mac2PhyStartTx() ---->MAC layer of the NODE "
1641 "passes the DATA"
1642 << " packet to its physical layer." << std::endl;
1643
1644 if (debugMio_)
1645 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
1646 << ")::Mac2PhyStartTx()_________________Start_"
1647 "tx_DATA_pck_"
1648 << "to_the_HN(" << mach->macDA() << ")."
1649 << std::endl;
1650
1651 tx_DATA_start_time = NOW;
1652
1653 Tdata_NODE_pck = Mac2PhyTxDuration(p);
1654 Tdata_NODE_pck = TIME_BETWEEN_2_TX_DATA_NODE_HN;
1655
1656 MMac::Mac2PhyStartTx(p);
1657 }
1658 }
1659} // end Mac2PhyStartTx();
1660
1661void
1662uwUFetch_NODE::Phy2MacEndTx(const Packet *p)
1663{
1664 if (isHeadNode()) {
1665 /*********************
1666 * I'm the HEAD NODE *
1667 *********************/
1668 uwUFetch_NODE::Phy2MacEndTx_HN(p);
1669
1670 } else {
1671 /****************************
1672 * I'm the SENSOR NODE *
1673 ****************************/
1674 hdr_cmn *cmh = hdr_cmn::access(p);
1675
1676 if (cmh->ptype() == PT_PROBE_UFETCH) {
1677 // PROBE section
1678 if (debug_)
1679 std::cout << NOW << " uwUFetch_NODE (" << addr
1680 << ") ::Phy2MacEndTx() ---->Physical layer of the "
1681 "NODE has finished"
1682 << " to transmit a PROBE packet to the HN with MAC "
1683 "address: "
1684 << mac_addr_HN_in_beacon << std::endl;
1685 if (debugMio_)
1686 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
1687 << ")::Phy2MacEndTx()___________________"
1688 "Finished_to_tx_PROBE_pck"
1689 << "_to_the_HN(" << mac_addr_HN_in_beacon
1690 << ")." << std::endl;
1691
1692 tx_PROBE_finish_time = NOW;
1693
1694 incrProbePckTx_by_NODE();
1695 incrTotalProbePckTx_by_NODE();
1696
1697 txPROBEEnabled = false;
1698
1699 state_wait_POLL();
1700
1701 } else {
1702 // DATA section
1703 if (debug_)
1704 std::cout << NOW << " uwUFetch_NODE (" << addr
1705 << ") ::Phy2MacEndTx() ---->Physical layer of the "
1706 "NODE has finished"
1707 << " to transmit a DATA packet to the HN with MAC "
1708 "address: "
1709 << mac_addr_HN_in_poll << std::endl;
1710
1711 tx_DATA_finish_time = NOW;
1712
1713 incrDataPckTx_by_NODE();
1714 incrTotalDataPckTx_by_NODE();
1715
1716 if (debugMio_)
1717 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
1718 << ")::Phy2MacEndTx()___________________"
1719 "Finished_to_tx_DATA_pck"
1720 << "_to_the_HN(" << mac_addr_HN_in_beacon
1721 << ")." << std::endl;
1722
1723 dataAlreadyTransmitted = true;
1724 rxBEACONEnabled = false;
1725 if (getDataPckTx_by_NODE() < (num_pck_to_tx_by_NODE)) {
1726 DATA_BEFORE_TX_timer.schedule(Tdata_NODE_pck);
1727 } else {
1728 state_DATA_NODE_finish_tx();
1729 }
1730 }
1731 }
1732} // end Phy2MacEndTx();
1733
1734/******************************************************************************
1735 * SENSOR NODE *
1736 ******************************************************************************/
1737void
1738uwUFetch_NODE::stateIdle_NODE()
1739{
1740 if (debug_)
1741 std::cout << NOW << " uwUFetch_NODE (" << addr
1742 << ") ::stateIdle_NODE() ---->NODE is in IDLE STATE"
1743 << std::endl;
1744
1745 if (debugMio_)
1746 out_file_logging
1747 << NOW << "uwUFetch_SENSOR_NODE(" << addr
1748 << ")::stateIdle_NODE()_________________NODE_is_IDLE_STATE."
1749 << std::endl;
1750
1751 refreshState(UWUFETCH_NODE_STATUS_IDLE);
1752 if (print_transitions)
1753 printStateInfo();
1754
1755 rxBEACONEnabled = true;
1756
1757 if (debug_)
1758 std::cout << NOW << " uwUFetch_NODE (" << addr
1759 << ") ::stateIdle_NODE() ---->NODE is waiting a BEACON packet"
1760 << " from an HN." << std::endl;
1761 if (debugMio_)
1762 out_file_logging
1763 << NOW << "uwUFetch_SENSOR_NODE(" << addr
1764 << ")::stateIdle_NODE()_________________....Waiting_BEACON_pck."
1765 << std::endl;
1766 if (debugMio_)
1767 out_file_logging
1768 << NOW << "uwUFetch_SENSOR_NODE(" << addr
1769 << ")::stateIdle_NODE()_________________....Waiting_BEACON_pck."
1770 << std::endl;
1771 if (debugMio_)
1772 out_file_logging
1773 << NOW << "uwUFetch_SENSOR_NODE(" << addr
1774 << ")::stateIdle_NODE()_________________....Waiting_BEACON_pck."
1775 << std::endl;
1776
1777} // end stateIdle_NODE();
1778
1779void
1780uwUFetch_NODE::BEACON_rx()
1781{
1782
1783 refreshState(UWUFETCH_NODE_STATUS_BEACON_RECEIVE);
1784 if (print_transitions)
1785 printStateInfo();
1786
1787 hdr_mac *mach = HDR_MAC(curr_BEACON_NODE_pck_rx);
1788 hdr_BEACON_UFETCH *beaconh = HDR_BEACON_UFETCH(curr_BEACON_NODE_pck_rx);
1789
1790 /*
1791 * Save the header data of the beacon
1792 */
1793 T_min_bck_probe_node = (double) beaconh->t_min_bc() / 1000;
1794 T_max_bck_probe_node = (double) beaconh->t_max_bc() / 1000;
1795 num_cbeacon_node_rx =
1796 beaconh->num_Max_CBEACON_tx_by_HN(); // Number of CBEACON that the
1797 // SENSOR NODE will be received
1798 // from the HN from which it
1799 // has
1800 // received the BEACON
1801 if (debug_)
1802 std::cout << NOW << " uwUFetch_NODE (" << addr
1803 << ") ::BEACON_rx() ---->NUMERO DI CBEACON: "
1804 << num_cbeacon_node_rx << std::endl;
1805
1806 mac_addr_HN_in_beacon = mach->macSA(); // Mac address from which the node
1807 // has received a BEACON
1808
1809 if (debugMio_)
1810 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
1811 << ")::BEACON_rx()______________________PARAMETERS_of_"
1812 "BEACON_PACKET:"
1813 << std::endl;
1814 if (debugMio_)
1815 out_file_logging
1816 << NOW << "uwUFetch_SENSOR_NODE(" << addr
1817 << ")::BEACON_rx()______________________Source_address:_"
1818 << mach->macSA() << "." << std::endl;
1819 if (mach->macDA() == -1) {
1820 if (debugMio_)
1821 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
1822 << ")::BEACON_rx()______________________"
1823 "Destination_address:_BROADCAST."
1824 << std::endl;
1825 } else {
1826 if (debugMio_)
1827 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
1828 << ")::BEACON_rx()______________________"
1829 "Destination_address:_"
1830 << mach->macDA() << "." << std::endl;
1831 }
1832 if (debugMio_)
1833 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
1834 << ")::BEACON_rx()______________________MIN_backoff_"
1835 "time_PROBE_pck:_"
1836 << T_min_bck_probe_node << "[s]." << std::endl;
1837 if (debugMio_)
1838 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
1839 << ")::BEACON_rx()______________________MAX_backoff_"
1840 "time_PROBE_pck:_"
1841 << T_max_bck_probe_node << "[s]." << std::endl;
1842 if (debugMio_)
1843 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
1844 << ")::BEACON_rx()______________________MAX_number_of_"
1845 "CBEACON_that_HN_will_tx:_"
1846 << num_cbeacon_node_rx << "." << std::endl;
1847
1848 rxBEACONEnabled = false;
1849
1850 bck_before_tx_probe = choiceBackOffTimer();
1851 if (debugMio_)
1852 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
1853 << ")::BEACON_rx()______________________Backoff_"
1854 "choice_before_tx_PROBE:_"
1855 << bck_before_tx_probe << "[s]." << std::endl;
1856
1857 BCK_timer_probe.schedule(bck_before_tx_probe);
1858
1859} // end BEACON_rx();
1860
1861void
1862uwUFetch_NODE::BCKTOExpired()
1863{
1864 if (isHeadNode()) {
1865 /*********************
1866 * I'm the HEAD NODE *
1867 *********************/
1868 BCKTOExpired_HN();
1869
1870 } else {
1871
1872 if (debug_)
1873 std::cout << NOW << " uwUFetch_NODE (" << addr
1874 << ") ::BCKTOExpired() ---->Back-off timeout is expired:"
1875 << " so the PROBE packet now can be transmitted by the "
1876 "NODE to the HN."
1877 << std::endl;
1878 if (debugMio_)
1879 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
1880 << ")::BCKTOExpired()___________________PROBE_"
1881 "Backoff_expired."
1882 << std::endl;
1883 state_PROBE_tx();
1884 }
1885} // end BCKTOExpired();
1886
1887void
1888uwUFetch_NODE::state_PROBE_tx()
1889{
1890
1891 if (!Q_data.empty()) {
1892 // QUEUE is not empty so transmit the PROBE packet
1893 if (debug_)
1894 std::cout << NOW << " uwUFetch_NODE (" << addr
1895 << ") ::state_PROBE_tx() ---->NODE create a PROBE packet"
1896 << " that will then transmit at the HN with MAC address: "
1897 << mac_addr_HN_in_beacon << std::endl;
1898
1899 refreshState(UWUFETCH_NODE_STATUS_TRANSMIT_PROBE);
1900 if (print_transitions)
1901 printStateInfo();
1902
1903 Packet *p = Packet::alloc();
1904 hdr_cmn *cmh = hdr_cmn::access(p);
1905 hdr_mac *mach = HDR_MAC(p);
1906 hdr_PROBE_UFETCH *probeh = HDR_PROBE_UFETCH(p);
1907
1908 cmh->ptype() = PT_PROBE_UFETCH;
1909 cmh->size() = sizeof(hdr_PROBE_UFETCH);
1910
1911 mach->set(MF_CONTROL, addr, mac_addr_HN_in_beacon);
1912 mach->macSA() = addr;
1913 mach->macDA() = mac_addr_HN_in_beacon;
1914
1915 // Filling the HEADER of the PROBE packet
1916 probeh->backoff_time_PROBE() =
1917 (int) (bck_before_tx_probe * 1000); // Back off value choose by
1918 // the NODE before to
1919 // transmit the PROBE packet
1920 probeh->n_DATA_pcks_Node_tx() =
1921 Q_data.size(); // Maximum quantity of DATA packets that the NODE
1922 // would like to transmit at the HN
1923
1924 if (debugMio_)
1925 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
1926 << ")::state_PROBE_tx()_________________PARAMETER_"
1927 "of_PROBE_pck:"
1928 << std::endl;
1929 if (debugMio_)
1930 out_file_logging
1931 << NOW << "uwUFetch_SENSOR_NODE(" << addr
1932 << ")::state_PROBE_tx()_________________Source_address:_"
1933 << mach->macSA() << "." << std::endl;
1934 if (debugMio_)
1935 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
1936 << ")::state_PROBE_tx()_________________"
1937 "Destination_address:_"
1938 << mach->macDA() << "." << std::endl;
1939 if (debugMio_)
1940 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
1941 << ")::state_PROBE_tx()_________________DATA_pck_"
1942 "would_be_tx:_"
1943 << probeh->n_DATA_pcks_Node_tx() << "[pck]."
1944 << std::endl;
1945 if (debugMio_)
1946 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
1947 << ")::state_PROBE_tx()_________________Backoff_"
1948 "time_choice:_"
1949 << bck_before_tx_probe << "[s]." << std::endl;
1950 if (debugMio_)
1951 out_file_logging
1952 << NOW << "uwUFetch_SENSOR_NODE(" << addr
1953 << ")::state_PROBE_tx()_________________Size_of_PROBE_pck:_"
1954 << cmh->size() << "[byte]." << std::endl;
1955
1956 curr_PROBE_NODE_pck_tx = p->copy();
1957
1958 /*hdr_uwmphy_modem* modemh = HDR_UWMPHY_MODEM(curr_PROBE_NODE_pck_tx);
1959 modemh->use_burst_data() = 0;*/
1960
1961 Packet::free(p);
1962
1963 txPROBEEnabled = true;
1964
1965 PROBE_tx();
1966
1967 } else {
1968 // QUEUE is empty, so the NODE doesn't transmit a PROBE packet to the
1969 // HN.
1970 if (debug_)
1971 std::cout << NOW << " uwUFetch_NODE (" << addr
1972 << ") ::state_PROBE_tx() ----> NODE has no DATA packet "
1973 "to be transmitted"
1974 << " to the HN, then ignore the BEACON received from the "
1975 "HN with MAC address: "
1976 << mac_addr_HN_in_beacon << std::endl;
1977 if (debugMio_)
1978 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
1979 << ")::state_PROBE_tx()_________________0_DATA_to_"
1980 "tx_so_NO_tx_PROBE_pck."
1981 << std::endl;
1982
1983 if (getCBeaconPckRx_by_NODE() == num_cbeacon_node_rx) {
1984 // Node has received the maximum number of CBEACON
1985 if (debug_)
1986 std::cout << NOW << " uwUFetch_NODE (" << addr
1987 << ") ::state_PROBE_tx() ---->NODE has received the "
1988 "maximum"
1989 << " number of CBEACON packet from the HN with MAC "
1990 "address: "
1991 << mac_addr_HN_in_beacon << ", so"
1992 << " return in IDLE STATE." << std::endl;
1993
1994 n_BEACON_pck_rx_by_NODE = 0;
1995 n_PROBE_pck_tx_by_NODE = 0;
1996 n_POLL_pck_rx_by_NODE = 0;
1997 n_DATA_pck_tx_by_NODE = 0;
1998 n_CBEACON_pck_rx_by_NODE = 0;
1999
2000 rxBEACONEnabled = true;
2001 txPROBEEnabled = false;
2002
2003 dataAlreadyTransmitted = false;
2004
2005 stateIdle_NODE();
2006
2007 } else {
2008 // Node can received another CBEACON
2009 txPROBEEnabled = false;
2010 rxCBEACONEnabled = true;
2011
2012 n_PROBE_pck_tx_by_NODE = 0;
2013 n_POLL_pck_rx_by_NODE = 0;
2014 n_DATA_pck_tx_by_NODE = 0;
2015
2016 state_wait_CBEACON();
2017 }
2018 }
2019} // end state_PROBE_tx();
2020
2021void
2022uwUFetch_NODE::PROBE_tx()
2023{
2024 // NODE is enabled to transmit PROBE packet
2025 if (debug_)
2026 std::cout << NOW << " uwUFetch_NODE(" << addr
2027 << ") ::PROBE_tx() ---->NODE is transmitting a PROBE packet "
2028 "to the HN"
2029 << " with MAC address: " << mac_addr_HN_in_beacon
2030 << std::endl;
2031
2032 refreshReason(UWUFETCH_NODE_STATUS_CHANGE_PROBE_TX);
2033
2034 computeTxTime(UWUFETCH_NODE_PACKET_TYPE_PROBE);
2035
2036 Mac2PhyStartTx(curr_PROBE_NODE_pck_tx);
2037
2038} // end PROBE_tx();
2039
2040void
2041uwUFetch_NODE::state_wait_POLL()
2042{
2043
2044 computeTxTime(UWUFETCH_NODE_PACKET_TYPE_DATA);
2045
2046 if (debug_)
2047 std::cout << NOW << " uwUFetch_NODE (" << addr
2048 << ") ::state_wait_POLL() ---->NODE is waiting for a POLL "
2049 "packet from HN"
2050 << " with MAC address: " << mac_addr_HN_in_beacon
2051 << ". The maximum waiting time is: " << T_POLL << std::endl;
2052
2053 if (debugMio_)
2054 out_file_logging
2055 << NOW << "uwUFetch_SENSOR_NODE(" << addr
2056 << ")::state_wait_POLL()________________Waiting_POLL_pck"
2057 << "_from HN(" << mac_addr_HN_in_beacon << ")." << std::endl;
2058
2059 if (debugMio_)
2060 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
2061 << ")::state_wait_POLL()________________Waiting_time:_"
2062 << T_POLL << "[s]." << std::endl;
2063 if (debugMio_)
2064 out_file_logging
2065 << NOW << "uwUFetch_SENSOR_NODE(" << addr
2066 << ")::state_wait_POLL()________________....Waiting_POLL."
2067 << std::endl;
2068 if (debugMio_)
2069 out_file_logging
2070 << NOW << "uwUFetch_SENSOR_NODE(" << addr
2071 << ")::state_wait_POLL()________________....Waiting_POLL."
2072 << std::endl;
2073 if (debugMio_)
2074 out_file_logging
2075 << NOW << "uwUFetch_SENSOR_NODE(" << addr
2076 << ")::state_wait_POLL()________________....Waiting_POLL."
2077 << std::endl;
2078
2079 refreshState(UWUFETCH_NODE_STATUS_WAIT_POLL_PACKET);
2080 if (print_transitions)
2081 printStateInfo();
2082
2083 rxPOLLEnabled = true;
2084
2085 POLL_timer.schedule(T_POLL);
2086
2087} // end state_wait_POLL();
2088
2089void
2090uwUFetch_NODE::PollTOExpired()
2091{
2092
2093 refreshReason(UWUFETCH_NODE_STATUS_CHANGE_TO_WAIT_POLL_EXPIRED);
2094
2095 if (getCBeaconPckRx_by_NODE() >=
2096 num_cbeacon_node_rx) { //|| (getCBeaconPckRx_by_NODE() == 0)) {
2097 // Node has received the maximum number of CBEACON
2098 if (debug_)
2099 std::cout << NOW << " uwUFetch_NODE (" << addr
2100 << ") ::PollTOExpired() ---->NODE has received the "
2101 "maximum number of"
2102 << " CBEACON packet from the HN with MAC address: "
2103 << mac_addr_HN_in_beacon << ", so"
2104 << " return in IDLE STATE." << std::endl;
2105
2106 if (debugMio_)
2107 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
2108 << ")::PollTOExpired()_______________POLL_timeout_"
2109 "EXPIRED:_Max_CBEACON_pck_rx."
2110 << std::endl;
2111
2112 n_BEACON_pck_rx_by_NODE = 0;
2113 n_PROBE_pck_tx_by_NODE = 0;
2114 n_POLL_pck_rx_by_NODE = 0;
2115 n_DATA_pck_tx_by_NODE = 0;
2116 n_CBEACON_pck_rx_by_NODE = 0;
2117
2118 rxBEACONEnabled = true;
2119 rxPOLLEnabled = false;
2120 txDATAEnabled = false;
2121 rxCBEACONEnabled = false;
2122 mac_addr_HN_in_beacon = addr;
2123
2124 dataAlreadyTransmitted = false;
2125
2126 stateIdle_NODE();
2127
2128 } else {
2129 // Node wait the successive CBEACON
2130 if (debugMio_)
2131 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
2132 << ")::PollTOExpired()_______________POLL_timeout_"
2133 "EXPIRED:_another_CBEACON_can_be_rx."
2134 << std::endl;
2135
2136 rxPOLLEnabled = false;
2137
2138 n_PROBE_pck_tx_by_NODE = 0;
2139 n_POLL_pck_rx_by_NODE = 0;
2140 n_DATA_pck_tx_by_NODE = 0;
2141
2142 state_wait_CBEACON();
2143 }
2144} // end PollTOExpired();
2145
2146void
2147uwUFetch_NODE::POLL_rx()
2148{
2149
2150 if (rxPOLLEnabled) {
2151
2152 refreshState(UWUFETCH_NODE_STATUS_POLL_RECEIVE);
2153 if (print_transitions)
2154 printStateInfo();
2155
2156 hdr_mac *mach = HDR_MAC(curr_POLL_NODE_pck_rx);
2157 hdr_POLL_UFETCH *pollh = HDR_POLL_UFETCH(curr_POLL_NODE_pck_rx);
2158
2162 num_pck_to_tx_by_NODE =
2163 pollh->num_DATA_pcks_MAX_rx(); // Number of DATA packets that
2164 // the node will transmit to the
2165 // HN
2166
2167 mac_addr_HN_in_poll = mach->macSA(); // MAC address of the HN from which
2168 // the node has received the POLL
2169 // packet
2170
2171 if (debugMio_)
2172 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
2173 << ")::POLL_rx()________________________"
2174 "PARAMETERS_of_POLL_PACKET:"
2175 << std::endl;
2176 if (debugMio_)
2177 out_file_logging
2178 << NOW << "uwUFetch_SENSOR_NODE(" << addr
2179 << ")::POLL_rx()________________________Source_address:_"
2180 << mach->macSA() << std::endl;
2181 if (debugMio_)
2182 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
2183 << ")::POLL_rx()________________________"
2184 "Destination_address:_"
2185 << mach->macDA() << std::endl;
2186 if (debugMio_)
2187 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
2188 << ")::POLL_rx()________________________DATA_pck_"
2189 "want_rx_from_SN:_"
2190 << num_pck_to_tx_by_NODE << std::endl;
2191 if (debugMio_)
2192 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
2193 << ")::POLL_rx()________________________MAC_"
2194 "address_of_POLL_rx_("
2195 << mac_addr_HN_in_poll << ")." << std::endl;
2196
2197 rxPOLLEnabled = false;
2198
2199 state_DATA_NODE_first_tx();
2200 } else {
2201 // POLL reception is not enabled
2202 hdr_mac *mach = HDR_MAC(curr_POLL_NODE_pck_rx);
2203
2204 if (debug_)
2205 std::cout << NOW << " uwUFetch_NODE (" << addr
2206 << ") ::POLL_rx() ---->NODE is not enabled to receive the"
2207 << " POLL packet: DROP IT." << std::endl;
2208
2209 if (debugMio_)
2210 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
2211 << ")::POLL_rx()________________________Not_"
2212 "ENABLED_to_rx_POLL_pck_from_HN("
2213 << mach->macSA() << ")." << std::endl;
2214 drop(curr_POLL_NODE_pck_rx, 1, UWUFETCH_NODE_DROP_REASON_NOT_ENABLE);
2215 }
2216} // end POLL_rx();
2217
2218void
2219uwUFetch_NODE::state_DATA_NODE_first_tx()
2220{
2221
2222 if (debug_)
2223 std::cout << NOW << " uwUFetch_NODE (" << addr
2224 << ") ::state_DATA_NODE_first_tx() ---->NODE is starting "
2225 "transmission of the"
2226 << " FIRST DATA packet to the HN with MAC address: "
2227 << mac_addr_HN_in_poll << std::endl;
2228
2229 // Pick up the first element of the queue
2230 curr_DATA_NODE_pck_tx = (Q_data.front())->copy();
2231 // Remove the element from the queue that we have pick up the packet
2232 Q_data.pop();
2233
2234 hdr_mac *mach = HDR_MAC(curr_DATA_NODE_pck_tx);
2235 hdr_cmn *cmh = hdr_cmn::access(curr_DATA_NODE_pck_tx);
2236
2237 mach->set(MF_CONTROL, addr, mac_addr_HN_in_poll);
2238 mach->macSA() = addr;
2239 mach->macDA() = mac_addr_HN_in_poll;
2240 cmh->size() = sizeof(curr_DATA_NODE_pck_tx);
2241
2242 hdr_uwcbr *cbrh = HDR_UWCBR(curr_DATA_NODE_pck_tx);
2243
2244 if (debugMio_)
2245 out_file_logging
2246 << NOW << "uwUFetch_SENSOR_NODE(" << addr
2247 << ")::state_DATA_NODE_first_tx()_______DATA_pck_tx:_source("
2248 << mach->macSA() << ")_"
2249 << "destination(" << mach->macDA() << ")_id_pck:" << cbrh->sn()
2250 << "_size:" << cmh->size() << "[byte]" << std::endl;
2251
2252 txDATAEnabled = true;
2253
2254 DATA_NODE_tx();
2255} // end state_DATA_NODE_first_tx();
2256
2257void
2258uwUFetch_NODE::DATA_NODE_tx()
2259{
2260
2261 if (debug_)
2262 std::cout << NOW << " uwUFetch_NODE (" << addr
2263 << ") ::DATA_NODE_tx() ---->NODE is transmitting a DATA "
2264 "packet to the HN"
2265 << " with MAC address: " << mac_addr_HN_in_poll << std::endl;
2266
2267 refreshReason(UWUFETCH_NODE_STATUS_CHANGE_DATA_PCK_TX);
2268
2269 Mac2PhyStartTx(curr_DATA_NODE_pck_tx);
2270
2271} // end DATA_NODE_tx();
2272
2273void
2274uwUFetch_NODE::DataBeforeTxTOExpired()
2275{
2276 if (isHeadNode()) {
2277 /*********************
2278 * I'm the HEAD NODE *
2279 *********************/
2280 DataBeforeTxTOExpired_HN();
2281 } else {
2282
2283 if (debug_)
2284 std::cout << NOW << " uwUFetch_NODE (" << addr
2285 << ") ::DataBeforeTxTOExpired() ---->NODE can transmit "
2286 "the next"
2287 << " DATA packet." << std::endl;
2288
2289 state_DATA_NODE_tx();
2290 }
2291} // end DataBeforeTxTOExpired();
2292
2293void
2294uwUFetch_NODE::state_DATA_NODE_tx()
2295{
2296
2297 if (debug_)
2298 std::cout << NOW << " uwUFetch_NODE (" << addr
2299 << ") ::state_DATA_NODE_tx() ---->NODE is starting "
2300 "transmission of the DATA"
2301 << " packet number: " << (getDataPckTx_by_NODE() + 1)
2302 << " to the HN with MAC"
2303 << " address: " << mac_addr_HN_in_poll << std::endl;
2304
2305 // Pick up the first element of the queue
2306 curr_DATA_NODE_pck_tx = (Q_data.front())->copy();
2307 // Remove the element from the queue that we have pick up the packet
2308 Q_data.pop();
2309
2310 hdr_mac *mach = HDR_MAC(curr_DATA_NODE_pck_tx);
2311 hdr_cmn *cmh = hdr_cmn::access(curr_DATA_NODE_pck_tx);
2312
2313 mach->set(MF_CONTROL, addr, mac_addr_HN_in_poll);
2314 mach->macSA() = addr;
2315 mach->macDA() = mac_addr_HN_in_poll;
2316 cmh->size() = sizeof(curr_DATA_NODE_pck_tx);
2317
2318 hdr_uwcbr *cbrh = HDR_UWCBR(curr_DATA_NODE_pck_tx);
2319
2320 if (debugMio_)
2321 out_file_logging
2322 << NOW << "uwUFetch_SENSOR_NODE(" << addr
2323 << ")::state_DATA_NODE_tx()_____________DATA_pck_tx:_source("
2324 << mach->macSA() << ")_"
2325 << "destination(" << mach->macDA() << ")_id_pck:" << cbrh->sn()
2326 << "_size:" << cmh->size() << "[byte]" << std::endl;
2327
2328 txDATAEnabled = true;
2329
2330 DATA_NODE_tx();
2331} // end state_DATA_tx();
2332
2333void
2334uwUFetch_NODE::state_DATA_NODE_finish_tx()
2335{
2336
2337 if (debug_)
2338 std::cout << NOW << " uwUFetch_NODE (" << addr
2339 << ") ::state_DATA_NODE_finish_tx() ---->NODE has "
2340 "transmitted all his DATA"
2341 << " packets to the HN with MAC address: "
2342 << mac_addr_HN_in_poll << std::endl;
2343 if (debugMio_)
2344 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
2345 << ")::state_DATA_NODE_finish_tx()______NODE_has_"
2346 "finished_to_tx_all_DATA_packets_to_the_HN("
2347 << mac_addr_HN_in_poll << ")." << std::endl;
2348
2349 dataAlreadyTransmitted = true;
2350
2351 if ((getCBeaconPckRx_by_NODE() >= num_cbeacon_node_rx)) {
2352 // Node has received the maximum number of CBEACON
2353 if (debug_)
2354 std::cout << NOW << " uwUFetch_NODE (" << addr
2355 << ") ::state_DATA_NODE_finish_tx() ---->NODE has "
2356 "received the maximum"
2357 << " number of CBEACON packet from the HN with MAC "
2358 "address: "
2359 << mac_addr_HN_in_poll << ", so"
2360 << " return in IDLE STATE." << std::endl;
2361
2362 n_BEACON_pck_rx_by_NODE = 0;
2363 n_PROBE_pck_tx_by_NODE = 0;
2364 n_POLL_pck_rx_by_NODE = 0;
2365 n_DATA_pck_tx_by_NODE = 0;
2366 n_CBEACON_pck_rx_by_NODE = 0;
2367
2368 rxBEACONEnabled = true;
2369 txDATAEnabled = false;
2370 rxCBEACONEnabled = false;
2371
2372 dataAlreadyTransmitted = false;
2373
2374 stateIdle_NODE();
2375
2376 } else {
2377 // Node wait the successive CBEACON
2378 if (debug_)
2379 std::cout << NOW << " uwUFetch_NODE (" << addr
2380 << ") ::state_DATA_NODE_finish_tx() ---->NODE has not "
2381 "received the maximum"
2382 << " number of CBEACON packet from the HN with MAC "
2383 "address: "
2384 << mac_addr_HN_in_poll << ", so"
2385 << " wait a CBEACON." << std::endl;
2386
2387 n_PROBE_pck_tx_by_NODE = 0;
2388 n_POLL_pck_rx_by_NODE = 0;
2389 n_DATA_pck_tx_by_NODE = 0;
2390
2391 txDATAEnabled = false;
2392 rxCBEACONEnabled = true;
2393
2394 state_wait_CBEACON();
2395 }
2396} // end state_DATA_NODE_finish_tx();
2397
2398void
2399uwUFetch_NODE::state_wait_CBEACON()
2400{
2401
2402 double T_CBEACON = 500;
2403
2404 if (debug_)
2405 std::cout << NOW << " uwUFetch_NODE (" << addr
2406 << ") ::state_wait_CBEACON() ---->NODE is scheduling CBEACON "
2407 "TIMER T= "
2408 << T_CBEACON << "[s]" << std::endl;
2409
2410 refreshState(UWUFETCH_NODE_STATUS_WAIT_CBEACON_PACKET);
2411 if (print_transitions)
2412 printStateInfo();
2413
2414 rxBEACONEnabled = false;
2415 rxCBEACONEnabled = true;
2416 if (debugMio_)
2417 out_file_logging
2418 << NOW << "uwUFetch_SENSOR_NODE(" << addr
2419 << ")::state_wait_CBEACON()_____________Waiting_CBEACON_pck"
2420 << "_from_HN(" << mac_addr_HN_in_beacon << ")" << std::endl;
2421 if (debugMio_)
2422 out_file_logging
2423 << NOW << "uwUFetch_SENSOR_NODE(" << addr
2424 << ")::state_wait_CBEACON()_____________....Waiting_CBEACON_pck"
2425 << std::endl;
2426 if (debugMio_)
2427 out_file_logging
2428 << NOW << "uwUFetch_SENSOR_NODE(" << addr
2429 << ")::state_wait_CBEACON()_____________....Waiting_CBEACON_pck"
2430 << std::endl;
2431 if (debugMio_)
2432 out_file_logging
2433 << NOW << "uwUFetch_SENSOR_NODE(" << addr
2434 << ")::state_wait_CBEACON()_____________....Waiting_CBEACON_pck"
2435 << std::endl;
2436
2437 CBEACON_timer.schedule(T_CBEACON);
2438} // end state_wait_CBEACON();
2439
2440void
2441uwUFetch_NODE::CBeaconTOExpired()
2442{
2443
2444 if (debug_)
2445 std::cout << NOW << " uwUFetch_NODE (" << addr
2446 << ") ::CBeaconTOExpired() ---->NODE can not receive other "
2447 "CBEACON"
2448 << " packet from the HN with MAC address: "
2449 << mac_addr_HN_in_beacon << ", so"
2450 << " return in IDLE STATE." << std::endl;
2451 if (debugMio_)
2452 out_file_logging
2453 << NOW << "uwUFetch_SENSOR_NODE(" << addr
2454 << ")::CBeaconTOExpired()_______NODE_CBEACON_timeout_expired."
2455 << std::endl;
2456
2457 n_BEACON_pck_rx_by_NODE = 0;
2458 n_PROBE_pck_tx_by_NODE = 0;
2459 n_POLL_pck_rx_by_NODE = 0;
2460 n_DATA_pck_tx_by_NODE = 0;
2461 n_CBEACON_pck_rx_by_NODE = 0;
2462
2463 rxBEACONEnabled = true;
2464 txPROBEEnabled = false;
2465 rxPOLLEnabled = false;
2466 txDATAEnabled = false;
2467 rxCBEACONEnabled = false;
2468
2469 dataAlreadyTransmitted = false;
2470 stateIdle_NODE();
2471} // end CBeaconTOExpired();
2472
2473void
2474uwUFetch_NODE::CBEACON_rx()
2475{
2476
2477 if (rxCBEACONEnabled) {
2478 // Node is enabled to receive a CBEACON
2479 refreshState(UWUFETCH_NODE_STATUS_CBEACON_RECEIVE);
2480 if (print_transitions)
2481 printStateInfo();
2482
2483 incrCBeaconPckRx_by_NODE();
2484
2485 CBEACON_timer.force_cancel();
2486
2487 hdr_mac *mach = HDR_MAC(curr_CBEACON_NODE_pck_rx);
2488 hdr_CBEACON_UFETCH *cbeaconh =
2489 HDR_CBEACON_UFETCH(curr_CBEACON_NODE_pck_rx);
2490
2491 /*
2492 * Save the header data of the cbeacon
2493 */
2494 T_min_bck_probe_node = (double) cbeaconh->t_min_bc() / 1000;
2495 T_max_bck_probe_node = (double) cbeaconh->t_max_bc() / 1000;
2496 num_cbeacon_at_now_HN_tx =
2497 cbeaconh->num_Max_CBEACON_tx_by_HN(); // Number of CBEACON that
2498 // the HN has transmitted
2499 // at this time
2500
2501 mac_addr_HN_in_cbeacon = mach->macSA(); // Mac address from which the
2502 // node has received a BEACON
2503
2504 if (debugMio_)
2505 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
2506 << ")::CBEACON_rx()_____________________"
2507 "PARAMETERS_of_CBEACON_pck:"
2508 << std::endl;
2509 if (debugMio_)
2510 out_file_logging
2511 << NOW << "uwUFetch_SENSOR_NODE(" << addr
2512 << ")::CBEACON_rx()_____________________Source_address:_"
2513 << mach->macSA() << ". " << std::endl;
2514 if (mach->macDA() == -1) {
2515 if (debugMio_)
2516 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
2517 << ")::CBEACON_rx()_____________________"
2518 "Destination_address:_BROADCAST."
2519 << std::endl;
2520 } else {
2521 if (debugMio_)
2522 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
2523 << ")::CBEACON_rx()_____________________"
2524 "Destination address:_"
2525 << mach->macDA() << ". " << std::endl;
2526 }
2527 if (debugMio_)
2528 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
2529 << ")::CBEACON_rx()_____________________MIN_"
2530 "backoff_time_PROBE_pck:_"
2531 << T_min_bck_probe_node << "[s]. " << std::endl;
2532 if (debugMio_)
2533 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
2534 << ")::CBEACON_rx()_____________________MAX_"
2535 "backoff_time_PROBE_pck:_"
2536 << T_max_bck_probe_node << "[s]." << std::endl;
2537
2538 if ((dataAlreadyTransmitted == false)) {
2539 // NODE in the past cycle has not transmitted his data packet, so
2540 // transmit a probe
2541 if (debugMio_)
2542 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
2543 << ")::CBEACON_rx()_____________________NODE_"
2544 "has_not_yet_tx_DATA_in_this_cycle"
2545 "_so_start_the_tx_of_PROBE."
2546 << std::endl;
2547
2548 rxCBEACONEnabled = false; // Indicates if or not the NODE is enabled
2549 // to receive a CBEACON packet to the HN
2550
2551 CBEACON_timer.force_cancel();
2552
2553 bck_before_tx_probe = choiceBackOffTimer();
2554 BCK_timer_probe.schedule(bck_before_tx_probe);
2555
2556 } else {
2557 // Node has already transmitted his data packet or the CBEACON
2558 // received is receive from an HN from which the NODE has never
2559 // receive a BEACON packet
2560 if (debug_)
2561 std::cout << NOW << " uwUFetch_NODE (" << addr
2562 << ") ::CBEACON_rx() ---->NODE has received a "
2563 "CBEACON and it"
2564 << " has already transmit his DATA packets in the "
2565 "previous cycle: DROP IT."
2566 << std::endl;
2567
2568 drop(curr_CBEACON_NODE_pck_rx,
2569 1,
2570 UWUFETCH_NODE_DROP_REASON_NOT_ENABLE);
2571
2572 if (getCBeaconPckRx_by_NODE() == num_cbeacon_node_rx) {
2573 // Node has received the maximum number of CBEACON
2574 if (debug_)
2575 std::cout << NOW << " uwUFetch_NODE (" << addr
2576 << ") ::CBEACON_rx() ---->NODE has received the "
2577 "maximum"
2578 << " number of CBEACON packet from the HN with "
2579 "MAC address: "
2580 << mac_addr_HN_in_beacon << ", so"
2581 << " return in IDLE STATE." << std::endl;
2582 if (debugMio_)
2583 out_file_logging
2584 << NOW << "uwUFetch_SENSOR_NODE(" << addr
2585 << ")::CBEACON_rx()_____________________NODE_has_"
2586 "already_tx_DATA_in_this_cycle_"
2587 << "_and_maximum_number_of_CBEACON_rx."
2588 << std::endl;
2589
2590 n_BEACON_pck_rx_by_NODE = 0;
2591 n_PROBE_pck_tx_by_NODE = 0;
2592 n_POLL_pck_rx_by_NODE = 0;
2593 n_DATA_pck_tx_by_NODE = 0;
2594 n_CBEACON_pck_rx_by_NODE = 0;
2595
2596 rxBEACONEnabled = true;
2597 txPROBEEnabled = false;
2598 rxPOLLEnabled = false;
2599 txDATAEnabled = false;
2600 rxCBEACONEnabled = false;
2601
2602 dataAlreadyTransmitted = false;
2603 stateIdle_NODE();
2604
2605 } else {
2606 if (debug_)
2607 std::cout << NOW << " uwUFetch_NODE (" << addr
2608 << ") ::CBEACON_rx() ---->NODE has not received "
2609 "the maximum"
2610 << " number of CBEACON packet from the HN with "
2611 "MAC address: "
2612 << mac_addr_HN_in_beacon << ", so"
2613 << " wait other CBEACON packets." << std::endl;
2614 if (debugMio_)
2615 out_file_logging
2616 << NOW << "uwUFetch_SENSOR_NODE(" << addr
2617 << ")::CBEACON_rx()_____________________NODE_has_"
2618 "already_tx_DATA_in_this_cycle_"
2619 << "_wait_another_CBEACON." << std::endl;
2620
2621 n_PROBE_pck_tx_by_NODE = 0;
2622 n_POLL_pck_rx_by_NODE = 0;
2623
2624 state_wait_CBEACON();
2625 }
2626 }
2627 } else {
2628 // Node is not enable to receive a CBEACON packet
2629 if (debug_)
2630 std::cout << NOW << " uwUFetch_NODE (" << addr
2631 << ") ::CBEACON_r() ---->NODE is not enabled to receive"
2632 << " the CBEACON packet: DROP IT." << std::endl;
2633 incrCBeaconPckRx_by_NODE();
2634
2635 CBEACON_timer.force_cancel();
2636 rxPOLLEnabled = false;
2637 POLL_timer.force_cancel();
2638
2639 hdr_mac *mach = HDR_MAC(curr_CBEACON_NODE_pck_rx);
2640 hdr_CBEACON_UFETCH *cbeaconh =
2641 HDR_CBEACON_UFETCH(curr_CBEACON_NODE_pck_rx);
2642
2643 if (debugMio_)
2644 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
2645 << ")::CBEACON_rx()_____________________SN_is_"
2646 "waiting_a_POLL_from_HN("
2647 << mach->macSA() << ")"
2648 << "_but_it_has_rx_CBEACON_from_this_HN."
2649 << std::endl;
2650 if (debugMio_)
2651 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
2652 << ")::CBEACON_rx()_____________________RESET_"
2653 "POLL_timeout_and_analyzed_CBEACON_pck."
2654 << std::endl;
2655
2656 /*
2657 * Save the header data of the cbeacon
2658 */
2659 T_min_bck_probe_node = (double) cbeaconh->t_min_bc() / 1000;
2660 T_max_bck_probe_node = (double) cbeaconh->t_max_bc() / 1000;
2661 num_cbeacon_at_now_HN_tx =
2662 cbeaconh->num_Max_CBEACON_tx_by_HN(); // Number of CBEACON that
2663 // the HN has transmitted
2664 // at this time
2665
2666 mac_addr_HN_in_cbeacon = mach->macSA(); // Mac address from which the
2667 // node has received a BEACON
2668
2669 if (debugMio_)
2670 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
2671 << ")::CBEACON_rx()_____________________"
2672 "PARAMETERS_of_CBEACON_pck:"
2673 << std::endl;
2674 if (debugMio_)
2675 out_file_logging
2676 << NOW << "uwUFetch_SENSOR_NODE(" << addr
2677 << ")::CBEACON_rx()_____________________Source_address:_"
2678 << mach->macSA() << ". " << std::endl;
2679 if (mach->macDA() == -1) {
2680 if (debugMio_)
2681 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
2682 << ")::CBEACON_rx()_____________________"
2683 "Destination_address:_BROADCAST."
2684 << std::endl;
2685 } else {
2686 if (debugMio_)
2687 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
2688 << ")::CBEACON_rx()_____________________"
2689 "Destination_address:_"
2690 << mach->macDA() << ". " << std::endl;
2691 }
2692 if (debugMio_)
2693 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
2694 << ")::CBEACON_rx()_____________________MIN_"
2695 "backoff_time_PROBE_pck:_"
2696 << T_min_bck_probe_node << "[s]. " << std::endl;
2697 if (debugMio_)
2698 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
2699 << ")::CBEACON_rx()_____________________MAX_"
2700 "backoff_time_PROBE_pck:_"
2701 << T_max_bck_probe_node << "[s]." << std::endl;
2702
2703 if ((dataAlreadyTransmitted == false)) {
2704 // NODE in the past cycle has not transmitted his data packet, so
2705 // transmit a probe
2706 if (debugMio_)
2707 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
2708 << ")::CBEACON_rx()_____________________Not_"
2709 "yet_tx_DATA_in_this_cycle"
2710 "_start_tx_of_another_PROBE_pck."
2711 << std::endl;
2712
2713 rxCBEACONEnabled = false; // Indicates if or not the NODE is enabled
2714 // to receive a CBEACON packet to the HN
2715
2716 CBEACON_timer.force_cancel();
2717
2718 bck_before_tx_probe = choiceBackOffTimer();
2719 BCK_timer_probe.schedule(bck_before_tx_probe);
2720
2721 } else {
2722 // Node has already transmitted his data packet or the CBEACON
2723 // received is receive from an HN from which the NODE has never
2724 // receive a BEACON packet
2725 if (debug_)
2726 std::cout << NOW << " uwUFetch_NODE (" << addr
2727 << ") ::CBEACON_rx() ---->NODE has received a "
2728 "CBEACON and it"
2729 << " has already transmit his DATA packets in the "
2730 "previous cycle: DROP IT."
2731 << std::endl;
2732
2733 drop(curr_CBEACON_NODE_pck_rx,
2734 1,
2735 UWUFETCH_NODE_DROP_REASON_NOT_ENABLE);
2736
2737 if (getCBeaconPckRx_by_NODE() == num_cbeacon_node_rx) {
2738 // Node has received the maximum number of CBEACON
2739 if (debug_)
2740 std::cout << NOW << " uwUFetch_NODE (" << addr
2741 << ") ::CBEACON_rx() ---->NODE has received the "
2742 "maximum"
2743 << " number of CBEACON packet from the HN with "
2744 "MAC address: "
2745 << mac_addr_HN_in_beacon << ", so"
2746 << " return in IDLE STATE." << std::endl;
2747 if (debugMio_)
2748 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
2749 << ")::CBEACON_rx()_____________________"
2750 "DATA_pck_already_tx_in_this_cycle_"
2751 << "and_maximum_number_of_CBEACON_pck_rx."
2752 << std::endl;
2753
2754 n_BEACON_pck_rx_by_NODE = 0;
2755 n_PROBE_pck_tx_by_NODE = 0;
2756 n_POLL_pck_rx_by_NODE = 0;
2757 n_DATA_pck_tx_by_NODE = 0;
2758 n_CBEACON_pck_rx_by_NODE = 0;
2759
2760 rxBEACONEnabled = true;
2761 txPROBEEnabled = false;
2762 rxPOLLEnabled = false;
2763 txDATAEnabled = false;
2764 rxCBEACONEnabled = false;
2765
2766 dataAlreadyTransmitted = false;
2767 stateIdle_NODE();
2768
2769 } else {
2770 if (debug_)
2771 std::cout << NOW << " uwUFetch_NODE (" << addr
2772 << ") ::CBEACON_rx() ---->NODE has not received "
2773 "the maximum"
2774 << " number of CBEACON packet from the HN with "
2775 "MAC address: "
2776 << mac_addr_HN_in_beacon << ", so"
2777 << " wait other CBEACON packets." << std::endl;
2778 if (debugMio_)
2779 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
2780 << ")::CBEACON_rx()_____________________"
2781 "DATA_pck_already_tx_in_this_cycle_"
2782 << "and_wait_another_CBEACON_pck."
2783 << std::endl;
2784 if (debugMio_)
2785 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
2786 << ")::CBEACON_rx()_____________________.."
2787 "..Waiting_CBEACON_pck."
2788 << std::endl;
2789 if (debugMio_)
2790 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
2791 << ")::CBEACON_rx()_____________________.."
2792 "..Waiting_CBEACON_pck."
2793 << std::endl;
2794 if (debugMio_)
2795 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
2796 << ")::CBEACON_rx()_____________________.."
2797 "..Waiting_CBEACON_pck."
2798 << std::endl;
2799
2800 n_PROBE_pck_tx_by_NODE = 0;
2801 n_POLL_pck_rx_by_NODE = 0;
2802
2803 state_wait_CBEACON();
2804 }
2805 }
2806 }
2807} // end CBEACON_rx();
2808
2809/*******************************************************************************
2810 * METODI AUSILIARI *
2811 ******************************************************************************/
2812bool
2813uwUFetch_NODE::isHeadNode()
2814{
2815 if (HEADNODE == 1) {
2816 return true;
2817 } else {
2818 return false;
2819 }
2820} // end isHeadNode();
2821
2822double
2823uwUFetch_NODE::choiceBackOffTimer()
2824{
2825 int random = (int) RNG::defaultrng()->uniform(T_min_bck_probe_node, T_max_bck_probe_node);
2826
2827 if (debug_)
2828 std::cout << NOW << "uwUFetch_NODE(" << addr
2829 << ") getting Backoff time...Value = " << 0.883 * random
2830 << std::endl;
2831 return (0.833 * random);
2832} // end choiceBackoffTimer();
2833
2834void
2835uwUFetch_NODE::computeTxTime(UWUFETCH_NODE_PACKET_TYPE tp)
2836{
2837 Packet *simple_pck = Packet::alloc();
2838
2839 if (tp == UWUFETCH_NODE_PACKET_TYPE_PROBE) {
2840 hdr_cmn *cmh = HDR_CMN(simple_pck);
2841 hdr_mac *mach = HDR_MAC(simple_pck);
2842 cmh->size() = sizeof(hdr_PROBE_UFETCH);
2843
2844 mach->macSA() = addr;
2845 mach->macDA() = mac_addr_HN_in_beacon;
2846 Tprobe = Mac2PhyTxDuration(simple_pck);
2847 } else {
2848 hdr_mac *mach = HDR_MAC(simple_pck);
2849 hdr_cmn *cmh = HDR_CMN(simple_pck);
2850 cmh->size() = MAX_PAYLOAD;
2851
2852 mach->macSA() = addr;
2853 Tdata_NODE = Mac2PhyTxDuration(simple_pck);
2854 }
2855 Packet::free(simple_pck);
2856} // end computeTxTime();
2857
2858void
2859uwUFetch_NODE::recvFromUpperLayers(Packet *p)
2860{
2861 if (isHeadNode()) {
2862 /**************************
2863 * I'm THE HEAD NODE *
2864 **************************/
2865 uwUFetch_NODE::recvFromUpperLayers_HN(p);
2866 } else {
2867 /**************************
2868 * I'm THE SENSOR NODE *
2869 **************************/
2870 hdr_uwcbr *cbrh = HDR_UWCBR(p);
2871
2872 if ((int) Q_data.size() < MAXIMUM_BUFFER_DATA_PCK_NODE) {
2873 if (debug_)
2874 std::cout << NOW << " uwUFetch_NODE (" << addr
2875 << ") ::recvFromUpperLayers() ---->NODE is queuing a "
2876 "DATA packet"
2877 << " generated by the APPLICATION layer" << std::endl;
2878
2879 if (debugMio_)
2880 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
2881 << ")::recvFromUpperLayers()____________DATA_"
2882 "rx_from_upper_layer:id_pck_"
2883 << cbrh->sn() << "_STORE_IT." << std::endl;
2884
2885 Q_data.push(p);
2886 } else {
2887 if (debug_)
2888 std::cout << NOW << " uwUFetch_NODE(" << addr
2889 << ") ::recvFromUpperLayers()--->NODE dropped DATA "
2890 "packet because"
2891 << " its buffer is full" << std::endl;
2892
2893 if (debugMio_)
2894 out_file_logging << NOW << "uwUFetch_SENSOR_NODE(" << addr
2895 << ")::recvFromUpperLayers()____________DATA_"
2896 "rx_from_upper_layer:id_pck_"
2897 << cbrh->sn() << "_MEMORY_IS_FULL:_DROP_IT."
2898 << std::endl;
2899
2900 drop(p, 1, UWUFETCH_NODE_DROP_REASON_BUFFER_FULL);
2901 }
2902 }
2903} // end recvFromUpperLayers();
2904
2905/*******************************************************************************
2906 * EXPIRE METHODS *
2907 ******************************************************************************/
2908void
2909uwUFetch_NODE::uwUFetch_BackOffTimer::expire(Event *e)
2910{
2911 if ((module->debug_))
2912 std::cout << NOW << "uwUFetch_NODE (" << module->addr
2913 << ") ::uwUFetch_BackOffTimer::expire() ---->BACK-OFF "
2914 "timeout expired."
2915 << std::endl;
2916 timer_status = UWUFETCH_TIMER_STATUS_EXPIRED;
2917
2918 module->BCKTOExpired();
2919} // end uwUFetch_BackOffTimer::expire();
2920
2921void
2922uwUFetch_NODE::uwUFetch_POLL_timer::expire(Event *e)
2923{
2924 if ((module->debug_))
2925 std::cout
2926 << NOW << " uwUFetch_NODE (" << module->addr
2927 << ")::uwUFetch_POLL_timer::expire() ---->POLL timeout expired"
2928 << std::endl;
2929 timer_status = UWUFETCH_TIMER_STATUS_EXPIRED;
2930
2931 module->PollTOExpired();
2932} // end uwUFetch_POLL_timer::expire();
2933
2934void
2935uwUFetch_NODE::uwUFetch_DATA_BEFORE_TX_timer::expire(Event *e)
2936{
2937 if ((module->debug_))
2938 std::cout << NOW << " uwUFetch_NODE (" << module->addr
2939 << ") ::uwUFetch_DATA_BEFORE_TX_timer::expire() ---->SINGLE "
2940 "DATA timeout expired"
2941 << std::endl;
2942 timer_status = UWUFETCH_TIMER_STATUS_EXPIRED;
2943
2944 module->DataBeforeTxTOExpired();
2945} // end uwUFetch_DATA_BEFORE_TX_timer::expire();
2946
2947void
2948uwUFetch_NODE::uwUFetch_CBeacon_timer::expire(Event *e)
2949{
2950 if ((module->debug_))
2951 std::cout << NOW << " uwUFetch_NODE (" << module->addr
2952 << ") ::uwUFetch_CBeacon_timer::expire() ---->CBEACON "
2953 "timeout expired"
2954 << std::endl;
2955 timer_status = UWUFETCH_TIMER_STATUS_EXPIRED;
2956
2957 module->CBeaconTOExpired();
2958} // end uwUFetch_CBeacon_timer::expire();
2959
2960void
2961uwUFetch_NODE::waitForUser()
2962{
2963 std::string response;
2964 std::cout << "Press Enter to continue";
2965 std::getline(std::cin, response);
2966} // end waitForUser();
2967
2968void
2969uwUFetch_NODE::printStateInfo(double delay)
2970{
2971 fout << NOW << " uwUFetch_NODE (" << addr << ") ::printStateInfo() "
2972 << "from " << statusInfo[prev_state] << " to "
2973 << statusInfo[curr_state] << ". Reason: " << statusChange[last_reason]
2974 << std::endl;
2975} // end printStateInfo()
uwUFetchNODEModuleClass
< class uwUFetchNODEModuleClass
Definition uwUFetch_NODE_SENSOR.cpp:50
uwUFetchNODEModuleClass::create
TclObject * create(int, const char *const *)
Definition uwUFetch_NODE_SENSOR.cpp:61
uwUFetchNODEModuleClass::uwUFetchNODEModuleClass
uwUFetchNODEModuleClass()
Constructor of uwUFetchNODEModuleClass class.
Definition uwUFetch_NODE_SENSOR.cpp:55
uwUFetch_NODE::uwUFetch_BackOffTimer::expire
virtual void expire(Event *e)
Method called when the timer expire.
Definition uwUFetch_NODE_SENSOR.cpp:2909
uwUFetch_NODE::uwUFetch_CBeacon_timer::expire
virtual void expire(Event *e)
Method called when the timer expire.
Definition uwUFetch_NODE_SENSOR.cpp:2948
uwUFetch_NODE::uwUFetch_DATA_BEFORE_TX_timer::expire
virtual void expire(Event *e)
Method called when the timer expire.
Definition uwUFetch_NODE_SENSOR.cpp:2935
uwUFetch_NODE::uwUFetch_NODE_timer::timer_status
uwUFetch_NODE *UWUFETCH_TIMER_STATUS timer_status
< Pointer to an object of type uwUFetch_NODE
Definition uwUFetch_NODE.h:436
uwUFetch_NODE::uwUFetch_NODE_timer::schedule
virtual void schedule(double val)
schedule a timer
Definition uwUFetch_NODE.h:327
uwUFetch_NODE::uwUFetch_POLL_timer::expire
virtual void expire(Event *e)
Method called when the timer expire.
Definition uwUFetch_NODE_SENSOR.cpp:2922
uwUFetch_NODE
Definition uwUFetch_NODE.h:136
uwUFetch_NODE::curr_PROBE_NODE_pck_tx
Packet * curr_PROBE_NODE_pck_tx
Pointer to the PROBE packet that is being transmitted by SN.
Definition uwUFetch_NODE.h:2254
uwUFetch_NODE::N_RUN
int N_RUN
Indicate the number of the run in execution.
Definition uwUFetch_NODE.h:2091
uwUFetch_NODE::incrTotalCBeaconPckRx_corrupted_by_NODE
void incrTotalCBeaconPckRx_corrupted_by_NODE()
Increase the total number of corrupted CBEACON packets received by SN during an entire duration of si...
Definition uwUFetch_NODE.h:2061
uwUFetch_NODE::rx_POLL_finish_time
double rx_POLL_finish_time
Indicates when SN finished the reception of POLL packet from HN.
Definition uwUFetch_NODE.h:2130
uwUFetch_NODE::rx_BEACON_finish_time
double rx_BEACON_finish_time
Indicates when SN finished the reception of BEACON packet from HN.
Definition uwUFetch_NODE.h:2121
uwUFetch_NODE::getCBeaconPckRx_by_NODE
int getCBeaconPckRx_by_NODE()
Number of CBEACON packets received by the SN during a single cycle BEACON-PROBE-POLL-DATA-CBEACON of ...
Definition uwUFetch_NODE.h:2029
uwUFetch_NODE::uwUFetch_NODE
uwUFetch_NODE()
Constructor of uwUFetch_NODE class.
Definition uwUFetch_NODE_SENSOR.cpp:81
uwUFetch_NODE::rxCBEACONEnabled
bool rxCBEACONEnabled
true if SN is enabled to receive a CBEACON packet from the HN
Definition uwUFetch_NODE.h:2248
uwUFetch_NODE::CBEACON_timer
uwUFetch_CBeacon_timer CBEACON_timer
Definition uwUFetch_NODE.h:2113
uwUFetch_NODE::getTotalBeaconPckRx_by_NODE
int getTotalBeaconPckRx_by_NODE()
Total number of BEACON packets received correctly or not by SN during an entire duration of simulatio...
Definition uwUFetch_NODE.h:1831
uwUFetch_NODE::n_POLL_pck_rx_by_NODE
int n_POLL_pck_rx_by_NODE
Number of POLL received by the SN during a single cycle BEACON-PROBE-POLL-DATA-CBEACON of the simulat...
Definition uwUFetch_NODE.h:2222
uwUFetch_NODE::incrBeaconPckRx_by_NODE
void incrBeaconPckRx_by_NODE()
Increase the number of BEACON packets received by the SN during a single cycle BEACON-PROBE-POLL-DATA...
Definition uwUFetch_NODE.h:1797
uwUFetch_NODE::last_reason
UWUFETCH_NODE_STATUS_CHANGE last_reason
Last reason because the SN or HN change its state.
Definition uwUFetch_NODE.h:2561
uwUFetch_NODE::getTotalPollPckTx_by_HN
int getTotalPollPckTx_by_HN()
Total number of POLL packets transmitted by the HN during an entire simulation.
Definition uwUFetch_NODE.h:1453
uwUFetch_NODE::getTotalCtsPckRx_corrupted_HN
int getTotalCtsPckRx_corrupted_HN()
Total number of corrupted CTS packets received by the HN during an entire simulation.
Definition uwUFetch_NODE.h:1739
uwUFetch_NODE::state_DATA_NODE_finish_tx
virtual void state_DATA_NODE_finish_tx()
SN has finished to transmit the last DATA packet promises with a PROBE packet to a specif HN.
Definition uwUFetch_NODE_SENSOR.cpp:2334
uwUFetch_NODE::incrTotalBeaconPckRx_corrupted_by_NODE
void incrTotalBeaconPckRx_corrupted_by_NODE()
Increase the total number of corrupted BEACON packets received by SN during an entire duration of sim...
Definition uwUFetch_NODE.h:1841
uwUFetch_NODE::T_MIN_BACKOFF_PROBE
double T_MIN_BACKOFF_PROBE
Lower bound timer interval of back-off value used by the SN to choice its back-off time before to tra...
Definition uwUFetch_NODE.h:2282
uwUFetch_NODE::DataBeforeTxTOExpired_HN
virtual void DataBeforeTxTOExpired_HN()
Backoff timeout is expired.
Definition uwUFetch_NODE_HEADNODE.cpp:2082
uwUFetch_NODE::BEACON_rx
virtual void BEACON_rx()
SN received a BEACON packet.
Definition uwUFetch_NODE_SENSOR.cpp:1780
uwUFetch_NODE::incrCBeaconPckRx_by_NODE
void incrCBeaconPckRx_by_NODE()
Increase the number of CBEACON packets received by the SN during a single cycle BEACON-PROBE-POLL-DAT...
Definition uwUFetch_NODE.h:2017
uwUFetch_NODE::prev_state
UWUFETCH_NODE_STATUS prev_state
Previous state in which the SN or HN it was located.
Definition uwUFetch_NODE.h:2565
uwUFetch_NODE::T_GUARD
double T_GUARD
Guard interval used for successive transmission of DATA packets.
Definition uwUFetch_NODE.h:2084
uwUFetch_NODE::getTotalTriggerPckRx_corrupted_HN
int getTotalTriggerPckRx_corrupted_HN()
Total number of corrupted TRIGGER packets received by the HN during an entire simulation.
Definition uwUFetch_NODE.h:1629
uwUFetch_NODE::incrDataPckTx_by_NODE
void incrDataPckTx_by_NODE()
Increase the number of DATA packets transmitted by the SN during a single cycle BEACON-PROBE-POLL-DAT...
Definition uwUFetch_NODE.h:1973
uwUFetch_NODE::Phy2MacEndTx_HN
virtual void Phy2MacEndTx_HN(const Packet *p)
Handle the end-of-PHY-transmission event for HEAD NODE.
Definition uwUFetch_NODE_HEADNODE.cpp:1107
uwUFetch_NODE::n_DATA_pck_tx_by_NODE
int n_DATA_pck_tx_by_NODE
Number of DATA transmitted by the SN during a single cycle BEACON-PROBE-POLL-DATA-CBEACON of the simu...
Definition uwUFetch_NODE.h:2226
uwUFetch_NODE::MAX_POLLED_NODE
int MAX_POLLED_NODE
Maximum number of PROBE packets that the HN can receive from the SN after the transmission of a BEACO...
Definition uwUFetch_NODE.h:2301
uwUFetch_NODE::Phy2MacStartRx_HN
virtual void Phy2MacStartRx_HN(const Packet *p)
Handle the detected-start-of-PHY-reception event for HEAD NODE.
Definition uwUFetch_NODE_HEADNODE.cpp:56
uwUFetch_NODE::getTotalProbePckRx_corrupted_HN
int getTotalProbePckRx_corrupted_HN()
Total number of corrupted PROBE packets received by the HN during an entire simulation.
Definition uwUFetch_NODE.h:1409
uwUFetch_NODE::T_POLL
double T_POLL
Interval time in which the SN wait a POLL packet from the HN.
Definition uwUFetch_NODE.h:2088
uwUFetch_NODE::stateIdle_HN
virtual void stateIdle_HN()
Idle state for HN.
Definition uwUFetch_NODE_HEADNODE.cpp:1283
uwUFetch_NODE::T_PROBE
double T_PROBE
Interval time in which HN is enabled to received PROBE packets from SNs after the transmission of TRI...
Definition uwUFetch_NODE.h:2289
uwUFetch_NODE::UWUFETCH_TIMER_STATUS_FROZEN
@ UWUFETCH_TIMER_STATUS_FROZEN
Definition uwUFetch_NODE.h:249
uwUFetch_NODE::UWUFETCH_TIMER_STATUS_IDLE
@ UWUFETCH_TIMER_STATUS_IDLE
Definition uwUFetch_NODE.h:247
uwUFetch_NODE::UWUFETCH_TIMER_STATUS_RUNNING
@ UWUFETCH_TIMER_STATUS_RUNNING
Definition uwUFetch_NODE.h:248
uwUFetch_NODE::UWUFETCH_TIMER_STATUS_EXPIRED
@ UWUFETCH_TIMER_STATUS_EXPIRED
Definition uwUFetch_NODE.h:250
uwUFetch_NODE::statusTimer
static std::map< UWUFETCH_TIMER_STATUS, std::string > statusTimer
Map the UWUFETCH_TIMER_STATUS to the description of the timers.
Definition uwUFetch_NODE.h:2588
uwUFetch_NODE::txDATAEnabled
bool txDATAEnabled
true if SN is enabled to transmit a DATA packet to the HN
Definition uwUFetch_NODE.h:2246
uwUFetch_NODE::num_pck_to_tx_by_NODE
int num_pck_to_tx_by_NODE
Number of DATA packets that the SN at the instant time of BEACON reception has available to transmit ...
Definition uwUFetch_NODE.h:2192
uwUFetch_NODE::crLayCommand
virtual int crLayCommand(ClMessage *m)
Cross-Layer messages interpreter.
Definition uwUFetch_NODE_SENSOR.cpp:264
uwUFetch_NODE::MAX_ALLOWED_CBEACON_TX
int MAX_ALLOWED_CBEACON_TX
Definition uwUFetch_NODE.h:2292
uwUFetch_NODE::BCKTOExpired_HN
virtual void BCKTOExpired_HN()
Backoff timeout is expired.
Definition uwUFetch_NODE_HEADNODE.cpp:1610
uwUFetch_NODE::BCKTOExpired
virtual void BCKTOExpired()
Handle the.
Definition uwUFetch_NODE_SENSOR.cpp:1862
uwUFetch_NODE::printStateInfo
virtual void printStateInfo(double delay=0)
Prints a file with every state change for debug purposes.
Definition uwUFetch_NODE_SENSOR.cpp:2969
uwUFetch_NODE::out_file_logging
std::ofstream out_file_logging
Variable that handle the file in which the protocol write the statistics.
Definition uwUFetch_NODE.h:2596
uwUFetch_NODE::Phy2MacEndRx_HN
virtual void Phy2MacEndRx_HN(Packet *p)
Handle the end-of-PHY-reception event for HEAD NODE.
Definition uwUFetch_NODE_HEADNODE.cpp:198
uwUFetch_NODE::T_max_bck_probe_node
double T_max_bck_probe_node
Upper bound timer interval used by the SN to choice the interval time before to transmit a PROBE pack...
Definition uwUFetch_NODE.h:2171
uwUFetch_NODE::TIME_BETWEEN_2_TX_DATA_NODE_HN
double TIME_BETWEEN_2_TX_DATA_NODE_HN
Interval time used by the SN before to transmit the next DATA packet to the HN.
Definition uwUFetch_NODE.h:2092
uwUFetch_NODE::TIME_BETWEEN_2_TX_DATA_HN_AUV
double TIME_BETWEEN_2_TX_DATA_HN_AUV
Interval time used by HN before to transmit the next DATA packet to the AUV.
Definition uwUFetch_NODE.h:2305
uwUFetch_NODE::mac_addr_HN_in_beacon
int mac_addr_HN_in_beacon
HN MAC address from which the SN has received PROBE packet.
Definition uwUFetch_NODE.h:2178
uwUFetch_NODE::initialized
static bool initialized
Indicate if the protocol has been initialized or not.
Definition uwUFetch_NODE.h:2569
uwUFetch_NODE::getTotalDataPckRx_by_HN
int getTotalDataPckRx_by_HN()
Total number of DATA packets correctly or not received by the HN during an entire simulation.
Definition uwUFetch_NODE.h:1497
uwUFetch_NODE::getTotalPollPckRx_by_NODE
int getTotalPollPckRx_by_NODE()
Total number of POLL packets received correctly or not by SN during an entire duration of simulation.
Definition uwUFetch_NODE.h:1941
uwUFetch_NODE::debugMio_
int debugMio_
Used if we want to create the logging file.
Definition uwUFetch_NODE.h:2090
uwUFetch_NODE::Mac2PhyStartTx_HN
virtual void Mac2PhyStartTx_HN(Packet *p)
This method must be called by the HN-MAC to instruct the PHY to start the transmission of a packet.
Definition uwUFetch_NODE_HEADNODE.cpp:984
uwUFetch_NODE::getTotalCBeaconPckTx_by_HN
int getTotalCBeaconPckTx_by_HN()
Total number of CBEACON packets transmitted by the HN during an entire simulation.
Definition uwUFetch_NODE.h:1563
uwUFetch_NODE::getTotalDataPckTx_by_NODE
int getTotalDataPckTx_by_NODE()
Total number of DATA packets transmitted by SN during an entire duration of simulation.
Definition uwUFetch_NODE.h:2007
uwUFetch_NODE::getTotalTriggerPckRx_HN
int getTotalTriggerPckRx_HN()
Total number of TRIGGER packets correctly or not received by the HN during an entire simulation.
Definition uwUFetch_NODE.h:1607
uwUFetch_NODE::refreshReason
virtual void refreshReason(UWUFETCH_NODE_STATUS_CHANGE reason)
Refresh the reason for the changing of the state.
Definition uwUFetch_NODE.h:872
uwUFetch_NODE::getTotalDataPckRx_corrupted_by_HN
int getTotalDataPckRx_corrupted_by_HN()
Total number of corrupted DATA packets received by the HN during an entire simulation.
Definition uwUFetch_NODE.h:1519
uwUFetch_NODE::mac_addr_HN_in_cbeacon
int mac_addr_HN_in_cbeacon
HN MAC address from which the SN has received the CBEACON packet.
Definition uwUFetch_NODE.h:2200
uwUFetch_NODE::curr_POLL_NODE_pck_rx
Packet * curr_POLL_NODE_pck_rx
Pointer to the POLL packet that is being received by SN.
Definition uwUFetch_NODE.h:2257
uwUFetch_NODE::HEADNODE
int HEADNODE
Indicate if the node work as HEAD NODE or SENSOR NODE.
Definition uwUFetch_NODE.h:2574
uwUFetch_NODE::MODE_COMM_HN_AUV
int MODE_COMM_HN_AUV
Indicate the type of communication between HN and AUV, 0 = communication with RTS-CTS,...
Definition uwUFetch_NODE.h:2095
uwUFetch_NODE::getTotalProbePckRx_HN
int getTotalProbePckRx_HN()
Total number of PROBE packets correctly or not received by the HN during an entire simulation.
Definition uwUFetch_NODE.h:1387
uwUFetch_NODE::getTotalBeaconPckRx_corrupted_by_NODE
int getTotalBeaconPckRx_corrupted_by_NODE()
Total number of corrupted BEACON packets received by SN during an entire duration of simulation.
Definition uwUFetch_NODE.h:1853
uwUFetch_NODE::Phy2MacEndRx
virtual void Phy2MacEndRx(Packet *p)
Handle the end-of-PHY-reception event.
Definition uwUFetch_NODE_SENSOR.cpp:696
uwUFetch_NODE::txPROBEEnabled
bool txPROBEEnabled
true if SN is enabled to transmit a PROBE packet to the HN
Definition uwUFetch_NODE.h:2242
uwUFetch_NODE::incrTotalPollPckRx_corrupted_by_NODE
void incrTotalPollPckRx_corrupted_by_NODE()
Increase the total number of corrupted POLL packets received by SN during an entire duration of simul...
Definition uwUFetch_NODE.h:1951
uwUFetch_NODE::getDataPckTx_by_NODE
int getDataPckTx_by_NODE()
Number of DATA packets transmitted by the SN during a single cycle BEACON-PROBE-POLL-DATA-CBEACON of ...
Definition uwUFetch_NODE.h:1985
uwUFetch_NODE::T_CTS
double T_CTS
Definition uwUFetch_NODE.h:2299
uwUFetch_NODE::getTotalBeaconTx_by_HN
int getTotalBeaconTx_by_HN()
Total number of BEACON packets transmitted by the HN during an entire simulation.
Definition uwUFetch_NODE.h:1343
uwUFetch_NODE::tx_DATA_start_time
double tx_DATA_start_time
Indicates when SN start a transmission of DATA packet to the HN.
Definition uwUFetch_NODE.h:2132
uwUFetch_NODE::MAXIMUM_BUFFER_DATA_PCK_NODE
int MAXIMUM_BUFFER_DATA_PCK_NODE
Maximum number of DATA packets that the SN can store in Its queue.
Definition uwUFetch_NODE.h:2086
uwUFetch_NODE::DATA_NODE_tx
virtual void DATA_NODE_tx()
SN transmit a DATA packet to a specific HN.
Definition uwUFetch_NODE_SENSOR.cpp:2258
uwUFetch_NODE::fout
std::ofstream fout
Variable that handle the file in which the protocol write the state transition for debug purposes.
Definition uwUFetch_NODE.h:2592
uwUFetch_NODE::T_MAX_BACKOFF_PROBE
double T_MAX_BACKOFF_PROBE
Upper bound timer interval of back-off value used by the SN to choice its back-off time before to tra...
Definition uwUFetch_NODE.h:2279
uwUFetch_NODE::n_BEACON_pck_rx_by_NODE
int n_BEACON_pck_rx_by_NODE
Number of BEACON receive by the SN during a single cycle BEACON-PROBE-POLL-DATA-CBEACON of the simula...
Definition uwUFetch_NODE.h:2214
uwUFetch_NODE::initInfo
virtual void initInfo()
Initialize the protocol at the beginning of the simulation.
Definition uwUFetch_NODE_SENSOR.cpp:415
uwUFetch_NODE::rx_CBEACON_start_time
double rx_CBEACON_start_time
Indicates when SN started the reception of CBEACON packet from HN.
Definition uwUFetch_NODE.h:2136
uwUFetch_NODE::Mac2PhyStartTx
virtual void Mac2PhyStartTx(Packet *p)
This method must be called by the SN-MAC to instruct the PHY to start the transmission of a packet.
Definition uwUFetch_NODE_SENSOR.cpp:1603
uwUFetch_NODE::CBeaconTOExpired
virtual void CBeaconTOExpired()
CBEACON timeout is expired.
Definition uwUFetch_NODE_SENSOR.cpp:2441
uwUFetch_NODE::num_cbeacon_at_now_HN_tx
int num_cbeacon_at_now_HN_tx
NUmber of CBEACON packets transmitted by the HN during the single cycle BEACON-PROBE-POLL-DATA-CBEACO...
Definition uwUFetch_NODE.h:2197
uwUFetch_NODE::getTotalCBeaconPckRx_by_NODE
int getTotalCBeaconPckRx_by_NODE()
Total number of CBEACON packets received correctly or not by SN during an entire duration of simulati...
Definition uwUFetch_NODE.h:2051
uwUFetch_NODE::incrTotalBeaconPckRx_by_NODE
void incrTotalBeaconPckRx_by_NODE()
Increase the total number of BEACON packets received correctly or not by SN during an entire duration...
Definition uwUFetch_NODE.h:1819
uwUFetch_NODE::bck_before_tx_probe
double bck_before_tx_probe
Backoff time choiced by SN before to transmit a PROBE packet to the HN.
Definition uwUFetch_NODE.h:2180
uwUFetch_NODE::n_CBEACON_pck_rx_by_NODE
int n_CBEACON_pck_rx_by_NODE
Number of CBEACON received by the SN during a single cycle BEACON-PROBE-POLL-DATA-CBEACON of the simu...
Definition uwUFetch_NODE.h:2230
uwUFetch_NODE::T_min_bck_probe_node
double T_min_bck_probe_node
Lower bound timer interval used by the SN to choice the interval time before to transmit a PROBE pack...
Definition uwUFetch_NODE.h:2168
uwUFetch_NODE::curr_state
UWUFETCH_NODE_STATUS curr_state
Current state in which the SN or HN is located.
Definition uwUFetch_NODE.h:2564
uwUFetch_NODE::packetType
static std::map< UWUFETCH_NODE_PACKET_TYPE, std::string > packetType
Map the UWUFETCH_NODE_PACKET_TYPE to the description of packet type.
Definition uwUFetch_NODE.h:2585
uwUFetch_NODE::incrTotalPollPckRx_by_NODE
void incrTotalPollPckRx_by_NODE()
Increase the total number of POLL packets received correctly or not by SN during an entire duration o...
Definition uwUFetch_NODE.h:1929
uwUFetch_NODE::mac_addr_HN_in_poll
int mac_addr_HN_in_poll
HN MAC address from which the SN has received the POLL packet.
Definition uwUFetch_NODE.h:2189
uwUFetch_NODE::getTotalPollPckRx_corrupted_by_NODE
int getTotalPollPckRx_corrupted_by_NODE()
Total number of corrupted POLL packets received by SN during an entire duration of simulation.
Definition uwUFetch_NODE.h:1963
uwUFetch_NODE::computeTxTime
virtual void computeTxTime(UWUFETCH_NODE_PACKET_TYPE tp)
Compute the transmission time for the packets transmitted by the SNs.
Definition uwUFetch_NODE_SENSOR.cpp:2835
uwUFetch_NODE::incrProbePckTx_by_NODE
void incrProbePckTx_by_NODE()
Increase the number of PROBE packets transmitted by the SN during a single cycle BEACON-PROBE-POLL-DA...
Definition uwUFetch_NODE.h:1863
uwUFetch_NODE::getTotalCBeaconPckRx_corrupted_by_NODE
int getTotalCBeaconPckRx_corrupted_by_NODE()
Total number of corrupted CBEACON packets received by SN during an entire duration of simulation.
Definition uwUFetch_NODE.h:2073
uwUFetch_NODE::curr_BEACON_NODE_pck_rx
Packet * curr_BEACON_NODE_pck_rx
Pointer to the BEACON packet that is being received by SN.
Definition uwUFetch_NODE.h:2252
uwUFetch_NODE::getTotalCtsPckRx_HN
int getTotalCtsPckRx_HN()
Total number of CTS packets correctly or not received by the HN during an entire simulation.
Definition uwUFetch_NODE.h:1717
uwUFetch_NODE::BCK_timer_probe
uwUFetch_BackOffTimer BCK_timer_probe
Interval time in which HN is enabled to receive PROBE packets from SNs.
Definition uwUFetch_NODE.h:2103
uwUFetch_NODE::tx_DATA_finish_time
double tx_DATA_finish_time
Indicates when SN finished a transmission of DATA packet to the HN.
Definition uwUFetch_NODE.h:2134
uwUFetch_NODE::getTotalDataPckTx_by_HN
int getTotalDataPckTx_by_HN()
Total number of DATA packets transmitted by the HN during an entire simulation.
Definition uwUFetch_NODE.h:1783
uwUFetch_NODE::DATA_BEFORE_TX_timer
uwUFetch_DATA_BEFORE_TX_timer DATA_BEFORE_TX_timer
Definition uwUFetch_NODE.h:2109
uwUFetch_NODE::CBEACON_rx
virtual void CBEACON_rx()
SN has received a CBEACON packet from HN.
Definition uwUFetch_NODE_SENSOR.cpp:2474
uwUFetch_NODE::rx_POLL_start_time
double rx_POLL_start_time
Indicates when SN started the reception of POLL packet from HN.
Definition uwUFetch_NODE.h:2127
uwUFetch_NODE::state_PROBE_tx
virtual void state_PROBE_tx()
SN initialize the PROBE packet that will be forwarded to a specific HN.
Definition uwUFetch_NODE_SENSOR.cpp:1888
uwUFetch_NODE::rxPOLLEnabled
bool rxPOLLEnabled
true if SN is enabled to receive a POLL packet from the HN
Definition uwUFetch_NODE.h:2244
uwUFetch_NODE::rx_BEACON_start_time
double rx_BEACON_start_time
Indicates when SN started the reception of BEACON packet from HN.
Definition uwUFetch_NODE.h:2119
uwUFetch_NODE::recvFromUpperLayers_HN
virtual void recvFromUpperLayers_HN(Packet *p)
Handle a packet coming from upper layers of HN.
Definition uwUFetch_NODE_HEADNODE.cpp:3479
uwUFetch_NODE::MAX_PAYLOAD
int MAX_PAYLOAD
Maximum size of payload DATA packet.
Definition uwUFetch_NODE.h:2082
uwUFetch_NODE::PollTOExpired
virtual void PollTOExpired()
POLL timeout is expired.
Definition uwUFetch_NODE_SENSOR.cpp:2090
uwUFetch_NODE::recvFromUpperLayers
virtual void recvFromUpperLayers(Packet *p)
Handle a packet coming from upper layers of SN.
Definition uwUFetch_NODE_SENSOR.cpp:2859
uwUFetch_NODE::tx_PROBE_start_time
double tx_PROBE_start_time
Indicates when SN start a transmission of PROBE packet.
Definition uwUFetch_NODE.h:2123
uwUFetch_NODE::Tdata_NODE_pck
double Tdata_NODE_pck
Time duration need for SN for transmit a DATA packet to the HN.
Definition uwUFetch_NODE.h:2195
uwUFetch_NODE::Tdata_NODE
double Tdata_NODE
Time duration needed for SN to transmit a DATA packet to the HN.
Definition uwUFetch_NODE.h:2184
uwUFetch_NODE::incrTotalCBeaconPckRx_by_NODE
void incrTotalCBeaconPckRx_by_NODE()
Increase the total number of CBEACON packets received correctly or not by SN during an entire duratio...
Definition uwUFetch_NODE.h:2039
uwUFetch_NODE::state_wait_CBEACON
virtual void state_wait_CBEACON()
SN wait a CBEACON packet for a pre-established interval time.
Definition uwUFetch_NODE_SENSOR.cpp:2399
uwUFetch_NODE::isHeadNode
virtual bool isHeadNode()
Indicate if the node created work as head node or sensor node.
Definition uwUFetch_NODE_SENSOR.cpp:2813
uwUFetch_NODE::tx_PROBE_finish_time
double tx_PROBE_finish_time
Indicates when SN finished a transmission of PROBE packet.
Definition uwUFetch_NODE.h:2125
uwUFetch_NODE::UWUFETCH_NODE_PACKET_TYPE
UWUFETCH_NODE_PACKET_TYPE
Definition uwUFetch_NODE.h:235
uwUFetch_NODE::UWUFETCH_NODE_PACKET_TYPE_CTS
@ UWUFETCH_NODE_PACKET_TYPE_CTS
Definition uwUFetch_NODE.h:242
uwUFetch_NODE::UWUFETCH_NODE_PACKET_TYPE_PROBE
@ UWUFETCH_NODE_PACKET_TYPE_PROBE
Definition uwUFetch_NODE.h:237
uwUFetch_NODE::UWUFETCH_NODE_PACKET_TYPE_BEACON
@ UWUFETCH_NODE_PACKET_TYPE_BEACON
Definition uwUFetch_NODE.h:239
uwUFetch_NODE::UWUFETCH_NODE_PACKET_TYPE_RTS
@ UWUFETCH_NODE_PACKET_TYPE_RTS
Definition uwUFetch_NODE.h:241
uwUFetch_NODE::UWUFETCH_NODE_PACKET_TYPE_DATA
@ UWUFETCH_NODE_PACKET_TYPE_DATA
Definition uwUFetch_NODE.h:236
uwUFetch_NODE::UWUFETCH_NODE_PACKET_TYPE_POLL
@ UWUFETCH_NODE_PACKET_TYPE_POLL
Definition uwUFetch_NODE.h:238
uwUFetch_NODE::UWUFETCH_NODE_PACKET_TYPE_TRIGGER
@ UWUFETCH_NODE_PACKET_TYPE_TRIGGER
Definition uwUFetch_NODE.h:240
uwUFetch_NODE::choiceBackOffTimer
virtual double choiceBackOffTimer()
Choose the backoff timeout used by SN before to transmit a PROBE packet.
Definition uwUFetch_NODE_SENSOR.cpp:2823
uwUFetch_NODE::MODE_BURST_DATA
int MODE_BURST_DATA
Indicate if it's used or not the burst data.
Definition uwUFetch_NODE.h:2099
uwUFetch_NODE::incrTotalDataPckTx_by_NODE
void incrTotalDataPckTx_by_NODE()
Increase the total number of DATA packets transmitted by SN during an entire duration of simulation.
Definition uwUFetch_NODE.h:1995
uwUFetch_NODE::stateIdle_NODE
virtual void stateIdle_NODE()
Idle state for SN.
Definition uwUFetch_NODE_SENSOR.cpp:1738
uwUFetch_NODE::Phy2MacStartRx
virtual void Phy2MacStartRx(const Packet *p)
Handle the detected-start-of-PHY-reception event for SENSOR NODE.
Definition uwUFetch_NODE_SENSOR.cpp:580
uwUFetch_NODE::~uwUFetch_NODE
virtual ~uwUFetch_NODE()
Destructor of uwUFetch_NODE class.
Definition uwUFetch_NODE_SENSOR.cpp:272
uwUFetch_NODE::UWUFETCH_NODE_STATUS_CHANGE_DATA_MAX_ALLOWED_PCK_RX_0_NODE_TO_POLL_NO_OTHER_CBEACON
@ UWUFETCH_NODE_STATUS_CHANGE_DATA_MAX_ALLOWED_PCK_RX_0_NODE_TO_POLL_NO_OTHER_CBEACON
Definition uwUFetch_NODE.h:223
uwUFetch_NODE::UWUFETCH_NODE_STATUS_CHANGE_DATA_PCK_TX
@ UWUFETCH_NODE_STATUS_CHANGE_DATA_PCK_TX
Definition uwUFetch_NODE.h:204
uwUFetch_NODE::UWUFETCH_NODE_STATUS_CHANGE_MAX_DATA_PCK_TX
@ UWUFETCH_NODE_STATUS_CHANGE_MAX_DATA_PCK_TX
Definition uwUFetch_NODE.h:203
uwUFetch_NODE::UWUFETCH_NODE_STATUS_CHANGE_DATA_MAX_ALLOWED_PCK_RX_0_NODE_TO_POLL_YES_OTHER_CBEACON
@ UWUFETCH_NODE_STATUS_CHANGE_DATA_MAX_ALLOWED_PCK_RX_0_NODE_TO_POLL_YES_OTHER_CBEACON
Definition uwUFetch_NODE.h:224
uwUFetch_NODE::UWUFETCH_NODE_STATUS_CHANGE_TRIGGER_RX
@ UWUFETCH_NODE_STATUS_CHANGE_TRIGGER_RX
Definition uwUFetch_NODE.h:205
uwUFetch_NODE::UWUFETCH_NODE_STATUS_CHANGE_DATA_RX
@ UWUFETCH_NODE_STATUS_CHANGE_DATA_RX
Definition uwUFetch_NODE.h:221
uwUFetch_NODE::UWUFETCH_NODE_STATUS_CHANGE_PROBE_TX
@ UWUFETCH_NODE_STATUS_CHANGE_PROBE_TX
Definition uwUFetch_NODE.h:199
uwUFetch_NODE::UWFETCH_NODE_STATUS_CHANGE_CBEACON_RX_DATA_ALREADY_TX
@ UWFETCH_NODE_STATUS_CHANGE_CBEACON_RX_DATA_ALREADY_TX
Definition uwUFetch_NODE.h:202
uwUFetch_NODE::UWUFETCH_NODE_STATUS_CHANGE_DATA_TO_EXPIRED_ANOTHER_NODE_TO_POLL
@ UWUFETCH_NODE_STATUS_CHANGE_DATA_TO_EXPIRED_ANOTHER_NODE_TO_POLL
Definition uwUFetch_NODE.h:220
uwUFetch_NODE::UWUFETCH_NODE_STATUS_CHANGE_TO_WAIT_POLL_EXPIRED
@ UWUFETCH_NODE_STATUS_CHANGE_TO_WAIT_POLL_EXPIRED
Definition uwUFetch_NODE.h:200
uwUFetch_NODE::UWUFETCH_NODE_STATUS_CHANGE_CBEACON_ALLOWED_TX_0_PROBE_RX
@ UWUFETCH_NODE_STATUS_CHANGE_CBEACON_ALLOWED_TX_0_PROBE_RX
Definition uwUFetch_NODE.h:213
uwUFetch_NODE::UWUFETCH_NODE_STATUS_CHANGE_DATA_TO_EXPIRED_0_NODE_TO_POLL_YES_OTHER_CBEACON
@ UWUFETCH_NODE_STATUS_CHANGE_DATA_TO_EXPIRED_0_NODE_TO_POLL_YES_OTHER_CBEACON
Definition uwUFetch_NODE.h:219
uwUFetch_NODE::UWUFETCH_NODE_STATUS_CHANGE_CBEACON_TX
@ UWUFETCH_NODE_STATUS_CHANGE_CBEACON_TX
Definition uwUFetch_NODE.h:210
uwUFetch_NODE::UWUFETCH_NODE_STATUS_CHANGE_CBEACON_MAX_ALLOWED_TX
@ UWUFETCH_NODE_STATUS_CHANGE_CBEACON_MAX_ALLOWED_TX
Definition uwUFetch_NODE.h:226
uwUFetch_NODE::UWUFETCH_NODE_STATUS_CHANGE_HN_RX_TRIGGER_FROM_AUV_CORRUPTED
@ UWUFETCH_NODE_STATUS_CHANGE_HN_RX_TRIGGER_FROM_AUV_CORRUPTED
Definition uwUFetch_NODE.h:230
uwUFetch_NODE::UWUFETCH_NODE_STATUS_CHANGE_RTS_TX
@ UWUFETCH_NODE_STATUS_CHANGE_RTS_TX
Definition uwUFetch_NODE.h:206
uwUFetch_NODE::UWFETCH_NODE_STATUS_CHANGE_PACKET_UNKNOWN_TYPE
@ UWFETCH_NODE_STATUS_CHANGE_PACKET_UNKNOWN_TYPE
Definition uwUFetch_NODE.h:197
uwUFetch_NODE::UWUFETCH_NODE_STATUS_CHANGE_PROBE_RX
@ UWUFETCH_NODE_STATUS_CHANGE_PROBE_RX
Definition uwUFetch_NODE.h:211
uwUFetch_NODE::UWUFETCH_NODE_STATUS_CHANGE_LAST_DATA_PCK_RX
@ UWUFETCH_NODE_STATUS_CHANGE_LAST_DATA_PCK_RX
Definition uwUFetch_NODE.h:222
uwUFetch_NODE::UWUFETCH_NODE_STATUS_CHANGE_DATA_TO_EXPIRED
@ UWUFETCH_NODE_STATUS_CHANGE_DATA_TO_EXPIRED
Definition uwUFetch_NODE.h:217
uwUFetch_NODE::UWFETCH_NODE_STATUS_CHANGE_STATE_IDLE
@ UWFETCH_NODE_STATUS_CHANGE_STATE_IDLE
Definition uwUFetch_NODE.h:194
uwUFetch_NODE::UWUFETCH_NODE_STATUS_CHANGE_DATA_TO_EXPIRED_0_NODE_TO_POLL_NO_OTHER_CBEACON
@ UWUFETCH_NODE_STATUS_CHANGE_DATA_TO_EXPIRED_0_NODE_TO_POLL_NO_OTHER_CBEACON
Definition uwUFetch_NODE.h:218
uwUFetch_NODE::UWUFETCH_NODE_STATUS_CHANGE_CBEACON_MAX_ALLOWED_TX_0_PROBE_RX
@ UWUFETCH_NODE_STATUS_CHANGE_CBEACON_MAX_ALLOWED_TX_0_PROBE_RX
Definition uwUFetch_NODE.h:212
uwUFetch_NODE::UWUFETCH_NODE_STATUS_CHANGE_POLL_TX
@ UWUFETCH_NODE_STATUS_CHANGE_POLL_TX
Definition uwUFetch_NODE.h:216
uwUFetch_NODE::UWUFETCH_NODE_STATUS_CHANGE_POLL_RX
@ UWUFETCH_NODE_STATUS_CHANGE_POLL_RX
Definition uwUFetch_NODE.h:201
uwUFetch_NODE::UWUFETCH_NODE_STATUS_CHANGE_DATA_MAX_ALLOWED_PCK_RX_YES_NODE_TO_POLL
@ UWUFETCH_NODE_STATUS_CHANGE_DATA_MAX_ALLOWED_PCK_RX_YES_NODE_TO_POLL
Definition uwUFetch_NODE.h:225
uwUFetch_NODE::UWUFETCH_NODE_STATUS_CHANGE_CTS_RX
@ UWUFETCH_NODE_STATUS_CHANGE_CTS_RX
Definition uwUFetch_NODE.h:208
uwUFetch_NODE::UWUFETCH_NODE_STATUS_CHANGE_BEACON_RX
@ UWUFETCH_NODE_STATUS_CHANGE_BEACON_RX
Definition uwUFetch_NODE.h:198
uwUFetch_NODE::UWUFETCH_NODE_STATUS_CHANGE_BEACON_TO_EXPIRED
@ UWUFETCH_NODE_STATUS_CHANGE_BEACON_TO_EXPIRED
Definition uwUFetch_NODE.h:227
uwUFetch_NODE::UWUFETCH_NODE_STATUS_CHANGE_TO_WAIT_CTS_EXPIRED
@ UWUFETCH_NODE_STATUS_CHANGE_TO_WAIT_CTS_EXPIRED
Definition uwUFetch_NODE.h:207
uwUFetch_NODE::UWUFETCH_NODE_STATUS_CHANGE_TO_EXPIRED_AT_LEAST_1_PROBE_RX
@ UWUFETCH_NODE_STATUS_CHANGE_TO_EXPIRED_AT_LEAST_1_PROBE_RX
Definition uwUFetch_NODE.h:215
uwUFetch_NODE::UWUFETCH_NODE_STATUS_CHANGE_TRIGGER_RX_BUT_HN_NO_DATA_TO_TX
@ UWUFETCH_NODE_STATUS_CHANGE_TRIGGER_RX_BUT_HN_NO_DATA_TO_TX
Definition uwUFetch_NODE.h:228
uwUFetch_NODE::UWFETCH_NODE_STATUS_CHANGE_PACKET_FOR_ANOTHER_NODE
@ UWFETCH_NODE_STATUS_CHANGE_PACKET_FOR_ANOTHER_NODE
Definition uwUFetch_NODE.h:196
uwUFetch_NODE::UWFETCH_NODE_STATUS_CHANGE_PACKET_ERROR
@ UWFETCH_NODE_STATUS_CHANGE_PACKET_ERROR
Definition uwUFetch_NODE.h:195
uwUFetch_NODE::UWUFETCH_NODE_STATUS_CHANGE_BEACON_TX
@ UWUFETCH_NODE_STATUS_CHANGE_BEACON_TX
Definition uwUFetch_NODE.h:209
uwUFetch_NODE::UWUFETCH_NODE_STATUS_CHANGE_HN_FINISH_TX_DATA_PCK_TO_AUV_RETURN_CBEACON_TX
@ UWUFETCH_NODE_STATUS_CHANGE_HN_FINISH_TX_DATA_PCK_TO_AUV_RETURN_CBEACON_TX
Definition uwUFetch_NODE.h:231
uwUFetch_NODE::UWUFETCH_NODE_STATUS_CHANGE_HN_TX_ALL_DATA_TO_AUV
@ UWUFETCH_NODE_STATUS_CHANGE_HN_TX_ALL_DATA_TO_AUV
Definition uwUFetch_NODE.h:229
uwUFetch_NODE::UWUFETCH_NODE_STATUS_CHANGE_MAX_PROBE_RX_PROBE_TO_NOT_EXPIRED
@ UWUFETCH_NODE_STATUS_CHANGE_MAX_PROBE_RX_PROBE_TO_NOT_EXPIRED
Definition uwUFetch_NODE.h:214
uwUFetch_NODE::curr_CBEACON_NODE_pck_rx
Packet * curr_CBEACON_NODE_pck_rx
Pointer to the CBEACON packet that is being received by SN
Definition uwUFetch_NODE.h:2263
uwUFetch_NODE::rxBEACONEnabled
bool rxBEACONEnabled
true if SN is enabled to receive a BEACON packet from the HN
Definition uwUFetch_NODE.h:2239
uwUFetch_NODE::dataAlreadyTransmitted
bool dataAlreadyTransmitted
Indicate whether the SN has transmit at least one DATA packets during the cycle BEACON-PROBE-POLL-DAT...
Definition uwUFetch_NODE.h:2234
uwUFetch_NODE::getTotalRtsPckTx_by_HN
int getTotalRtsPckTx_by_HN()
Total number of RTS packets transmitted by the HN during an entire simulation.
Definition uwUFetch_NODE.h:1673
uwUFetch_NODE::Tprobe
double Tprobe
Time duration needed for SN to transmit a PROBE packet to the HN.
Definition uwUFetch_NODE.h:2182
uwUFetch_NODE::MAX_PCK_HN_WANT_RX_FROM_NODE
int MAX_PCK_HN_WANT_RX_FROM_NODE
Definition uwUFetch_NODE.h:2295
uwUFetch_NODE::getTotalProbePckTx_by_NODE
int getTotalProbePckTx_by_NODE()
Total number of PROBE packets transmitted by SN during an entire duration of simulation.
Definition uwUFetch_NODE.h:1897
uwUFetch_NODE::statusChange
static std::map< UWUFETCH_NODE_STATUS_CHANGE, std::string > statusChange
Map the UWUFETCH_NODE_STATUS_CHANGE to the description the reason of changing state.
Definition uwUFetch_NODE.h:2582
uwUFetch_NODE::statusInfo
static std::map< UWUFETCH_NODE_STATUS, std::string > statusInfo
Map the UWUFETCH_NODE_STATUS to the description of each state.
Definition uwUFetch_NODE.h:2579
uwUFetch_NODE::PRINT_TRANSITIONS_INT
int PRINT_TRANSITIONS_INT
0 reason because the SN or HN is passed from a state to another state is not logged in a file
Definition uwUFetch_NODE.h:2285
uwUFetch_NODE::state_DATA_NODE_first_tx
virtual void state_DATA_NODE_first_tx()
SN initialize the FIRST DATA packet that will be forwarded to a specific HN.
Definition uwUFetch_NODE_SENSOR.cpp:2219
uwUFetch_NODE::incrTotalProbePckTx_by_NODE
void incrTotalProbePckTx_by_NODE()
Increase the total number of PROBE packets transmitted by SN during an entire duration of simulation.
Definition uwUFetch_NODE.h:1885
uwUFetch_NODE::T_START_PROCEDURE_HN_NODE
double T_START_PROCEDURE_HN_NODE
Time within HN is enabled to received a TRIGGER packet from AUV.
Definition uwUFetch_NODE.h:2274
uwUFetch_NODE::state_wait_POLL
virtual void state_wait_POLL()
SN wait a POLL packet from a specific HN.
Definition uwUFetch_NODE_SENSOR.cpp:2041
uwUFetch_NODE::Q_data
std::queue< Packet * > Q_data
Queue of DATA packets stored by the SN.
Definition uwUFetch_NODE.h:2267
uwUFetch_NODE::command
virtual int command(int argc, const char *const *argv)
TCL command interpreter.
Definition uwUFetch_NODE_SENSOR.cpp:278
uwUFetch_NODE::POLL_timer
uwUFetch_POLL_timer POLL_timer
Interval time in which SN is enabled to receive POLL packet from the specific HN.
Definition uwUFetch_NODE.h:2107
uwUFetch_NODE::n_PROBE_pck_tx_by_NODE
int n_PROBE_pck_tx_by_NODE
Number of PROBE transmitted by the SN during a single cycle BEACON-PROBE-POLL-DATA-CBEACON of the sim...
Definition uwUFetch_NODE.h:2218
uwUFetch_NODE::PROBE_tx
virtual void PROBE_tx()
Transmission of PROBE packet by SN to the specific HN.
Definition uwUFetch_NODE_SENSOR.cpp:2022
uwUFetch_NODE::incrPollPckRx_by_NODE
void incrPollPckRx_by_NODE()
Increase the number of POLL packets received by the SN during a single cycle BEACON-PROBE-POLL-DATA-C...
Definition uwUFetch_NODE.h:1907
uwUFetch_NODE::waitForUser
virtual void waitForUser()
Method used for debug.
Definition uwUFetch_NODE_SENSOR.cpp:2961
uwUFetch_NODE::curr_DATA_NODE_pck_tx
Packet * curr_DATA_NODE_pck_tx
Pointer to the DATA packet that is being transmitted by SN.
Definition uwUFetch_NODE.h:2260
uwUFetch_NODE::state_DATA_NODE_tx
virtual void state_DATA_NODE_tx()
SN initialize the second or successive DATA packet that will be forwarded to a specific HN.
Definition uwUFetch_NODE_SENSOR.cpp:2294
uwUFetch_NODE::POLL_rx
virtual void POLL_rx()
SN has received a POLL packet from a specific HN.
Definition uwUFetch_NODE_SENSOR.cpp:2147
uwUFetch_NODE::print_transitions
bool print_transitions
true if the writing of state transitions in the file is enabled.
Definition uwUFetch_NODE.h:2572
uwUFetch_NODE::getProbePckTx_by_NODE
int getProbePckTx_by_NODE()
Number of PROBE packets transmitted by the SN during a single cycle BEACON-PROBE-POLL-DATA-CBEACON of...
Definition uwUFetch_NODE.h:1875
uwUFetch_NODE::refreshState
virtual void refreshState(UWUFETCH_NODE_STATUS state)
Definition uwUFetch_NODE.h:883
uwUFetch_NODE::Phy2MacEndTx
virtual void Phy2MacEndTx(const Packet *p)
Handle the end-of-PHY-transmission event.
Definition uwUFetch_NODE_SENSOR.cpp:1662
uwUFetch_NODE::DataBeforeTxTOExpired
virtual void DataBeforeTxTOExpired()
Data timeout.
Definition uwUFetch_NODE_SENSOR.cpp:2274
uwUFetch_NODE::UWUFETCH_NODE_STATUS_PROBE_RX
@ UWUFETCH_NODE_STATUS_PROBE_RX
Definition uwUFetch_NODE.h:184
uwUFetch_NODE::UWUFETCH_NODE_STATUS_WAIT_CBEACON_PACKET
@ UWUFETCH_NODE_STATUS_WAIT_CBEACON_PACKET
Definition uwUFetch_NODE.h:188
uwUFetch_NODE::UWUFETCH_NODE_STATUS_POLL_TX
@ UWUFETCH_NODE_STATUS_POLL_TX
Definition uwUFetch_NODE.h:185
uwUFetch_NODE::UWUFETCH_NODE_STATUS_WAIT_CTS_PACKET
@ UWUFETCH_NODE_STATUS_WAIT_CTS_PACKET
Definition uwUFetch_NODE.h:180
uwUFetch_NODE::UWUFETCH_NODE_STATUS_CBEACON_RECEIVE
@ UWUFETCH_NODE_STATUS_CBEACON_RECEIVE
Definition uwUFetch_NODE.h:189
uwUFetch_NODE::UWUFETCH_NODE_STATUS_TRIGGER_RECEIVE
@ UWUFETCH_NODE_STATUS_TRIGGER_RECEIVE
Definition uwUFetch_NODE.h:178
uwUFetch_NODE::UWUFETCH_NODE_STATUS_POLL_RECEIVE
@ UWUFETCH_NODE_STATUS_POLL_RECEIVE
Definition uwUFetch_NODE.h:176
uwUFetch_NODE::UWUFETCH_NODE_STATUS_BEACON_RECEIVE
@ UWUFETCH_NODE_STATUS_BEACON_RECEIVE
Definition uwUFetch_NODE.h:173
uwUFetch_NODE::UWUFETCH_NODE_STATUS_CTS_RECEIVE
@ UWUFETCH_NODE_STATUS_CTS_RECEIVE
Definition uwUFetch_NODE.h:181
uwUFetch_NODE::UWUFETCH_NODE_STATUS_WAIT_DATA_NODE
@ UWUFETCH_NODE_STATUS_WAIT_DATA_NODE
Definition uwUFetch_NODE.h:186
uwUFetch_NODE::UWUFETCH_NODE_STATUS_WAIT_POLL_PACKET
@ UWUFETCH_NODE_STATUS_WAIT_POLL_PACKET
Definition uwUFetch_NODE.h:175
uwUFetch_NODE::UWUFETCH_NODE_STATUS_TRANSMIT_PROBE
@ UWUFETCH_NODE_STATUS_TRANSMIT_PROBE
Definition uwUFetch_NODE.h:174
uwUFetch_NODE::UWUFETCH_NODE_STATUS_WAIT_PROBE_PACKET
@ UWUFETCH_NODE_STATUS_WAIT_PROBE_PACKET
Definition uwUFetch_NODE.h:183
uwUFetch_NODE::UWUFETCH_NODE_STATUS_DATA_RX
@ UWUFETCH_NODE_STATUS_DATA_RX
Definition uwUFetch_NODE.h:187
uwUFetch_NODE::UWUFETCH_NODE_STATUS_TRANSMIT_DATA
@ UWUFETCH_NODE_STATUS_TRANSMIT_DATA
Definition uwUFetch_NODE.h:177
uwUFetch_NODE::UWUFETCH_NODE_STATUS_TRANSMIT_BEACON
@ UWUFETCH_NODE_STATUS_TRANSMIT_BEACON
Definition uwUFetch_NODE.h:182
uwUFetch_NODE::UWUFETCH_NODE_STATUS_IDLE
@ UWUFETCH_NODE_STATUS_IDLE
Definition uwUFetch_NODE.h:172
uwUFetch_NODE::UWUFETCH_NODE_STATUS_RTS_TRANSMIT
@ UWUFETCH_NODE_STATUS_RTS_TRANSMIT
Definition uwUFetch_NODE.h:179
uwUFetch_NODE::num_cbeacon_node_rx
int num_cbeacon_node_rx
Number of CBEACON that the node have received from the specific HN before to receive an another BEACO...
Definition uwUFetch_NODE.h:2175
hdr_BEACON_UFETCH
Content header of BEACON packet.
Definition uwUFetch_cmn_hdr.h:253
hdr_BEACON_UFETCH::t_max_bc
int & t_max_bc()
Reference to t_max_bc_ variable.
Definition uwUFetch_cmn_hdr.h:288
hdr_BEACON_UFETCH::num_Max_CBEACON_tx_by_HN
int & num_Max_CBEACON_tx_by_HN()
Reference to num_Max_CBEACON_tx_by_HN_ variable.
Definition uwUFetch_cmn_hdr.h:299
hdr_BEACON_UFETCH::t_min_bc
int & t_min_bc()
Reference to t_min_bc_ variable.
Definition uwUFetch_cmn_hdr.h:277
hdr_CBEACON_UFETCH
Content header of CBEACON packet.
Definition uwUFetch_cmn_hdr.h:414
hdr_CBEACON_UFETCH::t_max_bc
int & t_max_bc()
Reference to t_max_bc_ variable.
Definition uwUFetch_cmn_hdr.h:449
hdr_CBEACON_UFETCH::t_min_bc
int & t_min_bc()
Reference to t_min_bc_ variable.
Definition uwUFetch_cmn_hdr.h:438
hdr_CBEACON_UFETCH::num_Max_CBEACON_tx_by_HN
int & num_Max_CBEACON_tx_by_HN()
Reference to num_Max_CBEACON_tx_by_HN_ variable.
Definition uwUFetch_cmn_hdr.h:460
hdr_POLL_UFETCH
Content header of POLL packet.
Definition uwUFetch_cmn_hdr.h:364
hdr_POLL_UFETCH::num_DATA_pcks_MAX_rx
int & num_DATA_pcks_MAX_rx()
Reference to num_DATA_pcks_MAX_rx variable.
Definition uwUFetch_cmn_hdr.h:388
hdr_PROBE_UFETCH
Content header of PROBE packet.
Definition uwUFetch_cmn_hdr.h:314
hdr_PROBE_UFETCH::n_DATA_pcks_Node_tx
int & n_DATA_pcks_Node_tx()
Reference to n_DATA_pcks_Node_tx_ variable.
Definition uwUFetch_cmn_hdr.h:338
hdr_PROBE_UFETCH::backoff_time_PROBE
int & backoff_time_PROBE()
Reference to backoff_time_PROBE_ variable.
Definition uwUFetch_cmn_hdr.h:349
hdr_uwcbr
hdr_uwcbr describes UWCBR packets.
Definition uwcbr-module.h:73
hdr_uwcbr::sn
uint16_t & sn()
Reference to the sn_ variable.
Definition uwcbr-module.h:102
uwUFetch_NODE.h
Declaration of uwUFetch_NODE class.
PT_POLL_UFETCH
packet_t PT_POLL_UFETCH
POLL packet type for UFetch protocol.
Definition DESERT_Framework/DESERT/data_link/uwUFetch/initlib.cpp:56
UWFETCH_NODE_DROP_REASON_ERROR
#define UWFETCH_NODE_DROP_REASON_ERROR
Packet dropped: packet is corrupted.
Definition uwUFetch_NODE.h:62
UWUFETCH_NODE_DROP_REASON_BUFFER_FULL
#define UWUFETCH_NODE_DROP_REASON_BUFFER_FULL
Packet dropped: buffer of the node is completely full.
Definition uwUFetch_NODE.h:64
PT_CBEACON_UFETCH
packet_t PT_CBEACON_UFETCH
CBEACON packet type for UFetch protocol.
Definition DESERT_Framework/DESERT/data_link/uwUFetch/initlib.cpp:57
PT_TRIGGER_UFETCH
packet_t PT_TRIGGER_UFETCH
TRIGGER packet type for UFetch protocol.
Definition DESERT_Framework/DESERT/data_link/uwUFetch/initlib.cpp:51
PT_BEACON_UFETCH
packet_t PT_BEACON_UFETCH
BEACON packet type for UFetch protocol.
Definition DESERT_Framework/DESERT/data_link/uwUFetch/initlib.cpp:54
UWUFETCH_NODE_DROP_CAN_NOT_RX_THIS_PCK
#define UWUFETCH_NODE_DROP_CAN_NOT_RX_THIS_PCK
Packet dropped: node can not receive this type of node.
Definition uwUFetch_NODE.h:71
UWFETCH_NODE_DROP_REASON_WRONG_RECEIVER
#define UWFETCH_NODE_DROP_REASON_WRONG_RECEIVER
Packet dropped: Packet is addressed to another node.
Definition uwUFetch_NODE.h:57
PT_PROBE_UFETCH
packet_t PT_PROBE_UFETCH
PROBE packet type for UFetch protocol.
Definition DESERT_Framework/DESERT/data_link/uwUFetch/initlib.cpp:55
UWUFETCH_NODE_DROP_REASON_NOT_ENABLE
#define UWUFETCH_NODE_DROP_REASON_NOT_ENABLE
Packet dropped: node is not enabled to receive this type of \ packet.
Definition uwUFetch_NODE.h:66
class_module_uwufetchnode
uwUFetchNODEModuleClass class_module_uwufetchnode
uwUFetch_cmn_hdr.h
Common structures and variables in the protocol.
HDR_BEACON_UFETCH
#define HDR_BEACON_UFETCH(p)
alias defined to access the BEACON HEADER
Definition uwUFetch_cmn_hdr.h:56
HDR_POLL_UFETCH
#define HDR_POLL_UFETCH(p)
alias defined to access the POLL \ HEADER
Definition uwUFetch_cmn_hdr.h:66
HDR_CBEACON_UFETCH
#define HDR_CBEACON_UFETCH(p)
alias defined to access the CBEACON HEADER
Definition uwUFetch_cmn_hdr.h:70
v_speed_sound
static const int v_speed_sound
Underwater sound propagation speed.
Definition uwUFetch_cmn_hdr.h:84
HDR_PROBE_UFETCH
#define HDR_PROBE_UFETCH(p)
alias defined to access the PROBE HEADER
Definition uwUFetch_cmn_hdr.h:61
uwcbr-module.h
Provides the UWCBR packets header description and the definition of the class UWCBR.
HDR_UWCBR
#define HDR_UWCBR(p)
Definition uwcbr-module.h:64