Event_Logger

for TomTom

Version 9.1 - RELEASED

 

 

NEW!!! Click this LINK to browse the NEW presentation of Event_Logger v9.1. NEW!!!

 

 

 

May 8, 2010

 

Added new presentation of Event_Logger 9.1

 

 

 

February 28, 2010

 

Event_Logger 9.0 offers a vast improvement over the previous releases and provides end-to-end management of itineraries from planning to reporting, fully integrated with Google Maps and TomTom.

 

The relevant effort to upgrade Event_Logger took over almost one year and produced a new framework including many additions and upgrades.

Event_Logger v9 now introduces a Web Application called GmapToItn, which allows designing an itinerary through Google Maps, with no restrictions. Not only Google waypoints are fully managed, but also draggable directions and points of interest (POI) are allowed. After designing the whole itinerary with the standard Google Maps web application, including multiple subsequent destinations and dragged points on the paths to customize each route, the TomTom Itinerary data is simply produced by selecting a simple bookmark: a panel appears presenting the ITN report ready to be copied to a file on the TomTom device; besides, data can be further customized through an easy user interface providing appropriate configuration switches. POIs produced by Google local searches are presented as multiple destinations and every point or destination includes the related description. GmapToItn is compatible with virtually any Internet browser and does not require installation (just a bookmark is needed).

Transferring the data produced by GmapToItn to the TomTom device requires a very simple manual operation consisting in creating an ITN file (e.g., with notepad) and pasting the acquired data; alternatively, Event_Logger 9.0 provides a separate tool called SendTomTom, which allows transferring data to TomTom via Bluetooth with only the need to provide a file name (it requires that BTConsole is installed and running on TomTom; the application supports UNIX, Mac OS X, Linux and PC through Cygwin).

The GPX Browser (gpx.xsl), already available in previous Event_Logger versions to allow interactive track analysis, now introduces many enhancements including draggable direction markers, Street view overlays as well as Panoramio, Wikipedia and YouTube overlays, reverse geocoding (translating coordinates and map points into addresses), GPX 1.1 support (other than GPX 1.0), right key mouse options, complete integration with Google Earth and many bug fixes.

Other than the widely used GPX Browser, Event_Logger v9 introduces a new reporting tool called ITN Browser. It consists of a comprehensive web application that offers a new way to review travels through detailed analysis of more ITN files even within long timeframes. It can browse any ITN file as well as the enriched ones produced by Event_Logger, aggregating data from more files and organizing the produced report in a very descriptive and readable table. ITN Browser is not only linked with GmapToItn (the Google Maps plugin allowing generating the TomTom itinerary data) but is also extensively integrated with Google Maps, exploiting all geodecoding and direction capabilities offered by Google. For instance, ITN Browser allows to quickly identify which and how many destinations have been travelled for work in the previous month, together with the related distances, tour durations and stay times.

The core stack of Event_Logger v9 running inside TomTom devices supports any model and NavCore version, including NavCore v9 that has introduced unexpected restrictions. Event_Logger v9 provides further enrichments to the features available with Event_Logger 8.2 (like the periodic ITN autoupdate during the trip), it is very responsive and does not inhibit TomTom’s functionality in any way. Bugs are virtually nonexistent. 

The following elements, which are included in Event_Logger 9.0 and run on NavCore 7 and 8, are unfortunately no more compatible with NavCore 9:
 - reverse geocoding,
 - snap-to-road positioning,
 - delayed flashing overlay messages (including Event_Logger ShowAltitude switch),
 - automatic day/night change,
 - POI management.
These restrictions are due to the limitations of NavCore v9 compared to the previous versions.

The additional software included with Event_Logger v9 should compensate the geodecoding limitation, considering that gpx.xsl, GmapToItn and Itn Browser offer advanced reverse geocoding features through Google Maps.

A completely rewritten and optimized NMEA/SiRF binary driver transparent to TomTom’s software can decode and record direct GPS data without virtually impacting NavCore and with automatic installation; this should compensate the missing Snap-To-Road capability.

An upgraded highly performing screen management functionality including different fonts together with a new driver managing screen and keyboard interaction with NavCore, again completely transparent to TomTom’s software, shall compensate the missing flashing messaging capability of NavCore v9.

 

Unfortunately, by now there is nothing doing for the inhibited SDK features that allowed automatic day/night change and add POI. It is the result of a direction by TomTom to completely close the navigation appliance to software contributors, differently from the original TomTom strategy providing a well documented and working SDK.

 

While Event_Logger 8.3 is feely downloadable , due to the effort I needed to accomplish this upgrade, Event_Logger v9 is only reserved to donors.

 

The update Event_Logger 9.1 is released now.

 

Here is a link to a complete presentation.

 

Again, thanks to people who already donated, supporting my work. Visit soon this site to review the new Event_Logger v9 documentation.

 

Amacri

 

1. Introduction

Event_Logger provides end-to-end management of itineraries from planning to reporting, fully integrated with Google Maps and TomTom; Event_Logger includes a tracking and logging Agent enhancing all all-in-one TomTom GPS devices. It can log TomTom events to Itinerary files that are managed by TomTom like native Itinerary files created through the ordinary user interface; besides, Event_Logger can produce standard GPX XML files where events are represented as waypoints and the whole route is logged through a sequence of track points obtained by querying TomTom GO for location information at short periodical intervals; the produced tracking will result bound to the roads through the assistance of both the TomTom GO mapping and the ASN feature (if active) in order to normalize tracking even without proper GPS reception; other than this default process to produce snapped-to-road GPX tracks, an additional option allows retrieving raw GPS data not intermediated by TomTom GO, useful for off-road tracking and also including altitude; Itinerary records and GPX waypoints take account of boot, resume, suspend events and optionally other information generated by manually tapping on the available (and extensible) logging menu icons. Other than generating Itinerary and GPX files, Event_Logger can create POIs (Points of Interest) for each event (or for a configurable subset).

The production and archiving of Itinerary and GPX tracks is completely automatic; no user intervention is needed to regularly split files upon new paths, save and catalogue them as well as store old information in compressed archives. The history of all travelled paths can be accessed by browsing the Itn directory of the SD card (or HD).

As the power button of TomTom GO is actually a suspend/resume button, any related pressure is logged by Event_Logger. Besides, Event_Logger automatically defines a new path each time the TomTom device is switched off and then switched on again after six minutes or more. If the docking station is connected to the vehicle ignition, the driver’s interaction with the vehicle will automatically raise ‘resume’ and ‘suspend’ events, caught by Event_Logger. This means that each ignition will automatically catalogue a new path (unless a short break is performed).

A boot happens when the user manages the USB, the SD Card as well as the reset hole on the unit’s bottom (the last action also resets the TomTom GO system clock); boot events are accounted by Event_Logger too.

All Itinerary records include date and time of each event occurrence as well as the associated duration data and possibly the current position, altitude, speed, course and address. Depending on Event_Logger configuration settings (e.g., snap-to-road/off-road) and on the NavCore version, GPX data can potentially deal with all parameters produced by the GPS device, including also number of used satellites, HDOP, PDOP, VDOP, magnetic variation (when available) and geoid separation (see related description).

A special selection activates a snapshot report displaying advanced statistics related to the current trip, also including slope computation. An additional panel included in Event_Logger provides an astronomical calendar in textual format where data depend on the current local time and position. Besides, switching between day and night colours of TomTom GO is automatically performed according to the elevation of the sun.

For instance, Event_Logger helps answering the following questions:

• What itinerary did I travel yesterday?
• When did I start driving this morning?
• How long did I take?
• Which is the current altitude and speed?
• How can I remind precise positions?
• When exactly I travelled there?
• Which is the altitude of this place?
• Which was the maximum uphill and downhill slope of my previous trip?
• Where is the moon now?

And so on.

The GPX files collected by Event_Logger allow performing any kind of post-processing, batch analysis, statistics and file conversion together with XSLT stylesheets or external applications (file converter, GIS, mapping and analysis tools running on PC or legacy systems).

An XSL file included with Event_Logger allows Internet Explorer to automatically transform each GPX file into an HTML interactive report with zoomable graphical map from Google Maps, including coloured tracks and fully clickable waypoints; the map provides advanced functionalities and is followed by detailed tables analyzing almost all data registered inside the GPX file, with computation of distance, speed, altitude and slope related to each fix, segment, trace or whole file. Each table can be easily imported to Excel. Besides, two delimiters can be easily set over the map in order to allow interactive trip analysis.

Event_Logger virtually supports any all-in-one GPS TomTom device and is designed to be independent from specific models (e.g., display size and geometry), firmware versions (including NavCore v7) and GPS device (SiRF Star II, SiRF Star III, SiRF Star III with QuickGPSfix and Global Locate's Hammerhead GPS units are all supported).

The subsequent chapters describe all these functionalities in detail.

Event_Logger today delivers the most comprehensive set of functionalities that complement TomTom and is a reference for independent tools on top of the TomTom firmware and of the NavCore application.

Differently from the majority of similar applications, Event_Logger also provides fully commented source code, allowing verification of the implementation quality and sharing the innovation; with its pervasive documentation including development guide, Event_Logger not only details functions and customisation aspects to users, but also is a common reference for independent developers. Great care was taken in preparing the whole documentation, constantly updated upon each release of new features.

Pioneering the methods to add software into the TomTom device, Event_Logger was the first to automatically intercept and log TomTom events like “switch on”, “switch off” and “boot”, exploiting them in a core functional process that is able to automatically split trips through the analysis of the switch off time; any derived process of Event_Logger is based on this automation; this provides great help to users which have not to remind to manually mark the beginning of a new trip. This method, which is innovative on a TomTom device, has been inspired from the behaviour of software odometers embedded in some vehicles.

Event_Logger perfectly harmonizes with TomTom, avoiding any redundant information already provided by the standard application and introducing a lot of additional trip based data to users; it was the first application to successfully interface NavCore through its “file transportation layer” without requiring the SDK platform; the result was the implementation of a free method which allows NavCore to display messages and to retrieve normalized fixes through the TomTom map assistance (the basis of the “snap-to-road” method). Event_Logger was also the first application exploiting the Itinerary management of TomTom, to allow user reading externally collected fixes through the NavCore function “Itinerary Planning”, introduced with NavCore 5.

Besides, Event_Logger first introduced GPS tracking and since the beginning adopted the GPX standard; it is also the only application providing both “snap-to-road” and “off-road” collection methods.

Event_Logger v9 introduced a Web Application called GmapToItn, which allows designing an itinerary through Google Maps, with no restrictions. Not only Google waypoints are fully managed, but also draggable directions and points of interest (POI) are allowed. After designing the whole itinerary with the standard Google Maps web application, including multiple subsequent destinations and dragged points on the paths to customize each route, the TomTom Itinerary data is produced by selecting a simple bookmark: a panel appears presenting the ITN report ready to be copied to a file on the TomTom device; besides, data can be further customized through an easy user interface providing appropriate configuration switches. POIs produced by Google local searches are presented as multiple destinations and every point or destination includes the related description. GmapToItn is compatible with virtually any Internet browser and does not require installation (just a bookmark is needed).

Transferring the data produced by GmapToItn to the TomTom device requires a very simple manual operation consisting in creating an ITN file (e.g., with notepad) and pasting the acquired data; alternatively, Event_Logger 9.0 provides a separate tool called SendTomTom, which allows transferring data to TomTom via Bluetooth with only the need to provide a file name (it requires that BTConsole is installed and running on TomTom; the application supports UNIX, Mac OS X, Linux and PC through Cygwin).

The GPX Browser (gpx.xsl), already available in previous Event_Logger versions to allow interactive track analysis, now introduces many enhancements including draggable direction markers, Street view overlays as well as Panoramio, Wikipedia and YouTube overlays, reverse geocoding (translating coordinates and map points into addresses), GPX 1.1 support (other than GPX 1.0), right key mouse options, complete integration with Google Earth and many bug fixes.

Other than the widely used GPX Browser, Event_Logger v9 introduces a new reporting tool called ITN Browser. It consists of a comprehensive web application that offers a new way to review travels through detailed analysis of more ITN files even within long timeframes. It can browse any ITN file as well as the enriched ones produced by Event_Logger, aggregating data from more files and organizing the produced report in a very descriptive and readable table. ITN Browser is not only linked with GmapToItn (the Google Maps plugin allowing generating the TomTom itinerary data) but is also extensively integrated with Google Maps, exploiting all geodecoding and direction capabilities offered by Google. For instance, ITN Browser allows to quickly identify which and how many destinations have been travelled for work in the previous month, together with the related distances, tour durations and stay times.

With the goal to allow smooth execution into the limited resources of embedded systems (CPU, RAM memory, SD memory), Event_Logger singularly implemented the functional process through scripting and the building blocks by extending an efficient interpreter with C functions; zsh was selected as the basis for the script interpreter, not only because much tinier and lighter than external perl or java portings, but also because it outperforms the system tools available inside the TomTom firmware; a considerable set of customizations have been applied to zsh in order to increase functionalities and in parallel to further reduce its executable size. Event_Logger also integrates the infoZIP archiver into an unmatched functional management process to classify and incrementally save data on the SD card. The result is an architecture that provides robust functionalities without introducing performance degradation.

      Notice that it is mandatory to carefully read and accept the disclaimer of warranty and license conditions at the end of this document before downloading and using Event_Logger.

2. What's new

What's new in 9.0 and 9.1

(May 8 - January 23, 2010)

This version is ready and offers a vast improvement over its predecessors.

Click at this LINK to browse the NEW presentation of Event_Logger V9.

Donations are more than happily accepted! Event_Logger took a lot of development time, as well as large number of testing and user support; if you like this software, you are kindly invited to send donations; click on the PayPal button to proceed, or email to amacri@tiscali.it to know how to perform this.

2.1. What's new in 8.2

(June 29, 2009)

This version includes the following changes and corrections versus 8.1.

• New shortcut button functionality for “Log Position to Itinerary”. Simply press the screen very close to its top left margin (e.g., near the “+” zoom symbol during standard navigation); after an audible shutter click produced by TomTom, the position is logged as if the “Log Position to Itinerary” was pressed. This also enables this function on TomTom devices not supporting custom menus. In order to speed up the TomTom response to an Event_Logger request, tap on the default navigation screen to get the TomTom menu (e.g., to exit the default real time navigation map) and wait for the displayed message (which should come faster through this operation, in few seconds).  If the new shortcut button function is not wanted, set DoWtchScrFld variable to no. Besides, again in case custom menus are not supported by your TomTom version, all files of SdkRegistry/Geo can be copied to SdkRegistry; then menus are available as map position detail elements (menu à second page à Browse map  à Navigator icon (  ).
• This version supports also the display popup of altitude (above sea level) and normalized slope (percent) each time this information is received by the GPS and roughly every minute. Set ShowAltitude=yes in order to enable this function. The display method is the same of all other popup messages and follows the delay issue of the main NavCore navigation mask mentioned in the previous point. If prompter popup timing is needed, tap on the screen to select a different screen (e.g., the TomTom menus). Each popup message remains active on the screen for four seconds (ref. AltDuration variable). By switching to off-road (e.g., long off road travel) this popup is shown every polling time (ref. TrackingGranularity variable) whenever a GPS 3D fix (including altitude) is fetched.
• Now, when keeping the touchscreen pressed while executing “Log Position to Itinerary”, the Advanced Statistics splash screen remains frozen on the screen even if the finger is immediately released (there is no more need to keep the finger pressed until the HOLD message is displayed). Press again the touchscreen to restore the NavCore screens. This behaviour can be controlled through the variable “WaitBeforeHold” (which is now set to 0).
• As explained in the instructions, GPX.XSL is a file, available inside Itn directory, which allows opening GPX files (both GPX and XML extensions) with Internet Explorer. Simply double click each XML file to graphically render it. In order to allow this, Gpx.xsl should be in the same directory of the XML and GPX files (typically, the itn folder). If these files are moved from the Itn folder to another directory, also Gpx.xsl shall be copied. A new version of GPX.XSL provides the following new functionalities:

·         Included messages with units in miles and feet other than km and meters. Simply move GPX.XML in a backup directory and rename gpxMilesFeet.xsl to GPX.XSL.

·         Now GPX.XSL overcomes a current Google Maps bug (by forcing version 2.99). You will not find an error anymore while clicking on markers to show related details.

·         GPX.XML now manages BOOT events and POI events with appropriate icons.

·         The map rendering performed by GPX.XML (press P = “More maps”) also includes the following sources:

·         Microsoft MSN Virtual Earth (Map, Satellite and Hybrid; http://maps.live.com)

·         Yahoo! Maps (Map, Satellite and Hybrid; http://maps.yahoo.com)

·         OpenStreetMap tiles (http://www.openstreetmap.org and http://wiki.openstreetmap.org) using the following renderers:

• Mapnik (http://www.openstreetmap.org/index.html)
• Osmarender (http://www.openstreetmap.org/index.html)
• Cycle Map (http://www.opencyclemap.org)
• CloudMade (http://maps.cloudmade.com)

·         MyTopo (http://www.mytopo.com)

·         RunwayFinder (http://www.runwayfinder.com)

·         OnEarth daily MODIS (http://onearth.jpl.nasa.gov)

Now the full list of allowed tiles is: Google Map, Google Satellite, Google Hybrid, Google Terrain, USGS topo, USGS aerial, USGS aerial+Google, U.S. Nexrad, Canada topo, Can. topo+names, Landsat 30m, Blue Marble, Blue Marble Next Gen., Daily "Terra", Daily "Aqua", Daily MODIS, SRTM elevation, EarthTools Contour, OpenStreetMap Mapnik, OpenStreetMap Osmarender, OpenStreetMap CycleMap, OpenStreetMap CloudMade. Virtual Earth Map, Virtual Earth Satellite, Virtual Earth Hybrid, Yahoo! Map, Yahoo! Satellite, Yahoo! Hybrid, RunwayFinder, U.S./Can. MyTopo.

• Event_Logger is comprehensively ported to NavCore 8.2x and 8.3x (including Event_Logger agent auto start-up during boot time, development of the new touchscreen functions which are now transparently supported by bsh, new timing algorithm to avoid reboots during resume operations). Tested versions: 8.204, 8.300, 8.320, 8.410, 8.412, 8.413.
• Event_Logger is also tested also with NavCore 8.002, 8.010, 8.011, 8.051 and with additional TomTom models, including GO 930T.
• NavCore firmware versions 8.350 and 8.351 do not allow interacting with external applications started through menu items; what happens is that the touchscreen is shared between the started external application and NavCore, which is not brought to background (differently from all other NavCore firmware versions). The behaviour of versions 8.350 and 8.351 do not compromise the log tracking of Event_Logger, which is performed in background with no need of user interaction. Besides, the shortcut button functionality activating “Log Position to Itinerary” still works. Anyway, functionalities provided by selecting the Event_Logger menu items are unusable with the standard devshare.so included in the Tracer directory. To allow interaction with versions 8.350 and 8.351, after the installation replace the file Tracer\devshare.so with Tracer\navcore8.35x\devshare.so. In case this is not enough to overcome the display issue, try replacing file Tracer\devshare.so with Tracer\navcore8.35x_and_old_devices\devshare.so.
• Now comments inside ITN files can be inhibited in order to provide full compliance with TomTom specifications (that ignores the possibility of adding comments even if NavCore can show them at the beginning or at the end of a file). See “NoCmtInItn” variable (setting it to yes would result in loosing general comments unrelated to positions in all generated Itinerary files, but provides increased compatibility with Tyre).
• A new feature allows exploiting the external SD card (for those TomTom devices supporting it). If the external SD card includes a directory named itn (which the user has to manually create in advance), the GPX logs are archived on that directory instead of exploiting the default itn directory of the internal TomTom memory (this might be useful when the space of the internal memory is very limited). Besides, if the external SD card also includes the “Tracer” directory, Event_Logger is executed from that directory (anyway, cleanup.txt and ttn must be in the root directory of the internal memory and a directory named “Tracer” including at least mkel has to be installed in the internal memory). If for some reason Event_Logger is required to run on a specific card or different hard disk from the previously described process (e.g., both Tracer and Itn directory on an external SD card also including the whole TomTom program and maps), simply create a null file called “hererun” (with no double quotes and no txt extension) inside the related Tracer directory.
• Translation strings have been improved, thanks to suggestions coming from users; Croatian translation has been added.
• Improved management of date strings in ITN and GPX files; date comments are clearer; now date syncs do not affect trip time accounting. Added “IncorrectDateSymbol”, used to identify ITN records with incorrect or inaccurate date (it defaults to a question mark, displayed just after an incorrect date). Besides, additional comments can be found in GPX files which highlight whether a date is incorrect (e.g., because not yet synced after a hard reset).
• A note has been added in relation to TomTom models hosting a SiRF Star III with QuickGPSfix software; when decoding from that GPS device, the returned PDOP (Position Dilution of Precision) and VDOP (Vertical Dilution of Precision) are actually Estimated Horizontal Position Error (EHPE in meters) and Estimated Vertical Position Error (EVPE in meters). Dilution of Precision (DOP) is a measure of how the geometry of the satellites affects the current solution’s accuracy.
• This version includes additional controls that avoid incorrect GPX formats (which might have happened in previous versions under rare circumstances).
• Now event logging of waypoints in GPX files (like RESUME, SUSPEND in “wpt” tags) take advantage of the Event_Logger Agent cache memory other than the NavCore one. This improves precision when both GPS and NavCore cannot return valid fixes (e.g., while suspending). The Event_Logger Agent cache is also dumped to the file named TripData under the Tracer directory.
• Other than supporting the new touchscreen functions for the latest NavCore versions, BSH has been further developed: read command now accepts a timeout argument; ztouch command has been updated; added also new setopt FunctionPhArgZ, new commands watchd, zrd, watchf, lease, inotify, dnotify (see documentation, in the last part of the development section). Even if implemented, inotify and dnotify are currently disabled due to the missing TomTom Linux kernel functionalities; for the currently available ttsystem versions, the kernel has been compiled with the related switches disabled.
• To improve suspend/resume performance, now “OldGpxToKeepOnline” is set to 0 by default, so that archiving of GPX file is disabled. Can be enabled by setting this variable to a value greater than zero.
• This version has a completely redefined GPS decoder, to improve performance. Now the measured speed parameter is correctly included in GPX files for off-road settings. Removed a bug producing wrong course in GPX files under some rare cases.
• Corrected a bug occurring when processing negative time zones.
• Additional bug fixing and performance tuning.
• When devshare.so is available inside the Tracer directory, the tracking granularity can be configured up to two seconds; notice that this takes additional CPU resources. Remove or rename devshare.so for standard operation (by default files devshare.so and ttn are both positioned in the startup subdirectory, so that the related functions are disabled).
• Documentation has been updated.
• Source code (Sources.zip) has been revised in order to allow easier recompilation (make clean; make; make clean; ./mkarm).
• Additional notes:
• It is normal that Top reports three Event_Logger instances concurrently running: this is because Event_Logger consists of a Posix milti-threaded application which is shown in such a way by Linux /proc. Actually, only one single process and memory resource are used of the three shown Linux tasks.
• Files created by Event_Logger inside the Tracer directory are for internal usage. Target GPX and ITN files can be found inside the Itn directory.
• If the automatic start-up of Event_Logger at boot time is not wanted, a null file named noeventlogger can be created in the root directory of NavCore (where also the file ttsystem can be found). Event_Logger will be started at the first pressure of the “Log Position to Itinerary” button icon.
• As described in the instructions, setting NoWatchDog=yes has the effect to inhibit the standard NavCore watchdog agent and to start a custom agent included in Event_Logger, which prevents NavCore reboots under certain conditions; this setting is generally not needed and becomes active after an initial reboot. In order to avoid this initial reboot, a null file named nowatchdog can be created in the root directory of NavCore (where also ttsystem can be found).
• This version also allows compatibility with Height (http://gps.dg4sfw.de/files/height_8.zip). Notice anyway that the ttn file to install on TomTom should be the one included in Event_Logger, not the one insight Height.

INSTALLATION AND UPGRADE NOTES: same as in “What's new in 7.2” below.

 2.2. What's new in 8.1

(March 10, 2008)

This version includes the following changes and corrections versus 8.0.

• Optional support of the bzip2 compression method in zip files produced by Event_Logger (often gives a better compression ratio than standard zip deflate, at the cost of greater CPU time). Before using bzip2 compression, please verify that a modern UnZip program with bzip2 support will be used to read the resulting zip archives so that entries compressed with bzip2 can be read.  Set “Bzip=9Zbzip2 ZipExec=zip3” in the configuration section to enable bzip2 compression.
• Now Event_Logger can automatically create an optional Itinerary file (ITN) and an optional POI file (OV2) including detailed tracking of each travelled route (e.g., basing on each produced GPX file and transforming it through GPSBabel). Both ITN and OV2 tracks can exploit a simplification method which removes points that have the smallest effect on the overall shape of the route; this filter is particularly important for ITN files, because NavCore allows browsing only the first 48 lines of them. Check ItnTrkPt and Ov2TrkPt variables to enable these transformations and control the simplification factor. Enable this feature only if really needed: each file generation takes some seconds to the power-on, power-off and boot procedures; consider that these files can always be manually generated basing on XML/GPX tracks.
• Corrected bug related to NoWatchDog=yes when running NavCore 7, that was causing cyclic reboots; now NoWatchDog=yes should inhibit all unattended reboots even with slow TomTom devices or SD memories. Besides, a specific description on how to manage possible cyclic reboots after the initial Event_Logger installation has been added in the Installation chapter.
• Corrected bug causing wrong computation of motion duration.
• Corrected bug in GPX.XSL related to the rendering of distance calculations in case of initial GPX segment with zero elements.
• Removed a bug preventing correct renaming of ITN and GPX archive backups.
• Now splash messages more appropriately manage TomTom screens with different sizes.
• Corrected mistype in icons.
• Documentation corrected and updated.

INSTALLATION AND UPGRADE NOTES: same as in “What's new in 7.2” below.

2.3. What's new in 8.0

(January 20, 2008)

This version includes minor changes and corrections versus 7.2.

• Corrected bug in SirfBinToAscii (bsh) setting some latitudes or longitudes to zero
• Corrected bug in geoid (bsh) not accepting longitude values between +/-90 and +/-180 degrees
• Corrected bug in Event_Logger.txt resetting GeoidSeparation (altitude shift issue)
• Corrected bug in Event_Logger.txt when computing altitude in feet (besides, altitude computation in GPX files has been slightly improved)
• Corrected bug in GPX.XSL related to the rendering of time calculations in case of initial GPX segment with zero elements.
• Now the Astronomical Calendar has an increased timeout for the fix retrieval operation; besides, the fix retrieval to start the Astronomical Calendar also exploits the direct GPS device interface if NavCore fails to provide data via SDK.
• Now, when the "advanced statistics" splash screen is selected, no event is recorded unless the IgnLongList variable is set to yes.
• Added WaitBeforeHold variable related to the "advanced statistics" splash screen, which allows configuring the timeout in seconds to keep the touchscreen pressed before the splash is frozen, so that the finger can be immediately released with the splash frozen if WaitBeforeHold=0 (as usual, a second pressure will make the splash disappear).
• Documentation corrected and updated.

INSTALLATION AND UPGRADE NOTES: same as in “What's new in 7.2” below.

2.4. What's new in 7.2

(December 30, 2007)

This version could be considered like a major upgrade for the relevant enhancements included. The most noticeable one is the support of virtually all the TomTom devices now available, including the various embedded GPS units and also NavCore 7 (with some limitation; ref. to the “Compatibility” paragraph). Considering the occasionally very slow SDK API response of NavCore 7 used by Event_Logger in snap-to-road mode, a specific feature (that can be configurable) automatically gets positioning information from the GPS when NavCore 7 does not provide any answer within a predefined timeframe. All other changes are described here below.

·         Setting the GeoidHeight variable is no more needed: for older TomTom devices, this value is now dynamically calculated by Event_Logger basing on latitude and longitude; besides, for newer models, this value is directly generated by the internal GPS device and fetched by Event_Logger. The algorithm used by Event_Logger exploits a function available in the GPSD project (http://gpsd.berlios.de/). Basing on the automatically computed values, GeoidHeight is still in place (and defaulted to 0) to allow statically setting a further translation correction, when really needed. As a reminder, the altitude is logged only when the off-road options are selected (not the snap-to-road ones).

·         Now an important limitation of the off-road feature of Event_Logger has been removed; it prevented retrieving direct information from the GPS devices in newer TomTom models, e.g., those ones hosting a SiRF Star III GPS unit which is set to use the SiRF binary protocol rather than the NMEA one. Event_Logger can now auto-detect the GPS unit type and decode both NMEA and binary SiRF frames, managing the off-road feature for any TomTom model; this allows tracking real coordinates, altitude, number of satellites and position error estimations with no specific configuration to apply, apart from enabling the off-road option from the related menu button.

·         Support of TomTom devices hosting Hammerhead GPS unit.

·         A further tuning has been performed to the NMEA driver which decodes information produced by TomTom devices and now GPX files should always include PDOP, VDOP, HDOP and Number of satellites in each GPX <trkpt> fix.

·         Slope computation has been added, including instantaneous slope, average slope for the last stretch of the path, maximum downhill and uphill slope, all accurately tuned for pretty reliable values. These parameters are included in the Event_Logger advanced statistics pop-up, which is the splash screen shown after selecting "Log Position to Itinerary" and when then keeping the touchscreen pressed for more than five seconds. Max uphill and downhill slope values also appear in the <name> tag of the GPX file.

·         As many users found difficulties in opening GPX files with Internet Explorer, now a new configuration setting allows saving GPX track files with either the “.gpx” or the “.xml” extension. By default, the latter is configured (rather than the previous versions, where .gpx was used), enabling easy GPX browsing: Internet Explorer opens XML files and automatically starts the XSL parser when the file “gpx.xsl” is available in the same directory of the GPX/XML files. Check the GpxFileExt variable in the configuration section of Event_Logger to select the wanted extension type. Notice that switching among the two extensions is a standard rename operation, which can be manually accomplished by any user in any moment. Besides, an Event_Logger function automatically renames un-archived GPX files (the last five ones by default) according to the value set in the GpxFileExt variable.

·         GPX files can now be correctly edited with notepad, because the DOS/Windows <CR> - <NL> character sequence is used for line separator. A new CR0 variable has been introduced for this; it can be configured for Windows or UNIX formats.

·         Previous version 7.1 reported the issue to lock the TomTom auto-reboot when extracting the SD card or when connecting the USB; this is a side effect of disabling the kernel watchdog feature (thanks Franz Haas of the OpenTom list for this hint), which sometimes happens to generate a device reboot when Event_Logger takes too many seconds to perform its internal operations (e.g., including archiving, file backup and zip compressions); notice this should never happen in normal operation, but only in debug mode, e.g., when resuming while tracing at level 5. Now this no-watchdog setting is configurable and by default is disabled (watchdog enabled, WatchDog=yes). If some user happens to verify reboots once in a while and wants to ensure avoiding them, the WatchDog variable in the configuration section can be set to no (and it needs a manual reboot via suspend button after inserting the USB cable or extracting the SD card).

·         Now each single backed-up archive inside itn\Bkp will never exceed a predefined size (which is configurable for Itn and Gpx types) in order to prevent too slow update operations. This should avoid that an automatic reboot might happen while resuming.

·         New button icons are available, thanks to Herbert Macho. The installation package also includes alternative TomTom button icons in a separate directory (provided by Herbert Macho and by Francesco Bombassei); simply select the icons you prefer.

·         The accuracy of distance computation has been improved by ignoring fixes with HDOP = 20 or greater.

·         Now the radius of the Earth has been set to 6378.137 kilometres in Event_Logger configuration (E_RADIUS variable), in order to produce values compatible with Google Maps.

·         Removed a bug preventing ITN and GPX archiving in some cases.

·         Removed rare syntax bugs in GPX tracks (now GPX files should always be syntactically correct or 'well formed', e.g., should never generate errors when opened with Internet Explorer).

·         Reduced refresh rate in the Astronomical Calendar, allowing improved readability.

·         Now bsh and zip (Info-ZIP) are compiled optimizing performance (-O3) rather than size (-Os).

·         Minor bug fixing.

·         Revised documentation.

·         New BSH commands: SirfEnvelope, SirfBinToAscii, dumps and geoid (see documentation, in the last part of the development section).

·         Further improvement to the Google Maps integration of the GPX browser, with a number of relevant additions included in GPX.XSL:

1.       Automatic management of locale settings (with very limited need of configuration)

2.       Local search component, which can be activated via key S or through the options panel (see documentation)

3.       New map layers (including other 13 maps from external providers other than the three standard Google maps types) and online altitude retrieval for any selected point

4.       Support of the new Google Map Layer named “Terrain”

5.       Fixes are now highlighted with small coloured square blocks than square icons, highly improving performance and allowing a wider default of concurrently managed fix elements.

6.       All waypoint markers can be dragged to improve readability, especially in case they are overlapped. Delimiters can also be dragged.

7.       Now all shown graphic elements have a tooltip.

8.       Simplified management of X key.

9.       New blue colour for the “delimiter” markers.

10.    Minor additions and fixes.

11.    Tested to also run inside Firefox through the IE Tab addon http://ietab.mozdev.org.

INSTALLATION NOTES: copy all files (apart from “Sources“ directory, Event_Logger.pdf and any ReadMe.txt). It is essential to preserve the directory structure included in the ZIP package unaltered. Edit Tracer\Event_Logger.txt with any editor (including notepad) and, above all, check variables TIMEZONE and LANGUAGE. If the Tracer directory is missing after the archive extraction, this mean that the directory structure of the package has not been respected. See the Installation paragraph for further information.

UPGRADE NOTES: replace all files (apart from “Sources“ directory, Event_Logger.pdf and any ReadMe.txt); remove H:\ttn (if existing) of any old Event_Logger version (important), then rename _Logger.itn (if existing) to _Latest_Events.itn; files EventLogger.tgz and Event_Logger.tgz (if existing) in “Itn” directory are no more used: they can be archived out in the Bkp directory; “Track” directory (inside "Tracer" directory) is no more used (can be saved out and then deleted); expr in the "Tracer" directory (if still existing) can be removed. Edit Tracer\Event_Logger.txt with any editor (including notepad) and, above all, check variables TIMEZONE and LANGUAGE. If using POIs, rename Tracker.ov2/.bmp (if existing) to POI_Tracker.ov2/.bmp. See the Installation paragraph for further information.

Verify that Debug is set to 0 inside Event_Logger.txt. If any of the files ttnlog-<date>.txt, TtnLog.txt, TrxLog.txt, trxlog-<date>.txt are available in the Tracer directory, this means that the Debug flag was not set to 0 in a previous Event_Logger version; all these files can be safely deleted to save space; anyway, before deleting them, with the WordPad editor please check the presence of the string _Event_Logger_Script_ERROR_ inside each of them; if this string exists, email the files to amacri@tiscali.it in order to facilitate bug fixing.

FURTHER INSTALLATION NOTES:

-          Do not forget to copy the file named “cleanup.txt” to the root of the SD or HD. If this file already exists, see the Installation paragraph for further information.

-          Do not exceed the maximum number of 10 “.cap” files in the “SdkRegistry” directory.

-          Setting the owner's preferences (a specific menu of TomTom) is discouraged (it might freeze the TomTom SDK functions until the "Continue" button is pressed).

-          A random menu reset to the initial menu page (e.g., page 1) might happen while navigating into the menu pages (typically after powering the device on; this is due to a small glitch in NavCore while processing the Event_Logger command changing night/day colours).

2.5. What's new in 7.1

(June 11, 2007)

·         Significantly improved browsing of GPX files with the addition of interactive analysis through Internet Explorer.

·         Slightly revised behaviour of “Toggle snap-to-road or raw GPS” button.

·         Some bug fixed (now the produced GPX file is always browsable with Internet Explorer and the suspend/resume operations are a bit more robust when the trace/profiling level is maximized).

·         Revised documentation.

INSTALLATION AND UPGRADE NOTES: same as in “What's new in 6.5” below.

2.6. What's new in 7.0

(March 17, 2007)

·         When opening the GPX files with Internet Explorer (e.g., "Open with… Internet Explorer" or drag and drop a GPX file to IE), Google Maps is started inside the browser, graphically representing the recorded path, together with many additional tables of statistics about the trip. Check to be connected to the Internet and that "gpx.xsl" is available in the same directory of the new gpx files.

·         Event_Logger can calculate the travelled distance (km or miles) while producing GPX logging; consequently, the average speed of a trip (km/h or miles per hour) and other new statistics can be produced. Besides, the GPX agent can trace the max and min altitude (meters or feet) as well as the motion duration (minutes) and max. speed.

·         When selecting "Log Position to Itinerary", a new mask can be activated by keeping the pop-up message pressed for some seconds. The new splash page shows advanced statistics related to the current trip. As soon as the touchscreen is released, the mask disappears unless the screen is kept pressed for additional five seconds: in the latter case the mask remains frozen on the screen until a new pressure is performed.

·         The GPX logging and GPX segmentation have been improved, with more precise timings and values. The process also monitors possible cases of wide distance between adjacent fixes, reporting conditions of nearby or faraway restarts (the former as new segment, the latter as new track).

·         Event_Logger now allows promiscuous usage; an appropriate chapter describes how to properly configure the application. GPX and ITN generation can be disabled, with decoupled behaviour to the day/night colour switcher. Besides, ITN and GPX archives can now include password protected files.

·         ITN and GPX archives now take advantage of an additional automatic backup copy of old archives inside the Bkp directory; this improves resilience in case of fault while producing a ZIP archive.

·         Event_Logger has been further tuned for performance with NavCore version 6.520 (SpeedNotAvailable variable is now set to yes, disabling the related NMEA feature).

·         The “Toggle GPX Tracker” icon is revised not to interfere with the day/night colour switcher. A new icon "Toggle Event_Logger Agent" in now available, with similar functions to what available in previous versions. (It is not really useful, so not suggested to be installed for normal operation.)

·         A bug introduced with version 6.5 about archiving old Itinerary files is now fixed. Other minor bugs have been fixed. SyncTime capability has been restored.

·         The documentation has been revised in all parts.

INSTALLATION AND UPGRADE NOTES: same as in “What's new in 6.5” below.

2.7. What's new in 6.5

(November 12, 2006)

·         Ported to NavCore 6.140, 6.150 and 6.520.

·         Fixed bug when setting negative values of GeoidHeight.

·         Improved NMEA driver including validation of the commands generated by the GPS device through the new NmeaChkSum function added in BSH.

·         GpxFileName variable with revised format in order to avoid two dots in GPX files, for better Google Earth compatibility

·         Debug now defaulted to 0 (it was set to 2 in version 6.4).

·         SyncTime capability is now disabled for better compatibility with NavCore 6.

·         NewGpxWhenDateChanges changed to NewGpxWhenDateAdjusted in order to avoid confusion.

·         Added Dutch translation.

·         All programs recompiled with the latest TomTom toolchain.

·         Some errors corrected in the documentation.

INSTALLATION AND UPGRADE NOTES: same as in “What's new in 6.4” below.

Verify that Debug is set to 0 inside Event_Logger.txt. If any of the files ttnlog-<date>.txt, TtnLog.txt, TrxLog.txt, trxlog-<date>.txt are available in the Tracer directory, this means that the Debug flag was not set to 0 in a previous Event_Logger version; all these files can be safely deleted to save space; anyway, before deleting them, with the WordPad editor please check the presence of the string _Event_Logger_Script_ERROR_ inside each of them; if this string exists, email the files to amacri@tiscali.it to facilitate bug fixing.

2.8. What's new in 6.4

(July 25, 2006)

·         Added off-road option to the GPX Tracker in order to allow processing data directly fetched from the raw GPS device (through the NMEA driver of Event_Logger). Check TTGOtoGPX and GpsToGPX variables for this; tracking can be tuned through TrackingGranularity and DelayToBreakTracks (representing intervals in seconds). (Off-road setting means GpsToGPX=yes, TrackingGranularity=5, DelayToBreakTracks=180).

·         Improved GPX Tracker with superior accuracy; each <trk> now includes geodecoded data; The NMEA driver has been enhanced to support additional messages and names.

·         Revised framebuffer and touchscreen calls in fb.c, (but without embedded touchscreen calibration); a printf wrapper is included, supporting bold attribute, ink/background/numeric colours, configurable shifts and ISO-8859-1 charset. Associated refinements in Top, Astronomical Calendar, bsh.

·         Slight revisions in Event_Logger.txt (added Norwegian language; now GeoidHeight supports decimals; other refinements)

·         Tested with TomTom GO version 5.450.

·         Ported and tuned to NavCore 6.120. Due to v6 busybox limitations, archiving is completely revised: the “Track” directory is no more used (can be saved out and then deleted). All ITN and GPX files are now stored in “itn” directory, including related archives (ItnArchive.zip and GpxArchive.zip) which are compressed in standard ZIP format (gzipped tar format is no more used). NavCore 6 automatically syncs Linux time to UTC; by consequence of this, browsing SD (or HD) files through a PC will produce “last modification times” set to UTC time zone (not local times); this feature is correctly managed by Event_Logger 6.4.

·         Revised documentation:

·         new information related to the additional features of this version and specifically to the GPX format;

·         Added mention of GPSBabel, a conversion tool which can be used to translate the GPX files produced by Event_Logger into many different output formats;

·         for developers, revised usage of zstat, framebuffer and touchscreen (now ts_press automatically removes bounces with no need of additional coding).

INSTALLATION AND UPGRADE NOTES: replace all files (apart from Sources directory, Event_Logger.pdf and any ReadMe.txt); remove H:\ttn (if existing) of any old Event_Logger version (important), then rename _Logger.itn (if existing) to _Latest_Events.itn; files EventLogger.tgz and Event_Logger.tgz (if existing) in “Itn” directory are no more used: they can be archived out and then deleted; “Track” directory (inside "Tracer" directory) is no more used (can be saved out and then deleted); expr in the "Tracer" directory (if still existing) can be removed. Edit Tracer\Event_Logger.txt with any editor (including notepad) and, above all, check variables TIMEZONE, LANGUAGE and GeoidHeight. If using POIs, rename Tracker.ov2/.bmp (if existing) to POI_Tracker.ov2/.bmp. See the Installation paragraph for further information.

Do not exceed the maximum number of 10 “.cap” files in the “SdkRegistry” directory.

Setting the owner's preferences (a specific menu of TomTom) is discouraged with NavCore 6.210 (it might freeze SDK functions until the "Continue" button is pressed).

A random menu reset to the initial menu page (e.g., page 1) might happen while navigating into the menu pages (typically after powering the device on; this is due to a small glitch in NavCore while processing the Event_Logger command changing night/day colours).

2.9. What's new in 6.3

(May 20, 2006)

·         Fixed a display bug with RIDER (e.g., now Top, Astronomical Calendar and splash messages are correctly shown on the screen of the RIDER). Now the display should support any TomTom model, including those with increased screen sizes.

·         Corrected small bugs in Astronomical Calendar (computation of moonrise and moonset; slightly improved descriptions). Added horizontal coordinates of the moon.

Upgrade note: same as in “What's new in 6.2” below.

2.10. What's new in 6.2

(May 6, 2006)

·           Corrected a bug preventing Bluetooth to work.

·           Fixed ts_press bug in bsh.

·           Improved pen management in “top” command; added “df” command (disk free) too (keep the screen pressed for more than 5 sec.).

·           Corrected small bugs in GPX description fields.

·           Further tuning for TomTom GO version 5.440.

·           Added Astronomical Calendar.

·           Added Automatic Switching between Night and Day colours basing on the elevation of the sun (original idea by ScaredyCat).

·           Updated documentation.

·           Revised installation process.

NOTE: Upgrade by replacing all files; remove H:\ttn (if existing) of any old Event_Logger version (important), then rename _Logger.itn to _Latest_Events.itn and EventLogger.tgz to Event_Logger.tgz in the “Itn” directory; expr in the "Tracer" directory can be removed. Check above all variables TIMEZONE, LANGUAGE and GeoidHeight. If using POIs, rename Tracker.ov2/.bmp to POI_Tracker.ov2/.bmp. See the Installation paragraph for further information. NOTE: Do not exceed the maximum number of 10 “.cap” files in the “SdkRegistry” directory.

2.11. What's new in 6.1

(Apr 11, 2006)

·           Corrected GPX bug occurring when coordinates are smaller than 1 degree.

·           Fixed TIMEZONE bug.

·           Corrected a small bug preventing VERSION expansion in GPX headers.

·           Further performance improvement (sleep builtin command of BSH now accepts decimals).

·           Updated documentation.

Upgrade note: same as in “What's new in 6.0” below. For programmers: usage of “ts_press” is discouraged in this version.

2.12. What's new in 6.0

(Apr 6, 2006)

·           Now Event_Logger.txt can be configured with any editor including notepad.

·           Simplified timezone setting.

·           Performance enhancements. The busybox ash interpreter as well as the external expr command are no more used by Event_Logger, which now exploits a new 265KB shell (called bsh, with sources and programming manual included) based on zsh 3.0.5 (http://www.zsh.org) and implemented by simplifying the original zsh code from one side and extending it from another. The Event_Logger script (now called Event_Logger.txt and placed inside the Tracer directory) was ported to efficiently support bsh.

·           Improved tracking accuracy.

·           Bug fixing and further tuning for TomTom GO version 5.420 and 5.440.

·           The new “Top” menu button is now available, producing the same output of the UNIX top command: it continuously monitors the system until the touchscreen is pressed.

·           Updated documentation.

NOTE: Upgrade by replacing all files; then rename _Logger.itn to _Latest_Events.itn and EventLogger.tgz to Event_Logger.tgz in the “Itn” directory; expr in the "Tracer" directory can be removed. Check above all variables TIMEZONE, LANGUAGE and GeoidHeight. If using POIs, rename Tracker.ov2/.bmp to POI_Tracker.ov2/.bmp. See the Installation paragraph for further information. NOTE: do not exceed the maximum number of 10 “.cap” files in the “SdkRegistry” directory. For programmers: usage of “ts_press” is discouraged in this version.

2.13. What's new in 5.9beta

(Jan 9, 2006)

·           Added geoid height correction constant, to be manually edited in order to generate Mean See Level altitude (TomTom GO GPS does not support geoid separation: altitude values returned by NMEA GGA messages are WGS84 ellipsoid heights; MSL altitude should be obtained by adding the relative geoid height; Event_Logger approximates this with the constant GeoidHeight).

·           Additional tuning for TomTom GO version 5.420. Added variable DoAnotherGpsRead, to be used in order to improve GPS retrieval (but reducing performance); it might be appropriate when using TomTom GO version 5.420.

·           Unit conversion functions (km/h to miles/h and meters to feet)

·           Updated documentation

2.14. What's new in 5.8beta

(Dec 31, 2005)

·           Additional tuning for TomTom GO version 5.420

·           fixed other minor bugs

2.15. What's new in 5.7beta

(Dec 29, 2005)

·           Added German translation (LANGUAGE variable now supports IT, FR, EN, DE)

·           Added menu entry to toggle the logging level

·           improved configuration and tracing

·           the NMEA interpreter has been rewritten to avoid usage of the 'sed' command

·           Improved flashing messages readability

·           support of an additional optional newline in GPX files to improve readability (see CR1 and CR2 variables)

·           fixed a bug related to the startup and shutdown of the GPX tracker through the menu button

·           fixed other minor bugs

2.16. What's new in 5.6beta

(Dec 12, 2005)

·           Fixed an error that prevented managing negative coords in itinerary files

·           AllowDateTranslation substituted with LANGUAGE; support of IT, FR, EN

·           Improved procedure to show date changes

·           The GPX tracker can now be started and stopped through new menu button

·           included optional GPX counter

·           support of optional newline in GPX files to improve readability

2.17. Features available in release 5.4beta

(Nov 28, 2005)

·           Fixed bug which prevented date sync.

·           Fixed bug which prevented GPX logging of negative coords.

·           First porting to TomTom GO version 5.420

2.18. Features available in release 5.2beta

(Oct 8, 2005)

·           GPX Tracking system (GPX files automatically archived with gzip compression)

·           Automatic track segmentation inside GPX files based on stop periods.

·           Geodecoding

·           POI creation

·           Integration with TomTom GO via file SDK (display message; more accurate positioning in case of poor radio coverage)

·           Management of short intervals, with the introduction of the aggregate items.

·           Computation of the duration of aggregated periods, including total journey time, total run time, time of small stops.

·           Archiving of past itinerary files into a single TGZ file (tar archive compressed with gzip).

·           This release also includes a bug correction in the GPX speed format (m/sec instead of km/h).

2.19. Previous versions

·           Release 5.1beta (Sep 19, 2005), including GPX Tracking system with the following issues:

·           geodecoding of waypoints generated by switch-off events do not work; related GPX information missing.

·           code not tuned ("sed" usage should be substituted by internal loops); very slow suspend time; usage of the enbedded version of busybox "ash" + external "expr" with so many process forks and pipes might reduce the used filesystem size to the minimum but I do not think not the best choose...

·           release 5.0beta, exploiting SDK

·           release 4.0beta (Sep 3, 2005), aggregating events occurred within short intervals

·           release 3.0beta (Aug 5, 2005), (Single ttn file. GpsLogger can be deleted.)

·           release 2beta (July 19, 2005, slight improvement)

·           release 1beta (July 14, 2005): POIs replaced by Itinerary files. Two separated files: GpsLogger (to be placed in the directory "Tracer" of the SD card) and TTN (to be placed in the root filesystem of the SD card). Many bugs and limitations.

·           release 0beta and initial development called Event POI Category Manager (June 2005), creating dummy POIs upon events.

3. Function list

The following features are available in Event_Logger release 8.2.

o        Application fully integrated with all NavCore versions and with any TomTom all-in-one device. An optional plugin allows managing specific NavCore issues.

o        Support of the following GPS units: SiRFstar IIe/LP, SiRF Star III with and without QuickGPSfix (SiRF binary and NMEA protocols), Global Locate's Hammerhead.

o        Management of the following hardware events: boot, resume (switch-on), suspend (switch-off).

o        Management of software events manually produced by pressing appropriate menu buttons. Two of them added by default: “Log Position to Itinerary” and “Log Position and add POI”. There is also a fast alternative to the “Log Position to Itinerary” menu button, consisting in pressing the top left margin of the screen until a shutter click is heard.

o        Aggregation of events occurred within short intervals (period is configurable).

o        Creation of Itinerary files including all events occurred within one or more consecutive journeys; information is shown by TomTom GO so that start of journey, end of journey and waypoints can be clearly distinguished.

o        Computation of the duration of each travel and stop period and other statistical data.

o        Flashing message within TomTom GO, showing collected information. Optional flashing message continuously showing altitude (above sea level) and normalized slope (percent).

o        GPX Tracking system, creating standard GPX files (GPX or XML file extensions) and supporting full tracking as well as waypoints for all occurred events; tracks are automatically segmented by managing short stop periods, including geodecoded data for each stop. Event_Logger also calculates the travelled distance, the average speed of a trip, the max and min altitude as well as the motion duration and slope.

o        All events occurred in one day are grouped in the same Itinerary file; when a file is going to exceed the max. number of allowed lines, data are automatically segmented into more files including sequencing reference.

o        A GPX file by default includes only information related to a single journey (configurable) in order to improve management.

o        GPX files are produced by either querying TomTom GO (producing snap-to-road traces) or directly the GPS device (this is useful when performing off-road travels). Related control is facilitated through appropriate menu icons. The direct access to the GPS device can extensively decode both the NMEA protocol and the SiRF binary one. An optional plugin allows

o        Other than GPX files, Event_Logger can optionally create Itinerary file (ITN) and POI file (OV2) that include detailed tracking of each travelled route. It can also simplify the ITN or OV2 track by removing points that have the smallest effect on the overall shape of the route.

o        GPS data are automatically retrieved from the TomTom cache in case the GPS device does not produce valid information.

o        Past Itinerary and GPX files are automatically archived into single ZIP files to save space on the SD card (or HD); anyway, the most recent files are not archived so that they can be easily managed (and, in case of ITN files, they can be opened within TomTom GO). Optionally, ZIP files can be compressed with the bzip2 algorithm.

o        Each position is possibly geodecoded. The current speed and altitude is also collected in case the GPX device provides the data. Values can be shown in km/h, miles/h, m, feet. Slope is also computed, together with pretty reliable maximum and minimum values. Altitude is automatically calibrated when needed.

o        Optionally, POIs (Points of Interest) are created upon each event.

o        When opening the GPX files created by Event_Logger with Internet Explorer (e.g., drag and drop a GPX file to IE), a GPX browser is started, graphically representing the recorded path through Google Maps, together with many additional tables analyzing the path in detail. The GPX browser also allows interactive analysis through the usage of mouse, keyboard and with the support of a comprehensive option menu. Functionalities include centre/zoom, fixes, direction arrows, traffic layer, local search, additional map layers, draggable waypoint markers, tooltip, altitude retrieval for any selected point, etc.

o        When selecting "Log Position to Itinerary" and then keeping the touchscreen pressed for some seconds, a mask appears, showing advanced statistics related to the current trip, also including slope computation.

o        Event_Logger allows both personal and promiscuous usage. GPX and ITN generation can be disabled. Besides, ITN and GPX archives can include password protected data.

o        An astronomical calendar is included, based on the current time and coordinates, providing standard calendar data, Ephemerides of sun and moon, rise and set time, twilight time, moon phase, etc.

o        The Event_Logger Agent includes a silent feature which automatically switches between night colours and day colours of TomTom GO basing on the elevation of the sun at the current position and time.

o        Two additional menu buttons easily allow toggling the tracing level and stopping/restarting the Event_Logger Agent; besides, a service button implements the UNIX “top” utility which easily allows to verify CPU and memory consumption as well as disk usage of the TomTom GO processes.

o        A shortcut soft-key function to log position can be activated from any NavCore screen or menu.

o        Event_Logger includes the full set of documented source code to allow revision and improvements.

4. Menu Buttons and Icons

Event_Logger adds the following menu buttons and icons to TomTom GO:

The previously described functions are fully customizable through the configuration section of the Event_Logger.txt file (inside the Tracer directory). The following chapters describe this in more details, as well as all the features of Event_Logger. A development guide is also included.

Depending on the firmware version and TomTom model, some TomTom devices do not support custom menus (even after a correct installation of Event_Logger, custom menu buttons are not shown).  This is unfortunately a TomTom limitation (or bug) with some device model. When menus are not shown, you can use the shortcut button: press the screen very close to its top left margin (e.g., near the “+” zoom symbol during standard navigation); after an audible shutter click produced by TomTom, the position is logged as if the “Log Position to Itinerary” was pressed; of course this method does not allow the same interaction as pressing the custom menu buttons. Another possibility is to install the custom menu buttons to a different (and more cumbersome) position: copy all files from SdkRegistry/Geo to SdkRegistry, replacing previous files; then menus are available as map position detail elements; to find them, press the screen to show the standard menu, go to the second page, select the Browse map menu () and finally press the Navigator icon (  ). You should find there the additional menus.

5. Examples

The following pictures show examples of flashing messages produced by selecting the “Log Position to Itinerary” button (or by pressing the upper left margin of the screen).

Example 1.

In this picture, 33.3km is the total travelled distance; 351m is the altitude above the sea; 47km/h is the current speed, 93km/h is the maximum speed within the same travel; the asterisk means that the message was manually generated through the “Log Position to Itinerary” icon (or through the pressure of the top left margin of the screen); [46’,44'] indicates that the whole travel took 46 minutes, but the real duration was 44' with two minutes of stop (i.e., TomTom GO has been switched off for two minutes in between). The geodecoded address shows street, civic numbers when available and town. (A trailing dot informs that the debug option is disabled, otherwise a number is shown, representing the debug level.) Notice that flashing is directly managed by TomTom and currently there is no way to convert the flashing information into a fixed pop-up.

Example 2.

Here {25'}  means that the TomTom device has just been powered on (i.e., resumed) after 25 minutes from the previous power-off (i.e., suspension); 10.5km is the total travelled distance of the previous trip and max=113km/h is the maximum speed registered during the previous trip. Currently the vehicle is stationary (this is because no current speed shown).

Example 3.

In this last picture, -1 means that TomTom GO (e.g., the vehicle) has just been restarted after a short stop of one minute; the current trip has taken 36 minutes effectively or 37 minutes in total, including the sum of the short stops (which in this case corresponds to the shown minute).

Example 4.

The following example shows advanced statistics produced when selecting the button "Log Position to Itinerary". In order to produce the reporting screen, keep the touchscreen pressed for some seconds while the splash message is shown (this message is composed of two lines reporting "Running Event_Logger Version 7.1 - [LOG]" followed by the current date or by the privacy reminder "Warning: your actual travel is being tracked"). Notice that advanced statistics cannot be produced when pressing the top left border of the screen.

After few seconds, a white mask is shown with some information. You can the release the touchscreen; the mask is frozen on the screen for 120 seconds and it can be closed in any moment by tapping on it.

Advanced statistics include the following data:

-          Trip length: total distance covered in the current travel

-          Total trip duration: this also includes any possible short stop (time when the TomTom device is switched off for a short while during the same travel)

-          Real duration (excluding stops): this duration excludes short stops and only includes the time when TomTom has been switched on

-          Settings: standard snap-to-road driving, off road trekking and racing, long travel, snapped-to-road, long off road travel, custom settings. off-road settings are coloured in green.

-          Current/max. speed: instantaneous and maximum speed within the current travel

-          Average speed (Avg.): this average value relates to the total trip duration

-          Average speed excluding stops: this average value relates to the real trip duration

-          Motion duration (excluding halts): time in minutes representing the duration of the travel calculated excluding any halt (no significant change of coordinates) or stop (TomTom switched off)

-          Average speed when in motion: this is the average speed (in minutes) during the motion time

-          Total halt time: in minutes; this time includes pull up (no significant change of coordinates) and stops (TomTom switched off)

-          Pull up time: sum of all the stationary periods reported in minutes (during this time, the coordinates have not significantly changed)

-          The optional message "No positioning data from TomTom and GPS device" means that the current fix is not available.

-          Source of positioning data: 'cache' means that the GPS device is not currently providing the fix, but TomTom has this information cached; 'active GPS' means that the fix is directly fetched form the GPS

-          Altitude: normalized information MSL (fetched from the GPS device when active). Max and min registered altitude values are also included.

-          Slope: instantaneous slope (percent value, computed on the last two fixes; might be imprecise), in parentheses, average slope for the last stretch of the path (percent value, computed more or less on the last kilometre, depending on the speed); maximum downhill and uphill slope. The last three values are calculated through a specific algorithm, tuned for pretty reliable values.

-          Follows the description of the geodecoded position also including an header message produced by TomTom.

-          The optional last message "Data referred to last recorded event: " reminds the previous flash message (i.e., the message preceding the current log, which of course might not be up to date); this information is shown when the current fix is not reliable or not available.

By default, when selecting the “advanced statistics" splash screen, no event is recorded (unless a specific configuration is applied).

Example 5.

This example shows how to access the Itinerary file: press the touchscreen, select “Itinerary Planning”

then select “Load Itinerary”,

the list of Itinerary files created by Event_Logger are shown; the last one, called “_Latest_Events”, is highlighted in red in the picture; the blue square shows the past files, which are sorted by crescent date. Select “_Latest_Events”,

confirm to load the Itinerary (press yes).

Find below examples of details of some Itinerary files.

Description lines include date of previous and current logs, list of events, boots, marks indicating each trip, automatic time synchronization and information related to log closure (date of rotation).

Lines can be browsed with TomTom GO. Selecting one of them, the panel showing the line property is presented. Press “Show on map” to check the graphical position of the logged event in the map.

Example 6.

Example of Astronomical Calendar:

(Note: can be simulated with Cygwin through ./acal.exe -a -m 1145696710 49.52607 11.51662 7200; the last parameter means UTC+2)

Remarks: when horizontal coordinates of sun and moon are highlighted in gold, the celestial body is locally visible in the sky. Times are local.

Example 7.

Event_Logger records tracking information to GPX files. A file named GPX.XSL allows transforming the tracked itinerary into a browsable map. In order to perform this, expand the Itn directory with Windows Explorer, verify that gpx.xsl is available in this directory (in general, verify that gpx.xsl is available in the same directory of the GPX file), select a GPX file produced by Event_Logger and simply drag it to Internet Explorer when connected to the network (e.g., accessing http://maps.google.com); alternatively, open the GPX file with Internet Explorer (e.g., select the GPX file, press the right key of the mouse, select “open with”, select Internet Explorer).

Wait for some tens of seconds. The resulted map is like the one shown in the next page, where the coloured “polyline” represents the tracked route with descriptions, segmentation and waypoints. The map also allows interactive analysis, as detailed in the related chapter. Press the “Map options” button to access the menu page.

The following picture shows an available feature allowing to interactively drag each marker, one by one; this is useful to improve visibility in case many markers are crowded inside a restricted perimeter.

6. GPX Tracking System

GPX (the GPS Exchange Format) is a light-weight XML data format for the interchange of GPS data (waypoints, routes, and tracks) between applications and Web services on the Internet. Find more information at http://www.topografix.com/gpx.asp.

Event_Logger creates GPX files. Other than including waypoints in GPX files basing on information logged to the Itinerary files (e.g., while processing the “Log Position To Itinerary” button), Event_Logger automatically logs GPX tracks through a specific process called Event_Logger Agent, which periodically polls TomTom GO and the GPS device in background; the Event_Logger Agent does not need to be activated (it is started by the Event_Logger startup features at boot time); a specific menu button allows to shutdown and to restart it on demand; appropriate configuration settings allow controlling all the GPX features.

Event_Logger archives GPX information as follows: the files /Tracer/Wpt.gpx (including current waypoints) and /Tracer/Trk.gpx (including current tracks) consist of incomplete GPX data (with missing envelope) collected at runtime. The file /itn/Trk_Last_Path.gpx is an uncompressed GPX full format generated when powering off TomTom GO: it collects all the latest GPX data (e.g., fetched from /Tracer/Wpt.gpx and /Tracer/Trk.gpx). After restarting or rebooting TomTom GO, GPX files are definitively consolidated under /itn (GPX repository). Old GPX files are then archived inside “GpxArchive.zip”.

As GPX is a XML format, a browser (e.g., Internet Explorer) can be used to open it.

Event_Logger also provides an XSL stylesheet (named “gpx.xsl” inside Itn directory) only compatible with Internet Explorer, transforming each GPX file into a XHTML interactive document. The produced report includes a Google Maps JavaScript which creates the map and allows interactive analysis; besides, detailed tables are available following the map.

In case of error, check the presence of the file “gpx.xsl” in the same directory of the GPX file. Check also to be connected to the Internet. Notice that the GPX file should also include

<?xml-stylesheet href="gpx.xsl" type="text/xsl"?>

in the second line (all GPX files produced by Event_Logger versions previous to 7 are missing of this line and need manual editing).

Of course, different stylesheets can be produced by users, implementing any kind of data transformation as well as additional capabilities than those ones provided by gpx.xsl.

In order to simplify the opening of GPX files with Internet Explorer, a configuration setting of Event_Logger allows saving GPX track files with either the “.gpx” or the “.xml” extension. By default, the latter is configured, enabling easy GPX browsing: Internet Explorer immediately opens XML files and automatically starts the XSL parser when the file “gpx.xsl” is available in the same directory of the GPX/XML files. The GpxFileExt variable allows selecting the wanted extension type. Notice that switching among the two extensions is a standard rename operation, which can be manually accomplished in any moment. Besides, an Event_Logger function automatically renames un-archived GPX files (the last five ones by default) according to the value set in the GpxFileExt variable. In this manual the GPX files are all named with .gpx extension in order to simplify understanding, even if as mentioned the GpxFileExt variable is defaulted to “.xml”.

Other than XSL transformations, a lot of programs can manage GPX data. Among them, TopoFusion, Google Earth and GPSBabel are notable for their capabilities. TopoFusion is an appropriate tool to perform basic graphical representation and analysis of GPX files produced by Event_Logger (with 2D and 3D rendering); it can download and cache maps and digital elevation data from Internet as well as access them locally. It allows normalizing tracks (e.g., see spline/interpolate functionality), calculates speed (average, instantaneous, etc.), path length (also interpolated) and allows adding elevation data to a track; it can then perform lap and climbing statistics as well as other types of analysis. Google Earth is the well known 3G soft globe and graphical information application; it can directly import the GPX files produced by Event_Logger, graphically representing the related tracks within the many available free layers (including the TeleAtlas road network). GPSBabel is one of the most interesting utility to convert the GPX files (waypoints, tracks, and routes) produced by Event_Logger in many other formats. It is a freeware and can manage about four dozen file formats, including TomTom POI, NMEA, HTML, Keyhole Markup Language (used by Google Earth), Magellan, Garmin and many others. (The syntax used by Google Earth to do the internal conversion of GPX to KML should be: gpsbabel -i gpx -f foo.gpx -o kml,points=0 -F foo.kml). GPSBabel runs on almost any computer and provides both a command-line interface and a GUI. An up-to-date ARM Linux version of the GPSBabel command line tool is also integrated with Event_Logger in order to perform optional automatic batch conversions, as subsequently described.

Event_Logger creates GPX files if at least one of the two variables DoGpxWpt and DoSdkTracking is set to yes (the latter also conditions the automatic switching between day and night).

When DoGpxWpt is set to yes, <wpt> elements are created upon each waypoint (suspend, resume and log menu buttons events). When DoGpxWpt is set to yes, DoTrackWpt allows adding <trkseg> elements upon each waypoint, including altitude information in case this is retrieved from the GPS device (this option is not invasive and should always be set to yes).

If DoSdkTracking is set to yes, a background agent is started in low priority execution, repeatedly fetching positioning data every TrackingGranularity seconds (sampling period). Data can be retrieved from TomTom GO via SDK (default, also called as snap-to-road) or directly from the GPS device (used for off-road tracking). When querying for TomTom GO, the process takes irrelevant CPU and limited memory (about 1.7 – 2.0 MB of RAM memory). In case the automatic switching between daytime and nighttime is set (e.g., DoSdkChSet=yes), Event_Logger takes additional CPU and memory (e.g., a constant memory size of about 2.2 – 2.3 MB and limited CPU which can go up to 40% for a very short fraction of time on each TrackingGranularity timeout; this does not produce any sensible degradation of performance). In case tracking information is unneeded (as well as the automatic day/night switching), the automatic start-up of the agent can be avoided by unsetting DoSdkTracking.

Notice that the Event_Logger Agent must be active in order to enable the automatic switching between day and night colours.

As mentioned, the standard settings optimize the performance impact by interacting with the TomTom GO application via SDK file interface without performing direct collection from the GPS device; by consequence of this, altitude data (not provided by the TomTom GO application) are not retrieved inside <trkseg> elements. (Notice also that speed and heading are not provided by TomTom GO versions 5.4XX. Either Version 5.2xx or 6.xxx are needed to get these parameters). Querying the TomTom GO takes advantage of the map assistance provided by the application in order to improve tracking information especially when the GPS reception is weak; ASN can also be exploited when configured; due to the mapping references, the resulting tracks will be generally bound to the road.

Alternatively, when the TomTom GO device needs to be used off-road (e.g., sailing, biking, flying, hiking and trekking), snap-to-road tracks might provide imprecise information of the actual path (especially when the mapping system includes roads close to the off-road track); in this case, it is worthwhile setting GpsToGPX=yes, which performs direct retrieval of raw GPS data via NMEA protocol. As TomTom models exploiting the SiRF Star III chipset are interfaced to TomTom via SiRF Binary Protocol rather than NMEA commands (like in older SiRF Star IIe/LP chipset), a driver decoding SiRF Binary Protocol is included in Event_Logger (see gpsdecoder bsh function). This allows the "off road" tracking with the old models like TomTom GO Classic or 500 as well as with TomTom 510, 710, 910, One, Rider, Rider II and newer models.

More generally, the variables managing the query methods are:

Snap-to road settings (tracks assisted by TomTom maps, without altitude):

Off-road settings (including altitude and many other parameters; tracks are not assisted by TomTom maps when the GPS is active, but in case the GPS device does not provide data, Event_Logger tries to fetch the fixes from TomTom, exploiting also the related mapping):

Off-road settings (including altitude and many other parameters; tracks are never assisted by TomTom maps, even if the GPS does not provide data):

TrackingGranularity defaults to 5 and can be raised to any value (for better performance and reduced size of the collected data); lower values, even if possible (e.g., 3 or 4), are untested and not generally suggested (will significantly reduce the TomTom GO response). Setting TTGOtoGPX to yes allows querying TomTom GO for georeferenced data (standard option); when setting GpsToGPX to yes, data are first attempted for retrieval from the raw GPS device and, in case of failure (no GPS data), fetched from TomTom GO (the latter provided that also TTGOtoGPX is set to yes); notice that GpsToGPX has the effect that Event_Logger contends with TomTom GO for the GPS resource, almost always winning the conflict. This means that the produced GPX files are rather accurate, while the TomTom GO response time will be slightly affected. The icon "Toggle snap-to-road or raw GPS" simplifies the related configuration. As already mentioned, the off-road settings (GpsToGPX=yes and TrackingGranularity=5) takes significant GPS resources to TTGO (even if not heavily affecting CPU and memory resources, so not significantly perceived by the user).

As previously summarized, when TTGOtoGPX is set to yes, the following information are retrieved from TomTom GO and converted to GPX: Latitude, Longitude, Date, Time, Course and Speed.

When GpsToGPX is set to yes, the retrieved GPX data include Latitude, Longitude, Date/Time, Speed, Course, Altitude, Number of used satellites, HDOP, PDOP, VDOP (horizontal/position/vertical dilution of precision). When supported by the GPS device, also the Magnetic Variation and Geoid Separation are collected; besides, in case “AddGeoidheight” is set to yes, Geoid Separation can also report the “GeoidHeight” predefined variable when the related GPS value is missing. For SiRF Star III devices, PDOP and VDOP are substituted by the “Estimated Horizontal Position Error” and the “Estimated Vertical Position Error” values, both in meters.

NavCore 7 introduces a relevant issue related to the periodic retrieval of positioning data when Event_Logger is set in the default snap-to-road configuration: occasionally, the unsupported NavCore 7 SDK API interface produces very inefficient answers; in order to overcome this problem, a specific feature of Event_Logger automatically gets positioning information directly from the GPS when NavCore 7 does not provide any answer within a predefined timeframe. The variable BkupFixFromGps controls this option: when TTGOtoGPX=yes, it can occasionally force a direct GPS retrieval in case of missing positioning information from the NavCore 7 SDK API interface.

In addition to the previously described settings, other options are available, influencing performance.

The first two options should be left unchanged; the related performance improvement goes at the cost of reduced functionalities. SirfIgnoreChkSum might be set to yes in order to process any SiRF binary message, including those ones that the GPS device generates with wrong checksum value; by consequence of this, the retrieval performance is slightly improved.

In case GPX data are used to draw new road maps (e.g., like contributing to the free mapping initiative at http://www.openstreetmap.org), consider setting TTGOtoGPX to “no” in order to avoid introducing copyrighted information (e.g., TeleAtlas mapping) into the produced GPX files.

A GPX file can include zero or more <wpt> (waypoints) and/or zero or more <trk> sections with optional <trkseg> (track points). Null GPX files are anyway discarded. Track points and waypoints are distributed into more files basing on rules controlled by variables:

-          NewGpxWhenDayChanges,

-          NewGpxWhenNewItinerary,

-          NewGpxWhenBooting,

-          NewGpxWhenDateAdjusted and

-          NewGpxWhenNewTravel.

If NewGpxWhenDayChanges is set to yes, a new GPX file is created as soon as the day changes. If NewGpxWhenNewItinerary is set to yes, a new GPX file is created if the itinerary file is missing, renamed or deleted. If NewGpxWhenBooting is set to yes, a new GPX file is created upon each boot. If NewGpxWhenNewTravel is set to yes, a new GPX file is created as soon as a new travel is identified (e.g., suspend interval taking more than ShortInterval minutes). If NewGpxWhenDateAdjusted is set to yes, a new GPX file is created as soon as the date is adjusted by Event_Logger through the automatic sync with the GPS device, which requires SyncTime=yes.

Appropriate variables control tracks segmentation, which produces more <trk> sections basing on a timeout expiration. GPX tracks are segmented if DoBreakTracks is set to yes and when the same 2d fix (latitude, longitude) does not change for more than (TrackingGranularity + DelayToBreakTracks) seconds. The configuration variable AllowDuplicatedCoords controls the process used to segment tracks; if not set, no information is collected when TomTom GO stands in a fixed position for enough time (typically when the vehicle stops for enough time, e.g., waiting in queue with ignition on) and a new track segment is produced when the position returns to change; besides, a new track segment is generated each time the vehicle ignition is restarted (e.g., TomTom GO stays suspended for enough time). If AllowDuplicatedCoords is set to yes, only when TomTom GO stays suspended for enough time a new track segment is generated.

Event_Logger monitors possible cases of wide distance between adjacent fixes; if NearbyRestart is set to yes and the residual speed (difference between real speed and measured one) is greater than 50 m/sec., a condition of nearby restart is reported (new trkseg inside the GPX file and warning inside the ITN file). Residual speed greater than 200 m/sec. generates a condition of faraway restart (new trk inside the GPX file and warning inside the ITN file).

Readability of GPX files can be configured through the variables CR0, CR1 and CR2, which can add linefeed separators in standard cases (CR0), after <trk> (CR1), <trkseg> (CR1) and </trk> (CR2). When CR0 is set to <CR> - <NL> (DOS/Windows character sequence, default configuration), GPX files can be correctly edited with notepad; notice that the end of line notation used in CR0 (e.g., Windows or UNIX) should be kept coherent with the settings of CR1 and CR2 (unless they are not valued).

An optional counter field can be added inside the GPX records, by setting the variable AddGpxCounter to yes. In this case, a new item <name>Point n</name> is added to each <trkseg> section, where n is a sequential integer starting from 0.

As mentioned before, generated GPX files are archived under the directory /itn inside the SD card (or HD) and zipped to save space. Dates in the names of each GPX archive refer to the archiving instant and use local time; dates inside GPX comments use local time as well, while internal dates in the trk and trkseg sections use UTC time, as reported in the related GPX directive. Each file date can be either a local time or UTC time depending on “LinuxTimeIsUTC” (setting it to “yes” allows usage of UTC times). Notice that LinuxTimeIsUTC must be set to yes when using NavCore 6.

GPX file size depends on the selected information and on the travelling period. In general, each travelling hour might produce up to about 5 KB of compressed GPX data (assumption is to set snap-to-road with 10 seconds sampling period). Files in itn should be periodically deleted or moved out of the SD card (or HD) in order to preserve space.

In summary, usage of GPX Tracking system can be configured through the following variables:

GPX files of Event_Logger exploit a free interpretation of <name> and <descr> tags inside the heading “<gpx…” element, the former including “END date” (so not really the descriptive name of the file) and the latter “BEGIN date”: these refer to the time of the first and last fix tracked inside the GPX file. Following “END Date”, the “<gpx…” element also includes “Total distance”, “Max speed”, “Motion duration”, max. uphill and downhill slope values.

<trkpt> elements may also consist of SUSPEND or RESUME events when the GPX reception is good enough; they are specifically marked with tags <sym>Waypoint</sym><type>SUSPEND</type> or <sym>Waypoint</sym><type>RESUME</type>. Besides, log events are reported as <sym>Dot</sym><type>LOG</type>.

Track segmentation is performed through the repetition of more <trk> elements with relevant information inside the related <name> field; each <trk> includes one <trkseg> tag containing zero or more <trkpt> fixes (trackpoints). The reason for breaking on <trk> tags rather than on <trkseg> is related to the need to add information to each segment (e.g., inside a <name> tag), which is not possible within <trkseg> in GPX 1.0.

GPX 1.1 is not used, due to the need to exploit some types of tag inside <trkpt> (like speed) that are defined for GPX 1.0 but unfortunately not for GPX 1.1.

The following table details the syntax of the tags in <trk> elements, which actually includes information related to the track segment.

All <name> tags include the current date using local time translated into the selected language (while dates inside <trkpt> are standard GPX strings with UTC time). An optional geodecoded position is available inside <desc> tags only when TomTom returns it.

As mentioned before, GPSBabel version 1.3.5 is included with Event_Logger in order to optionally generate Itinerary files (ITN) and POI files (OV2) from GPX tracks (only the command line tool has been ported to ARM Linux). ITN conversion exploits a custom style embedded in the program. Through the “simplify” filter, fixes can be reduced to a predefined value with the smallest effect on the overall shape of the route; this is particularly important for ITN files, considering that NavCore allows browsing only the first 48 lines of them.

In order to allow the generation of Itinerary files (ITN), set the ItnTrkPt configuration variable to a value different than zero. To generate POI files (OV2), set Ov2TrkPt to a value different than zero. Each value controls the related simplification factor (e.g., it sets the maximum number of produced points for the target format).

OV2 files are saved in the same directory of the latest active map (so, where all the other ov2 files are stored). NavCore seems to ignore the existence of any new OV2 file generated by GPSBabel until a soft reboot is performed (e.g., extract and reinsert the SD card, or plug and unplug the USB cable). Notice that too many OV2 files can slow down NavCore execution if all of them are loaded and active.

None of the files generated by GPSBabel is compressed by Event_Logger.

Notice that all these conversions take additional seconds to the power-on, power-off and boot procedures of TomTom, so they should be enabled only if really needed.

Alternatively to the automatic conversions allowed by Event_Logger, file format conversions can always be manually obtained by running GPSBabel on a PC and using the following command syntaxes:

GPX to Itinerary:

gpsbabel -w -r -t -i gpx -f "<input GPX file>.xml" -x track,merge -x simplify,count=<max points> -x transform,rte=trk,del=n -o tomtom_itn -F "<output file>.itn"

This command implements the standard transformation included in gpsbabel, where route points are automatically labelled with short descriptions like the following ones:

RPT001

RPT002

RPT003

RPT004

...

The transformation implemented by Event_Logger exploits a special TomTom ITN style embedded in the gpsbabel porting for ARM Linux (included in the Event_Logger package). This file (check file tomtom_itn.style in Sources.zip) allows creating ITN items with descriptions like the following one:

RPT016 fix=3d. 08-03-10 21:16:52. Alt=138 m. Distance=1.2 km. Speed=0.0 km/h

When using a standard GPSBabel tool to get this type of custom ITN files, use the xcsv format instead of tomtom_itn, specifying the custom style included in Sources.zip. Specifically, the related command line is:

gpsbabel -w -r -t -i gpx -f "<input GPX file>.xml" -x track,merge -x simplify,count=<max points> -x transform,rte=trk,del=n -o xcsv,style=tomtom_itn.style -F "<output file>.itn"

Notice that Itinerary files generated through this command (or by setting ItnTrkPt to a value different than zero) have different content from those ones described in the next chapter, because including all the fixes of a GPX file (or a simplification of them). ITN files in next chapter only log each TomTom event instead of the whole route (or simplified route).

GPX to TomTom POIs:

gpsbabel -w -r -t -i gpx -f "<input GPX file>.xml" -x track,merge -x simplify,count=<max points> -x transform,wpt=trk,del=n -o tomtom -F "<output file>.ov2"

GPX to Google Earth (Keyhole) Markup Language (KML):

gpsbabel -w -r -t -i gpx -f "<input GPX file>.xml" -o kml,line_color=995555ff,line_width=4,points=0,units=m -F "<output file>.kml" 

Follow the GPSBabel instructions (gpsbabel.html) to set up additional options or select other target formats like CSV, NMEA, additional transformations for GPX files, etc.

If GPSBabel is not used, the file named gpsbabel in the Tracer directory can be deleted to save considerable space.

7. Itinerary file format

Event_Logger creates Itinerary files compliant with the TomTom file format.

The management of Itinerary files is included in any updated TomTom version, regardless of the used processor or embedded system (TomTom Mobile for Symbian mobile phones, TomTom Navigator for PDA, all the TomTom GO models exploiting ARM Linux, etc.).

A TomTom user can manually create, edit and use Itinerary files as an alternative method to the single destination route planning (with optional single 'via' location) allowed by the standard “Navigate to…” function of TomTom: exploiting itineraries allows managing journeys which consist of a list of 'waypoints' and 'destinations'; other than planning compound journeys, itineraries can be saved and, as they are ascii files, they can be easily exported.

The general syntax for Itinerary records managed by TomTom GO (e.g., format of each line of an Itinerary file) is:

< longitude >|< latitude >|< comment >|< flag >|

where:

< longitude > is the longitude in millionths of degrees (WGS84 datum);

< latitude > is the latitude in millionths of degrees (WGS84 datum)

Note: when both <longitude> and <latitude> are valued to 0, it means no positioning available and TomTom shows the related line barred.

< comment > might include any string (e.g., in general there should be the fix name in the itinerary); see below for the actual syntax used by Event_Logger inside this field.

< flag > is a number (typically 0, 1, 2, 3 and 4). The following component values are allowed to generate the flag (all components have to be ORed together in order to produce the flag value).

• 0x00 None
• 0x01 Itinerary location is enabled
• 0x02 Itinerary location is a stop-over (as opposed to a pass-by location)
• 0x04 Itinerary location is departure point (should only be set for the first item in the itinerary file)

Considering how Event_Logger manages this flag, value 4 is never used, while 3 is used to mark the last record of a journey, separating the closed journey from the next one. 0, 1 and 2 are used for lines within the same journey (e.g., 0 and 2 make TomTom GO show the previous records in grey instead of black; this is used by Event_Logger in order to differentiate the representation of heading comments).

Event_Logger generates Itinerary files if DoGenerateItn=yes. If DoGenerateItn is set to no, any Itinerary file generation is inhibited (this setting is useful in case of privacy issue or promiscuous usage).

The syntax used by Event_Logger in the Itinerary comment field is:

<hour>:<minute> <first set of symbols> [<total journey duration>,<real journey duration>]<short stopover interval> <distance> <altitude> <speed><second set of symbols> <Address>

Alternate duration syntax:

{<total stop duration>,<real journey duration following the stop>}

Note: all symbols are configurable, including altitude and speed symbols.

Detailed description of each field in the comment string:

<hour>:<minute>: two digits for hour (00-24 format), column symbol, two digits for minutes. A subsequent question mark indicates incorrect or inaccurate date (check IncorrectDateSymbol variable)

<first set of symbols> the following symbol might optionally be shown:

• ^: meaning outdated positioning; when this symbol is shown, the related positioning is referred to the previous registered event (both TomTom GO and the GPS device were not able to provide positioning data).

<short stopover interval>: it reports short stops within a journey, representing the total minutes resulting from the calculation of the sum of any contiguous short stop period; more precisely, the reported value consists of the overall period of a sequence of one or more “stop-and-go” taking in total up to 6 minutes (configurable timeout); these short breaks are aggregated into one line and made part of the current journey in order to improve readability of itinerary records by differentiating the representation of short stopovers from long stops, where the latter case (e.g., stops longer than four minutes) winds up a journey and produces the separation of the performed track from the next one (e.g., set the < flag > field of the last record of the journey to 3 instead of 1). The syntax is "-<minutes>" (e.g., minutes preceded by the dash symbol) and in case the period at a waypoint takes less than one minute, the additional <’> apostrophe character is added at the end. The related date is referred to the last aggregated event (by subtracting the reported minutes, the date of the occurrence of the first aggregated event can be easily calculated). Notice that <-0> (referring to more aggregated events occurred in the same minute) is substituted by <-1’>.

<distance>: this parameter reports the covered space between the starting point of the journey and the last measure log, meaning the actual length of the current trip, followed by its unit symbol (configurable); km is the default unit, unless the unit conversion variables are set to show feet.

<altitude>: parameter optionally returned by the GPS device, followed by its unit symbol (configurable); meters is the default unit (e.g., “m” symbol), unless the configuration variable mToFeet is set to yes, so that the value is converted to feet). Notice that altitude is always mean-sea-level and might optionally be calibrated through the GeoidHeight variable.

<speed>: (<current speed>-<max. speed><unit>) one or two parameters (separated by a dash symbol) optionally returned by the GPS device or by TomTom GO, followed by their unit symbol (configurable); kilometres per hour is the default unit (e.g., “km/h” symbol), unless the unit conversion variables are appropriately set. The two values represent the instantaneous and maximum velocity; the former relates to the measured speed at the time of the last log event; the latter is the maximum speed collected by Event_Logger during the current trip.

< second set of symbols >: the following symbols are used:

• *: the related line is generated by the manual selection of the appropriate menu button. (A line without the asterisk symbol (*) is instead produced by a TomTom GO event.)
• !: the positioning information might be slightly outdated (not produced by the GPS device, simply fetched from the TomTom GO application cache; in this case, altitude is missing as the TomTom GO application does not currently manage this dimension)

<total journey duration>: period covering the time difference between the last registered event of a journey (e.g., last stop) and the first one (e.g., first start).

<total stop duration>: duration of a long stop (more than 6 minutes), reporting the time separating two different and consecutive journeys. It is enclosed within curly brackets to differentiate it from the total journey duration, which is enclosed in square brackets. The first line (event) of a journey should include this data, optionally followed by the real journey duration, which is separated by a comma inside the braces.

<real journey duration>: sum of all the real trip durations composing a single journey (different from the “total journey duration”, which also computes the small stop timings between trips). To improve readability, the < real journey duration > field is only reported if the related value is different from the <total journey duration> field (e.g., in general the real duration is slightly shorter than the total duration; anyway the values can be the same if a journey does not include short stopover intervals).

Time formats used in fields <total journey duration>, <total stop duration> and <real journey duration> are:

• For intervals up to 59 minutes: <minutes>’ (number of minutes followed by the apostrophe symbol)
• For intervals between 1 hour and 23:59 hours: <hour>:<minute> (one or two digits for hour in 0-24 format, column symbol and two digits for minutes).
• For longer intervals: <number of days>-<hour>:<minute> [Note: this option does not apply to <real journey duration>, that always uses the “<hour>:<minute>” syntax]
• An automatic date change during the Event_Logger processing might incorrectly produce negative durations; in this case, the RESET label will appear instead of negative values.

The syntax used by Event_Logger in the Address field of the Itinerary comment is:

<street name> <adjacent number1>-<adjacent number2>, <city>

The optional geodecoded information represents house number or numbers (when available) after the street name (syntax can be changed by revising the code). If there are two house numbers, they are separated by a dash symbol. Street (when available) and city names are separated by the comma symbol.

Note: the two configuration variables $UnnamedRoadString1 and $UnnamedRoadString2 allow deletion of useless internal predefined strings informing of unnamed road or unknown place. This variables should be valued in accordance with the locale setting of the TomTom GO application.

For each event, the date when the event occurred and the related interval computations are basic information always available. As a matter of fact, these data can be directly managed by Event_Logger and do not depend from the TomTom GO application and from the GPS device.

Through the interaction with TomTom GO via SDK, Event_Logger enhances the data by adding the following values:

• Positioning, speed and altitude, when provided by the GPS;
• Cached positioning, important when the GPS device cannot provide information (the altitude field is anyway unmanaged by the TomTom GO application and so not cached);
• Geodecoding: street, street number or neighbouring street numbers and city name

There are cases in which the SDK interaction fails and does not produce enhancements to the basic information produced by Event_Logger; for example, after a reset the SDK management is temporarily frozen until TomTom GO retrieves the first valid information from the GPS device; as soon as this information is retrieved, the SDK management starts and correctly provides updated information received from the GPS device (or cached information in case the GPS data are not available). Consider also that, when a route calculation freezes waiting for a valid GPS data, also the SDK management is inhibited. Notice that even if the GPS data are available, TomTom GO might give precedence to its internal routing (or re-routing) calculation than managing SDK requests; for this reason, Event_Logger treats asynchronously all external requests managing internal timeouts; so, during a route recalculation or while other TomTom GO internal processing algorithms execute, the data enhancement might not be fulfilled in time. In all these cases the enhancements are lost (e.g., not used by Event_Logger).

When browsing or managing an Itinerary file within TomTom, while TomTom controls the longitude, altitude, and flag fields in each Itinerary line, it completely ignores all the previously described syntax internally used by Event_Logger and simply shows the whole comment field as a multiline string (e.g., one or two lines per record, depending on the field length).

Example:

934137|4556701|17:49 [50',46'] 15.3km 197.6m 57-125km/h* A4/E64 Autostrada Milano Brescia, Agrate Brianza|1|

Meaning: during a journey, at 17:49, the driver pressed the custom menu icon when travelling about 57 km/h over a position with longitude 9.34137 degrees, latitude 45.56701 degrees (WGS84) and altitude 198 meters, which corresponds to the highway “A4/E64 Autostrada Milano Brescia” within the town “Agrate Brianza”; The travel duration took 50 minutes but the actual run took 46 minutes (that is, there was a short stop of 4 minutes before). The covered distance is 15.3 km and the maximum speed is 125 km/h. The TomTom GO application shows this information as follows:

17:49 [50',46'] 15.3km 197.6m 57-125km/h* A4/E64 Autostrada Milano Brescia, Agrate Brianza

As this comment is long and by default only the first characters are displayed, press the line and keep it pressed in order to make the TomTom GO application change the character format and show the full multi-line comment. (Besides, when tapping on the line, the related menu appears and, in its heading note, the first part of the comment is shown.)

Comments inside ITN files can be inhibited in order to provide full compliance with TomTom specifications (that ignores the possibility of adding comments even if NavCore can show them at the beginning or at the end of a file). This can be done by setting NoCmtInItn to yes.

8. Astronomical data

Event_Logger manages astronomical data through the Astronomical Calendar, providing a full-screen textual presentation (where times are represented as local, not UTC); it also exploits a BSH additional component through the Event_Logger Agent for the automatic switching between day and night colours/brightness of TomTom GO.

The point of switch between night and day can be calibrated through the “MaxSunElevation” variable also mentioned in the next paragraph (ref. to “Usage of the SDK”), which can be valued to:

The default setting is -4, inside the civil twilight. When setting MaxSunElevation, decimal point is dot, like for any other BSH variable.

Variables "DNChangeCounter" and "DNChangeFactor" can be used to further tune the repetition of commands sent by Event_Logger to TomTom GO in order to change the day/night colours.

Many internet sites can help to understand the meaning of the shown data. Check in particular http://www.stjarnhimlen.se/comp/tutorial.html and http://www.stjarnhimlen.se/comp/riset.html for further information.

For the definition of sunrise and sunset, moonrise and moonset, civil, nautical and astronomical twilight, visit page http://aa.usno.navy.mil/faq/docs/RST_defs.html. (Civil twilight is when illumination is sufficient, under good weather conditions, for terrestrial objects to be clearly distinguished. During nautical twilight general outlines of ground objects may be distinguishable, but detailed outdoor operations are not possible, and the horizon is indistinct. In astronomical twilight sky illumination is so faint that it is practically imperceptible even if it is not dark enough for accurate star observation.)

Sun and moon can be immediately identified in the sky above us through their horizontal coordinates:

-          Azimuth (Az): the horizontal angle of the sun (or of the moon) or related direction produced through compass bearing, like that one graphically represented by TomTom. The azimuth is the arc between the true north and the vertical circle passing through the centre of the sun or the moon, clockwise from the north point (0°) through 360 degrees

-          Elevation (Elev.): the angular distance of the sun (or of the moon) above the horizon, represented in degrees between -90° and 90°; 0° represents the horizon; the elevation is the arc of a vertical circle intercepted between the sun (or the moon) and the horizon

elevation and azimuth: 1 horizon, 2 zenith, 3 sun or moon, 4 meridian, 5 vertical circle; the angle from the horizon is the elevation, 6 azimuth (angle from north=0°), 7 observer

Position of the sun and of the moon:

-          Read the azimuth and elevation of the sun through the Astronomical Calendar

-          Ensure that the elevation angle is positive (when negative, the celestial object is not visible; notice that when the celestial object is visible, the Astronomical Calendar highlights the related values in gold yellow)

-          Switch back to TomTom and ensure that the compass is shown including the direction angle; move TomTom for some meters in order to read a valid compass bearing

-          Orientate the TomTom compass to the same azimuth angle of the celestial body

-          The elevation measures the vertical angle of the sun or moon in degrees from the horizon. A negative value means sun or moon below the horizon. More specifically: -0.5833 degrees is sunrise/sunset (which will delimit nighttime from daytime), -6 degrees is the civil twilight, -12 degrees is the nautical twilight and the astronomical twilight is 18 degrees below the horizon (-18°).

Solar eclipse:

-          Both sun and moon are visible, apart from the period when the moon obscures the sun (e.g., each elevation > 0)

-          Azimuth of the sun = azimuth of the moon

-          Elevation of the sun = elevation of the moon

Lunar eclipse:

-          Moon is visible, apart from the period when not obscured by the sun (e.g., elevation > 0; possibly the moon should be gibbous or full)

-          Azimuth of the sun = opposite of the azimuth of the moon (e.g., difference of 180 degrees between them)

-          Elevation of the sun = opposite of the elevation of the moon (e.g., same absolute value with opposite sign)

eclipse (umbra and penumbra): E= earth, M =moon, , S =sun

9. Event_Logger GPX Browser

This chapter describes the information produced by Internet Explorer when browsing a GPX file generated by Event_Logger, provided that the file ‘gpx.xsl’ is also available in the same directory of the GPX file. As the produced report allows interactive analysis, this chapter also provides the related instructions.

The following browser error means that “gpx.xsl” cannot be found in the same directory of the GPX file:

Currently, ‘gpx.xsl’ is only compatible with Internet Explorer versions 6 and 7; all the other browsers will produce an error similar to the following one:

Event_Logger should also run inside Firefox through the IE Tab addon http://ietab.mozdev.org (this might also allow using Linux by installing IEs4Linux and then configuring IE Tab to open IEs4Linux as an external application).

As many users successfully run GPX.XSL through IE, I would suppose that there should be some issue on your browser configuration.

I take this occasion to inform everybody that Event Logger V7.2 is currently being sent to selected testers and donators and will soon be available to the community.

When opening a big sized GPX file with Internet Explorer, the document generation might take many tens of seconds (e.g., up to 2 minutes or more, depending on the number of fixes in the GPX file). This waiting duration is normal.

The document generation and the interactive analysis application exploit the browser status line, which always reports the result of the last command or event.

The first two displayed elements at the beginning of the document are the main title (with hyperlink to the related URL) and the author’s name (with hyperlink to the author’s e-mail). These data are fetched from the <gpx> header tag of the GPX file:

• Main title: content of “urlname” and “url” tags (e.g., Event_Logger 7.1)
• Author: content of “author” and “email” tags (e.g., amacri)

After the title, two items are generally shown, indicating begin and end dates of the path as well as total distance, max speed and motion duration. Also these data are fetched from the <gpx> header tag of the GPX file:

• <name>: end date, total distance, max speed, motion duration, max. uphill and downhill slope values (data produced by Event_Logger)
• <desc>: begin date (information produced by Event_Logger)

Example:

Subsequently, the Google Maps window is shown: the map includes a large pan/zoom control in its top left corner (where the centre button allows returning back to the original pan and zoom settings), a map scale in miles and kilometers, localized buttons that let the user toggle between map types (such as Map, Satellite, Hybrid), a collapsible overview map in the bottom right corner of the screen and of course the path descriptors. A specific “Map options” button is also available.

Example:

The map is automatically resized to the window dimension. By resizing Internet Explorer, the map dimension automatically changes accordingly.

The track attributes added to the map include:

-          travelled path, represented with subsequent brown, blue and green segments;

-          arrow indicators, showing the directions;

-          stopover markers (representing the start of a GPX <trk> segment; red or green colours depend on the presence of the “cmt” tag);

-          waypoint markers (showing data included in <wpt> tags; dot represents a LOG event, small arrow a resume event and small square a suspend event);

-          fixes (referring to <trkpt> tags and also showing data included in the “fix” tag; more precisely, red, gold and white, respectively represent 2d, 3d and cached fix quality).

Below the map, a complete set of tables extensively report the path analysis. Map and tables are fully interconnected by virtual hyperlinks which simply allow to switch from graphical representation of a fix to related tabular analysis and vice versa. The produced map also allows interactive analysis through the usage of keyboard and mouse. The interactive analysis can control visibility, switch specific map elements to related description and manage a comprehensive interactive segment calculator. Other than using the keyboard to select the interactive options, a menu panel is available, graphically showing all the possible configuration settings; this menu can be opened by pressing the “Map options” button or when the mouse flies over the right red border of the map.

After selecting an option, the menu disappears; besides, in case of selection through the right red border of the map, the menu automatically fades away when the mouse goes outside the panel perimeter.

While segments, stopovers and waypoints are always shown by default, in order to speed up map rendering and reduce visual clutter, arrows and fixes are visible only at closer zoom levels, where these details are relevant; besides, these attributes (fixes and arrows) are shown only when their number is lower than 500. For higher number of attributes, their granularity is automatically reduced by a proportional factor, so that up to about 500 fixes are drawn in all cases. This factor is called graininess. Irrespective to the selected graininess, fixes including “sym” comments are always shown, as well as the first and last one of each <trkseg> segment. Appropriate controls (numeric keys pressed once or twice) allow manually changing the graininess factor; higher values speed up map rendering but reduce outline sharpness (graininess=3 or more should be effective at wider zoom levels, where details might not be so relevant; the smallest graininess level is 1, where all fixes are shown, meaning the first 500 elements by default). Key ‘F’ has two behaviours; when the number of fixes is limited (specifically, up to 200 - not even 500), it simply toggles their visualization (either always visible or only at closer zoom levels); when the fixes are more than 200, by repeatedly pressing key ‘F’, subsequent trunks of 200 fixes are switched in turn, including also path lines; in order to highlight the condition of sliced path in the middle of a <trkseg> segment (e.g., broken brown or blue line), the line colour will be green for broken segments which continue with next trunk. Key ‘A’ simply toggles direction arrows visibility (either always visible or only at closer zoom levels).

The interactive segment calculator exploits two specific markers, called Delimiter A and Delimiter B. Delimiters are interactive objects that can be positioned over the map, clicked on, removed and, in some cases, they can be also dragged to a new location. To add a delimiter, click on the map and press key ‘Y’. Depending on the kind of selection before pressing this key, delimiters can be inside the path or over a generic map position. A selection outside the path (e.g., through a generic click over the map) will generate a generic delimiter, which can always be dragged together with its position. A selection inside the path (e.g., referred to a table element or to a fix point) will generate a special delimiter; its graphic object can be dragged as any other waypoint markers to improve visibility, but the related position remains statically bound to the selected fix. One or two delimiters can be added to the map in sequence (first Delimiter A, then Delimiter B). When clicking on a delimiter, a segment calculator appears as a pop-up table, showing information related to the whole path, to the relative position of the delimiter inside the path and to the correlations with the other delimiter (when available). While a delimiter outside the path offers limited correlations (not related to any path position), when both delimiters are placed inside the path, by clicking on each of them the segment calculator will display full data and computations.

In order to test the delimiters, browse the path tables below the map and, using the mouse, select an hyperlink referred to a specific fix; the map is shown and a closeup pop-up table appears in correspondence to the selected point; besides, the related selected information is also cached so that, by pressing key ‘Y’, a delimiter appears on the map over the specified fix position. Trying to drag it, the graphic object will be moved, but not its related reference position. This operation also works when clicking on any generic point of the map (i.e., outside the travelled path): after pressing ‘Y’, a draggable delimiter appears (this is different from the delimiter referring to a fix within the travelled path, which statically points to the selected position, even if the removal operation is anyway allowed). When clicking on each delimiter, the segment calculator appears, reporting computed data inside a table.

Here is an example of calculator referred to Delimiter A:

Both delimiters A and B are within the path.
Direction is Delimiter A to Delimiter B.

The initial sentence “Both delimiters A and B are within the path” means that all data are available and that both delimiters are bound to path positions. Elements in red refer to the whole path (irrespective to the delimiter position). Elements in blue are only shown in case of delimiters within the path. “Linear distance from Delimiter” refers to the most direct route between the two points, as the crow flies; it appears when both of them are available (regardless within or outside the path); all the other black elements require two delimiters linked to the path. Difference of altitude and slope only appear when related heights are available.

“Total” means whole path including stopovers (intervals while the TomTom is kept switched off) and also including junctions between separate segments (like space and time between different tracks or different track segments, also called nearby or faraway restarts). “Real” means whole path excluding stopovers and junction segments (which typically do not refer to travelled space). “Motion” reduces the travelled time to the motion periods, keeping the travelled space unaltered (i.e., it excludes all temporary suspensions of movement, like intervals when the vehicle stops for a while or moves at a speed lower than 1,4 m/sec = 5 km/h). “Units” are fixed.

When “Total” and “Real” values (both distances and times) are the same, the path consists of a set of consecutive segments (or single unbroken segment) without stopovers. When “Total” and “Real” distances are the same, but with different times, the path consists of a single unbroken segment and includes stopovers (e.g., periods when the TomTom device has been temporarily switched off for few minutes). There is no difference between “Real” and “Motion” distances. When “Real” and “Motion” periods are the same, the vehicle has always been in movement for the whole path duration.

The following picture shows two delimiters manually placed somewhere in the map (not bound to the path).

In next picture, delimiters are both are within the path.

Notice that in this picture delimiters and some waypoints have been dragged to improve visibility. Anyway, the pink line connecting both delimiters remains bound to the path.

Key ‘Z’ allows centring and zooming; it applies to zero, one or both delimiters and can be pressed once or more times. When no delimiter is available and no generic click is made over the map, key ‘Z’ simply resets the map to the original centre (i.e., default pan and zoom positions; in this case, when pressed another time, also allows the full application reset). After a generic click over a map, it centres the clicked position when pressed once and when pressed twice also opens an info window over the last clicked point with a closeup map around the position. When one delimiter is available, key ‘Z’ centres it the first time it is pressed, while the second time the related info windows appears (like clicking over the delimiter). When both delimiters are available, key ‘Z’ zooms the map to them the first time it is pressed and makes the related info windows appear in turn when subsequently pressed more times.

Considering that two delimiters define a zoom rectangular perimeter, keys ‘Y’ and ‘Z’ can be used to easily zoom a specific part of the map. For this, click over a map position (i.e., close to the top left corner of the desired zoom rectangle) and press ‘Y’ to add Delimiter A. Then click close to the bottom right corner of the zoom rectangle; press again ‘Y’ to add Delimiter B. Drag both delimiters in order to more precisely define the zoom rectangle. Press ‘Z’ to zoom. After zooming, delimiters can still be dragged to further restrict the zoom rectangle; press ‘Z’ to zoom again to the new perimeter.

Other procedures allow fast zooming. When no delimiter is set, simply click on the point to be zoomed, then press key ‘Z’ to centre this point (this is an alternative and quicker way to pan the map by dragging it through the mouse). Then press keys ‘+’ or ‘-’ (or the zoom slider) to zoom in or out. The same operation can also be accomplished through the usage of one delimiter. Click around the point to be zoomed. Press ‘y’ to add the first delimiter. Drag the delimiter to precisely position it to the centre of the zoom rectangle (you will find this operation easier than dragging the whole map). Press ‘Z’ to centre the delimiter; the map will be dragged accordingly. Finally press keys ‘+’ or ‘-’ to zoom in or out.

The following picture shows an example of map with available attributes.

The main attribute is the track path, consisting of segments which in turn plot sequence of fixes (<trkpt> elements in the GPX file). Segments are represented with subsequent red and blue “polylines” in order to highlight the related separations (<trkseg> elements in the GPX file), which typically occur in correspondence with a stopover/pull-up event (shown through a small red marker). A red interconnection segment represents separated track segments (this happens in case a new <trkseg> element within a single <trk> one is spatially separated from the previous segment).

Other than the track path, the attribute elements might also include clickable waypoints, clickable stopovers, direction arrows, clickable fix indicators. All these markers can also be dragged to improve visibility. Each of them is subsequently described.

Clickable waypoint:

It represents <wpt> elements inside the GPX file, which corresponds with Event_Logger events, like BOOT, RESUME, SUSPEND, LOG, etc. The related color might vary accordingly. The graphic object can be dragged to improve visibility.

-          red with black dot symbol in case of standard LOG event,

-          green with ‘right arrow’ symbol for initial resume event,

-          red with black square symbol in case of last suspend,

-          red with ‘S’ letter in case of intermediate suspend,

-          red with ‘R’ letter in case of intermediate resume.

Clickable stopover: this attribute represents <trk> elements in the GPX file and indicates a pull-up event (e.g., vehicle standing still for some seconds). The graphic object can be dragged to improve visibility.

Direction arrow: in the middle of a segment, indicates the direction of the path.

Clickable fix indicator:

It represents <trkpt> elements inside the GPX file, which correspond with 2d, 3d or cached fixes produced by TomTom. The related color varies accordingly:

-          red dot: 2d fix provided by TomTom while the GPS is active (latitude and longitude are available, but with no altitude);

-          gold dot: 3d fix directly provided by the GPS (latitude, longitude and altitude are available, together with many additional information elements);

-          white dot: 2d fix in TomTom cache, without GPS assistance (might be imprecise).

When the fix is clicked, the control goes to the related table element, which is also highlighted; this simply allows analyzing details. Besides, the related position is used by subsequent Y (yank), Z (zoom), G (Google Maps) operations.

As previously described, the keyboard and mouse controls allow interactive analysis; the available actions are detailed here below.

Mouse instructions:

-          Mouse left click and drag: map dragged to the mouse direction

-          Mouse left double click: zoom in

-          Mouse right double click: zoom out

-          Mouse Scroll wheel: Zoom in and zoom out

Keyboard instructions:

If Google Maps cannot be contacted, the following message is shown:

Below the map, If the browser if off-line, the following message is shown:

Your browser is set to work off-line, exploiting cached data. If you are connected to the network, set it to on-line in order to read updated content (start a new instance of Internet Explorer by pressing CTRL+N, select the File menu. There would be a tick by the 'Work Offline' option. Click it to take IE off 'Work Offline' mode; reload the GPX file).

The following table describes how to read the overall statistics.

10. Compatibility

Event_Logger is specifically designed for the all-in-one GPS TomTom devices (like TomTom GO), which exploit the ARM Linux operating system; it is not suitable for TomTom Navigator and TomTom Mobile (e.g, it does not support Poket PC, Windows CE and Symbian devices).

Event_Logger also supports TomTom models which include a disk instead of the SD card (the installation is exactly the same).

The screen functions inside Event_Logger support 240 x 320 3.5”, 320 x 240 3.5” and 480x272 4” displays (e.g., TomTom GO 700, 500, 300, Classic, ONE, OneXL, RIDER, RIDER II, GO 910, 710 and 510); in case of problems with the screen functions, they can be disabled through DoSplashTxt=never and by avoiding to run the Top and the Astronomical Calendar commands.

This version has been currently tested with NavCore 5.202, 5.420, 5.440, 5.450, 6.120, 6.140, 6.150, 6.5*, 7.13, 7.162, 7.163, 7.221, 7.45x, 8.002, 8.010, 8.011, 8.051, 8.204, 8.300, 8.320, 8.410, 8.412, 8.413, 8.350 and 8.351. Possibly, more recent versions are supported.

NavCore firmware versions 8.350 and 8.351 do not allow interacting with external applications started through menu items; what happens is that the touchscreen is shared between the started external application and NavCore, which is not brought to background (differently from all other NavCore firmware versions). The behaviour of versions 8.350 and 8.351 do not compromise the log tracking of Event_Logger, which is performed in background with no need of user interaction. Besides, the shortcut button functionality activating “Log Position to Itinerary” still works. Anyway, functionalities provided by selecting the Event_Logger menu items are unusable with the standard devshare.so included in the Tracer directory. To allow interaction with versions 8.350 and 8.351, after the installation replace the file Tracer\devshare.so with Tracer\navcore8.35x\devshare.so. In case this is not enough to overcome the display issue, try replacing file Tracer\devshare.so with Tracer\navcore8.35x_and_old_devices\devshare.so.

Event_Logger can manage all GPS units included in the current TomTom all-in-one models. Specifically, it supports SiRFstar IIe/LP Chip Set via NMEA protocol, SiRF Star III without QuickGPSfix via NMEA protocol, SiRF Star III with QuickGPSfix via SiRF binary protocol and Global Locate's Hammerhead via translated NMEA protocol (accomplished by the internal TomTom gltt daemon).

Technically, Event_Logger is a special zsh script executed by the bsh interpreter (a modified zsh shell included in the Event_Logger package); additional applications are also included (top, Astronomical Calendar). The Event_Logger loader (Tracer/mkel) also modifies /etc/rc.suspend and /etc/rc.resume files which are automatically executed by TomTom GO upon suspend and resume events. Other aspects are managed, like temporarily mounting the SD card filesystem on suspend and usage of the “File transportation layer” to invoke TomTom GO SDK functions. Some of the exploited interfaces might depend on internal TomTom GO development strategies which could change in future versions. Check at http://www.opentom.org/FileInterface for further information on the “File transportation layer” used by Event_Logger.

TomTom declares compatibility of SDK with NavCore version 6.x up to 6.15 and SDK is currently discontinued with NavCore version 7 (even if still functional).

The following SDK limitations have been empirically found with NavCore 7.

-          NavCore 7 does not provide correct city geodecoding when managing v6 maps; if NavCore 7 accesses a v6 map, when tapping on “Help me!” and then “where am I?”, the resulted street name should always be correct, but possibly not the city/town/place name, which might report a nearby place. In general, there should not be relevant reasons to introduce NavCore 7 when browsing v6 maps. The same problem happens when Event_Logger interfaces NavCore via SDK in order to retrieve a fix geodecoding; it is better to disable geodecoding (DoSdkGeodecode=no) when necessarily running NavCore 7 with a v6 map.

-          Customized menu items do not support any newly introduced icons (ref. to new V7 features), which will result missing when applying customized menus (tomtom.mnu). Notice anyway that tomtom.mnu is correctly working on NavCore 7, even if not supported; unfortunately no new entry can be added anyway, like “Help Me!” and “Map Corrections”. If Help Me is really needed, it is suggested to delete tomtom.mnu with NavCore7.

-          Newly introduced custom icons (i.e., new .CAP files) will influence the standard NavCore 7 menus by removing some of the V7 icons like “Help me” (for some NavCore 7 version) and changes the behaviour “Map Corrections” (for all the known versions). For instance, if Event_Logger is installed (hence including the related .CAP files), when pressing "Map Corrections" on screen 2, some the latest menu page appears instead of the related "Map Corrections" submenus. Anyway, when browsing the map (“Browse Map” menu item), the new “Correct location” item should always be available (it can be found when tapping on the Cursor button and it allows correcting the location shown at the cursor position). If the whole V7 menus are wanted, it is better to delete all the .CAP files in the SdkRegistry directory (or simply rename the SdkRegistry directory); Event_Logger will still continue to work in background, but without possibility of user interaction.

-          Occasionally, the SDK API response of NavCore 7 may be very slow, taking a lot of seconds. This include also geopositioning, geodecoding and providing flashing information on the display. A feature on Event_Logger overcomes this problem when BkupFixFromGps is set to yes. An hint to speed up the generation of the final flashing message after selecting “Log Position to Itinerary” is to try tapping on the display and navigating through menus.

To better clarify, Event_Logger has nothing to do with these limitations, which are completely related to the unsupported SDK of NavCore 7.

The Itinerary files produced by Event_Logger follow the TomTom GO specifications and should be compatible with any TomTom software supporting them.

Usage of SDK function can be controlled through the following configuration variables (SDK functions are activated when the variables are set to “yes”; unsetting or commenting them out will disable the related SDK options):

# NOTE: avoid using spaces in any filename

See also “Poi” configuration variables subsequently described.

The embedded tracking system follows the GPX 1.0 specifications and should allow interfacing any GIS, mapping or analysis tool accepting the GPX 1.0 format. GPX files produced by Event_Logger should pass the validation described at http://www.topografix.com/gpx_validation.asp.

GPX files produced by Event_Logger have been tested for compatibility with:

o        TopoFusion (all versions; specifically, v. 2.85 was successfully tested; v.3.21 is a very stable release)

o        GPS Visualizer (on-line tool)

o        GPSBabel (converts GPS route and waypoint data from one format type to another. GPS Visualizer also provides a Web interface to GPSBabel).

o        TopoGrafix EasyGPS and ExpertGPS (all versions; specifically, v. 1.3.7 was tested)

o        Google Earth (tested versions: 3.0.0616 beta and 3.0.0762)

o        uTrack (on-line GPX track report generator which produces HTML and PDF maps including information about elevation, speed, time and calculating flat and real distance).

GPX.XSL is only compatible with Internet Explorer version 6 and 7. Tested Google Maps API versions are 2.81 and all more recent ones.

11. Installation

o        Download the latest release of the Event_Logger software from http://web.tiscali.it/macri/Event_Logger; the downloaded zip package includes everything: software, documentation, sources; only the software should be installed on the TomTom device.

o        In case a ReadMe.txt file is available inside the Event_Logger archive, this includes the latest version information which might not be fully documented here.

o        Verify that the PC used for the installation has the date reasonably adjusted. This is because, in case of hard reset of TomTom device, Event_Logger will set the TomTom GO date to the last modification time of the Event_Logger.txt file (this also takes correctly care of the LinuxTimeIsUTC variable). In relation to the feature that automatically syncs the date with the GPS device, the last part of this chapter reports a detailed description of possible reboot issues and how to overcome them.

o        Unzip the Event_Logger zip archive and place the files in the TomTom GO SD card (or HD device, when supported instead of the SD), respecting directories and cases; directories must be created if not existing. The Sources directory is not needed on the TomTom device and may not be extracted or can be deleted in any moment to save space. A typical error during this operation is to save all the files in the same flat directory instead of respecting the directory structure of the ZIP installation archive. Renaming files or file extensions are other errors (also renaming cases is not allowed).

o        For instance, in case the TomTom GO file system is named “H:” when mounted to an external system via USB, verify that the following files have been installed:

o        H:\cleanup.txt (notice that H:\ttn of any previous Event_Logger version must be deleted)

o        H:\ttn (only needed in case of NavCore version 8.2 or higher)

o        H:\Tracer\acal

o        H:\Tracer\bsh.bz2

o        H:\Tracer\bz2cat