• UART1 = UART1A = (RX0 pin A0 / TX0 pin A1)
• UART2 = UART3A = (RX2 pin 17 / TX2 pin 16)
• UART3 = UART2A = (RX pin 29 / TX pin 43)
• UART4 = UART1B =  (RX1 pin 19 / TX1 pin 18)
• UART5 = UART3B =  (RX3 pin 15 / TX3 pin 14)
• UART6 = UART2B =  (RX pin A3 / TX pin A2)

Note, the chipKIT Max32 uses the PIC32MX795F512L hence the 6 UART’s.

/*********************************************************************
  UART Library Interface Example

  Summary:
    This file contains the interface definition for the UART peripheral
    library.

  Description:
    This library provides a low-level abstraction of the UART (Universal
    Asynchronous Receiver/Transmtter) module on Microchip PIC32MX family
    microcontrollers with a convenient C language interface.  It can be
    used to simplify low-level access to the module without the
    necessity of interacting directly with the module's registers, thus
    hiding differences from one microcontroller variant to another.

 Modifications:
    This version has been modified from the original by Trevor
    (http://electronics.trev.id.au) to allow use of the functions with
    multiple UART's. The three functions
        * SendDataBuffer,
        * GetMenuChoice,
        * GetDataBuffer
    now reqiure the UART id to be the first variable passed to
    the function (eg: GetMenuChoice(UART1);)
    Also added a buffer compare function to allow comparison of what is
    recieved. Key point to note with the compare, the buffer is not
    a \0 terminated string.
 Testing modifications:
    This has been tested on the chipKIT Max32 from Digilent using
    UART1 -> FTDI chip -> PC. The source is compiled using
    MPLAB X IDE v1.10 and programmed into the device using an MPLAB
    ICD3. Compiler was the Microchip C32 v2.02.

**********************************************************************/
//DOM-IGNORE-BEGIN
/*********************************************************************
FileName:       main.c
Dependencies:   See includes
Processor:      PIC32MX

Complier:       Microchip MPLAB C32 v1.06 or higher
Company:        Microchip Technology Inc.

Copyright © 2008-2009 released Microchip Technology Inc.  All
rights reserved.
Modifications as described above are Copyright © 2012 released
by Trevor van der Linden. All rights reserved.

The modifications have the same license terms as the original
Microchip license, with the exception that where it states Microchip,
it should be read as Trevor van der Linden.

Microchip licenses to you the right to use, modify, copy and distribute
Software only when embedded on a Microchip microcontroller or digital
signal controller that is integrated into your product or third party
product (pursuant to the sublicense terms in the accompanying license
agreement).

You should refer to the license agreement accompanying this Software
for additional information regarding your rights and obligations.

SOFTWARE AND DOCUMENTATION ARE PROVIDED ?AS IS? WITHOUT WARRANTY OF
ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION,
ANY WARRANTY OF MERCHANTABILITY, TITLE, NON-INFRINGEMENT AND FITNESS
FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL MICROCHIP, TREVOR VAN DER
LINDEN, OR THEIR LICENSORS BE LIABLE OR OBLIGATED UNDER CONTRACT,
NEGLIGENCE, STRICT LIABILITY, CONTRIBUTION, BREACH OF WARRANTY, OR
OTHER LEGAL EQUITABLE THEORY ANY DIRECT OR INDIRECT DAMAGES OR
EXPENSES INCLUDING BUT NOT LIMITED TO ANY INCIDENTAL, SPECIAL,
INDIRECT, PUNITIVE OR CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST
DATA, COST OF PROCUREMENT OF SUBSTITUTE GOODS, TECHNOLOGY, SERVICES,
OR ANY CLAIMS BY THIRD PARTIES (INCLUDING BUT NOT LIMITED TO ANY
DEFENSE THEREOF), OR OTHER SIMILAR COSTS.
*********************************************************************/
//DOM-IGNORE-END

// ******************************************************************
// ******************************************************************
// Section: Includes
// ******************************************************************
// ******************************************************************
#include <GenericTypeDefs.h>
#include <plib.h>

// ******************************************************************
// ******************************************************************
// Section: Configuration bits
// ******************************************************************
// ******************************************************************
#pragma config FPLLODIV = DIV_1, FPLLMUL = MUL_20, FPLLIDIV = DIV_2,\
                FWDTEN = OFF, FCKSM = CSECME, FPBDIV = DIV_1
#pragma config OSCIOFNC = ON, POSCMOD = XT, FSOSCEN = ON,\
                FNOSC = PRIPLL
#pragma config CP = OFF, BWP = OFF, PWP = OFF

// ******************************************************************
// ******************************************************************
// Section: System Macros
// ******************************************************************
// ******************************************************************
#define	GetSystemClock()      (80000000ul)
#define	GetPeripheralClock()  (GetSystemClock()/(1 << OSCCONbits.PBDIV))
#define	GetInstructionClock() (GetSystemClock())

// ******************************************************************
// ******************************************************************
// Section: Function Prototypes
// ******************************************************************
// ******************************************************************
BOOL BufferCompare(char *buffer, UINT32 size,\
                    const unsigned char *compareto,\
                    UINT32 expectedSize);
void SendDataBuffer(UART_MODULE id, const char *buffer, UINT32 size);
UINT32 GetMenuChoice(UART_MODULE id);
UINT32 GetDataBuffer(UART_MODULE id, char *buffer, UINT32 max_size);
// ******************************************************************
// ******************************************************************
// Section: Constant Data
// ******************************************************************
// ******************************************************************
const char mainMenu[] =
{
    "Welcome to PIC32 UART Peripheral Library Demo! (Trevor's mods)\r\n"\
    "Here are the main menu choices\r\n"\
    "1. View Actual BAUD rate\r\n"\
    "2. Use AUTOBAUD\r\n"\
    "3. Set Line Control\r\n"\
    "4. ECHO\r\n"
    "\r\n\r\nPlease Choose a number\r\n"
};
const char lineMenu[] =
{
  "Line Control Menu\r\n"\
  "You may need to change the line control on the terminal to see data\r\n"\
  "1. 8-N-1\r\n"\
  "2. 8-E-1\r\n"\
  "3. 8-O-1\r\n"\
  "4. 8-N-2\r\n"\
  "5. 8-E-2\r\n"\
  "6. 8-O-2\r\n"\
  "\r\n\r\nPlease Choose a number\r\n"
};
const UINT32 lineControl[] =
{
    (UART_DATA_SIZE_8_BITS | UART_PARITY_NONE | UART_STOP_BITS_1),
    (UART_DATA_SIZE_8_BITS | UART_PARITY_EVEN | UART_STOP_BITS_1),
    (UART_DATA_SIZE_8_BITS | UART_PARITY_ODD | UART_STOP_BITS_1),
    (UART_DATA_SIZE_8_BITS | UART_PARITY_NONE | UART_STOP_BITS_2),
    (UART_DATA_SIZE_8_BITS | UART_PARITY_EVEN | UART_STOP_BITS_2),
    (UART_DATA_SIZE_8_BITS | UART_PARITY_ODD | UART_STOP_BITS_2)
};
const unsigned char response[] = {"AOK"};

const UART_MODULE monitorUART = UART1;
const UART_MODULE WiFlyUART = UART2;
const UART_MODULE gpsUART = UART3;

// ******************************************************************
// Section: Code
// ******************************************************************
// ******************************************************************

// ******************************************************************
// int main(void)
// ******************************************************************
int main(void)
{
    UINT32  menu_choice;
    UINT8   buf[1024];

    UARTConfigure(monitorUART, UART_ENABLE_PINS_TX_RX_ONLY);
    UARTSetFifoMode(monitorUART, UART_INTERRUPT_ON_TX_NOT_FULL\
            | UART_INTERRUPT_ON_RX_NOT_EMPTY);
    UARTSetLineControl(monitorUART, UART_DATA_SIZE_8_BITS\
            | UART_PARITY_NONE\
            | UART_STOP_BITS_1);
    UARTSetDataRate(monitorUART, GetPeripheralClock(), 115200);
    UARTEnable(monitorUART, UART_ENABLE_FLAGS(UART_PERIPHERAL\
            | UART_RX |\
            UART_TX));

    SendDataBuffer(monitorUART, mainMenu, sizeof(mainMenu));

    while(1)
    {
        menu_choice = GetMenuChoice(monitorUART);

        switch(menu_choice)
        {
        case 1:
            sprintf(buf, "Actual Baud Rate: %ld\r\n\r\n",\
                 UARTGetDataRate(monitorUART, GetPeripheralClock()));
            SendDataBuffer(monitorUART, buf, strlen(buf));
            break;

        case 2:
            SendDataBuffer(monitorUART,\
               "Press 'U' to allow AUTO BAUD to sync\r\n",\
               strlen("Press 'U' to allow AUTO BAUD to sync\r\n"));

            UARTStartAutoDataRateDetect(monitorUART);

            while(!UARTDataRateDetected(monitorUART))
                ;

            sprintf(buf, "Actual Baud Rate: %ld\r\n\r\n",\
                 UARTGetDataRate(monitorUART, GetPeripheralClock()));
            SendDataBuffer(monitorUART, buf, strlen(buf));
            break;

        case 3:
            SendDataBuffer(monitorUART, lineMenu, sizeof(lineMenu));
            menu_choice = GetMenuChoice(monitorUART);
            menu_choice--;

            if(menu_choice >= 6)
            {
                SendDataBuffer(monitorUART, "Invalid Choice",\
                        sizeof("Invalid Choice"));
                SendDataBuffer(monitorUART, mainMenu,\
                        sizeof(mainMenu));
                break;
            }

            SendDataBuffer(monitorUART,\
  "Press Any Character after re-configuring you terminal\r\n",\
  strlen("Press Any Character after re-configuring you terminal\r\n"));
            UARTSetLineControl(monitorUART, lineControl[menu_choice]);

            menu_choice = GetMenuChoice(monitorUART);
            SendDataBuffer(monitorUART, mainMenu, sizeof(mainMenu));
           break;

        case 4:
            {
                UINT32 rx_size;
                unsigned char s[1024];
                BOOL strcorrect;
                SendDataBuffer(monitorUART,\
"Type a message (less than 100 characters) and press return\r\n",\
strlen("Type a message (less than 100 characters) and press return\r\n"));

                rx_size = GetDataBuffer(monitorUART, buf, 1024);
                strcorrect = BufferCompare(buf, rx_size,\
                        "AOK", sizeof("AOK") - 1);  // dont count the \0
                if(strcorrect == TRUE)
                {
                    SendDataBuffer(monitorUART,\
                        "recieved expected response\r\n\r\n",\
                        strlen("recieved expected response\r\n\r\n"));
                }
                else
                {
                    SendDataBuffer(monitorUART,\
                            "You Typed:\r\n\r\n",\
                            strlen("You Typed:\r\n\r\n"));
                    SendDataBuffer(monitorUART, buf, rx_size);
                }
                SendDataBuffer(monitorUART,\
                   "\r\n\r\nPress any key to continue\r\n\r\n",\
                   strlen("\r\n\r\nPress any key to continue\r\n\r\n"));
                GetMenuChoice(monitorUART);
            }
            break;

        default:
            SendDataBuffer(monitorUART, mainMenu, sizeof(mainMenu));

        }
    }

    return -1;
}

/********************************************************************
BOOL BufferCompare(\
        char *buffer,UINT32 size,\
        char *compareto,\
        UINT32 expectedSize)
 Inputs:
 * buffer - the buffer containing the data returned from the UART
 * size - the number of charachters that the UART returned in buffer
 * compareto - char array of the characters to compare buffer to
 * expected size - the number of characters in compareto excluding
        any \0 chars
 Returns:
 * Boolean - True if the two are the same, otherwise false.
 SPECIAL NOTE:
 * The contents of the buffer coming from the UART is not a
    traditional null terminated string (does not have a \0 as
    a terminating char. For this reason you need to provide the
    size and expectedSize variables so the function knows how
    many characters from the start of buffer to compare.

********************************************************************/
BOOL BufferCompare(char *buffer,\
        UINT32 size,\
        const unsigned char *compareto,\
        UINT32 expectedSize)
{
    UINT8 i;
    BOOL same;
    same = FALSE;                   // 1st default to false
    if(size == expectedSize)   // check to see if the size is the same
    {
        same = TRUE;                // default to true
        for (i=0;i<=size-1;i++)
        {
            if(buffer[i] != compareto[i])   // compare
            {
                same = FALSE;       // if not the same, set to false
            }
        }
    }
    return same;                    // return result.
}
// ******************************************************************
// void UARTTxBuffer(UART_MODULE id, char *buffer, UINT32 size)
// ******************************************************************
void SendDataBuffer(UART_MODULE id, const char *buffer, UINT32 size)
{
    while(size)
    {
        while(!UARTTransmitterIsReady(id))
            ;
        UARTSendDataByte(id, *buffer);
        buffer++;
        size--;
    }
    while(!UARTTransmissionHasCompleted(id))
        ;
}
// *******************************************************************
// UINT32 GetDataBuffer(UART_MODULE id, char *buffer, UINT32 max_size)
// *******************************************************************
UINT32 GetDataBuffer(UART_MODULE id, char *buffer, UINT32 max_size)
{
    UINT32 num_char;

    num_char = 0;

    while(num_char < max_size)
    {
        UINT8 character;

        while(!UARTReceivedDataIsAvailable(id))
            ;
        character = UARTGetDataByte(id);
        if(character == '\r')
            break;
        *buffer = character;
        buffer++;
        num_char++;
    }

    return num_char;
}
// *******************************************************************
// UINT32 GetMenuChoice(UART_MODULE id)
// *******************************************************************
UINT32 GetMenuChoice(UART_MODULE id)
{
    UINT8  menu_item;

    while(!UARTReceivedDataIsAvailable(id))
        ;
    menu_item = UARTGetDataByte(id);
    menu_item -= '0';

    return (UINT32)menu_item;
}

The variable globalvariable is defined in the main source file, and then refered to in source-file-two.c using the extern command.

The #warning statements are there only to see how the compiler compiles each part. They can be left out without any impact.

***********************   source-file-one.c   ***************************

#warning begin source-file-one.c
#include <plib.h>   // so Nop() is recognised
#include "source-file-two.h"
int globalvariable;     // this is where you declare the variable
int main(void)
{
   initGlobalVariable();
   while(1)
   {
       if (globalvariable > _MAX_GLOBAL_VARIABLE_VALUE)
       {
           globalvariable = 0;
       }
       else
       {
           incrementValue();
       }
       Nop(); // something to put a break point on
    }
}
#warning end source-file-one.c

**********************  source-file-two.h  ************************

#warning begin source-file-two.h
#ifndef _SOURCEFILETWO_H
#define _SOURCEFILETWO_H
#warning including source-file-two.h main content

#define _INCREMENT_VARIABLE_BY 2
#define _MAX_GLOBAL_VARIABLE_VALUE 500

void incrementValue(void);
void initGlobalVariable(void);

#endif
#warning end source-file-two.h

****************   source-file-two.c   *********************

#warning begin source-file-two.c
#include "source-file-two.h"

extern int globalvariable;    // declare variable as a variable in another file

void incrementValue(void)
{
    globalvariable = globalvariable + _INCREMENT_VARIABLE_BY;
}

void initGlobalVariable(void)
{
    globalvariable = 0;
}
#warning end source-file-two.c

The library uses the standard Arduino Server and Client libraries for compatibility with existing scripts.

Platform I’m using is the chipKIT Max32 which has the Microchip PIC32MX795F512L along with my Max32 breadboard with LED’s connected to pins 3, 5 & 6. I have the GainSpan WiFi Breakout connected to pins 18 and 19 on the Max32 (UART1).

The library is available on github at http://github.com/smitthhyy/wirefree.

Installation:

1. Download library
2. Copy the folder within the zip file to your Arduino libraries folder. ([sketch folder]\libraries\).
3. Rename folder to Wirefree
4. Restart mpide and/or arduino ide.

Over time will develop the library further. Please see it’s readme for latest on it’s status.

You can also get a Arduino Uno shield with the Gainspan module from http://diysandbox.com/our-products/arduino-shields/hydrogen

In the file lib\include\pic24_libconfig.h at line 76, change the following section of code:

/** Select one of the hardware platform above to compile for. */
#ifndef HARDWARE_PLATFORM
#define HARDWARE_PLATFORM DEFAULT_DESIGN
#endif
// Verify that a valid hardware platform is selectd
#if (HARDWARE_PLATFORM != EXPLORER16_100P)   && \
    (HARDWARE_PLATFORM != DANGEROUS_WEB)     && \
    (HARDWARE_PLATFORM != STARTER_BOARD_28P) && \
    (HARDWARE_PLATFORM != DEFAULT_DESIGN)
#error Invalid hardware platform selected.
#endif
//@}

Replacing the above code with this code:

/** Select one of the hardware platform above to compile for. */
/* The automated method expects the board is defined in MPLAB
   using Use Project->Build Options-> Project, click on
   the MPLAB C30 tab, and in Macro Definitions click 'Add',
   and add:
      - For the Explorer 16 board - EXPLORER16_100P
      - For the Dangerous Prototypes web server - DANGEROUS_WEB
      - For the Microchip 16-bit 28-pin Starter Board - STARTER_BOARD_28P
   If the above is not set, the code will compile with the default
   of DEFAULT_DESIGN
*/
#ifndef HARDWARE_PLATFORM
#ifdef EXPLORER16_100P
#define HARDWARE_PLATFORM EXPLORER16_100P
#elif STARTER_BOARD_28P
#define HARDWARE_PLATFORM STARTER_BOARD_28P
#elif DANGEROUS_WEB
#define HARDWARE_PLATFORM DANGEROUS_WEB
#else
#define HARDWARE_PLATFORM DEFAULT_DESIGN
#endif
#endif
// Verify that a valid hardware platform is selectd
#if (HARDWARE_PLATFORM != EXPLORER16_100P)   && \
    (HARDWARE_PLATFORM != DANGEROUS_WEB)     && \
    (HARDWARE_PLATFORM != STARTER_BOARD_28P) && \
    (HARDWARE_PLATFORM != DEFAULT_DESIGN)
#error Invalid hardware platform selected.
#endif
//@}

This will now pick up the Macro definition set in MPLab and compile the components of the library needed for the Explorer 16 to function.

So far have tested the above with the Explorer 16, PIC24HJ256GP610A PIM, and the reset.c example from chapter 8 in the Microcontrollers: From Assembly Language to C Using the PIC24 Family.

This article shows how I modified the library (12 Apr 2011 version) from http://www.ece.msstate.edu/courses/ece3724/main_pic24/labs/files/pic24_code_examples.zip

In lib\common\pic24_configbits.c at about line 261 fine the line that contains

#if defined(EXPLORER16_100P) && defined(__PIC24HJ256GP610__)

and change it to

#if defined(EXPLORER16_100P) && (defined(__PIC24HJ256GP610__) || defined(__PIC24HJ256GP610A__))

In lib\include\pic24_ports.h at about line 700 you will find the following:

00700 #elif defined(__PIC24HJ256GP610__)
00701
00702 #include "devices/pic24hj256gp610_ports.h"

Change line 700 to:

#elif defined((__PIC24HJ256GP610__) || defined(__PIC24HJ256GP610A__))

The above uses the same .h file for the 610A as for the 610 on the assumption the two are pin compatible in every way. I have not yet found they are not, or any other reason to use a seperate ports file for the chip.

In lib\include\pic24_chip.h at aprox line 336 you will find the following little block of code:

#ifdef __PIC24HJ256GP610__
#define DEV_ID 0x00007B
#define DEV_ID_STR "PIC24HJ256GP610"
#endif

#if (defined(__PIC24HJ64GP206__) || defined(__PIC24HJ64GP210__) || defined(__PIC24HJ64GP506__)
|| defined(__PIC24HJ64GP510__)\
|| defined(__PIC24HJ128GP206__) || defined(__PIC24HJ128GP210__) || defined(__PIC24HJ128GP306__)\
|| defined(__PIC24HJ128GP310__) || defined(__PIC24HJ128GP506__)|| defined(__PIC24HJ128GP510__)\
|| defined(__PIC24HJ256GP206__) || defined(__PIC24HJ256GP210__)|| defined(__PIC24HJ256GP610__))

#define EXPECTED_REVISION1 0x003002
#define EXPECTED_REVISION1_STR "A2"
#define EXPECTED_REVISION2 0x003004
#define EXPECTED_REVISION2_STR "A3"
#define EXPECTED_REVISION3 0x003040
#define EXPECTED_REVISION3_STR "A4"
#endif

Replace this block of code above with:

#ifdef __PIC24HJ256GP610__
#define DEV_ID 0x00007B
#define DEV_ID_STR "PIC24HJ256GP610"
#endif

#ifdef __PIC24HJ256GP610A__
#define DEV_ID 0x0000077B
#define DEV_ID_STR "PIC24HJ256GP610A"
#endif

#if (defined(__PIC24HJ64GP206__) || defined(__PIC24HJ64GP210__) || defined(__PIC24HJ64GP506__)\
|| defined(__PIC24HJ64GP510__)\
|| defined(__PIC24HJ128GP206__) || defined(__PIC24HJ128GP210__) || defined(__PIC24HJ128GP306__)\
|| defined(__PIC24HJ128GP310__) || defined(__PIC24HJ128GP506__)|| defined(__PIC24HJ128GP510__)\
|| defined(__PIC24HJ256GP206__) || defined(__PIC24HJ256GP210__)|| defined(__PIC24HJ256GP610__))
#define EXPECTED_REVISION1 0x003002
#define EXPECTED_REVISION1_STR "A2"
#define EXPECTED_REVISION2 0x003004
#define EXPECTED_REVISION2_STR "A3"
#define EXPECTED_REVISION3 0x003040
#define EXPECTED_REVISION3_STR "A4"
#endif

#if defined(__PIC24HJ256GP610A__)
#define EXPECTED_REVISION1 0x003003
#define EXPECTED_REVISION1_STR "A1"
#endif

I’m not sure what the second last line #define EXPECTED_REVISION1_STR “A1″ should be and have not been able to find it, but the above has been tested using the reset.c example from chapter 8 of the book on the Explorer 16 and is working (provided you have also performed the mod described in this article).

This will update the library to accommodate for the new version of the PIC24HJ256GP610 PIM which now uses a PIC24HJ256GP610A.

To help, included here are two diagrams of the wiring needed. Note that the Mega has specific I2C pins available while the Uno uses Analog pin 4 for SDA and Analog pin 5 for SCL. SDA is the data line, and SCL is the clock line.

The Arduino has pull up resistors built in and the Compass Module has them as well so there is no need to add them in this case.

Both the wiring diagrams and the code will read the compass module twice per second and send it out via serial to the computer where it can be viewed by a serial aware program like the serial viewer in the Arduino software.

Wiring up the Uno, connect the following:

• +5V and GND connects from the UNO to the “hv” side of the level converter
• +3.3V and GND connects from the UNO to the “lv” side of the level converter
• Connect Analog pin A4 from the UNO to Ch1 TXO on the level converter
• Connect Analog pin A5 from the UNO to Ch2 TXO on the level converter
• +3.3V from the UNO also connects to the VCC on the compas module
• GND from the UNO connects to the GND on the compas module
• SDA on the compas module connects to Ch1 TXI on the level converter
• SCL on the compas module connects to Ch2 TXI on the level converter

See the following picture for details

How to wire the compass module to the Arduino Uno via the level shifter from Sparkfun
Wiring up the Uno, connect the following:

• +5V and GND connects from the MEGA to the “hv” side of the level converter
• +3.3V and GND connects from the MEGA to the “lv” side of the level converter
• Connect  pin 21 SCL from the MEGA to Ch1 TXO on the level converter
• Connect pin 20 SDA from the MEGA to Ch2 TXO on the level converter
• +3.3V from the UNO also connects to the VCC on the compas module
• GND from the UNO connects to the GND on the compas module
• SDA on the compas module connects to Ch1 TXI on the level converter
• SCL on the compas module connects to Ch2 TXI on the level converter

See the following picture for details

How to wire the Sparkfun Compass Module to the Arduino Mega 2560

The source code.

And here is the code, inspired by the code posted by Vaibhav Bhawsar. Note the source is the same for both boards.

#include <Wire.h>              // Where all the routines for controlling
                               //    the I2C bus are
int HMC6352 = 0x42;            // device address from the data sheet
int slaveAddress;              // variable to hold the slave address
int ledPin = 13;               // LED on the Arduino board
boolean ledState = false;      // state of the LED for the flash routine
byte headingFromCompass[2];    // array to store the two byte data from compass
int i;                         // array element id
int heading;                   // calculated heading for printing

void setup()
{
  slaveAddress = HMC6352 >> 1;   // The wire library only wants the 7 most significant
                                  //   bits of the address.
  Serial.begin(9600);            // Start Serial, change baud rate to suit
  pinMode(ledPin, OUTPUT);       // Set the LED pin as output to show program is running
  Wire.begin();                  // Initialise the Two Wire Interface (I2C)
}

void loop()
{
  ledState = !ledState;
  if (ledState)
  {
    digitalWrite(ledPin,HIGH);
  }
  else
  {
    digitalWrite(ledPin,LOW);
  }

Wire.beginTransmission(slaveAddress);
  Wire.send(0x41);                          // Send the Get Data command
  Wire.endTransmission();
  delay(10);                                // The HMC6352 needs 70us delay
  Wire.requestFrom(slaveAddress, 2);        // Request 2 bytes of data (MSB then LSB)
  i = 0;                                    // This is used as the array element pointer for
                                            //   data
  while(Wire.available() && i < 2)          // We're receiving data
  {
    headingFromCompass[i] = Wire.receive(); // Put the data into the array element
    i++;                                    // increment for the next data piece
  }
  heading = headingFromCompass[0]*256 + headingFromCompass[1];  // Combine MSB and LSB
  // Change the following output to suit your application
  Serial.print("Heading: ");
  Serial.print(int (heading / 10));     // The whole number part of the heading
  Serial.print(".");
  Serial.print(int (heading % 10));     // The fractional part of the heading
  Serial.println(" degrees");
  delay(500);
}

Error – Device not specified. Use /p option to specify a device.

Setting the /p option is simple, click ‘Project – Build Options – Project’, go to the MPLINK Linker tab. Then check the ‘Use Alternate Settings’ check box.

The default string will look like:

/m”$(BINDIR_)$(TARGETBASE).map” /w /o”$(BINDIR_)$(TARGETBASE).cof”

Change this to:

/m”$(BINDIR_)$(TARGETBASE).map” /w /p18F2450  /o”$(BINDIR_)$(TARGETBASE).cof”

using your processor instead of the /p18F2450 in the above example. Note, there is no space between the p and the 1. It’s just the font makes it look like there is.