Loading [MathJax]/extensions/tex2jax.js
iCub-main
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
ethParser.cpp
Go to the documentation of this file.
1// -*- Mode:C++; tab-width:4; c-basic-offset:4; indent-tabs-mode:nil -*-
2
3
4/*
5 * Copyright (C) 2017 iCub Facility - Istituto Italiano di Tecnologia
6 * Author: Marco Accame
7 * email: marco.accame@iit.it
8 * website: www.robotcub.org
9 * Permission is granted to copy, distribute, and/or modify this program
10 * under the terms of the GNU General Public License, version 2 or any
11 * later version published by the Free Software Foundation.
12 *
13 * A copy of the license can be found at
14 * http://www.robotcub.org/icub/license/gpl.txt
15 *
16 * This program is distributed in the hope that it will be useful, but
17 * WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
19 * Public License for more details
20*/
21
22
23// --------------------------------------------------------------------------------------------------------------------
24// - public interface
25// --------------------------------------------------------------------------------------------------------------------
26
27#include "ethParser.h"
28
29
30
31// --------------------------------------------------------------------------------------------------------------------
32// - external dependencies
33// --------------------------------------------------------------------------------------------------------------------
34
35
36#include <yarp/os/Log.h>
37#include <yarp/os/LogStream.h>
38using yarp::os::Log;
39
40#include <yarp/os/Bottle.h>
41#include <yarp/os/Value.h>
42
43using namespace yarp::os;
44
45
46// --------------------------------------------------------------------------------------------------------------------
47// - pimpl: private implementation (see scott meyers: item 22 of effective modern c++, item 31 of effective c++
48// --------------------------------------------------------------------------------------------------------------------
49
50
51
52// --------------------------------------------------------------------------------------------------------------------
53// - the class
54// --------------------------------------------------------------------------------------------------------------------
55
56
57bool eth::parser::print(const pc104Data &pc104data)
58{
59
60 yDebug() << "eth::parser::print(pc104Data) for PC104:";
61
62 yDebug() << "PC104/PC104IpAddress:PC104IpPort = " << pc104data.addressingstring;
63 yDebug() << "PC104/PC104TXrate = " << pc104data.txrate;
64 yDebug() << "PC104/PC104RXrate = " << pc104data.rxrate;
65
66 return true;
67}
68
69bool eth::parser::print(const boardData &boarddata)
70{
71
72 yDebug() << "eth::parser::print(boardData) for BOARD" << boarddata.settings.name;
73
74 yDebug() << "ETH_BOARD/ETH_BOARD_PROPERTIES:";
75 yDebug() << "ETH_BOARD/ETH_BOARD_PROPERTIES/IpAddress = " << boarddata.properties.ipv4string;
76 yDebug() << "ETH_BOARD/ETH_BOARD_PROPERTIES/IpPort = " << boarddata.properties.ipv4addressing.port;
77 yDebug() << "ETH_BOARD/ETH_BOARD_PROPERTIES/Type = " << boarddata.properties.typestring;
78 yDebug() << "ETH_BOARD/ETH_BOARD_PROPERTIES/maxSizeRXpacket = " << boarddata.properties.maxSizeRXpacket;
79 yDebug() << "ETH_BOARD/ETH_BOARD_PROPERTIES/maxSizeROP = " << boarddata.properties.maxSizeROP;
80
81 yDebug() << "ETH_BOARD/ETH_BOARD_SETTINGS:";
82 yDebug() << "ETH_BOARD/ETH_BOARD_SETTINGS/Name = " << boarddata.settings.name;
83 yDebug() << "ETH_BOARD/ETH_BOARD_SETTINGS/RUNNINGMODE/ = " << boarddata.settings.to_string(boardSettings::ENTITY::runningmode);
84 yDebug() << "ETH_BOARD/ETH_BOARD_SETTINGS/RUNNINGMODE/LOGGING/ = " << boarddata.settings.to_string(boardSettings::ENTITY::logging);
85 yDebug() << "ETH_BOARD/ETH_BOARD_ACTIONS/MONITOR_ITS_PRESENCE";
86 yDebug() << "ETH_BOARD/ETH_BOARD_ACTIONS/MONITOR_ITS_PRESENCE/(enabled, timeout, periodOfMissingReport) = " <<
88
89 return true;
90}
91
92bool eth::parser::read(yarp::os::Searchable &cfgtotal, pc104Data &pc104data)
93{
94 pc104data.setdefault();
95
96 Bottle groupDEBUG = cfgtotal.findGroup("DEBUG");
97 if ((! groupDEBUG.isNull()) && (groupDEBUG.check("embBoardsConnected")))
98 {
99 pc104data.embBoardsConnected = groupDEBUG.find("embBoardsConnected").asBool();
100 }
101
102 if(!pc104data.embBoardsConnected)
103 {
104 yDebug() << "ATTENTION: NO EMBEDDED BOARDS CONNECTED. YOU ARE IN DEBUG MODE";
105 }
106
107 // localaddress
108
109 Bottle groupPC104 = Bottle(cfgtotal.findGroup("PC104"));
110 if (groupPC104.isNull())
111 {
112 yError() << "eth::parser::read() cannot find PC104 group in config files";
113 return false;
114 }
115
116 Value *value;
117
118 if (!groupPC104.check("PC104IpAddress", value))
119 {
120 yError() << "eth::parser::read(): missing PC104/PC104IpAddress in config files";
121 return false;
122 }
123 if (!groupPC104.check("PC104IpPort", value))
124 {
125 yError() << "eth::parser::read(): missing PC104/PC104IpPort in config files";
126 return false;
127 }
128
129 Bottle paramIPaddress(groupPC104.find("PC104IpAddress").asString());
130 uint16_t port = groupPC104.find("PC104IpPort").asInt32(); // .get(1).asInt32();
131 char strIP[64] = {0};
132
133
134 snprintf(strIP, sizeof(strIP), "%s", paramIPaddress.toString().c_str());
135 // strIP is now "10.0.1.104" ... i want to remove the "".... VERY IMPORTANT: use \" in sscanf
136 int ip1, ip2, ip3, ip4;
137 sscanf(strIP, "\"%d.%d.%d.%d", &ip1, &ip2, &ip3, &ip4);
138
139 pc104data.localaddressing.addr = eo_common_ipv4addr(ip1, ip2, ip3, ip4);
140 pc104data.localaddressing.port = port;
141
142 char ss[30];
143 snprintf(ss, sizeof(ss), "%d.%d.%d.%d:%d", ip1, ip2, ip3, ip4, port);
144
145 pc104data.addressingstring = ss;
146
147
148 // txrate
149 if(cfgtotal.findGroup("PC104").check("PC104TXrate"))
150 {
151 int value = cfgtotal.findGroup("PC104").find("PC104TXrate").asInt32();
152 if(value > 0)
153 {
154 pc104data.txrate = value;
155 }
156 }
157 else
158 {
159 yWarning () << "eth::parser::read() cannot find ETH/PC104TXrate. thus using default value" << pc104data.txrate;
160 }
161
162 // rxrate
163 if(cfgtotal.findGroup("PC104").check("PC104RXrate"))
164 {
165 int value = cfgtotal.findGroup("PC104").find("PC104RXrate").asInt32();
166 if(value > 0)
167 {
168 pc104data.rxrate = value;
169 }
170 }
171 else
172 {
173 yWarning () << "eth::parser::read() cannot find ETH/PC104RXrate. thus using default value" << pc104data.rxrate;
174 }
175
176 // now i print all the found values
177
178 //print(pc104data);
179
180 return true;
181}
182
183
184bool eth::parser::read(yarp::os::Searchable &cfgtotal, boardData &boarddata)
185{
186 Bottle groupEthBoard = Bottle(cfgtotal.findGroup("ETH_BOARD"));
187 if(groupEthBoard.isNull())
188 {
189 yError() << "eth::parser::read() cannot find ETH_BOARD group in config files";
190 return false;
191 }
192 Bottle groupEthBoardProps = Bottle(groupEthBoard.findGroup("ETH_BOARD_PROPERTIES"));
193 if(groupEthBoardProps.isNull())
194 {
195 yError() << "eth::parser::read() cannot find ETH_BOARD_PROPERTIES group in config files";
196 return false;
197 }
198 Bottle groupEthBoardSettings = Bottle(groupEthBoard.findGroup("ETH_BOARD_SETTINGS"));
199 if(groupEthBoardSettings.isNull())
200 {
201 yError() << "eth::parser::read() cannot find ETH_BOARD_PROPERTIES group in config files";
202 return false;
203 }
204
205 // -> ETH_BOARD/ETH_BOARD_PROPERTIES
206
207 boarddata.properties.reset();
208
209 // IpAddress:
210 if(true == groupEthBoardProps.check("IpAddress"))
211 {
212 Bottle paramIPboard(groupEthBoardProps.find("IpAddress").asString());
213 char str[64] = {0};
214 strcpy(str, paramIPboard.toString().c_str());
215 int ip1, ip2, ip3, ip4;
216 sscanf(str, "\"%d.%d.%d.%d", &ip1, &ip2, &ip3, &ip4);
217 boarddata.properties.ipv4addressing.addr = eo_common_ipv4addr(ip1, ip2, ip3, ip4);
218 }
219 else
220 {
221 yError() << "eth::parser::read() cannot find ETH_BOARD_PROPERTIES/IpAddress group in config files";
222 return false;
223 }
224
225 char ipinfo[20] = {0};
226 eo_common_ipv4addr_to_string(boarddata.properties.ipv4addressing.addr, ipinfo, sizeof(ipinfo));
227 boarddata.properties.ipv4string = ipinfo;
228
229
230 // IpPort:
231 if(true == groupEthBoardProps.check("IpPort"))
232 {
233 boarddata.properties.ipv4addressing.port = groupEthBoardProps.find("IpPort").asInt32();;
234 }
235 else
236 {
237 boarddata.properties.ipv4addressing.port = 12345;
238 yWarning() << "eth::parser::read() cannot find ETH_BOARD_PROPERTIES/IpPort group in config files." << " using:" << boarddata.properties.ipv4addressing.port;
239 }
240
241 snprintf(ipinfo, sizeof(ipinfo), ":%d", boarddata.properties.ipv4addressing.port);
242 boarddata.properties.ipv4addressingstring = boarddata.properties.ipv4string + ipinfo;
243
244
245 // Type:
246 Bottle b_ETH_BOARD_PROPERTIES_Type = groupEthBoardProps.findGroup("Type");
247 std::string Type = b_ETH_BOARD_PROPERTIES_Type.get(1).asString();
248 const char *strType = Type.c_str();
249 // 1. compare with the exceptions which may be in some old xml files ("EMS4", "MC4PLUS", "MC2PLUS"), and then then call proper functions
250 if(0 == strcmp(strType, "EMS4"))
251 {
252 boarddata.properties.type = eobrd_ethtype_ems4;
253 }
254 else if(0 == strcmp(strType, "MC4PLUS"))
255 {
256 boarddata.properties.type = eobrd_ethtype_mc4plus;
257 }
258 else if(0 == strcmp(strType, "MC2PLUS"))
259 {
260 boarddata.properties.type = eobrd_ethtype_mc2plus;
261 }
262 else
263 {
264 eObrd_type_t brd = eobrd_unknown;
265 if(eobrd_unknown == (brd = eoboards_string2type2(strType, eobool_true)))
266 {
267 brd = eoboards_string2type2(strType, eobool_false);
268 }
269
270 // if not found in compact or extended string format, we accept that the board is unknown
271
272 boarddata.properties.type = eoboards_type2ethtype(brd);
273 }
274 char boardTypeString[30];
275 snprintf(boardTypeString, sizeof(boardTypeString), "%s", eoboards_type2string2(eoboards_ethtype2type(boarddata.properties.type), eobool_true));
276
277 boarddata.properties.typestring = boardTypeString;
278
279 // maxSizeRXpacket:
280 if(true == groupEthBoardProps.check("maxSizeRXpacket"))
281 {
282 boarddata.properties.maxSizeRXpacket = groupEthBoardProps.find("maxSizeRXpacket").asInt32();
283 //yDebug() << "eth::parser::read() has detected capacityofTXpacket =" << boarddata.properties.maxSizeRXpacket << "for BOARD w/ IP" << boarddata.properties.ipv4string;
284 }
285 else
286 {
287 boarddata.properties.maxSizeRXpacket = 768;
288 yWarning() << "eth::parser::read() in BOARD w/ IP" << boarddata.properties.ipv4string << "cannot find: capacityofTXpacket. using:" << boarddata.properties.maxSizeRXpacket;
289 }
290
291 // maxSizeROP:
292 if(true == groupEthBoardProps.check("maxSizeROP"))
293 {
294 boarddata.properties.maxSizeROP = groupEthBoardProps.find("maxSizeROP").asInt32();
295 //yDebug() << "eth::parser::read() has detected maxSizeOfROP =" << boarddata.properties.maxSizeROP << "for BOARD w/ IP" << boarddata.properties.ipv4string;
296 }
297 else
298 {
299 boarddata.properties.maxSizeROP = 384;
300 yWarning() << "eth::parser::read() in BOARD w/ IP" << boarddata.properties.ipv4string << "cannot find: maxSizeROP. using:" << boarddata.properties.maxSizeROP;
301 }
302
303
304
305 // <- ETH_BOARD/ETH_BOARD_PROPERTIES
306
307
308 // -> ETH_BOARD/ETH_BOARD_SETTINGS
309
310 Bottle paramNameBoard(groupEthBoardSettings.find("Name").asString());
311 char xmlboardname[64] = {0};
312 snprintf(xmlboardname, sizeof(xmlboardname), "%s", paramNameBoard.toString().c_str());
313
314 // at first we provide boarddata.settings w/ default values that are safe
315 // in this way we dont need to manage the case of a missing tag unless we want to force somthing different
316 // note that reset() removes all diagnostics
317
318 boarddata.settings.reset();
319
320 if(0 != strlen(xmlboardname))
321 {
322 boarddata.settings.name = xmlboardname;
323 }
324 else
325 {
326 boarddata.settings.name = "NOT-NAMED";
327 }
328
329
330 // -> ETH_BOARD/ETH_BOARD_SETTINGS/RUNNINGMODE
331
332 Bottle groupEthBoardSettings_RunningMode = Bottle(groupEthBoardSettings.findGroup("RUNNINGMODE"));
333 if(groupEthBoardSettings_RunningMode.isNull())
334 {
335 yWarning() << "eth::parser::read(): cannot find ETH_BOARD_PROPERTIES/RUNNINGMODE group in config files for BOARD w/ IP" << boarddata.properties.ipv4string << " and will use default values";
336 yWarning() << "Default values for ETH_BOARD_PROPERTIES/RUNNINGMODE group: (period, maxTimeOfRXactivity, maxTimeOfDOactivity, maxTimeOfTXactivity, TXrateOfRegularROPs) = " <<
337 boarddata.settings.txconfig.cycletime << boarddata.settings.txconfig.maxtimeRX << boarddata.settings.txconfig.maxtimeDO << boarddata.settings.txconfig.maxtimeTX << boarddata.settings.txconfig.txratedivider;
338 }
339 else
340 {
341 // Default to synchronized mode.
342 boarddata.settings.txconfig.runnermode = eomn_appl_runnermode_synchronized;
343 if (groupEthBoardSettings_RunningMode.check("execution"))
344 {
345 std::string tmp = groupEthBoardSettings_RunningMode.find("execution").asString();
346 if (tmp == "besteffort")
347 {
348 boarddata.settings.txconfig.runnermode = eomn_appl_runnermode_besteffort;
349 }
350 else if (tmp != "synchronized")
351 {
352 yWarning() << "eth::parser::read() for BOARD" << boarddata.properties.ipv4string
353 << ": ETH_BOARD_SETTINGS::RUNNINGMODE::execution has unknown value '" << tmp
354 << "', defaulting to 'synchronized'.";
355 }
356 }
357
358 if(true == groupEthBoardSettings_RunningMode.check("period"))
359 {
360 int tmp = groupEthBoardSettings_RunningMode.find("period").asInt32();
361
362 if(1000 != tmp)
363 {
364 yWarning() << "eth::parser::read() for BOARD" << boarddata.properties.ipv4string << "ETH_BOARD_SETTINGS::RUNNINGMODE::period can be only 1000 (so far) and it was:" << tmp;
365 tmp = 1000;
366 }
367 boarddata.settings.txconfig.cycletime = tmp;
368 }
369
370 if(true == groupEthBoardSettings_RunningMode.check("safetygap"))
371 {
372 int tmp = groupEthBoardSettings_RunningMode.find("safetygap").asInt32();
373
374 if(tmp >= boarddata.settings.txconfig.cycletime)
375 {
376 yWarning() << "eth::parser::read() for BOARD" << boarddata.properties.ipv4string << ": ETH_BOARD_SETTINGS::RUNNINGMODE::safetygap (" << tmp << ") must be less than cycletime (" << boarddata.settings.txconfig.cycletime << "). Resetting to 0";
377 }
378
379 boarddata.settings.txconfig.safetygap = tmp;
380 }
381
382 if(true == groupEthBoardSettings_RunningMode.check("maxTimeOfRXactivity"))
383 {
384 int tmp = groupEthBoardSettings_RunningMode.find("maxTimeOfRXactivity").asInt32();
385
386 if((tmp < 5) || (tmp > 990))
387 {
388 yWarning() << "eth::parser::read() for BOARD" << boarddata.properties.ipv4string << "ETH_BOARD_SETTINGS::RUNNINGMODE::maxTimeOfRXactivity must be in [5, 990] (so far) and it was:" << tmp << "Using default value";
389 tmp = 400;
390 }
391
392 boarddata.settings.txconfig.maxtimeRX = tmp;
393 }
394
395 if(true == groupEthBoardSettings_RunningMode.check("maxTimeOfDOactivity"))
396 {
397 int tmp = groupEthBoardSettings_RunningMode.find("maxTimeOfDOactivity").asInt32();
398
399 if((tmp < 5) || (tmp > 990))
400 {
401 yWarning() << "eth::parser::read() for BOARD" << boarddata.properties.ipv4string << "ETH_BOARD_SETTINGS::RUNNINGMODE::maxtimeOfDOactivity must be in [5, 990] (so far) and it was:" << tmp << "Using default value";
402 tmp = 300;
403 }
404
405 boarddata.settings.txconfig.maxtimeDO = tmp;
406 }
407
408 if(true == groupEthBoardSettings_RunningMode.check("maxTimeOfTXactivity"))
409 {
410 int tmp = groupEthBoardSettings_RunningMode.find("maxTimeOfTXactivity").asInt32();
411
412 if((tmp < 5) || (tmp > 990))
413 {
414 yWarning() << "eth::parser::read() for BOARD" << boarddata.properties.ipv4string << "ETH_BOARD_SETTINGS::RUNNINGMODE::maxTimeOfTXactivity must be in [5, 990] (so far) and it was:" << tmp << "Using default value";
415 tmp = 300;
416 }
417
418 boarddata.settings.txconfig.maxtimeTX = tmp;
419 }
420
421
422 if(true == groupEthBoardSettings_RunningMode.check("TXrateOfRegularROPs"))
423 {
424 int tmp = groupEthBoardSettings_RunningMode.find("TXrateOfRegularROPs").asInt32();
425
426 if(tmp <=0)
427 {
428 yWarning() << "eth::parser::read() for BOARD" << boarddata.properties.ipv4string << "ETH_BOARD_SETTINGS::RUNNINGMODE::TXrateOfRegularROPs must be in [1, 20] and it was:" << tmp << "Using value = 1";
429 tmp = 1;
430 }
431 if(tmp >200)
432 {
433 yWarning() << "eth::parser::read() for BOARD" << boarddata.properties.ipv4string << "ETH_BOARD_SETTINGS::RUNNINGMODE::TXrateOfRegularROPs must be in [1, 20] and it was:" << tmp << "Using value = 20";
434 tmp = 20;
435 }
436 boarddata.settings.txconfig.txratedivider = tmp;
437 }
438
439 // consistency check
440 if((boarddata.settings.txconfig.maxtimeRX+boarddata.settings.txconfig.maxtimeDO+boarddata.settings.txconfig.maxtimeTX) != boarddata.settings.txconfig.cycletime)
441 {
442 yWarning() << "eth::parser::read() for BOARD" << boarddata.properties.ipv4string << "In ETH_BOARD_SETTINGS::RUNNINGMODE sum(maxTimeOfRXactivity, maxTimeOfDOactivity, maxTimeOfTXactivity) != period !!! Using default values";
443
444 yError() << boarddata.settings.txconfig.maxtimeRX+boarddata.settings.txconfig.maxtimeDO+boarddata.settings.txconfig.maxtimeTX;
445 boarddata.settings.txconfig.cycletime = 1000;
446 boarddata.settings.txconfig.maxtimeRX = 400;
447 boarddata.settings.txconfig.maxtimeDO = 300;
448 boarddata.settings.txconfig.maxtimeTX = 300;
449 }
450
451
452 // set initial values.
453
454 // in here i store the final values of the parsing
455 // they have the default values already in here
456 // they are all false except for sigOVRFLrxdotx so that we keep backwards compatibility
457 struct parseLOGGING
458 {
459 struct IMM
460 {
461 bool sigOVRFLrxdotx {true};
462 bool sigOVRFLperiod {false};
463 void clear()
464 {
465 sigOVRFLrxdotx = true;
466 sigOVRFLperiod = false;
467 }
468 std::string to_string() const
469 {
470 return std::string("IMM -> (sigOVRFLrxdotx = ") + std::to_string(sigOVRFLrxdotx) +
471 std::string(", sigOVRFLperiod = ") + std::to_string(sigOVRFLperiod) +
472 ")";
473 }
474 };
475 struct PER
476 {
477 double period {0.0};
478 bool sigSTATS_RXDOTXminavgmax {false};
479 bool sigSTATS_PERIODminavgmax {false};
480 bool sigSTATS_PERIODhistogram {false};
481 void clear()
482 {
483 period = 0;
484 sigSTATS_RXDOTXminavgmax = sigSTATS_PERIODminavgmax = sigSTATS_PERIODhistogram = false;
485 }
486 std::string to_string() const
487 {
488 return std::string("PER -> (sigSTATS_RXDOTXminavgmax = ") + std::to_string(sigSTATS_RXDOTXminavgmax) +
489 std::string(", sigSTATS_PERIODminavgmax = ") + std::to_string(sigSTATS_PERIODminavgmax) +
490 std::string(", sigSTATS_PERIODhistogram = ") + std::to_string(sigSTATS_PERIODhistogram) +
491 ")";
492 }
493 };
494
495 IMM immediate {};
496 PER periodic {};
497
498 void setdefault()
499 {
500 immediate.clear();
501 periodic.clear();
502 }
503
504 std::string to_string() const
505 {
506 return std::string("parseLOGGING -> ") + immediate.to_string() + ", " + periodic.to_string();
507 }
508 };
509
510 parseLOGGING pLOG {};
511
512 // we impose the default value that will have all false except for pLOG.immediate.sigOVRFLrxdotx true
513 pLOG.setdefault();
514
515
516 Bottle groupEthBoardSettings_RunningMode_Logging = Bottle(groupEthBoardSettings_RunningMode.findGroup("LOGGING"));
517 if(groupEthBoardSettings_RunningMode_Logging.isNull())
518 {
519 yWarning() << "eth::parser::read(): cannot find ETH_BOARD_PROPERTIES/RUNNINGMODE/LOGGING group in config files for BOARD w/ IP" << boarddata.properties.ipv4string << " and will use default values";
520 yWarning() << "Default values for ETH_BOARD_PROPERTIES/RUNNINGMODE/LOGGING group: (IMMEDIATE.emitRXDOTXoverflow = true, PERIODIC.period = 0, PERIODIC.emitRXDOTXstatistics = false";
521 }
522 else
523 {
524 // find groups: IMMEDIATE and PERIODIC
525
526 Bottle groupEthBoardSettings_RunningMode_Logging_Immediate = Bottle(groupEthBoardSettings_RunningMode_Logging.findGroup("IMMEDIATE"));
527 if(groupEthBoardSettings_RunningMode_Logging_Immediate.isNull())
528 {
529 // IMMEDIATE not found, so i keep default value that has only pLOG.immediate.sigOVRFLrxdotx true.
530 }
531 else
532 {
533
534 if(true == groupEthBoardSettings_RunningMode_Logging_Immediate.check("emitRXDOTXoverflow"))
535 {
536 Value& v = groupEthBoardSettings_RunningMode_Logging_Immediate.find("emitRXDOTXoverflow");
537 if (v.isBool())
538 {
539 pLOG.immediate.sigOVRFLrxdotx = v.asBool();
540 }
541 }
542
543 if(false == groupEthBoardSettings_RunningMode_Logging_Immediate.check("emitPERIODoverflow"))
544 {
545 // IMMEDIATE.emitPERIODoverflow not found, so i keep default (false)
546 // pLOG.immediate.sigOVRFLperiod = false;
547 }
548 else
549 {
550 if(groupEthBoardSettings_RunningMode_Logging_Immediate.find("emitPERIODoverflow").isBool())
551 {
552 pLOG.immediate.sigOVRFLperiod = groupEthBoardSettings_RunningMode_Logging_Immediate.find("emitPERIODoverflow").asBool();
553 }
554 else
555 {
556 // keep default (false)
557 // pLOG.immediate.sigOVRFLperiod = false;
558 }
559 }
560 }
561
562 Bottle groupEthBoardSettings_RunningMode_Logging_Periodic = Bottle(groupEthBoardSettings_RunningMode_Logging.findGroup("PERIODIC"));
563 if(groupEthBoardSettings_RunningMode_Logging_Periodic.isNull())
564 {
565 // PERIODIC not found, so i keep default values (period zero, all false)
566 }
567 else
568 {
569
570 if(false == groupEthBoardSettings_RunningMode_Logging_Periodic.check("period"))
571 {
572 // PERIODIC.period not found, so i keep default (0)
573 }
574 else
575 {
576 // i get it and i filter in range [0, 600]
577 if(true == groupEthBoardSettings_RunningMode_Logging_Periodic.find("period").isFloat64())
578 {
579 double tmp = groupEthBoardSettings_RunningMode_Logging_Periodic.find("period").asFloat64();
580 pLOG.periodic.period = (tmp<0.0) ? (0.0) : ( (tmp < 600.0) ? tmp : 600.0 );
581 }
582 }
583
584 // Handle emitRXDOTXstatistics for backward compatibility
585 Value& v_stats = groupEthBoardSettings_RunningMode_Logging_Periodic.find("emitRXDOTXstatistics");
586 if (v_stats.isBool())
587 {
588 pLOG.periodic.sigSTATS_RXDOTXminavgmax = v_stats.asBool();
589 }
590
591 // note: emitRXDOTXminavgmax and emitRXDOTXstatistics emit both the same thing and both are legal xml tags.
592 // however, emitRXDOTXminavgmax is the more correct name so it wins over emitRXDOTXstatistics
593 // Handle emitRXDOTXminavgmax, which is preferred and overrides emitRXDOTXstatistics
594 Value& v_minavgmax = groupEthBoardSettings_RunningMode_Logging_Periodic.find("emitRXDOTXminavgmax");
595 if (v_minavgmax.isBool())
596 {
597 pLOG.periodic.sigSTATS_RXDOTXminavgmax = v_minavgmax.asBool();
598 }
599
600
601 if(false == groupEthBoardSettings_RunningMode_Logging_Periodic.check("emitPERIODminavgmax"))
602 {
603 // PERIODIC.emitPERIODminavgmax not found, so i keep default (false)
604 //pLOG.periodic.sigSTATS_PERIODminavgmax = false;
605 }
606 else
607 {
608 pLOG.periodic.sigSTATS_PERIODminavgmax = groupEthBoardSettings_RunningMode_Logging_Periodic.find("emitPERIODminavgmax").asBool();
609 }
610
611 if(false == groupEthBoardSettings_RunningMode_Logging_Periodic.check("emitPERIODhistogram"))
612 {
613 // PERIODIC.emitPERIODhistogram not found, so i keep default (false)
614 //pLOG.periodic.sigSTATS_PERIODhistogram = false;
615 }
616 else
617 {
618 pLOG.periodic.sigSTATS_PERIODhistogram = groupEthBoardSettings_RunningMode_Logging_Periodic.find("emitPERIODhistogram").asBool();
619 }
620 }
621
622 yInfo() << "ETH_BOARD_PROPERTIES/RUNNINGMODE/LOGGING group for BOARD w/ IP" << boarddata.properties.ipv4string << " has values: " <<
623 " IMMEDIATE.emit* = " << pLOG.immediate.to_string() << " PERIODIC.period = " << pLOG.periodic.period << " PERIODIC.emit* = " << pLOG.periodic.to_string();
624
625 }
626
627
628 // now i apply the resulting values to the compact struct
629 constexpr uint16_t maskRXDOTXoverflow = (0x0001 << eomn_appl_log_asynchro_exectime_rxdotx_overflow);
630 constexpr uint16_t maskRXDOTXminavgmax = (0x0001 << eomn_appl_log_periodic_exectime_rxdotx_minavgmax);
631 constexpr uint16_t maskPERIODoverflow = (0x0001 << eomn_appl_log_asynchro_exectime_period_overflow);
632 constexpr uint16_t maskPERIODminavgmax = (0x0001 << eomn_appl_log_periodic_exectime_period_minavgmax);
633 constexpr uint16_t maskPERIODhistogram = (0x0001 << eomn_appl_log_periodic_exectime_period_histogram);
634
635
636 boarddata.settings.txconfig.logging.flags = 0;
637
638 if(true == pLOG.immediate.sigOVRFLrxdotx) { boarddata.settings.txconfig.logging.flags |= maskRXDOTXoverflow; }
639 if(true == pLOG.immediate.sigOVRFLperiod) { boarddata.settings.txconfig.logging.flags |= maskPERIODoverflow; }
640 if(true == pLOG.periodic.sigSTATS_RXDOTXminavgmax) { boarddata.settings.txconfig.logging.flags |= maskRXDOTXminavgmax; }
641 if(true == pLOG.periodic.sigSTATS_PERIODminavgmax) { boarddata.settings.txconfig.logging.flags |= maskPERIODminavgmax; }
642 if(true == pLOG.periodic.sigSTATS_PERIODhistogram) { boarddata.settings.txconfig.logging.flags |= maskPERIODhistogram; }
643
644 boarddata.settings.txconfig.logging.period10ms = static_cast<uint16_t>(100.0*pLOG.periodic.period); // period is uint16_t and keeps units of 10 ms to be able to manage up to 10 minutes
645
646 }
647
648
649 // <- ETH_BOARD/ETH_BOARD_SETTINGS/RUNNINGMODE
650
651
652 // <- ETH_BOARD/ETH_BOARD_SETTINGS
653
654
655 // -> ETH_BOARD/ETH_BOARD_ACTIONS
656 // -> ETH_BOARD/ETH_BOARD_ACTIONS/MONITOR_ITS_PRESENCE
657
658
659 // do we have a proper section ETH_BOARD_ACTIONS/MONITOR_ITS_PRESENCE? if so we change its config
660
661 Bottle groupEthBoardActions = Bottle(groupEthBoard.findGroup("ETH_BOARD_ACTIONS"));
662 if(!groupEthBoardActions.isNull())
663 {
664 Bottle groupEthBoardActions_Monitor = Bottle(groupEthBoardActions.findGroup("MONITOR_ITS_PRESENCE"));
665 if(!groupEthBoardActions_Monitor.isNull())
666 {
667 Bottle groupEthBoardActions_Monitor_enabled = groupEthBoardActions_Monitor.findGroup("enabled");
668 std::string Ena = groupEthBoardActions_Monitor_enabled.get(1).asString();
669 const char *strEna = Ena.c_str();
670
671 if(0 == strcmp(strEna, "true"))
672 {
673 boarddata.actions.monitorpresence_enabled = true;
674 }
675 else
676 {
677 boarddata.actions.monitorpresence_enabled = false;
678 }
679
680 if(true == groupEthBoardActions_Monitor.check("timeout"))
681 {
682 double presenceTimeout = groupEthBoardActions_Monitor.find("timeout").asFloat64();
683
684 if(presenceTimeout <= 0)
685 {
686 presenceTimeout = 0;
687 boarddata.actions.monitorpresence_enabled = false;
688 }
689
690 if(presenceTimeout > 0.100)
691 {
692 presenceTimeout = 0.100;
693 }
694
695 boarddata.actions.monitorpresence_timeout = presenceTimeout;
696
697 }
698
699
700 if(true == groupEthBoardActions_Monitor.check("periodOfMissingReport"))
701 {
702 double reportMissingPeriod = groupEthBoardActions_Monitor.find("periodOfMissingReport").asFloat64();
703
704 if(reportMissingPeriod <= 0)
705 {
706 reportMissingPeriod = 0.0;
707 }
708
709 if(reportMissingPeriod > 600)
710 {
711 reportMissingPeriod = 600;
712 }
713
714 boarddata.actions.monitorpresence_periodofmissingreport = reportMissingPeriod;
715 }
716 }
717 }
718
719 // <- ETH_BOARD/ETH_BOARD_ACTIONS/MONITOR_ITS_PRESENCE
720 // <- ETH_BOARD/ETH_BOARD_ACTIONS
721
722 return true;
723}
724
725
726// - end-of-file (leave a blank line after)----------------------------------------------------------------------------
727
728
bool read(yarp::os::Searchable &cfgtotal, pc104Data &pc104data)
Definition ethParser.cpp:92
bool print(const pc104Data &pc104data)
Definition ethParser.cpp:57
double monitorpresence_periodofmissingreport
Definition ethParser.h:111
boardActions actions
Definition ethParser.h:126
boardProperties properties
Definition ethParser.h:124
boardSettings settings
Definition ethParser.h:125
std::uint16_t maxSizeRXpacket
Definition ethParser.h:41
eOipv4addressing_t ipv4addressing
Definition ethParser.h:39
std::string ipv4addressingstring
Definition ethParser.h:43
std::string to_string(ENTITY e) const
Definition ethParser.h:75
eOmn_appl_config_t txconfig
Definition ethParser.h:59
eOipv4addressing_t localaddressing
Definition ethParser.h:138
std::string addressingstring
Definition ethParser.h:141
std::uint16_t rxrate
Definition ethParser.h:140
std::uint16_t txrate
Definition ethParser.h:139