Free gps for oziexplorer in canada software for linux

Tables for Ada is a library provides an implementation of tables indexed by strings. The binary search is used for names of known length. It is also possible to search a table for names of unknown length, i.e. to parse a string using some table. Table elements can be of any private type. Key- insensitive tables are supported.
Enhancements:
- GPS project files were added for GNAT users.

GPS Tracker project allows someone to track a GPS enabled cell phone using Google maps. For this project I used a Motorola i355 cell phone on the Sprint/Nextel network.
You need to have a data plan so that you can make updates to your website from the cellphone. Please read the ReadMe.txt file in the download for installation instructions. I hope you enjoy the project. If you have any questions, feel free ask them in the forum.
There are two projects available. The first project is built with .NET and Microsoft SQL Server. The second project is built with PHP and MySQL. If you have any suggestions, please feel free to let me know. Both projects use java (J2ME) on the phone.
How It Works:
None of the code for this project is very difficult, but it does span a number of tiers and languages which may be unfamiliar to some. Figure 1 shows the data flow from phone to Google map.
Phone
Lets start with the code on the phone. This app is written in java using Java 2 Micro Edition (J2ME). Java is very similar to C#. As you look through the code, the only thing that might confuse a C# coder is the vector. A java vector is pretty much a C# ArrayList, a dynamic array. There are 2 classes in the app, LBSMidlet7 and Qworker. A midlet is an app that runs on cell phones. Take a look at the class definition. It extends the MIDlet class and implements a LocationListener interface. That means that we need to put all the method definitions of that interface into our class. Well get to that in a bit, right now lets look at the constructor.
We do 2 things in the constructor. We create a QWorker object and pass it "this" and the website that we will be uploading to. The getAppProperty method gets attributes out of the JAD file. Open the JAD file in your favorite text editor and there youll see the webpage that youll be sending GPS data to. Notice how were passing "this" to the GWorker object? Thats the LBSMidlet7 object. Take a quick look at the QWorker class, it extends the Thread class. Thats why we call worker.start() in the LBSMidlet7 constructor. We want to start our worker thread.
When you start a thread, what you are doing is creating an object and then running that objects run() method. Take a look at the run method. It has an endless loop and in the loop the first thing it does is call queue.wait(). Look at the definition of the queue. The queue is an abstract data type (ADT), it just like a queue at a bank, enter the queue at the back of the line and leave the queue when you get to the front of the line. Look at the definition of the queue, its our vector (dynamic array). When you call wait() on an object within a class that extends the Thread class, it puts that object to sleep. Think about that a little. When we hit that line, our QWorker object is now waiting... Whats it waiting for? Well get to that in a minute. Before we do that, take a look at the synchronized keyword. Notice that its wrapping the queue. What that does is it puts a lock on the queue and tells all other processes not to touch the queue until that little block of code is done with it.
Ok, so now weve started a worker thread and put it to sleep. Lets now go back to the LBSMidlet7 class and take a look at the startApp() method. In the lifecycle of a midlet, the constructor is called once and then the startApp() method is called next. In fact it can be called several times, like for instance when you close a flip phone and then open it again. What happens is that the app is suspended and when you flip the phone open again, startApp() is called again. In startApp(), we get our display and then we create a LocationProvider if one hasnt already been created and we create another thread... Why are we creating all these threads? Good question. When a midlet (app) is suspended, the backgroud threads that are created keep running. That allows us to get our GPS data and send it to our webserver while we do other important stuff, like make phone calls.
The LocationProvider is what gets our GPS data. First we create a criteria, were using the default, but you can set stuff like accuracy, response time etc. Next we create our Location Listener. Its pretty much just what it sounds like. Here you can set the interval for how often you want to get GPS data. Its currently set to 60 which is in seconds. When data comes in, the locationUpdated() method is called. This is another one of the required methods in the LocationListener interface. Here we create yet another thread and call getLocation(). The getLocation() method gets the GPS coordinates, creates a queryString which we will send to the web server a little later and then calls worker.addToQueue in the QWorker class.
Lets go back over to the QWorker class and see what happens in that method. It add the queryString to the queue and then calls queue.notify(). Guess what queue.notify() does? It wakes up our sleeping QWorker thread and tells it to get to work! Notice that our calls to the queue are once again wrapped in a synchronized block. Please practice safe threading... When notify() is called on a thread, what it does is go back to the run() method and execute the next line of code right after where we told the queue to wait(). So now we are just about ready to send the GPS data to the web server. We have a couple of interesting lines of code there. First we call peekInQueue() which gets the queryString out of the queue but leaves it there for now. Then it sends the queryString to the getUrl method which attempts to send the queryString to our web server. If its successful, we can remove the queryString from the queue. If not, we leave the queryString in the queue and try to send it to the webserver again later.
Why in the world do we have this complicated queue here? Im glad you asked. There may be times when you are receiving GPS data but are not actually in an area that has a cell phone connection. If we dont have a cell phone connection, we cant send our GPS data to our web server. So we stick our queryString in our queue and wait until we get back into an area with cell phone connectability. Can you hear me now?
Well, weve spent a pretty fair bit of time explaining the phone code. Its a little complicated but its important to know whats going on if you want to take the code and make modifications to it to suit your needs. Heres a good article on the Sun website to let you know about more capabilities of the Location Based Services API. Right about now, our queryString should be arriving at our website, lets catch up to it and see what happens.
Enhancements:
- Added comments to code

GPS::Lowrance is a Perl module connect to Lowrance and Eagle GPS devices.

REQUIREMENTS

The following modules are required to use this module:

Carp::Assert
GPS::Lowrance::LSI 0.23
Parse::Binary::FixedFormat
Win32::SerialPort or Device::SerialPort

If you will be using the "get_plot_trails", "set_plot_trails", "set_waypoints" or "get_waypoints" methods, then you will need the following modules:

GPS::Lowrance::Trail 0.41
Geo::Coordinates::DecimalDegrees
Geo::Coordinates::UTM
XML::Generator

If you want to use the screen capture or icon download functions in GPS::Lowrance::Screen, you also need the following module:

GD

This module should work with Perl 5.6.x. It has been tested on Perl 5.8.2.
SYNOPSIS ^
use GPS::Lowrance;
use GPS::Lowrance::Trail;

$gps = GPS::Lowrance->connect(
Device => com1,
BaudRate => 57600,
);

$trail = $gps->get_plot_trail( plot_trail_number => 0 );

$gps->disconnect;

This module provides a variety of low- and high-level methods for communicating with Lowrance and Eagle GPS receivers which support the LSI 100 protocol. It also provides some utility functions for converting data.

GPS::PRN is a package for PRN - Object ID conversions.

SYNOPSIS

use GPS::PRN;
my $obj = GPS::PRN->new();
print "PRN: ", $obj->prn_oid(22231), "n";
print "OID: ", $obj->oid_prn(1), "n";

This module maps GPS PRN number to Satellite OID and vice versa.

Object Identification Number (OID)

The catalog number assigned to the object by the US Air Force. The numbers are assigned sequentially as objects are cataloged. This is the most common way to search for TLE data on this site.

Object numbers less then 10000 are always aligned to the right, and padded with zeros or spaces to the left.

Pseudo Random Numbers (PRNs)

GPS satellites are identified by the receiver by means of PRN-numbers. Real GPS satellites are numbered from 1 - 32. WAAS/EGNOS satellites and other pseudolites are assigned higher numbers. The PRN-numbers of the satellites appear on the satellite view screens of many GPS receivers.

METHODS

prn_oid

PRN given Object ID.

my $prn=prn_oid(22231);

oid_prn

Object ID given PRN.

my $oid=oid_prn(1);

listprn

List all known PRNs.

my @prn=$obj->listprn;
my $prn=$obj->listprn;

listoid

List all known OIDs.

my @oid=$obj->listoid;
my $oid=$obj->listoid;

data

OID to PRN hash reference

my $data=$self->data;

overload

Adds or overloads new OID/PRN pairs.

$obj->overload($oid=>$prn);

reset

Resets overloaded OID/PRN pairs to package defaults.

$obj->reset;

Geo::Spline is a Perl module to calculate geographic locations between GPS fixes.

SYNOPSIS

use Geo::Spline;
my $p0={time=>1160449100.67, #seconds
lat=>39.197807, #degrees
lon=>-77.263510, #degrees
speed=>31.124, #m/s
heading=>144.8300}; #degrees clockwise from North
my $p1={time=>1160449225.66,
lat=>39.167718,
lon=>-77.242278,
speed=>30.615,
heading=>150.5300};
my $spline=Geo::Spline->new($p0, $p1);
my %point=$spline->point(1160449150);
print "Lat:", $point{"lat"}, ", Lon:", $point{"lon"}, "nn";

my @points=$spline->pointlist();
foreach (@points) {
print "Lat:", $_->{"lat"}, ", Lon:", $_->{"lon"}, "n";
}

This program was developed to be able to calculate the position between two GPS fixes using a 2-dimensional 3rd order polynomial spline.

f(t) = A + B(t-t0) + C(t-t0)^2 + D(t-t0)^3 #position in X and Y
f(t) = B + 2C(t-t0) + 3D(t-t0)^2 #velocity in X and Y

I did some simple Math (for an engineer with a math minor) to come up with these formulas to calculate the unknowns from our knowns.

A = x0 # when (t-t0)=0 in f(t)
B = v0 # when (t-t0)=0 in f(t)
C = (x1-A-B(t1-t0)-D(t1-t0)^3)/(t1-t0)^2 # solve for C from f(t)
C = (v1-B-3D(t1-t0)^2)/2(t1-t0) # solve for C from f(t)
D = (v1(t1-t0)+B(t1-t0)-2x1+2A)/(t1-t0)^3 # equate C=C then solve for D

Linux ICE is a Linux distribution based on Ubuntu 7.04 for your car.
Main features:
- nGhost Media Center 0.94.5
- Linux kernel 2.6.20
- gps support via gspd
- Improved startup time
- XFCE 4.4
Enhancements:
- Linux ICE Development team is happy to release the third alpha in the development series of Linux ICE. Code named "Veyron ICE Breaker", this breed of release has a significantly reduced footprint and contains all the new technologies available in the newest version of Ubuntu 7.04.

blueMarine project is about an open source workflow for digital photography.

What does it mean?

Start thinking of an opensource application like Aperture or Lightroom that enables you to organize, develop, print and publish your photos. Pretty standard stuff nowadays. Opensource, at first sight, means that the application is free. Now think of an application written with the Java™ language: the application runs everywhere, Mac OS X, Linux, Windows. Now think of a community of people that adds code, plugins, crazy ideas, integrating some of the latest, cool technologies around, such as GPS positioning or geo-mapping.

Well, this is just the core concept of the blueMarine project.

Lets go on and lets think of the workflow. For the existing commercial applications the workflow starts just after shooting the photo and ends with a print on paper, the photo archived and maybe a web gallery published.

Just for a starter, we could do these things in innovative ways. For instance, trip reports could take advantage of GPS positioning data and Google Maps. Galleries could be presented in form of a virtual 3d gallery with walls and pictures hang on them.

Thinking of it twice, there are holes in workflows supported by current commercial applications. For instance, if you want to filter your images with a sophisticated noise reduction algorithm or if you want to create a bigger composite photo out of several shots, you likely have to use an external application. Some communities, such as amateur astrophotographers, need some very special processing that is usually performed by means of specific software. Wouldnt be better to have all of these facilities integrated in a single front end?

Now, lets broaden our workflow horizon. It can extend well beyond the print or the archival. For instance, an ornithologist usually manages field notes about the bird observed and photographed: directly binding them to photos and maybe GPS positioning data is much better than keeping a separate Excel sheet. It can also start much before shooting the photo. Think of trip planning: maybe you travel to nice places and spot interesting subjects, but not all the conditions are favorable: the weather, the light, the sun position, or the season (snow, blossomed flowers, foliage colors). Maybe you take some photos but at home you decide: hey, Im going to return there next Fall when the trees are reddish. Wouldnt be cool if a software application could allow you to easily manage all of these wanna-shoot-again photos, maybe providing assistance to guess which will be the sun position in a certain day and hour and integrating weather forecasts? And synthetising a trip program that can be uploaded on your palm gear?

Theres a further point with opensource photo workflow. Its related to the world of camera raw formats, that is the way professional DSLR cameras work. They provide you with the raw bits from the sensor that need to be extensively cooked, or developed, for getting a good image. This approach gives a tremendous amount of control to the photographers - too bad that most formats are proprietary and not documented. blueMarine supports the OpenRAW initiative and provide an opensource implementation of developing tools for camera raw formats from an ever increasing number of vendors.

Well, all of this and more is the aim of the blueMarine project.

MapGeneration Project is a project featuring a server and helper programs to collect GPS information from various sources and to then automatically generate a continuously improved, time annotated road map.
Nowadays gps-receivers are quite cheap and many people use them for route planning in their cars. On the other hand updated maps for the route planing systems are relativly expansive, if available at all.
The idea is to collect the data that people have recorded with their gps-receivers and combine it into one freely available road map. Besides being cheap and always current this map would also contain actual driving time information: Route planning on such a map would not have to use road type based approximations to calculate the fasted route.
In the MapGeneration Project we implement such a program and the end user tools needed to access the data. At the moment we concentrate on two programs: The MapGenerator itself and the MapGeneratorGUI used to administer the generator.
The MapGenerator is a server that accepts incoming data via network and combines the received road information into one big map. As the map might become quite big a database is used as storage. The MapGeneratorGUI connects to this database and displays the map.
As the best way to understand a program is to use it we will now give a short introduction to using the program.
Enhancements:
New features
- (Server) New filter to detect gaps in the input traces.
- (Server) Calculates and outputs total length and time of processed traces.
- (Server) Added full support for more than one processing thread, 2 is default now.
Changes
- (Server) Rewrote TraceServer and TraceConnection to support commoncpp2 1.0.x.
- (Server) Server tries to bind to 127.0.0.1 if no interfaces are found.
- (Server) Added curvature as a criterion for merging -> much better merging!
- (Server) Improved avoidance of double processing of nodes.
- (Server) Moved parsing of traces into TraceFilter.
- (General) Added lots of new methods to handle distances, bearings and interpolation.
- (General) Configuration system supports boolean values.
- (Buildsys) Changed parameters to specify config files to --with-wx-config and --with-ccgnu2-config
Bugfixes
- (Server) Protected data handling between thread with mutexs.
- (GUI) Fixed some string literals for full unicode support.
- (General) Cache: Fixed all size calculations and the size handling system.
- (General) Raised requirements for wxWidgets to 2.6 (beta versions since 2.5.3 should work).
- (General) Some small fixes to build with commoncpp2 1.0.x.