MRPT  2.0.2
RawlogGrabberApp.cpp
Go to the documentation of this file.
1 /* +------------------------------------------------------------------------+
2  | Mobile Robot Programming Toolkit (MRPT) |
3  | https://www.mrpt.org/ |
4  | |
5  | Copyright (c) 2005-2020, Individual contributors, see AUTHORS file |
6  | See: https://www.mrpt.org/Authors - All rights reserved. |
7  | Released under BSD License. See: https://www.mrpt.org/License |
8  +------------------------------------------------------------------------+ */
9 
10 #include "apps-precomp.h" // Precompiled headers
11 
14 #include <mrpt/core/lock_helper.h>
15 #include <mrpt/core/round.h>
17 #include <mrpt/img/CImage.h>
25 #include <mrpt/obs/CSensoryFrame.h>
27 #include <mrpt/system/CRateTimer.h>
28 #include <mrpt/system/filesystem.h>
29 #include <mrpt/system/os.h>
30 #include <thread>
31 
32 using namespace mrpt::apps;
33 
35  : mrpt::system::COutputLogger("RawlogGrabberApp")
36 {
37 }
38 
39 void RawlogGrabberApp::initialize(int argc, const char** argv)
40 {
42 
43  if ((getenv("MRPT_HWDRIVERS_VERBOSE") != nullptr) &&
44  atoi(getenv("MRPT_HWDRIVERS_VERBOSE")) != 0)
45  {
47  }
48 
49  MRPT_LOG_INFO(" rawlog-grabber - Part of the MRPT");
51  " MRPT C++ Library: %s - Sources timestamp: %s\n",
54 
55  // Process arguments:
56  if (argc < 2)
57  THROW_EXCEPTION_FMT("Usage: %s <config_file.ini>\n\n", argv[0]);
58 
59  {
60  std::string INI_FILENAME(argv[1]);
61  ASSERT_FILE_EXISTS_(INI_FILENAME);
63  }
64 
65  MRPT_END
66 }
67 
69 {
71 
72  using namespace mrpt;
73  using namespace mrpt::system;
74  using namespace mrpt::hwdrivers;
75  using namespace mrpt::config;
76  using namespace mrpt::serialization;
77  using namespace mrpt::img;
78  using namespace mrpt::obs;
79  using namespace mrpt::poses;
80  using namespace std;
81 
82  const std::string GLOBAL_SECT = "global";
83 
84  // ------------------------------------------
85  // Load config from file:
86  // ------------------------------------------
87  string rawlog_prefix = "dataset";
88  int time_between_launches = 300;
89  bool use_sensoryframes = false;
90  int GRABBER_PERIOD_MS = 1000;
91  int rawlog_GZ_compress_level = 1; // 0: No compress, 1-9: compress level
92 
93  MRPT_LOAD_CONFIG_VAR(rawlog_prefix, string, params, GLOBAL_SECT);
94  MRPT_LOAD_CONFIG_VAR(time_between_launches, int, params, GLOBAL_SECT);
95  MRPT_LOAD_CONFIG_VAR(SF_max_time_span, float, params, GLOBAL_SECT);
96  MRPT_LOAD_CONFIG_VAR(use_sensoryframes, bool, params, GLOBAL_SECT);
97  MRPT_LOAD_CONFIG_VAR(GRABBER_PERIOD_MS, int, params, GLOBAL_SECT);
98 
99  MRPT_LOAD_CONFIG_VAR(rawlog_GZ_compress_level, int, params, GLOBAL_SECT);
100 
101  // Build full rawlog file name:
102  string rawlog_postfix = "_";
103 
104  // rawlog_postfix += dateTimeToString( now() );
106  mrpt::system::timestampToParts(now(), parts, true);
107  rawlog_postfix += format(
108  "%04u-%02u-%02u_%02uh%02um%02us", (unsigned int)parts.year,
109  (unsigned int)parts.month, (unsigned int)parts.day,
110  (unsigned int)parts.hour, (unsigned int)parts.minute,
111  (unsigned int)parts.second);
112 
113  rawlog_postfix = mrpt::system::fileNameStripInvalidChars(rawlog_postfix);
114 
115  // Only set this if we want externally stored images:
117  rawlog_prefix +
118  fileNameStripInvalidChars(rawlog_postfix + string("_Images"));
119 
120  // Also, set the path in CImage to enable online visualization in a GUI
121  // window:
122  CImage::setImagesPathBase(m_rawlog_ext_imgs_dir);
123 
124  rawlog_postfix += string(".rawlog");
125  rawlog_postfix = fileNameStripInvalidChars(rawlog_postfix);
126 
127  rawlog_filename = rawlog_prefix + rawlog_postfix;
128 
129  MRPT_LOG_INFO_STREAM("Output rawlog filename: " << rawlog_filename);
130  MRPT_LOG_INFO_STREAM("External image storage: " << m_rawlog_ext_imgs_dir);
131 
132  // ----------------------------------------------
133  // Launch threads:
134  // ----------------------------------------------
135  std::vector<std::string> sections;
136  params.getAllSections(sections);
137 
138  vector<std::thread> lstThreads;
139 
140  for (auto& section : sections)
141  {
142  if (section == GLOBAL_SECT || section.empty() ||
143  params.read_bool(section, "rawlog-grabber-ignore", false, false))
144  continue; // This is not a sensor:
145 
146  lstThreads.emplace_back(&RawlogGrabberApp::SensorThread, this, section);
147 
148  std::this_thread::sleep_for(
149  std::chrono::milliseconds(time_between_launches));
150  }
151 
152  // ----------------------------------------------
153  // Run:
154  // ----------------------------------------------
156  auto out_arch_obj = archiveFrom(out_file);
157  m_out_arch_ptr = &out_arch_obj;
158 
159  out_file.open(rawlog_filename, rawlog_GZ_compress_level);
160 
161  CGenericSensor::TListObservations copy_of_m_global_list_obs;
162 
163  MRPT_LOG_INFO_STREAM("Press any key to exit program");
164 
165  mrpt::system::CTicTac run_timer;
166  run_timer.Tic();
167 
168  auto lambdaProcessPending = [&]() {
170  copy_of_m_global_list_obs.clear();
171 
172  if (!m_global_list_obs.empty())
173  {
174  auto itEnd = m_global_list_obs.begin();
175  std::advance(itEnd, m_global_list_obs.size() / 2);
176  copy_of_m_global_list_obs.insert(m_global_list_obs.begin(), itEnd);
177  m_global_list_obs.erase(m_global_list_obs.begin(), itEnd);
178  }
179 
180  if (use_sensoryframes)
181  process_observations_for_sf(copy_of_m_global_list_obs);
182  else
183  process_observations_for_nonsf(copy_of_m_global_list_obs);
184  };
185 
186  while (!os::kbhit() && !allThreadsMustExit)
187  {
188  // Check "run for X seconds" flag:
189  if (run_for_seconds > 0 && run_timer.Tac() > run_for_seconds) break;
190 
191  // See if we have observations and process them:
192  lambdaProcessPending();
193 
194  std::this_thread::sleep_for(
195  std::chrono::milliseconds(GRABBER_PERIOD_MS));
196  }
197 
198  if (allThreadsMustExit)
199  {
201  "[main thread] Ended due to other thread signal to exit "
202  "application.");
203  }
204 
205  // Final check of pending objects:
206  lambdaProcessPending();
207 
208  // Flush file to disk:
209  out_file.close();
210 
211  // Wait all threads:
212  // ----------------------------
213  allThreadsMustExit = true;
214  std::this_thread::sleep_for(300ms);
215 
216  MRPT_LOG_INFO("Waiting for all threads to close...");
217 
218  for (auto& lstThread : lstThreads) lstThread.join();
219 
220  MRPT_END
221 }
222 
225 {
226  // Show GPS mode:
228 
229  static auto last_t = mrpt::Clock::now();
230  const auto t_now = mrpt::Clock::now();
231  if (mrpt::system::timeDifference(last_t, t_now) < 1.0) return;
232  last_t = t_now;
233 
234  if (auto gps = std::dynamic_pointer_cast<mrpt::obs::CObservationGPS>(o);
235  gps)
236  {
237  dump_GPS_mode_info(*gps);
238  }
239  else if (auto imu =
240  std::dynamic_pointer_cast<mrpt::obs::CObservationIMU>(o);
241  imu)
242  {
243  dump_IMU_info(*imu);
244  }
245 }
246 
248  const mrpt::obs::CSensoryFrame& sf) const
249 {
251 
252  // Show GPS mode:
254  std::size_t idx = 0;
255  do
256  {
258  if (gps) dump_GPS_mode_info(*gps);
259  } while (gps);
260 
261  // Show IMU angles:
263  if (imu) dump_IMU_info(*imu);
264 }
265 
267  const mrpt::obs::CObservationGPS& o) const
268 {
269  if (o.has_GGA_datum())
270  {
272 
273  const auto fq = static_cast<int>(
274  o.getMsgByClass<Message_NMEA_GGA>().fields.fix_quality);
276  " GPS mode: " << fq << " label: " << o.sensorLabel);
277  }
278  {
279  std::stringstream ss;
280  o.getDescriptionAsText(ss);
281  MRPT_LOG_DEBUG_STREAM(ss.str());
282  }
283 }
284 
286 {
287  // Show IMU angles:
289  " IMU angles (degrees): "
290  "(yaw,pitch,roll)=(%.06f, %.06f, %.06f)",
294 }
295 
296 // ------------------------------------------------------
297 // SensorThread
298 // ------------------------------------------------------
299 void RawlogGrabberApp::SensorThread(std::string sensor_label)
300 {
301  try
302  {
303  std::string driver_name =
304  params.read_string(sensor_label, "driver", "", true);
305 
306  auto sensor =
308 
309  if (!sensor)
310  throw std::runtime_error(
311  std::string("Class name not recognized: ") + driver_name);
312 
313  // Load common & sensor specific parameters:
314  sensor->loadConfig(params, sensor_label);
315 
317  "[thread_" << sensor_label << "] Starting at "
318  << sensor->getProcessRate() << " Hz");
319 
320  ASSERT_ABOVE_(sensor->getProcessRate(), 0);
321 
322  // For imaging sensors, set external storage directory:
323  sensor->setPathForExternalImages(m_rawlog_ext_imgs_dir);
324 
325  // Init device:
326  sensor->initialize();
327 
329  rate.setRate(sensor->getProcessRate());
330 
331  while (!allThreadsMustExit)
332  {
333  // Process
334  sensor->doProcess();
335 
336  // Get new observations
338  sensor->getObservations(lstObjs);
339 
340  {
341  std::lock_guard<std::mutex> lock(cs_m_global_list_obs);
342  m_global_list_obs.insert(lstObjs.begin(), lstObjs.end());
343  }
344 
345  lstObjs.clear();
346 
347  // wait for the process period:
348  rate.sleep();
349  }
350 
351  sensor.reset();
352 
353  MRPT_LOG_INFO_FMT("[thread_%s] Closing...", sensor_label.c_str());
354  }
355  catch (const std::exception& e)
356  {
358  {
360  "Exception in SensorThread:\n"
361  << mrpt::exception_to_str(e));
362  }
363  allThreadsMustExit = true;
364  }
365  catch (...)
366  {
368  {
369  MRPT_LOG_ERROR("Untyped exception in SensorThread.");
370  }
371  allThreadsMustExit = true;
372  }
373 }
374 
376  const RawlogGrabberApp::TListObservations& list_obs)
377 {
378  using namespace mrpt::obs;
379 
380  // -----------------------
381  // USE SENSORY-FRAMES
382  // -----------------------
383  for (auto it = list_obs.begin(); it != list_obs.end(); ++it)
384  {
385  // If we have an action, save the SF and start a new one:
386  if (IS_DERIVED(*it->second, CAction))
387  {
388  CAction::Ptr act = std::dynamic_pointer_cast<CAction>(it->second);
389 
390  (*m_out_arch_ptr) << m_curSF;
392  "Saved SF with " << m_curSF.size() << " objects.");
393  m_curSF.clear();
394 
395  CActionCollection acts;
396  acts.insert(*act);
397  act.reset();
398 
399  (*m_out_arch_ptr) << acts;
400  }
401  else if (IS_CLASS(*it->second, CObservationOdometry))
402  {
404  std::dynamic_pointer_cast<CObservationOdometry>(it->second);
405 
406  auto act = CActionRobotMovement2D::Create();
407  act->timestamp = odom->timestamp;
408 
409  // Compute the increment since the last reading:
411  static CObservationOdometry last_odo;
412  static bool last_odo_first = true;
413 
414  mrpt::poses::CPose2D odo_incr;
415  int64_t lticks_incr, rticks_incr;
416 
417  if (last_odo_first)
418  {
419  last_odo_first = false;
420  odo_incr = mrpt::poses::CPose2D(0, 0, 0);
421  lticks_incr = rticks_incr = 0;
422  }
423  else
424  {
425  odo_incr = odom->odometry - last_odo.odometry;
426  lticks_incr =
427  odom->encoderLeftTicks - last_odo.encoderLeftTicks;
428  rticks_incr =
429  odom->encoderRightTicks - last_odo.encoderRightTicks;
430 
431  last_odo = *odom;
432  }
433 
434  // Save as action & dump to file:
435  act->computeFromOdometry(odo_incr, odomOpts);
436 
437  act->hasEncodersInfo = true;
438  act->encoderLeftTicks = lticks_incr;
439  act->encoderRightTicks = rticks_incr;
440 
441  act->hasVelocities = true;
442  act->velocityLocal = odom->velocityLocal;
443 
444  (*m_out_arch_ptr) << m_curSF;
446 
448  "Saved SF with " << m_curSF.size() << " objects.");
449  m_curSF.clear();
450 
451  CActionCollection acts;
452  acts.insert(*act);
453  act.reset();
454 
455  (*m_out_arch_ptr) << acts;
457  }
458  else if (IS_DERIVED(*it->second, CObservation))
459  {
460  CObservation::Ptr obs =
461  std::dynamic_pointer_cast<CObservation>(it->second);
462 
463  // First, check if inserting this OBS into the SF would
464  // overflow "SF_max_time_span":
465  if (m_curSF.size() != 0 &&
467  m_curSF.getObservationByIndex(0)->timestamp,
468  obs->timestamp) > SF_max_time_span)
469  {
471 
472  // Save and start a new one:
473  (*m_out_arch_ptr) << m_curSF;
475 
477  "Saved SF with " << m_curSF.size() << " objects.");
478  m_curSF.clear();
479  }
480 
481  // Now, insert the observation in the SF:
482  m_curSF.insert(obs);
483  }
484  else
486  "*** ERROR *** Class is not an action or an "
487  "observation");
488  }
489 }
490 
492  const RawlogGrabberApp::TListObservations& list_obs)
493 {
494  // ---------------------------
495  // DO NOT USE SENSORY-FRAMES
496  // ---------------------------
497  for (auto& ob : list_obs)
498  {
499  auto& obj_ptr = ob.second;
500  (*m_out_arch_ptr) << *obj_ptr;
502 
503  dump_verbose_info(obj_ptr);
504  }
505 
506  if (!list_obs.empty())
507  {
508  MRPT_LOG_INFO_STREAM("Saved " << list_obs.size() << " objects.");
509  }
510 }
void clear()
Clear all current observations.
double Tac() noexcept
Stops the stopwatch.
Definition: CTicTac.cpp:86
void timestampToParts(TTimeStamp t, TTimeParts &p, bool localTime=false)
Gets the individual parts of a date/time (days, hours, minutes, seconds) - UTC time or local time...
Definition: datetime.cpp:50
bool has_GGA_datum() const
true if the corresponding field exists in messages.
A class for calling sleep() in a loop, such that the amount of sleep time will be computed to make th...
void insert(const CObservation::Ptr &obs)
Inserts a new observation to the list: The pointer to the objects is copied, thus DO NOT delete the p...
mrpt::serialization::CArchive * m_out_arch_ptr
#define MRPT_START
Definition: exceptions.h:241
std::string read_string(const std::string &section, const std::string &name, const std::string &defaultValue, bool failIfNotFound=false) const
std::vector< double > rawMeasurements
The accelerometer and/or gyroscope measurements taken by the IMU at the given timestamp.
#define THROW_EXCEPTION(msg)
Definition: exceptions.h:67
std::string std::string format(std::string_view fmt, ARGS &&... args)
Definition: format.h:26
bool open(const std::string &fileName, int compress_level=1, mrpt::optional_ref< std::string > error_msg=std::nullopt)
Open a file for write, choosing the compression level.
mrpt::poses::CPose2D odometry
The absolute odometry measurement (IT IS NOT INCREMENTAL)
TListObservations m_global_list_obs
bool sleep()
Sleeps for some time, such as the return of this method is 1/rate (seconds) after the return of the p...
Definition: CRateTimer.cpp:25
orientation pitch absolute value (global/navigation frame) (rad)
std::string m_rawlog_ext_imgs_dir
Directory where to save externally stored images, only for CCameraSensor&#39;s.
A high-performance stopwatch, with typical resolution of nanoseconds.
void setMinLoggingLevel(const VerbosityLevel level)
Set the minimum logging level for which the incoming logs are going to be taken into account...
mrpt::system::TTimeStamp now()
A shortcut for system::getCurrentTime.
Definition: datetime.h:86
Contains classes for various device interfaces.
T::Ptr getObservationByClass(size_t ith=0) const
Returns the i&#39;th observation of a given class (or of a descendant class), or nullptr if there is no s...
STL namespace.
std::string MRPT_getCompilationDate()
Returns the MRPT source code timestamp, according to the Reproducible-Builds specifications: https://...
Definition: os.cpp:154
std::string fileNameStripInvalidChars(const std::string &filename, const char replacement_to_invalid_chars='_')
Replace invalid filename chars by underscores (&#39;_&#39;) or any other user-given char. ...
Definition: filesystem.cpp:329
This class stores measurements from an Inertial Measurement Unit (IMU) (attitude estimation, raw gyroscope and accelerometer values), altimeters or magnetometers.
mrpt::system::COutputLogger COutputLogger
The parameter to be passed to "computeFromOdometry".
static time_point now() noexcept
Returns the current time using the currently selected Clock source.
Definition: Clock.cpp:94
mrpt::hwdrivers::CGenericSensor::TListObservations TListObservations
Declares a class for storing a collection of robot actions.
bool show_sensor_thread_exceptions
If enabled (default), exceptions in sensor threads will be reported to std::cerr. ...
void dump_verbose_info(const mrpt::serialization::CSerializable::Ptr &o) const
CArchiveStreamBase< STREAM > archiveFrom(STREAM &s)
Helper function to create a templatized wrapper CArchive object for a: MRPT&#39;s CStream, std::istream, std::ostream, std::stringstream.
Definition: CArchive.h:592
VerbosityLevel getMinLoggingLevel() const
LockHelper< T > lockHelper(T &t)
Syntactic sugar to easily create a locker to any kind of std::mutex.
Definition: lock_helper.h:50
const CObservation::Ptr & getObservationByIndex(size_t idx) const
Returns the i&#39;th observation in the list (0=first).
void getDescriptionAsText(std::ostream &o) const override
Build a detailed, multi-line textual description of the observation contents and dump it to the outpu...
#define MRPT_LOG_DEBUG_FMT(_FMT_STRING,...)
Use: MRPT_LOG_DEBUG_FMT("i=%u", i);
void initialize(int argc, const char **argv)
Initializes the application from CLI parameters.
The parts of a date/time (it&#39;s like the standard &#39;tm&#39; but with fractions of seconds).
Definition: datetime.h:49
static Ptr createSensorPtr(const std::string &className)
Just like createSensor, but returning a smart pointer to the newly created sensor object...
std::string rawlog_filename
The generated .rawlog file.
void run()
Runs with the current parameter set.
#define IS_DERIVED(obj, class_name)
True if the given reference to object (derived from mrpt::rtti::CObject) is an instance of the given ...
Definition: CObject.h:151
uint8_t day
Month (1-12)
Definition: datetime.h:53
This namespace contains representation of robot actions and observations.
Declares a class for storing a "sensory frame", a set of "observations" taken by the robot approximat...
Definition: CSensoryFrame.h:51
#define IS_CLASS(obj, class_name)
True if the given reference to object (derived from mrpt::rtti::CObject) is of the given class...
Definition: CObject.h:146
std::atomic_bool allThreadsMustExit
#define MRPT_LOG_DEBUG_STREAM(__CONTENTS)
Use: MRPT_LOG_DEBUG_STREAM("Var=" << value << " foo=" << foo_var);
void SensorThread(std::string sensor_label)
MSG_CLASS & getMsgByClass()
Returns a reference to the message in the list CObservationGPS::messages of the requested class...
Classes for 2D/3D geometry representation, both of single values and probability density distribution...
void getAllSections(std::vector< std::string > &sections) const override
Returns a list with all the section names.
void process_observations_for_nonsf(const TListObservations &list_obs)
Declares a class for storing a robot action.
Definition: CAction.h:24
double second
Minute (0-59)
Definition: datetime.h:56
#define MRPT_LOAD_CONFIG_VAR( variableName, variableType, configFileObject, sectionNameStr)
An useful macro for loading variables stored in a INI-like file under a key with the same name that t...
void setRate(const double rate_hz)
Changes the object loop rate (Hz)
Definition: CRateTimer.cpp:20
#define MRPT_LOG_INFO_STREAM(__CONTENTS)
double run_for_seconds
If >0, run() will return after this period (in seconds)
std::string sensorLabel
An arbitrary label that can be used to identify the sensor.
Definition: CObservation.h:62
This is the global namespace for all Mobile Robot Programming Toolkit (MRPT) libraries.
const char * argv[]
int32_t encoderLeftTicks
For differential-driven robots: The ticks count for each wheel in ABSOLUTE VALUE (IT IS NOT INCREMENT...
uint8_t minute
Hour (0-23)
Definition: datetime.h:55
std::multimap< mrpt::system::TTimeStamp, mrpt::serialization::CSerializable::Ptr > TListObservations
void process_observations_for_sf(const TListObservations &list_obs)
A class used to store a 2D pose, including the 2D coordinate point and a heading (phi) angle...
Definition: CPose2D.h:39
Declares a class that represents any robot&#39;s observation.
Definition: CObservation.h:43
#define MRPT_LOG_ERROR(_STRING)
std::size_t rawlog_saved_objects
Counter of saved objects.
bool read_bool(const std::string &section, const std::string &name, bool defaultValue, bool failIfNotFound=false) const
void setContent(const std::vector< std::string > &stringList)
Changes the contents of the virtual "config file".
constexpr double RAD2DEG(const double x)
Radians to degrees.
#define ASSERT_ABOVE_(__A, __B)
Definition: exceptions.h:155
#define MRPT_END
Definition: exceptions.h:245
bool kbhit() noexcept
An OS-independent version of kbhit, which returns true if a key has been pushed.
Definition: os.cpp:392
std::string file_get_contents(const std::string &fileName)
Loads an entire text file and return its contents as a single std::string.
uint8_t month
The year.
Definition: datetime.h:52
std::string exception_to_str(const std::exception &e)
Builds a nice textual representation of a nested exception, which if generated using MRPT macros (THR...
Definition: exceptions.cpp:59
uint8_t hour
Day (1-31)
Definition: datetime.h:54
const int argc
orientation yaw absolute value (global/navigation frame) (rad)
double timeDifference(const mrpt::system::TTimeStamp t_first, const mrpt::system::TTimeStamp t_later)
Returns the time difference from t1 to t2 (positive if t2 is posterior to t1), in seconds...
Definition: datetime.h:123
orientation roll absolute value (global/navigation frame) (rad)
std::string MRPT_getVersion()
Returns a string describing the MRPT version.
Definition: os.cpp:187
An observation of the current (cumulative) odometry for a wheeled robot.
Saves data to a file and transparently compress the data using the given compression level...
void Tic() noexcept
Starts the stopwatch.
Definition: CTicTac.cpp:75
#define ASSERT_FILE_EXISTS_(FIL)
Definition: filesystem.h:22
void dump_GPS_mode_info(const mrpt::obs::CObservationGPS &o) const
This class stores messages from GNSS or GNSS+IMU devices, from consumer-grade inexpensive GPS receive...
#define THROW_EXCEPTION_FMT(_FORMAT_STRING,...)
Definition: exceptions.h:69
#define MRPT_LOG_ERROR_STREAM(__CONTENTS)
size_t size() const
Returns the number of observations in the list.
mrpt::config::CConfigFileMemory params
Populated in initialize().
void dump_IMU_info(const mrpt::obs::CObservationIMU &o) const
#define MRPT_LOG_INFO_FMT(_FMT_STRING,...)
#define MRPT_LOG_INFO(_STRING)
mrpt::obs::CSensoryFrame m_curSF
void insert(CAction &action)
Add a new object to the list.



Page generated by Doxygen 1.8.14 for MRPT 2.0.2 Git: 9efc2a654 Mon Apr 6 11:24:47 2020 +0200 at lun abr 6 11:30:12 CEST 2020