#include <Arduino.h>
#define _DEBUG_
#define _DISPLAY_
#ifdef _DISPLAY_
#define _BUTTON_
#define _LUXOMETER_
#include "TM1637_Mini.h"
#endif
#include "GPSport_config.h"
#include "NMEAGPS.h"
//#include <GPSport.h>
#ifdef _DEBUG_
#define DEBUG_PRINT(args...) DEBUG_PORT.print(args)
#define DEBUG_PRINTLN(args...) DEBUG_PORT.println(args)
#else
#define DEBUG_PRINT(args...)
#define DEBUG_PRINTLN(args...)
#endif
NMEAGPS gps; // This parses the GPS characters
gps_fix fix; // This holds on to the latest values
#include <SPI.h>
#include "SdFat_config.h"
#include <SdFat.h>
SdFat SD;
File32 trkFile;
#ifdef _DISPLAY_
const byte TM_CLK = 18;
const byte TM_DIO = 19;
#ifdef _BUTTON_
const byte BTN_PIN = 8;
#endif
#ifdef _LUXOMETER_
#include <Wire.h>
#include <BH1750.h>
BH1750 luxometro;
//const BH1750::Mode luxMode = CONTINUOUS_HIGH_RES_MODE;
#endif
TM1637 display(TM_CLK, TM_DIO);
#endif
// SPI pins
const byte SD_SCK = 2;
const byte SD_MOSI = 3;
const byte SD_MISO = 4;
const byte SD_CS = 5;
// I2C pins
const byte LX_SCL = 21;
const byte LX_SDA = 20;
// Serial pins
const byte SER1_RX = 1;
const byte SER1_TX = 0;
const byte SD_LED = 6;
const byte PWR_LED = 7;
const byte PWR_PIN = 26;
#ifdef _DISPLAY_
const char SCANNER[6][4] = {{45, 32, 32, 32}, {32, 45, 32, 32}, // "- ", " - "
{32, 32, 45, 32}, {32, 32, 32, 45}, // " - ", " -"
{32, 32, 45, 32}, {32, 45, 32, 32} // " - ", " - "
};
#ifdef _LUXOMETER_
const int THRESHOLD[7] = {1, 5, 50, 200, 500, 1000, 2000};
#endif
#endif
const int LOCAL_TIMEZONE = -3;
const int SECONDS_PER_HOUR = 3600;
const int32_t TIMEZONE_OFFSET = LOCAL_TIMEZONE * SECONDS_PER_HOUR;
const uint32_t DEBOUNCER_TIME = 20UL;
const uint32_t BATTERY_SAMPLE_TIME = 1 * 60000UL; // 5 min en mseg
const uint32_t BLINK_INTERVAL = 1000UL;
const uint32_t CHKBATT_INTERVAL = 1000UL;
const float VREF = 4.20; //5.0;
const float K_FACTOR = VREF / 1024.0;
const float VOLTS_PCT[21] = {3.31,3.68,3.69,3.71,3.74,3.76,3.77,3.78,
3.79,3.81,3.82,3.84,3.88,3.92,3.95,3.98,4.00,4.05,4.09,4.13,4.18};
bool validSDcard = true;
bool createFile = true;
bool validFix = false;
bool validTime = false;
bool validDate = false;
bool sdIndicator = false;
bool lowBattery = false;
bool chkBattery = true;
bool pwrLedStatus = true;
byte battPct;
#ifdef _BUTTON_
bool lastButtonState = false;
uint32_t showtimeTime;
#endif
uint32_t tkpCounter;
uint32_t sdIndicatorTime;
uint32_t repeatsCounter;
uint32_t repeatsControl;
uint32_t repeatsInterval;
uint32_t batteryTimeOld;
uint32_t blinkTimeOld;
uint32_t chkTimeOld;
String fileName;
struct memory_s {
float lat;
float lng;
float altitude;
float speed;
float course;
} memory;
#ifdef _DISPLAY_
enum dmode_e {
SHOWSPEED,
SHOWHOUR,
SHOWSECS,
SHOWBATT,
SHOWBATT_OK
};
dmode_e displayMode = SHOWSPEED;
#endif
NeoGPS::time_t localTime;
//------------------------------------------------------------------------------
// convierte UTC (del GPS) a hora local
void get_local_time(NeoGPS::time_t dt) {
NeoGPS::clock_t seconds = dt; // convert date/time structure to seconds
seconds += TIMEZONE_OFFSET;
localTime = seconds; // convert seconds back to a date/time structure
}
//------------------------------------------------------------------------------
#ifdef _BUTTON_
bool get_button(byte trigger) { // return true on pressed
bool state = false;
static bool oldState = false;
static bool debouncer = false;
static uint32_t oldTime = 0;
if (debouncer) {
if (millis() - oldTime >= DEBOUNCER_TIME) {
debouncer = false;
}
}
else {
state = (digitalRead(BTN_PIN) == trigger);
if (state != oldState) {
oldState = state;
debouncer = true;
oldTime = millis();
}
}
return oldState;
}
#endif
//------------------------------------------------------------------------------
void check_battery() {
static int count = 0;
static int samplesAcc = 0;
if (count < 10) {
samplesAcc += analogRead(PWR_PIN);
count++;
}
else {
float vBatt = samplesAcc / count * K_FACTOR;
DEBUG_PRINT(vBatt, 2);
DEBUG_PRINT(F("V - ADC: "));
DEBUG_PRINTLN(samplesAcc / count);
for (int i = 20; i >= 0; i--) {
if (vBatt >= VOLTS_PCT[i]) {
battPct = i * 5;
break;
}
else {
battPct = 0;
}
}
lowBattery = battPct <= 5;
samplesAcc = 0;
count = 0;
chkBattery = false;
}
}
//------------------------------------------------------------------------------
#ifdef _LUXOMETER_
uint8_t get_brightness() {
int lux = luxometro.readLightLevel();
for (uint8_t i = 0; i < 7; i++) {
if (lux <= THRESHOLD[i]) return i;
}
return 7;
}
#endif
//------------------------------------------------------------------------------
void read_gps_fix() {
while (gps.available(gpsPort)) {
fix = gps.read();
validFix = gps.is_safe();
}
}
//------------------------------------------------------------------------------
// call back for file timestamps
void dateTime(uint16_t* date, uint16_t* time) {
// return date using FAT_DATE macro to format fields
*date = FAT_DATE(localTime.year + 2000, localTime.month, localTime.date);
// return time using FAT_TIME macro to format fields
*time = FAT_TIME(localTime.hours, localTime.minutes, localTime.seconds);
}
//------------------------------------------------------------------------------
void setup() {
pinMode(PWR_LED, OUTPUT);
digitalWrite(PWR_LED, HIGH);
pinMode(SD_LED, OUTPUT);
digitalWrite(SD_LED, LOW);
#ifdef _BUTTON_
pinMode(BTN_PIN, INPUT_PULLUP);
#endif
fileName.reserve(22);
#ifdef _DEBUG_
// DEBUG_PORT.setRX(12);
// DEBUG_PORT.setTX(11);
DEBUG_PORT.begin(115200);
#endif
gpsPort.setRX(SER1_RX);
gpsPort.setTX(SER1_TX);
gpsPort.begin(115200);
SPI.setCS(SD_CS);
SPI.setRX(SD_MISO);
SPI.setTX(SD_MOSI);
SPI.setSCK(SD_SCK);
validSDcard = SD.begin(SD_CS);
digitalWrite(SD_LED, validSDcard ? HIGH : LOW);
/*
if(validSDcard) {
fileName = "adc.txt";
trkFile = SD.open(fileName, FILE_WRITE);
if(trkFile) {
for(int i=0; i<20;i++){
digitalWrite(SD_LED, LOW);
delay(100);
trkFile.println(analogRead(A0));
digitalWrite(SD_LED, HIGH);
delay(100);
}
trkFile.close();
}
}
*/
while (chkBattery) {
check_battery();
}
DEBUG_PRINT(F("Bateria: "));
DEBUG_PRINT(battPct);
DEBUG_PRINTLN(F("%"));
#ifdef _DISPLAY_
display.init();
#ifdef _LUXOMETER_
Wire.setSDA(LX_SDA);
Wire.setSCL(LX_SCL);
Wire.begin();
luxometro.begin (BH1750::CONTINUOUS_HIGH_RES_MODE); // (BH1750::ONE_TIME_HIGH_RES_MODE);
DEBUG_PRINTLN(luxometro.readLightLevel());
display.brightness(get_brightness());
#else
display.brightness(BRIGHT_TYPICAL);
#endif
display.point();
display.showStr(F("8888"));
delay(200);
display.displayOff();
delay(200);
display.displayOn();
delay(250);
display.clear();
delay(500);
uint32_t oldtime = millis();
byte i = 0;
while (!validFix) {
if (millis() - oldtime >= 200) {
oldtime = millis();
display.showStr(SCANNER[i]);
i++;
i %= 6;
}
read_gps_fix();
}
display.clear();
delay(250);
#else
read_gps_fix();
#endif
}
//------------------------------------------------------------------------------
void loop() {
#ifdef _BUTTON_
static uint32_t lastColonBlinkTime;
static uint32_t pressTime;
static bool hold = false;
bool newButtonState = get_button(LOW); // boton activo bajo
if (newButtonState && !lastButtonState) { // pulsado
pressTime = millis();
} else if (newButtonState && lastButtonState) { // retenido
if (!hold) {
if (millis() - pressTime >= 500UL) {
displayMode = SHOWBATT;
display.clear();
hold = true;
}
}
} else if (!newButtonState && lastButtonState) { // liberado
if (hold) {
hold = false;
}
display.clear();
switch (displayMode) {
case SHOWSPEED:
displayMode = SHOWHOUR;
lastColonBlinkTime = millis();
showtimeTime = lastColonBlinkTime;
break;
case SHOWHOUR:
displayMode = SHOWSECS;
lastColonBlinkTime = millis();
showtimeTime = lastColonBlinkTime;
break;
// case SHOWSECS:
// displayMode = SHOWSPEED;
// break;
// case SHOWBATT:
// displayMode = SHOWSPEED;
// break;
// case SHOWBATT_OK:
default:
displayMode = SHOWSPEED;
// break;
}
}
lastButtonState = newButtonState;
#endif
if (validFix) {
validDate = fix.valid.date && ((fix.dateTime.year + 2000) > 2020);
}
if (fix.valid.time && validDate) {
get_local_time(fix.dateTime);
}
#ifdef _DISPLAY_
#ifdef _LUXOMETER_
if (validFix) {
display.brightness(get_brightness());
}
#endif
#ifdef _BUTTON_
switch (displayMode) {
case SHOWSPEED:
if (validFix && fix.valid.speed) {
int speed = fix.speed_kph() + 0.5;
display.showNum(speed);
}
break;
case SHOWHOUR:
if (fix.valid.time && validDate) {
int16_t time = localTime.hours * 100 + localTime.minutes;
display.showClk(time);
lastColonBlinkTime = millis();
}
break;
case SHOWSECS:
if (fix.valid.time && validDate) {
display.point();
display.showNum(localTime.seconds, true, 2);
lastColonBlinkTime = millis();
}
break;
case SHOWBATT:
display.showBar(battPct);
displayMode = SHOWBATT_OK;
break;
default:
break;
}
#else
if (validFix && fix.valid.speed) {
int speed = fix.speed_kph() + 0.5;
display.showNum(speed);
}
#endif
#endif
if (validSDcard) {
if (createFile) {
if (fix.valid.time && validDate) {
char dt[20] = "00000000_000000.csv";
int loc_year = localTime.year + 2000;
dt[0] = loc_year / 1000 + 48;
dt[1] = loc_year % 1000 / 100 + 48;
dt[2] = loc_year % 100 / 10 + 48;
dt[3] = loc_year % 10 + 48;
dt[4] = localTime.month / 10 + 48;
dt[5] = localTime.month % 10 + 48;
dt[6] = localTime.date / 10 + 48;
dt[7] = localTime.date % 10 + 48;
dt[9] = localTime.hours / 10 + 48;
dt[10] = localTime.hours % 10 + 48;
dt[11] = localTime.minutes / 10 + 48;
dt[12] = localTime.minutes % 10 + 48;
dt[13] = localTime.seconds / 10 + 48;
dt[14] = localTime.seconds % 10 + 48;
fileName = dt;
// set date time callback function
SdFile::dateTimeCallback(dateTime);
trkFile = SD.open(fileName, FILE_WRITE);
if (trkFile) {
DEBUG_PRINTLN(fileName + F(" creado"));
sdIndicator = true;
sdIndicatorTime = millis();
digitalWrite(SD_LED, LOW);
trkFile.println(F("trackpoint,date,time,latitude,longitude,alt,speed,course"));
DEBUG_PRINTLN(F("trackpoint,date,time,latitude,longitude,alt,speed,course"));
//trkFile.sync();
trkFile.close();
createFile = false;
}
}
}
// DEBUG_PRINTLN("validFix = " + String(validFix));
if (validFix) {
bool newGpsData = fix.latitude() != memory.lat;
newGpsData |= fix.longitude() != memory.lng;
newGpsData |= fix.altitude() != memory.altitude;
newGpsData |= fix.speed_kph() != memory.speed;
newGpsData |= fix.heading() != memory.course;
repeatsCounter++;
repeatsControl++;
if (repeatsControl > 340UL) repeatsInterval = 45UL;
else if (repeatsControl > 160UL) repeatsInterval = 30UL;
else if (repeatsControl > 70UL) repeatsInterval = 15UL;
else if (repeatsControl > 10UL) repeatsInterval = 10UL;
else repeatsInterval = 1UL;
if ((newGpsData) || (repeatsCounter >= repeatsInterval)) { // si los datos son repetitivos los guarda cada "repeatsInterval" seg
repeatsCounter = 0;
if (newGpsData) repeatsControl = 0;
memory.lat = fix.latitude();
memory.lng = fix.longitude();
memory.altitude = fix.altitude();
memory.speed = fix.speed_kph();
memory.course = fix.heading();
trkFile = SD.open(fileName, FILE_WRITE);
if (trkFile) {
sdIndicatorTime = millis();
sdIndicator = true;
digitalWrite(SD_LED, LOW);
trkFile.print(++tkpCounter);
trkFile.print(F(","));
DEBUG_PRINT(tkpCounter);
DEBUG_PRINT(F(","));
char dt[12] = "0000/00/00,";
int loc_year = fix.dateTime.year + 2000;
dt[0] = loc_year / 1000 + 48;
dt[1] = loc_year % 1000 / 100 + 48;
dt[2] = loc_year % 100 / 10 + 48;
dt[3] = loc_year % 10 + 48;
// dt[4] = '/';
dt[5] = fix.dateTime.month / 10 + 48;
dt[6] = fix.dateTime.month % 10 + 48;
// dt[7] = dt[4];
dt[8] = fix.dateTime.date / 10 + 48;
dt[9] = fix.dateTime.date % 10 + 48;
// dt[10] = ',';
dt[11] = '\0';
trkFile.print(dt);
DEBUG_PRINT(dt);
strncpy(dt, "00:00:00,", 12);
dt[0] = fix.dateTime.hours / 10 + 48;
dt[1] = fix.dateTime.hours % 10 + 48;
// dt[2] = ':';
dt[3] = fix.dateTime.minutes / 10 + 48;
dt[4] = fix.dateTime.minutes % 10 + 48;
// dt[5] = dt[2];
dt[6] = fix.dateTime.seconds / 10 + 48;
dt[7] = fix.dateTime.seconds % 10 + 48;
// dt[8] = ',';
dt[9] = '\0';
trkFile.print(dt);
trkFile.print(fix.latitude(), 6) ;
trkFile.print(F(","));
trkFile.print(fix.longitude(), 6) ;
trkFile.print(F(","));
trkFile.print(fix.altitude(), 2);
trkFile.print(F(","));
trkFile.print(fix.speed_kph(), 2) ;
trkFile.print(F(","));
trkFile.println(fix.heading(), 2) ;
DEBUG_PRINT(dt);
DEBUG_PRINT(fix.latitude(), 6);
DEBUG_PRINT(F(","));
DEBUG_PRINT(fix.longitude(), 6);
DEBUG_PRINT(F(","));
DEBUG_PRINT(fix.altitude(), 2);
DEBUG_PRINT(F(","));
DEBUG_PRINT(fix.speed_kph(), 2);
DEBUG_PRINT(F(","));
DEBUG_PRINTLN(fix.heading(), 2);
//trkFile.sync();
trkFile.close();
}
else {
createFile = true;
}
}
}
}
if (sdIndicator && (millis() - sdIndicatorTime >= 150UL)) {
sdIndicator = false;
digitalWrite(SD_LED, HIGH);
}
if (!chkBattery) {
if (millis() - batteryTimeOld >= BATTERY_SAMPLE_TIME) {
chkBattery = true;
chkTimeOld = millis();
batteryTimeOld += BATTERY_SAMPLE_TIME;
check_battery();
}
} else {
if (millis() - chkTimeOld >= CHKBATT_INTERVAL) {
chkTimeOld += CHKBATT_INTERVAL;
check_battery();
}
}
if (lowBattery) {
if (millis() - blinkTimeOld >= BLINK_INTERVAL) {
pwrLedStatus = !pwrLedStatus;
digitalWrite(PWR_LED, pwrLedStatus ? HIGH : LOW);
blinkTimeOld += BLINK_INTERVAL;
}
}
#ifdef _BUTTON_
if ((displayMode == SHOWHOUR) || (displayMode == SHOWSECS)) {
if (millis() - lastColonBlinkTime >= 500UL) {
#ifdef _LUXOMETER_
display.brightness(get_brightness());
#endif
if (displayMode == SHOWHOUR) {
int16_t time = localTime.hours * 100 + localTime.minutes;
display.showClk(time, POINT_OFF);
}
else { // displayMode == SHOWSECS
display.noPoint();
display.showNum(localTime.seconds, true, 2);
}
lastColonBlinkTime += 500;
}
if (millis() - showtimeTime >= 10000UL) {
displayMode = SHOWSPEED;
display.clear();
}
}
#endif
validFix = false;
validTime = false;
validDate = false;
read_gps_fix();
delay(1);
}
//------------------------------------------------------------------------------