I2C Support?

[maxsrobotics]

Hey,

This library works well for use with UART applications. I wanted to suggest adding I2C support for those who don't want to work with the latency and efficiency of UART, using the Wire.h library..

Thanks!
W0MXX

[loginov-rocks]

Hi @maxsrobotics , do you have u-blox modules working over I2C?

[maxsrobotics]

Yes, my friend and I were able to get data (HEX codes) directly from the module over I2C. It's just a simple Wire.requestFrom, and then some reads over Wire.h. I'm not at my main computer with the working code right now, but in an hour or so I can post my I2C read script. Thanks so much for helping out!

Thanks,
Max W0MXX

[loginov-rocks]

Hi @maxsrobotics, it would be very interesting to take a look at the code! Can't guarantee I would be able to integrate it, because I don't have such a module, but let's see... What exact module from u-blox do you use? Is it on a board or do you connect directly? I2C is an interesting option, please share links/pics?

[maxsrobotics]

Yea, I am using the MAX-M10S that I picked up from DigiKey, and I have been testing it from the Sparkfun GPS library: https://github.com/sparkfun/SparkFun_u-blox_GNSS_v3

Here's some code that I modified from Dave Akerman's FlexTrack sketch that is able to read and parse UBX packets over I2C from the module:

`#define GPS_I2C

#ifdef GPS_I2C
// #include <Wire.h>
#include <I2C.h>
#endif

struct TGPS
{
int Hours, Minutes, Seconds;
unsigned long SecondsInDay; // Time in seconds since midnight
float Longitude, Latitude;
long Altitude;
unsigned int Satellites;
int Speed;
int Direction;
byte FixType;
byte psm_status;
float InternalTemperature;
float BatteryVoltage;
float ExternalTemperature;
float Pressure;
unsigned int BoardCurrent;
unsigned int errorstatus;
byte FlightMode;
byte PowerMode;
int CutdownStatus;
} GPS;

// Globals
byte RequiredFlightMode=0;
byte GlonassMode=0;
byte RequiredPowerMode=-1;
byte LastCommand1=0;
byte LastCommand2=0;
byte HaveHadALock=0;

char Hex(char Character)
{
char HexTable[] = "0123456789ABCDEF";

return HexTable[Character];
}

void FixUBXChecksum(unsigned char *Message, int Length)
{
int i;
unsigned char CK_A, CK_B;

CK_A = 0;
CK_B = 0;

for (i=2; i<(Length-2); i++)
{
CK_A = CK_A + Message[i];
CK_B = CK_B + CK_A;
}

Message[Length-2] = CK_A;
Message[Length-1] = CK_B;
}

void SendUBX(unsigned char *Message, int Length)
{
LastCommand1 = Message[2];
LastCommand2 = Message[3];

#ifdef GPS_I2C
I2c.write(0x42, 0, Message, Length);
#else
int i;

for (i=0; i<Length; i++)
{
Serial.write(Message[i]);
}
#endif
}

void DisableNMEAProtocol(unsigned char Protocol)
{
unsigned char Disable[] = { 0xB5, 0x62, 0x06, 0x01, 0x08, 0x00, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00};

Disable[7] = Protocol;

FixUBXChecksum(Disable, sizeof(Disable));

SendUBX(Disable, sizeof(Disable));

// Serial.print("Disable NMEA "); Serial.println(Protocol);
}

void SetFlightMode(byte NewMode)
{
// Send navigation configuration command
unsigned char setNav[] = {0xB5, 0x62, 0x06, 0x24, 0x24, 0x00, 0xFF, 0xFF, 0x06, 0x03, 0x00, 0x00, 0x00, 0x00, 0x10, 0x27, 0x00, 0x00, 0x05, 0x00, 0xFA, 0x00, 0xFA, 0x00, 0x64, 0x00, 0x2C, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0xDC};

setNav[8] = NewMode;

FixUBXChecksum(setNav, sizeof(setNav));

SendUBX(setNav, sizeof(setNav));
}

#ifdef POWERSAVING
void SetGNSSMode(void)
{
// Sets CFG-GNSS to disable everything other than GPS GNSS
// solution. Failure to do this means GPS power saving
// doesn't work. Not needed for MAX7, needed for MAX8's

uint8_t setGNSS[] = {
0xB5, 0x62, 0x06, 0x3E, 0x2C, 0x00, 0x00, 0x00,
0x20, 0x05, 0x00, 0x08, 0x10, 0x00, 0x01, 0x00,
0x01, 0x01, 0x01, 0x01, 0x03, 0x00, 0x00, 0x00,
0x01, 0x01, 0x03, 0x08, 0x10, 0x00, 0x00, 0x00,
0x01, 0x01, 0x05, 0x00, 0x03, 0x00, 0x00, 0x00,
0x01, 0x01, 0x06, 0x08, 0x0E, 0x00, 0x00, 0x00,
0x01, 0x01, 0xFC, 0x11};
SendUBX(setGNSS, sizeof(setGNSS));
}
#endif

#ifdef POWERSAVING
void SetPowerMode(byte SavePower)
{
uint8_t setPSM[] = {0xB5, 0x62, 0x06, 0x11, 0x02, 0x00, 0x08, 0x01, 0x22, 0x92 };

setPSM[7] = SavePower ? 1 : 0;

FixUBXChecksum(setPSM, sizeof(setPSM));

SendUBX(setPSM, sizeof(setPSM));
}
#endif

void ProcessUBX_ACK(unsigned char *Buffer, int Length)
{
if ((LastCommand1 == 0x06) && (LastCommand2 == 0x24))
{
GPS.FlightMode = RequiredFlightMode;
}
else if ((LastCommand1 == 0x06) && (LastCommand2 == 0x3E))
{
GlonassMode = 1;
}
else if ((LastCommand1 == 0x06) && (LastCommand2 == 0x11))
{
GPS.PowerMode = RequiredPowerMode;
}
LastCommand1 = 0;
LastCommand2 = 0;
}

void ProcessUBX_NAV_PVT(unsigned char *Buffer, int Length)
{
struct TUBlox
{
uint32_t GPSTime;
uint16_t Year;
uint8_t Month;
uint8_t Day;
uint8_t Hours;
uint8_t Minutes;
uint8_t Seconds;
uint8_t Valid;
uint32_t TimeAccuracy;
int32_t NanoSeconds;
uint8_t FixType;
uint8_t Flags;
uint8_t Reserved;
uint8_t Satellites;
int32_t Longitude;
int32_t Latitude;
int32_t HeightEllipsoid;
int32_t HeightSeaLevel;
uint32_t HAccuracy;
uint32_t VAccuracy;
} *UBlox;

UBlox = (struct TUBlox*)(Buffer+6);

GPS.FixType = UBlox->FixType;
GPS.Satellites = UBlox->Satellites;

if (UBlox->FixType > 0)
{
GPS.SecondsInDay = (UBlox->GPSTime / 1000) % 86400; // Time of day in seconds = Time in week in ms / 1000, mod 86400
GPS.Hours = UBlox->Hours; // GPS.SecondsInDay / 3600;
GPS.Minutes = UBlox->Minutes; // (GPS.SecondsInDay / 60) % 60;
GPS.Seconds = UBlox->Seconds; // GPS.SecondsInDay % 60;

if ((UBlox->FixType >= 2) && (UBlox->FixType <= 4))
{
  GPS.Longitude = (float)(UBlox->Longitude) / 10000000;
  GPS.Latitude = (float)(UBlox->Latitude) / 10000000;
  
  if ((UBlox->FixType >= 3) && (UBlox->FixType <= 4))
  {
    GPS.Altitude = UBlox->HeightSeaLevel / 1000;
  }
}

}

}

void ProcessUBX(unsigned char *Buffer, int Length)
{
if ((Buffer[2] == 0x05) && (Buffer[3] == 0x01))
{
ProcessUBX_ACK(Buffer, Length);
}
else if ((Buffer[2] == 1) && (Buffer[3] == 7))
{
ProcessUBX_NAV_PVT(Buffer, Length);
}
}

void ProcessNMEA(unsigned char *Buffer, int Count)
{
if (strncmp((char *)Buffer+3, "GGA", 3) == 0)
{
DisableNMEAProtocol(0);
}
else if (strncmp((char *)Buffer+3, "RMC", 3) == 0)
{
DisableNMEAProtocol(4);
}
else if (strncmp((char *)Buffer+3, "GSV", 3) == 0)
{
DisableNMEAProtocol(3);
}
else if (strncmp((char *)Buffer+3, "GLL", 3) == 0)
{
DisableNMEAProtocol(1);
}
else if (strncmp((char *)Buffer+3, "GSA", 3) == 0)
{
DisableNMEAProtocol(2);
}
else if (strncmp((char *)Buffer+3, "VTG", 3) == 0)
{
DisableNMEAProtocol(5);
}
}

void SetupGPS(void)
{
// Switch GPS on, if we have control of that
#ifdef GPS_ON
pinMode(GPS_ON, OUTPUT);
digitalWrite(GPS_ON, 1);
#endif

// Init I2C library if we're using it
#ifdef GPS_I2C
// Init i2c library
// Wire.begin();
I2c.begin();
#endif
}

int GPSAvailable(void)
{
int FD, FE, Bytes;

#ifdef GPS_I2C
// return Wire.available();
// return I2c.available();
I2c.read(0x42, 0xFD, 2); // Set up read from registers FD/FE - number of bytes available
FD = I2c.receive();
FE = I2c.receive();

Bytes = FD * 256 + FE;

if (Bytes > 32)
{
Bytes = 32;
}

if (Bytes > 0)
{
I2c.read(0x42, 0xFF, Bytes); // request 32 bytes from slave device 0x42 (Ublox default)
}

return Bytes;
#else
return Serial.available();
#endif
}

char ReadGPS(void)
{
#ifdef GPS_I2C
// return Wire.read();
return I2c.receive();
#else
return Serial.read();
#endif
}

void PollGPSTime(void)
{
uint8_t request[] = {0xB5, 0x62, 0x01, 0x21, 0x00, 0x00, 0x22, 0x67};
SendUBX(request, sizeof(request));
}

void PollGPSPosition(void)
{
// uint8_t request[] = {0xB5, 0x62, 0x01, 0x02, 0x00, 0x00, 0x03, 0x0A}; LLH
uint8_t request[] = {0xB5, 0x62, 0x01, 0x07, 0x00, 0x00, 0x08, 0x19};

SendUBX(request, sizeof(request));
}

void CheckGPS(void)
{
static unsigned long PollTime=0;
static unsigned char Line[128];
static int Length=0;
static int UBXLength=0;
static unsigned int PollMode=0;
unsigned char Character, Bytes, i;

do
{
Bytes = GPSAvailable();

for (i=0; i<Bytes; i++)
{ 
  Character = ReadGPS();

  if ((Character == 0xB5) && (Length <= 4))
  {
    Line[0] = Character;
    Length = 1;
  }
  else if ((Character == 0x62) && (Length <= 4))
  {
    if (Length == 0)
    {
      Line[0] = 0xB5;
    }
    Line[1] = Character;
    Length = 2;
  }
  else if ((Character == '$') && (Length == 0))
  {
    Line[0] = Character;
    Length = 1;
  }
  else if (Length >= (sizeof(Line)-2))
  {
    Length = 0;
  }
  else if (Length > 0)
  {
    if (Line[0] == 0xB5)
    {
      // UBX
      Line[Length++] = Character;
      if (Length == 6)
      {
        // Got UBX Length
        UBXLength = (int)Line[4] + (int)(Line[5]) * 256;
      }
      else if ((Length > 6) && (Length >= (UBXLength+8)))
      {
        ProcessUBX(Line, Length);
        
        LastCommand1 = Line[2];
        LastCommand2 = Line[3];
        
        Length = 0;
      }
    }
    else if (Line[0] == '$')
    {
      if (Character == '$')
      {
        Length = 1;
      }
      else if (Character != '\r')
      {
        Line[Length++] = Character;
        if (Character == '\n')
        {
          Line[Length] = '\0';
          ProcessNMEA(Line, Length);
          Length = 0;
        }
      }
    }
  }
}

} while (Bytes > 0);

if (millis() >= PollTime)
{
if (PollTime == 0)
{
PollTime = millis();
}
else
{
// PollTime += 200;
PollTime = millis() + 200;
}

Length = 0;

switch (PollMode)
{
  case 0:
    // Poll for position
    PollGPSPosition();
  break;
  
  case 1:
    // Flight/ped mode
    
    RequiredFlightMode = (GPS.Altitude > 1000) ? 6 : 3;    // 6 is airborne <1g mode; 3=Pedestrian mode
    if (RequiredFlightMode != GPS.FlightMode)
    {
      SetFlightMode(RequiredFlightMode);
      // Serial.println("Setting flight mode\n");
    }
  break;
  
  case 2:
    // Power saving
    #ifdef POWERSAVING
      if (!GlonassMode)
      {
        // Serial.println("*** SetGNSSMode() ***");
        SetGNSSMode();
      }
      else
      {           
        // All the following need to be true for us to try power saving mode
        RequiredPowerMode = (GPS.FixType==3) && (GPS.Satellites>=5);
        
        if (RequiredPowerMode != GPS.PowerMode)
        {
          // Serial.print("*** SetPowerMode("); Serial.print(RequiredPowerMode); Serial.println(") ***");
          SetPowerMode(RequiredPowerMode);
        }
      }
    #endif
  break;
}

if (++PollMode >= 3)
{
  PollMode = 0;
}

}
}

void setup() {
Serial.begin(9600);
delay(1000);
SetupGPS();
}

void loop() {
CheckGPS();
// Serial.print(GPS.Hours); Serial.print(":"); Serial.print(GPS.Minutes); Serial.print(":"); Serial.print(GPS.Seconds);Serial.print(" - ");
Serial.print("Lat: ");
Serial.print(GPS.Latitude, 6);
Serial.print(", Lon: ");
Serial.print(GPS.Longitude, 6);
Serial.print(", Alt: ");
Serial.print(GPS.Altitude);
Serial.print(", Sats: ");
Serial.println(GPS.Satellites);
delay(1000);
}`

Again, thanks so much for attempting this project!
Max W0MXX

[maxsrobotics]

Also, the board I'm using is a custom breakout board in KiCAD: