Teensy 3.6 + OLED 128x32 + Volt meter

Video

Please click thumbnail image to start the video

Video on Teensy 3.6 + OLED 128x32 + Volt meter

Photo

Teensy 3.6 + OLED 128x32 + Volt meter
Teensy 3.6 + OLED 128x32 + Volt meter
Teensy 3.6 + OLED 128x32 + Volt meter
Teensy 3.6 + OLED 128x32 + Volt meter

Sketch

// Teensy 3.6 and OLED display
// Copyright (C) 2019 https://www.roboticboat.uk
// 7cf2a4c4-2742-49a0-b8ae-4111a6ceb6a6
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
// These Terms shall be governed and construed in accordance with the laws of
// England and Wales, without regard to its conflict of law provisions.
#include <stdlib.h>
#include <Wire.h>
#include <SD.h>
//If you are getting all NMEA statements, some have more than 25 fields
#define MAXNUMFIELDS 25
#define MAXFIELDLENGTH 11
#define MAXLENGTH 120
#define TIMEOUT_MICROSECONDS 1000
#define pgm_read_byte(addr) (*(const unsigned char *)(addr))
#define OLED_WIDTH 128
#define OLED_HEIGHT 32
#define FONT_WIDTH 5
#define FONT_HEIGHT 8
//-------------------------------
//These variables are volitile as could be updated (in other code) using events
//Volatile tells the compiler not to chase thse variables in its code optimisation
int i=0;
volatile int ptr = 0;
volatile bool flag = true;
volatile char redbuffer[MAXLENGTH];
volatile char blubuffer[MAXLENGTH];
char gpsfields[MAXNUMFIELDS][MAXFIELDLENGTH];
float gpsdate;
int gpstime;
float latitude;
float longitude;
float altitude;
char str_oled[40];
char latNS, lonEW;
char gpsstatus = 'x';
int fixquality;
int numsatelites;
// Timer
int mytime;
int lasttime;
//LED light
bool islighton = false;
// Volatage monitor
int val = 0;
float voltage = 0.0;
float pinmaxvolt = 3.3;
float ratio = 5;
// Allocate memory to store the screen pixels
static uint8_t screen[OLED_WIDTH * OLED_HEIGHT / FONT_HEIGHT] = { 0x00 };
static const unsigned char fonttable[] PROGMEM = {
0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x1C, 0x22, 0x41, 0x00, // (
0x00, 0x41, 0x22, 0x1C, 0x00, // )
0x2A, 0x1C, 0x7F, 0x1C, 0x2A, // *
0x08, 0x08, 0x3E, 0x08, 0x08, // +
0x00, 0x80, 0x70, 0x30, 0x00, // ,
0x08, 0x08, 0x08, 0x08, 0x08, // -
0x00, 0x00, 0x60, 0x60, 0x00, // .
0x20, 0x10, 0x08, 0x04, 0x02, // /
0x3E, 0x41, 0x41, 0x41, 0x3E, // 0
0x00, 0x00, 0x7F, 0x00, 0x00, // 1
0x72, 0x49, 0x49, 0x49, 0x46, // 2
0x22, 0x41, 0x49, 0x49, 0x36, // 3
0x18, 0x14, 0x12, 0x7F, 0x10, // 4
0x4F, 0x49, 0x49, 0x49, 0x31, // 5
0x3E, 0x49, 0x49, 0x49, 0x32, // 6
0x01, 0x71, 0x09, 0x09, 0x07, // 7
0x36, 0x49, 0x49, 0x49, 0x36, // 8
0x26, 0x49, 0x49, 0x49, 0x3E, // 9
0x00, 0x00, 0x14, 0x00, 0x00, // :
0x00, 0x40, 0x34, 0x00, 0x00, // ;
0x00, 0x08, 0x14, 0x22, 0x41, // <
0x14, 0x14, 0x14, 0x14, 0x14, // =
0x00, 0x41, 0x22, 0x14, 0x08, // >
0x02, 0x01, 0x59, 0x09, 0x06, // ?
0x3E, 0x41, 0x5D, 0x59, 0x4E, // @
0x7E, 0x11, 0x11, 0x11, 0x7E, // A
0x7F, 0x49, 0x49, 0x49, 0x36, // B
0x3E, 0x41, 0x41, 0x41, 0x22, // C
0x7F, 0x41, 0x41, 0x41, 0x3E, // D
0x7F, 0x49, 0x49, 0x49, 0x41, // E
0x7F, 0x09, 0x09, 0x09, 0x01, // F
0x3E, 0x41, 0x41, 0x49, 0x3A, // G
0x7F, 0x08, 0x08, 0x08, 0x7F, // H
0x00, 0x41, 0x7F, 0x41, 0x00, // I
0x20, 0x40, 0x41, 0x3F, 0x01, // J
0x7F, 0x08, 0x14, 0x22, 0x41, // K
0x7F, 0x40, 0x40, 0x40, 0x40, // L
0x7F, 0x02, 0x0C, 0x02, 0x7F, // M
0x7F, 0x04, 0x08, 0x10, 0x7F, // N
0x3E, 0x41, 0x41, 0x41, 0x3E, // O
0x7F, 0x09, 0x09, 0x09, 0x06, // P
0x3E, 0x41, 0x51, 0x21, 0x5E, // Q
0x7F, 0x09, 0x19, 0x29, 0x46, // R
0x26, 0x49, 0x49, 0x49, 0x32, // S
0x01, 0x01, 0x7F, 0x01, 0x01, // T
0x3F, 0x40, 0x40, 0x40, 0x3F, // U
0x1F, 0x20, 0x40, 0x20, 0x1F, // V
0x3F, 0x40, 0x38, 0x40, 0x3F, // W
0x63, 0x14, 0x08, 0x14, 0x63, // X
0x03, 0x04, 0x78, 0x04, 0x03, // Y
0x61, 0x51, 0x49, 0x45, 0x43, // Z
0x00, 0x7F, 0x41, 0x41, 0x41, // [
0x02, 0x04, 0x08, 0x10, 0x20, //
0x00, 0x41, 0x41, 0x41, 0x7F, // ]
0x04, 0x02, 0x01, 0x02, 0x04, // ^
0x40, 0x40, 0x40, 0x40, 0x40, // _
0x00, 0x03, 0x07, 0x08, 0x00, // `
0x20, 0x54, 0x54, 0x78, 0x40, // a
0x7F, 0x28, 0x44, 0x44, 0x38, // b
0x38, 0x44, 0x44, 0x44, 0x28, // c
0x38, 0x44, 0x44, 0x28, 0x7F, // d
0x38, 0x54, 0x54, 0x54, 0x18, // e
0x00, 0x08, 0x7E, 0x09, 0x02, // f
0x18, 0xA4, 0xA4, 0x9C, 0x78, // g
0x7F, 0x08, 0x04, 0x04, 0x78, // h
0x00, 0x44, 0x7D, 0x40, 0x00, // i
0x20, 0x40, 0x40, 0x3D, 0x00, // j
0x7F, 0x10, 0x28, 0x44, 0x00, // k
0x00, 0x41, 0x7F, 0x40, 0x00, // l
0x7C, 0x04, 0x78, 0x04, 0x78, // m
0x7C, 0x08, 0x04, 0x04, 0x78, // n
0x38, 0x44, 0x44, 0x44, 0x38, // o
0xFC, 0x18, 0x24, 0x24, 0x18, // p
0x18, 0x24, 0x24, 0x18, 0xFC, // q
0x7C, 0x08, 0x04, 0x04, 0x08, // r
0x48, 0x54, 0x54, 0x54, 0x24, // s
0x04, 0x04, 0x3F, 0x44, 0x24, // t
0x3C, 0x40, 0x40, 0x20, 0x7C, // u
0x1C, 0x20, 0x40, 0x20, 0x1C, // v
0x3C, 0x40, 0x30, 0x40, 0x3C, // w
0x44, 0x28, 0x10, 0x28, 0x44, // x
0x4C, 0x90, 0x90, 0x90, 0x7C, // y
0x44, 0x64, 0x54, 0x4C, 0x44, // z
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x14, 0x08, 0x14, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00
};
int8_t _i2caddr;
int16_t _positionx;
int16_t _positiony;
void setup()
{
// Keep the User informed
Serial.begin(9600);
// initialize the LED pin as an output.
pinMode(13, OUTPUT);
// Setup the input pins used received by the RC receiver
pinMode(14, INPUT);
// initialize with the I2C addr 0x3C (for the 128x32)
// 4 = reset pin
begin(0x3C, 4);
clearDisplay();
setPosition(0,0);
println("Checking SD card...");
//sprintf(str_oled, "%f", (double)latitude); println(str_oled);
//println("ABCDEFGHIJKLMNOPQRSTU");
//println("abcdefghijklmnopqrstu");
update_display();
// Start up the GPS
Serial1.begin(9600);
delay(100);
Serial1.println("$PMTK314,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0*28");
delay(100);
// 1MHz update
Serial1.println("$PMTK220,1000*1F");
delay(100);
// Initialise the SD card
InitialiseSDcard(10);
}
void serialEvent1()
{
//This event is called when Serial1 receives new bytes
while (Serial1.available())
{
// Read the new byte:
gpsread((char)Serial1.read());
}
}
void loop()
{
//Timer
mytime = millis();
// Has 1 seconds passed yet?
// Approx once an hour this will roll over to zero again.
if (abs(mytime - lasttime) > 1000)
{
// So we enter this section every 1 second
lasttime = mytime;
//The GPS signal must be active (not void)
if (gpsstatus == 'A')
{
//Flash the light when receiving a GPS signal
if (islighton)
{
// Turn off the light
digitalWrite(13, LOW);
islighton = false;
}
else
{
// Turn on the light
digitalWrite(13, HIGH);
islighton = true;
}
}
else
{
// Turn off the light as no valid GPS location
digitalWrite(13, LOW);
islighton = false;
}
}
val = analogRead(A0);
voltage = val * pinmaxvolt * ratio / 1024;
// Print data to Serial Monitor window
Serial.print("v1,$TMR,");
Serial.print(mytime);
Serial.print(",$VIN,");
Serial.print(voltage);
Serial.print(",$GPS,");
Serial.print(gpsdate,0);
Serial.print(",");
Serial.print(gpstime);
Serial.print(",");
Serial.print(latitude,8);
Serial.print(",");
Serial.print(latNS);
Serial.print(",");
Serial.print(longitude,8);
Serial.print(",");
Serial.print(lonEW);
Serial.print(",");
Serial.print(altitude);
Serial.print(",");
Serial.print(fixquality);
Serial.print(",");
Serial.print(numsatelites);
Serial.print(",");
Serial.println(gpsstatus);
clearDisplay();
setPosition(0,0);
sprintf(str_oled, "%d %.2f V", mytime, voltage); println(str_oled);
sprintf(str_oled, "%f", (double)latitude); println(str_oled);
sprintf(str_oled, "%f", (double)longitude); println(str_oled);
sprintf(str_oled, "%d %.0f %d", numsatelites,gpsdate,gpstime); println(str_oled);
update_display();
File dataFile = SD.open("datalog.txt", FILE_WRITE);
if (dataFile)
{
dataFile.print("v1,$TMR,");
dataFile.print(mytime);
dataFile.print(",$VIN,");
dataFile.print(voltage);
dataFile.print(",$GPS,");
dataFile.print(gpsdate,0);
dataFile.print(",");
dataFile.print(gpstime);
dataFile.print(",");
dataFile.print(latitude,8);
dataFile.print(",");
dataFile.print(latNS);
dataFile.print(",");
dataFile.print(longitude,8);
dataFile.print(",");
dataFile.print(lonEW);
dataFile.print(",");
dataFile.print(altitude);
dataFile.print(",");
dataFile.print(fixquality);
dataFile.print(",");
dataFile.print(numsatelites);
dataFile.print(",");
dataFile.println(gpsstatus);
dataFile.close();
}
delay(500);
}
void gpsread(char nextChar){
//Serial.print(nextChar);
// Start of a GPS message
if (nextChar == '$') {
if (flag) {
//Reset the message as we have a starting character $
redbuffer[ptr] = '\0';
}
else {
//Reset the message as we have a starting character $
blubuffer[ptr] = '\0';
}
//Reset the string pointer to the start of the string
ptr = 0;
}
// Do we have the end of a GPS message?
if (nextChar == '\n') {
if (flag) {
flag = false;
redbuffer[ptr] = '\0';
// Do we have a valid GPS message?
if (CheckSum((char*) redbuffer )) {
parseString((char*) redbuffer );
checkGPGGA();
checkGPRMC();
}
}
else
{
flag = true;
blubuffer[ptr] = '\0';
// Do we have a valid GPS message?
if (CheckSum((char*) blubuffer )) {
parseString((char*) blubuffer );
checkGPGGA();
checkGPRMC();
}
}
ptr = 0;
}
// Add a new character
if (flag) {
redbuffer[ptr] = nextChar;
}
else {
blubuffer[ptr] = nextChar;
}
ptr++;
if (ptr >= MAXLENGTH) {
ptr = MAXLENGTH-1;
}
}
bool CheckSum(char* msg) {
// Check the checksum
//$GPGGA,.........................0000*6A
// Length of the GPS message
int len = strlen(msg);
// Does it contain the checksum, to check
if (msg[len-4] == '*')
{
// Read the checksum from the message
int cksum = 16 * Hex2Dec(msg[len-3]) + Hex2Dec(msg[len-2]);
// Loop over message characters
for (int i=1; i < len-4; i++) {
cksum ^= msg[i];
}
// The final result should be zero
if (cksum == 0)return true;
}
return false;
}
void checkGPGGA() {
// $GPGGA,094728.000,5126.4900,N,00016.0200,E,2,08,1.30,19.4,M,47.0,M,0000,0000*52
// Do we have a GPGGA message?
if (strstr(gpsfields[0], "$GPGGA")) {
gpstime = atol(gpsfields[1]); // 094728.000
latitude = atof(gpsfields[2]); // 5126.4900
latNS = gpsfields[3][0]; // N
longitude = atof(gpsfields[4]); // 00016.0200
lonEW = gpsfields[5][0]; // E
fixquality = atof(gpsfields[6]); // Fix quality (1=GPS)(2=DGPS)
numsatelites = atoi(gpsfields[7]); // Number of satellites being tracked
// Horizontal dilution of position
altitude = atof(gpsfields[9]); // Altitude above mean sea level, Meters
// Height of geoid (mean sea level)
// Time in seconds since last DGPS update
// DGPS station ID number
// the checksum data, always begins with *
latitude = DegreeToDecimal(latitude, latNS);
longitude = DegreeToDecimal(longitude, lonEW);
}
}
void checkGPRMC() {
// $GPRMC,094728.000,A,5126.4900,N,00016.0200,E,0.01,259.87,310318,,,D*6B
// Do we have a GPRMC message?
if (strstr(gpsfields[0], "$GPRMC")) {
gpstime = atol(gpsfields[1]); // 094728.000
gpsstatus = gpsfields[2][0]; // Status A=active or V=Void.
latitude = atof(gpsfields[3]); // 5126.4900
latNS = gpsfields[4][0]; // N
longitude = atof(gpsfields[5]); // 00016.0200
lonEW = gpsfields[6][0]; // E
// Speed over the ground in knots
// Track angle in degrees True
gpsdate = atof(gpsfields[9]); // Date - 31st of March 2018
// Magnetic Variation
// The checksum data, always begins with *
latitude = DegreeToDecimal(latitude, latNS);
longitude = DegreeToDecimal(longitude, lonEW);
}
}
float DegreeToDecimal(float num, byte sign)
{
// Want to convert DDMM.MMMM to a decimal number DD.DDDDD
int intpart= (int) num;
float decpart = num - intpart;
int degree = (int)(intpart / 100);
int mins = (int)(intpart % 100);
if (sign == 'N' || sign == 'E')
{
// Return positive degree
return (degree + (mins + decpart)/60);
}
// Return negative degree
return -(degree + (mins + decpart)/60);
}
void parseString(char* msg) {
// Length of the GPS message
int len = strlen(msg);
int n=0;
int j=0;
//Serial.println(msg);
// Loop over the string
for (int i=0; i<len; i++) {
if(msg[i] == ',' || msg[i] == '*') {
if (j == 0) {
gpsfields[n][0] = '_';
gpsfields[n][1] = '\0';
}
n++;
//Check for overflow
if (n == MAXNUMFIELDS){n--;}
j=0;
}
else {
gpsfields[n][j] = msg[i];
j++;
gpsfields[n][j] = '\0';
}
}
}
// Convert HEX to DEC
int Hex2Dec(char c) {
if (c >= '0' && c <= '9') {
return c - '0';
}
else if (c >= 'A' && c <= 'F') {
return (c - 'A') + 10;
}
else {
return 0;
}
}
void InitialiseSDcard(int testseconds)
{
Serial.print("Initializing SD card...");
if (!SD.begin(BUILTIN_SDCARD)) {
Serial.println("SD failed");
for (i=1;i<=testseconds;i++)
{
digitalWrite(13, HIGH);
delay(100);
digitalWrite(13, LOW);
delay(900);
}
return;
}
Serial.println("done.");
if (ReadWriteTest()){
Serial.println("OK");
digitalWrite(13, HIGH);
delay(testseconds * 1000);
digitalWrite(13, LOW);
}
else
{
Serial.println("ERROR");
for (i=1;i<=testseconds;i++)
{
digitalWrite(13, HIGH);
delay(500);
digitalWrite(13, LOW);
delay(500);
}
}
}
void InfoTest()
{
Sd2Card SDcard;
SdVolume volume;
SdFile root;
// Card information
Serial.print("\nCard info: ");
switch(SDcard.type()) {
case SD_CARD_TYPE_SD1:
Serial.print("SD1"); break;
case SD_CARD_TYPE_SD2:
Serial.print("SD2"); break;
case SD_CARD_TYPE_SDHC:
Serial.print("SDHC"); break;
default:
Serial.print("Unknown");
}
// Find the volume on the SD card
if (!volume.init(SDcard)) {
Serial.println("\nNo FAT16/FAT32 partition.");
return;
}
// FAT type
uint32_t volumesize;
Serial.print(", FAT"); Serial.print(volume.fatType(), DEC);
Serial.print(", ");
// Sector size (or Blocks) is fixed at 512 bytes
volumesize = volume.blocksPerCluster() * volume.clusterCount() * 512;
Serial.print(volumesize/1024);
Serial.println(" Kb");
Serial.println("\nFiles on the SD card: ");
root.openRoot(volume);
// list all files in the card with date and size
root.ls(LS_R | LS_DATE | LS_SIZE);
}
bool ReadWriteTest()
{
File myFile;
char filename[] = "testfile.txt";
char writestring[] = "abcdefghijklmnopqrstuvwxyz1234567890";
char readstring[40];
// First remove the file is it already exists
if (SD.exists(filename)) {
SD.remove(filename);
}
// Open file to write
myFile = SD.open(filename, FILE_WRITE);
// If okay, write to the file
if (myFile) {
Serial.print("Writing to file... ");
myFile.print(writestring);
myFile.close();
Serial.print('[');
Serial.print(writestring);
Serial.println("] done.");
}
else
{
// Error writing to the file
Serial.println("error opening testfile.txt");
}
// Open file to read. Which is the default option
myFile = SD.open(filename, FILE_READ);
if (myFile) {
Serial.print("Reading from file...");
int n = 0;
while (myFile.available()) {
if (n<39)
{
readstring[n] = myFile.read();
readstring[n+1] = '\0';
}
n=n+1;
}
myFile.close();
Serial.print('[');
Serial.print(readstring);
Serial.println("] done.");
}
else
{
// Error reading from the file
Serial.println("error opening testfile.txt");
}
// Return true if the two char arrays are equal
if (strcmp(writestring, readstring) == 0){
return true;
}
return false;
}
void i2c_command(uint8_t cmd)
{
// Begin the transmission
Wire.beginTransmission(_i2caddr);
// Address of the control register
Wire.write(0x00);
// Send the command
Wire.write(cmd);
// Send the transmission
Wire.endTransmission();
}
void begin(uint8_t i2caddr, int8_t resetpin) {
_i2caddr = i2caddr;
_positionx = 0;
_positiony = 0;
// starting the I2C bus
Wire.begin();
// Setup reset pin direction
pinMode(resetpin, OUTPUT);
// Set reset high
digitalWrite(resetpin, HIGH);
// VDD (3.3V) goes high at start
delay(100);
// Set reset low
digitalWrite(resetpin, LOW);
// wait 100ms
delay(100);
// Set reset high
digitalWrite(resetpin, HIGH);
// Initialization procedure
// Set Display Off
i2c_command(0xAE);
// Set Display Clock Ratio
i2c_command(0xD5);
// Set Display Clock Oscillator Frequency
i2c_command(0x80);
// Set Multiplex Ratio
i2c_command(0xA8);
i2c_command(OLED_HEIGHT - 1);
// Set Display Offset
i2c_command(0xD3);
i2c_command(0x00);
// Set Display Start Line
i2c_command(0x40);
// Set Charge Pump Regulator
i2c_command(0x8D);
i2c_command(0x14);
// Set Low Power Display Mode
i2c_command(0xD8);
i2c_command(0x05);
// There are 3 different memory addressing mode in SSD1306:
// page, horizontal and vertical addressing mode
i2c_command(0x20);
i2c_command(0x00);
// Set Segment Re-Map
i2c_command(0xA1);
// Set COM Output Scan Direction
i2c_command(0xC8);
// Set COM Pins Hardware Configuration
i2c_command(0xDA);
// 128x32 display set = 0x02
// 128x64 display set = 0x12. Otherwise alternate blank rows
i2c_command(0x02);
// Set Contract Control
i2c_command(0x81);
i2c_command(0x8F);
// Set Pre-Charge Period
i2c_command(0xD9);
i2c_command(0xF1);
// Set VCOMH Deselect Level
i2c_command(0xDB);
i2c_command(0x40);
// Set Entire Display On/Off
i2c_command(0xA4);
// Set Normal/Inverse Display
i2c_command(0xA6);
// Set Display On
i2c_command(0xAF);
delay(100);
// Set Column Address
// This triple byte command specifies column start address and
// end address of the display data RAM
i2c_command(0x21);
i2c_command(0);
i2c_command(OLED_WIDTH-1);
// Set Page Address
// This triple byte command specifies page start address and
// end address of the display data RAM.
i2c_command(0x22);
i2c_command(0);
i2c_command(OLED_HEIGHT/FONT_HEIGHT - 1);
}
void setPosition(int16_t x, int16_t y) {
_positionx = x;
_positiony = y;
}
void update_display(void)
{
// i2c
for (uint16_t i=0; i<(OLED_WIDTH * OLED_HEIGHT / FONT_HEIGHT); i++)
{
// Begin i2c message
Wire.beginTransmission(_i2caddr);
// Display Start Line Register
Wire.write(0x40);
for (uint8_t x=0; x < FONT_HEIGHT-1; x++)
{
Wire.write(screen[i]);
i++;
}
Wire.write(screen[i]);
// End the i2c transmission
Wire.endTransmission();
}
}
size_t writeOLED(uint8_t c) {
// Newline?
if(c == '\n')
{
// Set to the start of the row
_positionx = 0;
// Move to the next row
_positiony = _positiony + FONT_HEIGHT;
}
else if(c != '\r')
{
// Too far to the right?
if ((_positionx + FONT_WIDTH +1) > OLED_WIDTH)
{
// Set to the start of the row
_positionx = 0;
// Move to the next row
_positiony = _positiony + FONT_HEIGHT;
}
// Print the character to the screen
drawChar(_positionx, _positiony, c);
// Advance 1 character position
_positionx = _positionx + FONT_WIDTH +1;
}
return 1;
}
void drawChar(int16_t x, int16_t y, unsigned char c) {
// Check pixel is within the screen area
if ((x >= OLED_WIDTH) || (y >= OLED_HEIGHT) || ((x + FONT_WIDTH) < 0) || ((y + FONT_HEIGHT-1) < 0)) return;
// Characters are 5 bits wide and have a separating blank bit
for(int8_t i=0; i < FONT_WIDTH; i++ )
{
uint8_t mybyte = pgm_read_byte(&fonttable[c * FONT_WIDTH + i]);
for(int8_t j=0; j<FONT_HEIGHT; j++, mybyte >>= 1)
{
if (mybyte & 1) {drawPixel(x + i, y + j);}
}
}
}
void drawPixel(int16_t x, int16_t y) {
// Pixel is within the screen area
if ((x < 0) || (x >= OLED_WIDTH) || (y < 0) || (y >= OLED_HEIGHT)) return;
// Fill in the Pixel
screen[x+ (y/FONT_HEIGHT) * OLED_WIDTH] |= (1 << (y&(FONT_HEIGHT-1)));
}
// Clear the screen
void clearDisplay(void)
{
memset(screen, 0, (OLED_WIDTH * OLED_HEIGHT / FONT_HEIGHT));
}
void println(const char c[])
{
size_t i;
for (i=0; i< strlen(c); i++){
writeOLED(c[i]);
}
writeOLED('\r');
writeOLED('\n');
}
view raw sketch_TEENSY_OLED_128x32_GPS_b2.ino hosted with ❤ by GitHub
RoboticBoat.uk