Домашно GPS тракер на Arduino. Най-добрите GPS тракери за автомобили (маяци)

Добър ден (вечер/нощ по избор).

Днес ще има преглед на GPS приемника и приложението му в практиката.

ПРЕДГОВОР

Като цяло винаги съм искал да се занимавам с този тип устройства, исках да имам специфичен тракер, който да записва изминатото разстояние, но имаше едно нещо, исках тракера да има дисплей, аз по принцип обичам различни дисплеи и се опитвам да завийте ги във всичко възможно, такъв фетиш.

Имаше само няколко от най-обширните ревюта за този GPS приемник - около 4, един от тях беше наистина добър, останалите бяха описани общо. Няма да се повтарям много.

Както обикновено предупреждение:

Цялата отговорност, а именно независимото проникване в тялото на готовия продукт с последващо нарушаване на неговата цялост и ефективност, се носи от лицето, което е извършило това действие.

Външен вид

Комплектът включва пасивна антена:

Ако желаете, винаги можете да замените активния или да го направите сами, като използвате този метод:

Днес модулът не е остарял модел и се използва активно, + има поддръжка на производителя.

На фигурата по-долу показах кои линии къде трябва да бъдат свързани, за да може GPS да бъде открит в компютъра:

Изглежда нещо подобно:

След това инсталирайте приложението U-center, връзката е дадена по-горе, и изберете порта:

По подразбиране комуникираме на 9600 бода.

Ето как обикновено работи всичко, което хванах на закрито:

Свързване на модула към Arduino

След това зашиваме тази скица в Nano:

Допълнителна информация

// ArduinoISP // Copyright © 2008-2011 Randall Bohn // Ако имате нужда от лиценз, вижте // http://www.opensource.org/licenses/bsd-license.php // // Тази скица превръща Arduino в AVRISP, използващ следните изводи на Arduino: // // Пин 10 се използва за нулиране на целевия микроконтролер. // // По подразбиране хардуерните SPI пинове MISO, MOSI и SCK се използват за комуникация // с целта. На всички Arduinos тези щифтове могат да бъдат намерени // на ICSP/SPI хедъра: // // MISO °. . 5V (!) Избягвайте този щифт на Due, Zero... // SCK. . MOSI // . . GND // // На някои Arduinos (Uno,...), щифтовете MOSI, MISO и SCK са същите щифтове като // цифровите щифтове 11, 12 и 13, съответно. Ето защо много уроци ви инструктират // да свържете целта към тези щифтове. Ако намирате това окабеляване за по // практично, дефинирайте USE_OLD_STYLE_WIRING. Това ще работи дори когато // не използвате Uno. (На Uno това не е необходимо). // // Като алтернатива можете да използвате всеки друг цифров щифт, като конфигурирате // софтуерен ("BitBanged") SPI и имате подходящи дефиниции за PIN_MOSI, // PIN_MISO и PIN_SCK. // // ВАЖНО: Когато използвате Arduino, който не е толерантен към 5V (Due, Zero, ...) като // програмист, уверете се, че не излагате нито един от щифтовете на програмиста на 5V. // Лесен начин за постигане това е за захранване на цялата система (програматор // и цел) при 3V3. // // Поставете светодиод (с резистор) на следните щифтове: // 9: Сърдечен ритъм - показва, че програмистът работи // 8: Грешка - Светва, ако нещо се обърка (използвайте червено, ако това има смисъл) // 7: Програмиране - В комуникация с подчинения // #include "Arduino.h" #undef SERIAL #define PROG_FLICKER true // Конфигуриране на SPI часовник (в Hz).// Например за ATtiny @ 128 kHz: листът с данни гласи, че и високият, и ниският // SPI тактов импулс трябва да бъдат > 2 цикъла на процесора, така че вземете 3 цикъла, т.е. разделете целта // f_cpu на 6: // # define SPI_CLOCK (128000/6) // // Достатъчно бавен часовник за ATtiny85 @ 1 MHz е разумна настройка по подразбиране: #define SPI_CLOCK (1000000/6) // Изберете хардуерен или софтуерен SPI, в зависимост от SPI тактовата честота. // В момента само за AVR, за други архитектури (Due, Zero,...), хардуерният SPI // вероятно е твърде бърз. #if defined(ARDUINO_ARCH_AVR) #if SPI_CLOCK > (F_CPU / 128) #define USE_HARDWARE_SPI #endif #endif // Конфигуриране кои пинове да се използват: // Стандартната конфигурация на щифтове. #ifndef ARDUINO_HOODLOADER2 #define RESET 10 // Използвайте щифт 10, за да нулирате целта, а не SS #define LED_HB 9 #define LED_ERR 8 #define LED_PMODE 7 // Разкоментирайте следния ред, за да използвате старото окабеляване в стил Uno // (използвайки щифт 11, 12 и 13 вместо заглавката SPI) на Leonardo, Due. .. // #define USE_OLD_STYLE_WIRING #ifdef USE_OLD_STYLE_WIRING #define PIN_MOSI 11 #define PIN_MISO 12 #define PIN_SCK 13 #endif // HOODLOADER2 означава стартиране на скици върху чиповете за сериен преобразувател ATmega16U2 // на Uno или Mega платки. Трябва да използваме изведени щифтове: #else #define RESET 4 #define LED_HB 7 #define LED_ERR 6 #define LED_PMODE 5 #endif // По подразбиране използвайте хардуерни SPI щифтове: #ifndef PIN_MOSI #define PIN_MOSI MOSI #endif #ifndef PIN_MISO #define PIN_MISO MISO #endif #ifndef PIN_SCK #define PIN_SCK SCK #endif // Принудително налагане на bitbanged SPI, ако не се използват хардуерните SPI пинове: #if (PIN_MISO != MISO) || (PIN_MOSI != MOSI) || (PIN_SCK != SCK) #undef USE_HARDWARE_SPI #endif // Конфигуриране на серийния порт за използване. // // Предпочитайте USB виртуалния сериен порт (известен още като собствен USB порт), ако Arduino има такъв: // - той не се нулира автоматично (с изключение на магическата скорост на предаване от 1200). // - по-надежден е поради USB ръкостискане. // // Leonardo и подобни имат USB виртуален сериен порт: "Serial". // Due и Zero имат USB виртуален сериен порт: "SerialUSB". // // На Due и Zero може да се използва и "Serial", при условие че деактивирате автоматичното нулиране. // За да използвате "Serial": #define SERIAL Serial #ifdef SERIAL_PORT_USBVIRTUAL #define SERIAL SERIAL_PORT_USBVIRTUAL #else #define SERIAL Serial #endif // Конфигуриране на скоростта на предаване: #define BAUDRATE 19200 // #define BAUDRATE 115200 // #define BAUDRATE 100000 0 #define HWVER 2 #define SWMAJ 1 #define SWMIN 18 // STK дефиниции #define STK_OK 0x10 #define STK_FAILED 0x11 #define STK_UNKNOWN 0x12 #define STK_INSYNC 0x14 #define STK_NOSYNC 0x15 #define CRC_EOP 0x 20 //добре, това е пространство... void impulse(int pin, int times); #ifdef USE_HARDWARE_SPI #include "SPI.h" #else #define SPI_MODE0 0x00 клас SPISettings ( public: // часовникът е в Hz SPISettings(uint32_t clock, uint8_t bitOrder, uint8_t dataMode) : clock(clock) ( (void) bitOrder; ( void) dataMode; ); private: uint32_t часовник; приятелски клас BitBangedSPI; ); клас BitBangedSPI (публичен: void begin() ( digitalWrite(PIN_SCK, LOW); digitalWrite(PIN_MOSI, LOW); pinMode(PIN_SCK, OUTPUT); pinMode(PIN_MOSI, OUTPUT); pinMode(PIN_MISO, INPUT); ) void beginTransaction(SPISettings настройки) ( pulseWidth = (500000 + settings.clock - 1) / settings.clock; if (pulseWidth == 0) pulseWidth = 1; ) void end() () uint8_t transfer (uint8_t b) ( for (unsigned int i = 0;i< 8; ++i) { digitalWrite(PIN_MOSI, (b & 0x80) ? HIGH: LOW); digitalWrite(PIN_SCK, HIGH); delayMicroseconds(pulseWidth); b = (b << 1) | digitalRead(PIN_MISO); digitalWrite(PIN_SCK, LOW); // slow pulse delayMicroseconds(pulseWidth); } return b; } private: unsigned long pulseWidth; // in microseconds }; static BitBangedSPI SPI; #endif void setup() { SERIAL.begin(BAUDRATE); pinMode(LED_PMODE, OUTPUT); pulse(LED_PMODE, 2); pinMode(LED_ERR, OUTPUT); pulse(LED_ERR, 2); pinMode(LED_HB, OUTPUT); pulse(LED_HB, 2); } int error = 0; int pmode = 0; // address for reading and writing, set by "U" command unsigned int here; uint8_t buff; // global block storage #define beget16(addr) (*addr * 256 + *(addr+1)) typedef struct param { uint8_t devicecode; uint8_t revision; uint8_t progtype; uint8_t parmode; uint8_t polling; uint8_t selftimed; uint8_t lockbytes; uint8_t fusebytes; uint8_t flashpoll; uint16_t eeprompoll; uint16_t pagesize; uint16_t eepromsize; uint32_t flashsize; } parameter; parameter param; // this provides a heartbeat on pin 9, so you can tell the software is running. uint8_t hbval = 128; int8_t hbdelta = 8; void heartbeat() { static unsigned long last_time = 0; unsigned long now = millis(); if ((now - last_time) < 40) return; last_time = now; if (hbval >192) hbdelta = -hbdelta; ако (hbval< 32) hbdelta = -hbdelta; hbval += hbdelta; analogWrite(LED_HB, hbval); } static bool rst_active_high; void reset_target(bool reset) { digitalWrite(RESET, ((reset && rst_active_high) || (!reset && !rst_active_high)) ? HIGH: LOW); } void loop(void) { // is pmode active? if (pmode) { digitalWrite(LED_PMODE, HIGH); } else { digitalWrite(LED_PMODE, LOW); } // is there an error? if (error) { digitalWrite(LED_ERR, HIGH); } else { digitalWrite(LED_ERR, LOW); } // light the heartbeat LED heartbeat(); if (SERIAL.available()) { avrisp(); } } uint8_t getch() { while (!SERIAL.available()); return SERIAL.read(); } void fill(int n) { for (int x = 0; x < n; x++) { buff[x] = getch(); } } #define PTIME 30 void pulse(int pin, int times) { do { digitalWrite(pin, HIGH); delay(PTIME); digitalWrite(pin, LOW); delay(PTIME); } while (times--); } void prog_lamp(int state) { if (PROG_FLICKER) { digitalWrite(LED_PMODE, state); } } uint8_t spi_transaction(uint8_t a, uint8_t b, uint8_t c, uint8_t d) { SPI.transfer(a); SPI.transfer(b); SPI.transfer©; return SPI.transfer(d); } void empty_reply() { if (CRC_EOP == getch()) { SERIAL.print((char)STK_INSYNC); SERIAL.print((char)STK_OK); } else { error++; SERIAL.print((char)STK_NOSYNC); } } void breply(uint8_t b) { if (CRC_EOP == getch()) { SERIAL.print((char)STK_INSYNC); SERIAL.print((char)b); SERIAL.print((char)STK_OK); } else { error++; SERIAL.print((char)STK_NOSYNC); } } void get_version(uint8_t c) { switch © { case 0x80: breply(HWVER); break; case 0x81: breply(SWMAJ); break; case 0x82: breply(SWMIN); break; case 0x93: breply("S"); // serial programmer break; default: breply(0); } } void set_parameters() { // call this after reading parameter packet into buff param.devicecode = buff; param.revision = buff; param.progtype = buff; param.parmode = buff; param.polling = buff; param.selftimed = buff; param.lockbytes = buff; param.fusebytes = buff; param.flashpoll = buff; // ignore buff (= buff) // following are 16 bits (big endian) param.eeprompoll = beget16(&buff); param.pagesize = beget16(&buff); param.eepromsize = beget16(&buff); // 32 bits flashsize (big endian) param.flashsize = buff * 0x01000000 + buff * 0x00010000 + buff * 0x00000100 + buff; // AVR devices have active low reset, AT89Sx are active high rst_active_high = (param.devicecode >= 0xe0); ) void start_pmode() ( // Нулиране на целта преди задвижване на PIN_SCK или PIN_MOSI // SPI.begin() ще конфигурира SS като изход, така че е избран главният режим на SPI. // Дефинирахме RESET като пин 10, което за много Arduinos е не SS пин. // Така че трябва да конфигурираме RESET като изход тук, // (reset_target() първо задава правилното ниво) reset_target(true); pinMode(RESET, OUTPUT); SPI.begin(); SPI.beginTransaction (SPISettings(SPI_CLOCK, MSBFIRST, SPI_MODE0)); // Вижте таблици с данни на AVR, глава „Алгоритъм за програмиране на SERIAL_PRG“: // Импулсът RESET след PIN_SCK е нисък: digitalWrite(PIN_SCK, LOW); delay(20); // разреждане на PIN_SCK, произволно избрана стойност reset_target(false); // Импулсът трябва да бъде минимум 2 целеви тактови цикъла на CPU, така че 100 usec е добре за CPU // скорости над 20 KHz delayMicroseconds(100); reset_target(true); // Изпратете командата за активиране на програмиране: delay(50); // лист с данни: трябва да е > 20 msec spi_transaction(0xAC, 0x53, 0x00, 0x00); pmode = 1; ) void end_pmode() ( SPI.end(); // Ние сме на път да вземем целта е извън нулиране, така че конфигурирайте SPI щифтовете като вход pinMode(PIN_MOSI, INPUT); pinMode(PIN_SCK, INPUT); reset_target(false); pinMode(НУЛИРАНЕ, ВХОД); pmode = 0; ) void universal() ( uint8_t ch; fill(4); ch = spi_transaction(buff, buff, buff, buff); breply(ch); ) void flash(uint8_t hilo, unsigned int addr, uint8_t data) ( spi_transaction(0x40) + 8 * hilo, addr >> 8 & 0xFF, addr & 0xFF, data); ) void commit(unsigned int addr) ( if (PROG_FLICKER) ( prog_lamp(LOW); ) spi_transaction(0x4C, (addr >> 8) & 0xFF, addr & 0xFF, 0); if (PROG_FLICKER) ( delay(PTIME); prog_lamp(HIGH); ) ) unsigned int current_page() ( if (param.pagesize == 32) ( return here & 0xFFFFFF0; ) if ( param.pagesize == 64) ( връщане тук & 0xFFFFFFFE0; ) if (param.pagesize == 128) ( връщане тук & 0xFFFFFFC0; ) if (param.pagesize == 256) ( връщане тук & 0xFFFFFF80; ) връщане тук; ) void write_flash(int length) ( fill(length); if (CRC_EOP == getch()) ( SERIAL.print((char) STK_INSYNC); SERIAL.print((char) write_flash_pages(length)); ) else ( error++; SERIAL.print((char) STK_NOSYNC); ) ) uint8_t write_flash_pages(int length) ( int x = 0; unsigned int page = current_page(); докато (x< length) { if (page != current_page()) { commit(page); page = current_page(); } flash(LOW, here, buff); flash(HIGH, here, buff); here++; } commit(page); return STK_OK; } #define EECHUNK (32) uint8_t write_eeprom(unsigned int length) { // here is a word address, get the byte address unsigned int start = here * 2; unsigned int remaining = length; if (length >param.eepromsize) ( error++; return STK_FAILED; ) while (remaining > EECHUNK) ( write_eeprom_chunk(start, EECHUNK); start += EECHUNK; resting -= EECHUNK; ) write_eeprom_chunk(start, remaining); връщане STK_OK; ) // запис (дължина) байтове, (начало) е байт адрес uint8_t write_eeprom_chunk(unsigned int start, unsigned int length) ( // това записва байт по байт, писането на страница може да е по-бързо (4 байта наведнъж) fill(length); prog_lamp(LOW); for (unsigned int x = 0; x< length; x++) { unsigned int addr = start + x; spi_transaction(0xC0, (addr >> 8) & 0xFF, addr & 0xFF, buff[x]); забавяне (45); ) prog_lamp(HIGH); връщане STK_OK; ) void program_page() ( char result = (char) STK_FAILED; unsigned int length = 256 * getch(); length += getch(); char memtype = getch(); // флаш памет @тук, (дължина) байтове ако (memtype == "F") ( write_flash(length); return; ) if (memtype == "E") ( result = (char)write_eeprom(length); if (CRC_EOP == getch()) ( SERIAL.print ((char) STK_INSYNC); SERIAL.print(result); ) else ( error++; SERIAL.print((char) STK_NOSYNC); ) return; ) SERIAL.print((char)STK_FAILED); return; ) uint8_t flash_read(uint8_t hilo, unsigned int addr) ( return spi_transaction(0x20 + hilo * 8, (addr >> 8) & 0xFF, addr & 0xFF, 0); ) char flash_read_page(int length) ( for (int x = 0; x< length; x += 2) { uint8_t low = flash_read(LOW, here); SERIAL.print((char) low); uint8_t high = flash_read(HIGH, here); SERIAL.print((char) high); here++; } return STK_OK; } char eeprom_read_page(int length) { // here again we have a word address int start = here * 2; for (int x = 0; x < length; x++) { int addr = start + x; uint8_t ee = spi_transaction(0xA0, (addr >> 8) & 0xFF, адрес & 0xFF, 0xFF); SERIAL.print((char)ee); ) върне STK_OK; ) void read_page() ( char result = (char)STK_FAILED; int length = 256 * getch(); length += getch(); char memtype = getch(); if (CRC_EOP != getch()) ( error++; SERIAL .print((char) STK_NOSYNC); return; ) SERIAL.print((char) STK_INSYNC); if (memtype == "F") result = flash_read_page(length); if (memtype == "E") result = eeprom_read_page (дължина); SERIAL.print(резултат); ) void read_signature() ( if (CRC_EOP != getch()) ( error++; SERIAL.print((char) STK_NOSYNC); return; ) SERIAL.print((char) STK_INSYNC ); uint8_t високо = spi_transaction(0x30, 0x00, 0x00, 0x00); SERIAL.print((char) високо); uint8_t средно = spi_transaction(0x30, 0x00, 0x01, 0x00); SERIAL.print((char) средно); uint8_t ниско = spi_transaction(0x30, 0x00, 0x02, 0x00); SERIAL.print((char) ниско); SERIAL.print((char) STK_OK); ) //////////////// ///////////////////////// /////////////////////// / ///////////////// ////////////////////////////// // /// ///////////////////////////////// void avrisp() ( uint8_t ch = getch (); switch (ch) ( case "0": // грешка при влизане = 0; empty_reply(); break; case "1": if (getch() == CRC_EOP) ( SERIAL.print((char) STK_INSYNC); SERIAL. print("AVR ISP"); SERIAL.print((char) STK_OK); ) else (грешка++; SERIAL.print((char) STK_NOSYNC); ) break; case "A": get_version(getch()); break; case "B": fill(20); set_parameters(); empty_reply(); break; case "E": // разширени параметри - игнорирайте за сега fill(5); empty_reply(); break; case "P": if (!pmode) start_pmode(); empty_reply(); break; case "U": // задайте адрес (дума) тук = getch(); тук += 256 * getch(); empty_reply(); break; case 0x60: //STK_PROG_FLASH getch(); // low addr getch(); // high addr empty_reply(); break; case 0x61: //STK_PROG_DATA getch(); // data empty_reply(); break; case 0x64: //STK_PROG_PAGE program_page(); break; case 0x74: //STK_READ_PAGE "t" read_page(); break; case "V": //0x56 universal(); break; case "Q": //0x51 error = 0; end_pmode() празен_отговор(); прекъсване; case 0x75: //STK_READ_SIGN "u" read_signature(); прекъсване; // очакваме команда, а не CRC_EOP // така можем да се върнем в случай на синхронизация CRC_EOP: error++; SERIAL.print((char) STK_NOSYNC); прекъсване; // всичко друго, което ще върнем STK_UNKNOWN default: error++; if (CRC_EOP == getch()) SERIAL.print((char)STK_UNKNOWN); иначе SERIAL.print((char)STK_NOSYNC); ) )

След това изберете вашия Pro Mini контролер, посочете ArduinoISP програмиста и шийте контролера с помощта на командата Скица -> Качване чрез програмисти натиснете бутона Reset на Pro mini, фърмуерът на контролера ще започне да мига (при мен работи само при втория опит, трябва да имам търпение):

Както казах по-горе, наистина обичам да прикрепям дисплеи към всякакви джаджи, е, просто е страховито, така че това "проект"желанието ми не остана незабелязано.

Какво ни трябва за всичко това:

Като цяло събрах всички боклуци, които лежаха наоколо:

1. SD карта модул, много огромен, така че се опитах да се отърва от него възможно най-скоро.

2. Дисплей, базиран на контролера PCD8544, добре познатият дисплей на Nokia.

3. Карта с памет 1GB, с непопулярния стандарт MiniSD, нямах идея къде да я сложа, но исках да пусна всичко да работи, така че да работи за ползата от навигацията.

4. Ще ви трябва мозък, голям Pro Mini мозък на 328P чип.

Както писах по-горе, ще шием Arduino Nano със зашит в него буутлоудър.

Като цяло се опитах много да вместя целия проект в нано, добре, просто наистина. Не става, отказваме се или от картата памет, или от дисплея.

5. Разбира се, самият модул + антена, както писах по-горе, можете да направите сами.

6. А да, за малко да забравя, ще ти трябва още един калъф, иначе какво устройство е без калъф.

Като калъф пак са закупени, но в сребърна форма, за проба. Ще кажа това, абсолютно не ми хареса сребристия цвят, черното изглежда по-добре.

Когато всички компоненти са налични, можете да свържете и програмирате всичко.

Свързваме се с Pro Mini по следната схема:

Дисплей:

RST-D6
CE - D7
DC-D5
DIN - D4
CLK-D3
VCC - 5V (по избор в моя случай, в други 3.3V)
Светлина - GND
GND - GND

Подсветката не ми трябваше и затова не я свързах.

CS-D10
MOSI-D11
MISO-D12
SCK-D13
GND - GND
5V - VCC (по избор в моя случай, в някои с преобразувател се свързваме към 3.3V)

GPS модул:

RX-D8
TX-D2
GND - GND
VCC-3.3 (3.3 е границата!)

Не забравяйте да свържете антената към модула, взех захранването от Nano Tk. беше свързан за отстраняване на грешки, тогава всичко ще бъде преобразувано в батерията.

Приблизителен изглед:

Кодът е прост и ясен; за да го използвате вероятно ще ви трябва . По-нататък. Останалите са вградени. Според кода редът е time*0.000001+5, по същество пренесох времето в смилаема форма и добавих часова зона. Можете да пропуснете това и пак да получите чисти резултати.

Друг нюанс по отношение на библиотеката на дисплея е следният: дисплеят, включително този с нулевата линия, има общо 6 реда. Което е доста малко, така че трябва незабавно да решите каква информация да се показва; някои ще трябва да се показват в символи, спестявайки място. Дисплеят се преначертава всяка секунда, докато се актуализира и записва информация, идваща от сателити.

Ако има грешка при четене на файл или няма достъп до SD картата, ще се покаже съобщение SD-, в други случаи SD+.

#включи #включи #включи #включи //CS-D10, MOSI-D11, MISO-D12, SCK-D13, GND - GND, 5V - VCC (по избор в моя случай, в някои случаи се свързваме към 3.3V, ако няма конвертор) Файл GPS_file; TinyGPS gps; SoftwareSerial gpsSerial(2, 8);//RX - 8 пинов, TX - 2 пинов статичен PCD8544 lcd; //RST - D6, CE - D7, DC - D5, DIN - D4, CLK - D3, VCC - 5V (по избор, ако има преобразувател на 3.3V линия), светлина - GND, GND - GND bool newdata = невярно; неподписано дълго начало; дълга ширина, дължина; без подпис дълго време, дата; void setup() (lcd.begin(84, 48); gpsSerial.begin(9600); Serial.begin(9600); pinMode(10, OUTPUT); if (!SD.begin(10))( lcd.setCursor( 0, 0); lcd.println("SD-"); return;) lcd.setCursor(0, 0); lcd.println("SD+"); GPS_file = SD.open("GPSLOG.txt", FILE_WRITE) ; if (GPS_file)( Serial.print("Пише се в test.txt..."); GPS_file.print("LATITUDE"); GPS_file.print(","); GPS_file.print("LONGITUDE"); GPS_file .print(","); GPS_file.print("ДАТА"); GPS_file.print(","); GPS_file.print("ВРЕМЕ"); GPS_file.print(","); GPS_file.print("ВИСОЧИНА" "); GPS_file.println(); GPS_file.close(); Serial.println("готово."); )else( Serial.println("грешка при отваряне на test.txt"); ) lcd.setCursor(0,3) ; lcd.print("ALT: "); lcd.setCursor(0,2); lcd.print("SPD: "); lcd.setCursor(0,4); lcd.print("LAT: "); lcd .setCursor(0,5); lcd.print("LON: "); ) void loop() ( if (millis() - start > 1000)( newdata = readgps(); if (newdata)( start = millis( ); gps.get_position(&lat, &lon); gps.get_datetime(&дата, &час); lcd.setCursor(50,1); lcd.print(дата); lcd.setCursor(55,0); lcd.print(време*0,000001+5); lcd.setCursor(22, 4); lcd.print(lat); lcd.setCursor(22, 5); lcd.print(long); lcd.setCursor(22, 2); lcd.print(gps.f_speed_kmph()); lcd.setCursor(22, 3); lcd.print(gps.f_altitude()); ) ) GPS_file = SD.open("GPSLOG.txt", FILE_WRITE); if(GPS_file)( GPS_file.print(lat); GPS_file.print(","); GPS_file.print(lon); GPS_file.print(","); GPS_file.print(дата); GPS_file.print(", "); GPS_file.print(time*0.000001+5); GPS_file.print(","); GPS_file.print(gps.f_altitude()); GPS_file.println(); GPS_file.close(); )else( lcd .setCursor(0, 0); lcd.println("SD-"); ) ) bool readgps())( while (gpsSerial.available())( int b = gpsSerial.read(); if("\r" ! = b)( if (gps.encode(b)) return true;)) return false;)

След като мигате фърмуера, ще видите нещо подобно (в скицата изходната дата е редактирана до десния край под часа):

Можете да си поиграете с подреждането на елементите, имаше и такава опция, но разбрах, че осредняването на координатите дава огромна грешка и отказах.

За батериите, които ползвам LI-ion батерия. Купувам на едро батерии за екшън камери и ги използвам в занаятите си, освен това винаги могат да ми бъдат полезни за екшън камера, която използвам на походи. .

Използвайки макет, събирайки всичко заедно:

Залепих парче електрическа лента върху кутията за картата с памет, тъй като тя е в контакт с контактите на зарядното устройство. Мигаме картата с памет във FAT16.

След това стартираме и проверяваме, като не забравяме да включим превключвателя:

Обработка на резултатите

Задайте разделителя на колони на запетая:

След това можете да заредите всичко в софтуера Google Earth Pro, като използвате раздела Файл -> Отвори, отворете нашия файл и изберете колоните, отговарящи за географската ширина и дължина, и вземете подобна следа (тъй като бях на едно място, получих разпръснати точки):

Можете да изберете точка и да покажете целия брой точки, които съответстват на нея:

Долен ред

Повече от задоволих любопитството си.

Недостатъкът е, че е малка антена; понякога студеното стартиране може да отнеме до 10 минути (в зависимост от облачността и времето от деня). Антената, разбира се, може да бъде заменена с домашна или закупена допълнително; на пазара има доста активни антени.

Благодаря за отделеното време.

Актуализация от 22.05.18г

2. Преместих конектора за отстраняване на грешки навън (след като си поиграя, ще напиша по-интересен фърмуер, ще го публикувам тук)

3. За да намаля заеманото място, разглобих дисплея и го запоих към него.

Засега това е гледката.