## Geotag – EXIF GPS Latitude field format with libEXIF

I have been developing some software to geotag jpeg images by adding EXIF GPS information using libEXIF. This is very handy as loads of applications like GIS systems and google maps etc can correctly geographically position your images.

As usual I started in the middle rather than starting at the beginning and got a bit confused by how GPS latitude and longitude fields are specified in EXIF, so I decided to try to describe it here with pictures (so that I can test out the google drawing app).

So, latitude (and longitude) can be expressed in different ways bit it is essentially just an angle. Common ways of expressing these angles are:

Degrees, minutes & seconds (with decimal places)
N 52 58 40.44

Degrees & minutes (with decimal places)
N 52 58.674

Degrees (with decimal places)
52.97790

The EXIF latitude field allows you to specify the angle in all of these forms, it is made up of 3 parts as follows:

1.) Degrees – Rational (8 bytes)
2.) Minutes – Rational (8 bytes)
3.) Seconds – Rational (8 bytes)

Each part is an EXIF Rational, it is hard to find a description of its format, but a an EXIF rational contains two 4-byte words and is like a fraction. The first word specifies the value’s magnitude while the second denominates the units. Consider the following values, (where ‘/’ should be read as ‘over’ or ‘divided by’):

a.) 52 = 52 / 1 (52 units)
b.) 40.44 = 4044 / 100 (4044 hundredths)
c.) 52.97790 = 52977900 / 1000000 (52977900 millionths)
d.) 0 = 0/1

the last value ( 0/1 ) is handy as it allows us to specify, say, 0 seconds if we only want to provide degrees and fractional minutes.

To set a rational we can use libEXIF’s set_rational() function like this:

```//
// 40.44 = 4044 / 100 (4044 hundredths)
exif_set_rational(entry->data, EXIF_BYTE_ORDER_INTEL, { 4044, 100 });
//
```

or more generally, if, for example, you want to set a value to 6 decimal places:

```//
float lat = 52.977900;
exif_set_rational(entry->data, FILE_BYTE_ORDER, { (unsigned)(lat * 1000000.0), 1000000 });
//
```

So now, given a latitude value in degrees, minutes and seconds all we have to do is create a EXIF_TAG_GPS_LATITUDE tag and add a rational for each. Imagine that we want to encode 52, 58, 44.44 then the tag data will then end up looking like this:

This is all very well but I don’t normally bother holding minutes and seconds in my code, instead I preferr to use a degree value to many decimal places, e.g. 52.97790, no problem, this is where our rational value 0 / 1 comes in handy – it can be represented as follows:

So wrapping all of this up, here is some example code that sets a decimal degree value for latitude:

```/*
* create_tag() is from the write-exif.c sample code that is floating
* around the interweb - with thanks to whoever created it!
*/
/* Create a brand-new tag with a data field of the given length, in the
* given IFD. This is needed when exif_entry_initialize() isn't able to create
* this type of tag itself, or the default data length it creates isn't the
* correct length.
*/
static ExifEntry *create_tag(ExifData *exif, ExifIfd ifd, ExifTag tag, size_t len)
{
void *buf;
ExifEntry *entry;
/* Create a memory allocator to manage this ExifEntry */
ExifMem *mem = exif_mem_new_default();
/* Create a new ExifEntry using our allocator */
entry = exif_entry_new_mem (mem);
/* Allocate memory to use for holding the tag data */
buf = exif_mem_alloc(mem, len);
/* Fill in the entry */
entry->data = buf;
entry->size = len;
entry->tag = tag;
entry->components = len;
entry->format = EXIF_FORMAT_UNDEFINED;
/* Attach the ExifEntry to an IFD */
/* The ExifMem and ExifEntry are now owned elsewhere */
exif_mem_unref(mem);
exif_entry_unref(entry);
return entry;
}
// Set a decimal degree value with support for 6 decimal places
//
//
// create our latitude tag, the whole  field is 24 bytes long
entry = create_tag(exif, EXIF_IFD_GPS, EXIF_TAG_GPS_LATITUDE, 24);
// Set the field's format and number of components, this is very important!
entry->format = EXIF_FORMAT_RATIONAL;
entry->components = 3;
// Degrees
float lat = 52.977900;
exif_set_rational(entry->data, EXIF_BYTE_ORDER_INTEL, { (unsigned)(lat * 1000000.0), 1000000 });
//
//

```

I will probably do another post that details how to write EXIF data into a jpeg image’s header using libEXIF and libJPEG

The google drawing app actually worked quite well!

## Setup PIC Timer with Interrupt Example (18F Family, MikroC)

Setting up a PIC timer to the correct frequency can be a tricky business for the uninitiated Software Engineer (i.e. Me). So I was pretty happy when I came across this great on-line tool whereby you just type in your oscillator frequency and desired interrupt rate and it generates the setup code for you!

For example I have an 8Mhz clock and wanted a 1KHz interrupt on Timer0, I punched that in and the tool said I should use this set-up code:

```//
T0CONbits.T08BIT = 0;
T0CONbits.T0CS = 0;
T0CONbits.PSA = 0;
T0CONbits.T0PS2 = 1;
T0CONbits.T0PS1 = 0;
T0CONbits.T0PS0 = 0;
TMR0H = 0xB;
TMR0L = 0xDC;
T0CONbits.TMR0ON = 1;
//
```

Happy days!

Now there is a little more to defining the software interrupt handler and enabling the interrupt so I have included the code for a slightly more verbose example that configures and enables Timer0 via mikroC on the PIC18F25K22:

```//
void init_timers();
void main() {
init_timers();
for (;;) {
// do something...
}
}
void init_timers() {
// Initialise Timer0 for a 1Khz interrupt
// 8Mhz clock & want 1Khz interrupt
// See http://www.enmcu.com/software/timer0calculatorandcodegeneration
// for values.
//
INTCON.GIE=1;         //globle interrupt enable
INTCON.PEIE=1;        //peripharel interrupt enable
INTCON.TMR0IF = 0x0;  //Clear timer0 overflow interrupt flag
INTCON.TMR0IE = 1;    //enable the timer0 by setting TRM0IE flag
T0CON.T08BIT = 0;     // 16 Bit timer
T0CON.T0CS = 0;       // Internal clock
T0CON.PSA = 1;        // Set scaler to 1:4
TMR0H = 0xF8;         // Initial count of 0xF830
TMR0L = 0x30;
T0CON.TMR0ON = 1;     // Turn Timer0 on.
}
// interrupt handler for the timer0 overflow
void interrupt(void) {
// http://www.enmcu.com/software/timer0calculatorandcodegeneration

// Reset the timer count
TMR0H=0xF8;
TMR0L=0x30;

// Reset interrupt flag
INTCON.TMR0IF = 0;
// Do some work here
}
//
```