Házi készítésű GPS nyomkövető Arduino-n. A legjobb GPS nyomkövetők autókhoz (jelzők)

Házi készítésű GPS nyomkövető Arduino-n. A legjobb GPS nyomkövetők autókhoz (jelzők)
Házi készítésű GPS nyomkövető Arduino-n. A legjobb GPS nyomkövetők autókhoz (jelzők)
12.05.2022

Személyi GPS adók

Manapság a fejlődés olyan ütemben halad, hogy a korábban terjedelmes, drágák és rendkívül specializált eszközök gyorsan veszítenek méretükből, súlyukból és árából, de számos új funkciót kapnak.

Így jutottak el a GPS-technológiára épülő eszközök a zsebkütyükhöz, és ott szilárdan megtelepedtek, új lehetőségeket adva az embereknek. Külön érdemes kiemelni az egyes GPS-adókat.

Lényegében ugyanazok a GPS nyomkövetők, csak nem járműben való használatra tervezték, hanem egy személy a mindennapi életben.

Modelltől függően több különféle eszközök. A legegyszerűbb formájában egyszerűen egy kijelző nélküli kis doboz, ami lehetővé teszi a gyermekek, állatok vagy más tárgyak mozgásának vezérlését, amelyen rögzítve van.

Benne van egy GPS-modul, amely meghatározza a földi koordinátákat, egy GSM/GPRS-modul, amely információkat továbbít és fogad vezérlőparancsokat, valamint egy áramforrás, amely autonóm működés Hosszú időn keresztül.

A GPS-adók működése

A funkcionalitás növekedésével az eszköz következő képességei jelennek meg:


Lehetőségek GPS-adókhoz

A konfigurációtól függően a távadó házai jelentősen eltérhetnek. Az űrlapon különféle modellek állnak rendelkezésre mobiltelefonok, klasszikus navigátorok, vagy akár karórák.

Speciális változatok színes kialakítása és hasznos kiegészítések Engedjék meg, hogy a gyerekek ezeket az eszközöket ne „szülői kémként” kezeljék, hanem divatos és praktikus kütyükként.

Előnyként érdemes megemlíteni, hogy a készülék számos változata nélkülözheti előfizetési díj szakosodott szolgáltatók szolgáltatásaihoz, és minden szükséges információ közvetlenül az interneten vagy SMS-ben kerül elküldésre az ügyfélnek, ami jelentős megtakarítást tesz lehetővé az ilyen berendezések karbantartása során.

Cikkek a GPS nyomkövetőkről

Ebben a cikkben bemutatom, hogyan kell használni a gsm-modult arduino-val a sim800L példaként. Ugyanezek az utasítások nagyon alkalmasak bármilyen más gsm-modul, például sim900 stb., használatára, mivel minden modul megközelítőleg ugyanúgy működik - ez az AT-parancsok cseréje a porton keresztül.

A modul használatát az arduino-val egy SMS relé példáján mutatom be, amivel SMS parancsokkal távolról is vezérelhető a készülék. Használható autóriasztókkal stb.

A modul a szoftver soros portjának UART interfészén keresztül csatlakozik az Arduino-hoz, amely a 2-es és 3-as porton működik. digitális kimenetek Arduino nano.

Az Arduino használata GSM modulokkal

A modul táplálásához 3,6 V és 4,2 V közötti feszültségre van szükség, ez azt jelenti, hogy további feszültségstabilizátort kell használnia, mivel az Arduino 3,3 voltos stabilizátorral rendelkezik, amely nem alkalmas a modul táplálására , a második ok a kiegészítő stabilizátor felszerelésére az, hogy a GSM-modul komoly terhelést jelent, mivel gyenge adója van, amely stabil kommunikációt biztosít a mobilállomással. Az Arduino nano tápellátása a VIN érintkezőn keresztül történik – ez az Arduino-ba épített stabilizátor, amely biztosítja, hogy a modul széles feszültségtartományban (6-10 V) működjön. A relémodul a megadott programszöveg szerint az Arduino nano 10-es érintkezőjére csatlakozik, és könnyen átcserélhető bármilyen digitális kimenetként működőre.

Ez így működik: helyezzen be egy SIM-kártyát a GSM-modulba, kapcsolja be a tápfeszültséget és küldjön SMS-t az „1” szöveggel a számra SIM-kártyák a relénk bekapcsolásához a kikapcsoláshoz SMS-t küldünk „0” szöveggel.

#beleértve
SoftwareSerial gprsSerial(2, 3); // a 2. és 3. láb beállítása a szoftverporthoz
int LedPin = 10; // reléhez

void setup()
{
gprsSerial.begin(4800);
pinMode(LedPin, OUTPUT);

// üzenetfogadás beállítása

gprsSerial.print("AT+CMGF=1\r");
gprsSerial.print("AT+IFC=1, 1\r");
késleltetés(500);
gprsSerial.print("AT+CPBS=\"SM\"\r");
késleltetés(500); // késleltetés a parancsfeldolgozáshoz
gprsSerial.print("AT+CNMI=1,2,2,1,0\r");
késleltetés(700);
}

Karakterlánc currStr = "";
// ha ez a sor egy üzenet, akkor a változó True értéket vesz fel
logikai érték isStringMessage = false;

void loop()
{
if (!gprsSerial.available())
Visszatérés;

char currSymb = gprsSerial.read();
if ('\r' == currSymb) (
if (isStringMessage) (
// ha az aktuális sor üzenet, akkor...
if (!currStr.compareTo("1")) (
digitalWrite(LedPin, HIGH);
) else if (!currStr.compareTo("0")) (
digitalWrite(LedPin, LOW);
}
isStringMessage = false;
) más (
if (currStr.startsWith("+CMT")) (
// ha az aktuális sor „+CMT”-vel kezdődik, akkor a következő üzenet
isStringMessage = igaz;
}
}
currStr = "";
) else if ('\n' != currSymb) (
currStr += String(currSymb);
}
}

A cikk videós változata:

Címkék: #Arduino, #SIM800L

A jeled:

A cikkben használt termékek:

← GPS logger az arduino | Relé vezérlés COM porton keresztül →

GSM szkenner RTL-SDR-en

| itthon| angol | Fejlesztés | GYIK |

A szkenner főbb jellemzői

A GSM-szkenner pásztázza a lefelé irányuló GSM-csatornákat, és információkat jelenít meg a jelszintről, valamint arról, hogy a csatorna a három fő mobilszolgáltató, az MTS, a Beeline és a Megafon valamelyikéhez tartozik-e. Munkájának eredményei alapján a szkenner lehetővé teszi az azonosítók listájának elmentését bázisállomások MCC, MNC, LAC és CI minden letapogatott csatornához.
Egy GSM szkenner használható a GSM jelszint értékelésére és a jelminőség összehasonlítására különböző operátorok, rádiólefedettség felmérések, amikor a cellás jelerősítők telepítéséről és paramétereik beállításáról döntenek, oktatási célból stb.
A szkenner Windows alatt fut, és egy egyszerű és olcsó vevőt használ - RTL-SDR. Az RTL-SDR-ről itt olvashat:
RTL-SDR (RTL2832U) és szoftver által meghatározott rádióhírek és projektek,
RTL-SDR – OsmoSDR,
RTL-SDR oroszul.
Az RTL-SDR paraméterek határozzák meg a szkenner főbb jellemzőit. Természetesen a GSM szkenner nem helyettesíti a normál mérőberendezéseket.
A szkennert ingyenesen, használati korlátozás nélkül terjesztjük.
Jelenlegi verzió támogatja a GSM 900 sávot, és nem támogatja a GSM 1800-at. Ezt az a tény határozza meg, hogy az RTL-SDR működési frekvenciája az R820T tunerrel 1760 MHz-re van korlátozva. Remélhetőleg a kísérleti RTL-SDR meghajtó használata lehetővé teszi a működést az 1800 MHz-es tartomány legalább egy részén.

A szkenner elindítása

A szkenner legújabb verziója letölthető erről a linkről. Csak csomagolja ki a fájlt egy kényelmes helyre, és futtassa a gsmscan.exe-t.
A szkenner korábbi verziói, a forrásokkal ellátott repository linkje és a fejlesztéssel kapcsolatos egyéb információk a fejlesztési oldalon találhatók.
A szkenner működéséhez az RTL-SDR illesztőprogramok telepítése szükséges, ha még nincsenek telepítve, ez kényelmesen megtehető a Zadig programmal a telepítési eljárás leírásához.

A szkenner használata

Az alábbiakban látható a szkennerprogram ablakának képe:

A vízszintes tengelyen a GSM csatorna száma ARFCN vagy MHz-ben jelenik meg, ennek megfelelően függőleges tengely jelszint dBm-ben. A vonal magassága a jelerősséget mutatja.

GSM modul NEOWAY M590 kommunikáció Arduino-val

Ha a BS azonosítók dekódolása sikeresen megtörtént, és azok megfelelnek a három nagy távközlési szolgáltató azonosítóinak, a vonalak a megfelelő színekre vannak festve.
A képernyő tetején található legördülő listák lehetővé teszik az SDR vevő kiválasztását, ha több csatlakoztatva van, a GSM 900 vagy GSM 1800 működési tartományát és a vízszintes tengely mentén mért mértékegységeket ARFCN vagy MHz.
A gombok segítségével jelentést menthet a szkenner működéséről a dekódolt bázisállomások listája formájában, törölheti a BS dekódolás eredményeit, és információkat kaphat a programról.

A munka alapelvei és jellemzői.

A program működés közben 2,0 MHz-es lépésekkel pásztázza a működési frekvencia tartományt (10 GSM csatorna), és 2,4 MHz-es mintavételi frekvenciával digitalizálja a jelet. A szkennelési folyamat a jelerősség mérése érdekében a teljes tartományon történő gyors áthaladásból, valamint a BS azonosítók dekódolásához lassú lépésből áll.

Egy dekódolási lépést hajtanak végre a teljes tartomány bejárása után a teljesítmény mérésére. Így a GSM 900 tartományban a jelszint körülbelül 2 másodpercenként frissül, és a teljes dekódolási lépés körülbelül 1 percet vesz igénybe.
Az RTL-SDR-től kapott jel rossz minősége miatt a BS broadcast vezérlőcsatorna (BCCH) rendszerinformációjának (SI) helyes dekódolásának valószínűsége nem magas. A többutas terjedés következtében fellépő jelszint-ingadozások szintén csökkentik a rendszerinformációk dekódolásának valószínűségét. Ezen okok miatt a BS azonosítók megszerzéséhez szükséges, hogy a szkenner körülbelül 10 percen keresztül információt gyűjtsön. De még ebben az esetben sem minden csatorna biztosítja ez a hely elegendő jelszint és minőség a dekódoláshoz még a legideálisabb vevőkészülékkel is. Ráadásul nem minden GSM csatorna működik a GSM szabvány szerint, amint az a fenti ábrán látható, a 975 - 1000 csatornákat a Megafon foglalja el, hogy az UMTS szabvány szerint működjenek.
Működés közben a szkenner az új dekódolt csatornákra vonatkozó rendszerinformációkat ad hozzá a csatornákra vonatkozó általános információs tömbhöz. A korábban dekódolt csatornákra vonatkozó információk azonban nem törlődnek, ha a rendszerinformációt nem dekódolják ebben a lépésben, és a tömbben maradnak. Az információ törléséhez használja a gombot a BS dekódolási eredmények törléséhez.
A jelentés mentése gombra kattintva az összesített eredmények mentésre kerülnek szöveges fájl a program nevéből, az adatok mentésének dátumából és időpontjából álló névvel. Az alábbiakban egy példa látható a jelentésfájl egy részére:
A szkennert úgy tervezték, hogy Windows 7, 8.1 és 10 alatt működjön. A munkát az RTL-SDR három példányával, az R820T tunerrel tesztelték.
A program egy speciális verzióját fordították le, hogy Windows XP alatt működjön, többször lassabban fut, mint a normál verzió.

Fejlesztés.

A szkennerprogramot úgy szállítjuk, ahogy van, mindenféle garancia és felelősségvállalás nélkül. Ha van ésszerű ötlete a szkenner funkcionalitásának bővítésére vagy teljesítményének javítására, készek vagyunk megvitatni a megvalósítás lehetőségét.
Részt vehet a szkenner fejlesztésében, ehhez látogasson el a fejlesztési oldalra.
A GSM szkenner további fejlesztését tervezzük, esetleg az Önök részvételével.

Pontos időforrásra van szüksége a GPS-ből? Ez a cikk bemutatja, hogyan használhat GPS-modult az idő, a dátum és a koordináták lekéréséhez, és hogyan jelenítheti meg ezeket LCD-n az Arduino használatával.

Mi szükséges?

  • számítógép telepített Arduino IDE-vel;
  • Arduino (Arduino Mega-t használunk);
  • GPS modul (mi EM-411-et használunk, más is lehetséges, amely támogatja NMEA protokoll például VK2828U7G5LF vagy GY-NEO6MV2);
  • kenyértábla, jumperek és 5 kOhm-os potenciométer;
  • TinyGPS könyvtár (link lent).

Bevezetés

A globális helymeghatározó rendszer vagy a GPS fejlesztése az 1970-es évek elején kezdődött. Minden ország (Oroszország, USA, Kína stb.) rendelkezik saját rendszerrel, de a világ legtöbb műholdas navigációs létesítménye az Egyesült Államok rendszerét használja.

A rendszer minden műholdjához tartozik egy atomóra, amelyet a NORAD (North American Aerospace Defense Command) folyamatosan figyel és állít be minden nap.

Lényegében a vevő az óráját használja a négyes TOA (érkezési idő) mérésére műholdjelek. A TOA és a TOT (átviteli idő) alapján a vevő négy repülési időt (TOF) számít ki, amelyek a műhold és a vevő közötti távolság függvényében különböznek egymástól. Ezután a négy TOF értékből a vevő kiszámítja a 3D térben elfoglalt pozícióját és az órájának eltérését.

A legolcsóbb GPS-vevők a Föld legtöbb helyén körülbelül 20 méteres pontossággal rendelkeznek. Most nézzük meg, hogyan készíthet saját GPS-órát az Arduino segítségével.

Hardver

A GPS modulomban 6 érintkező van: GND, Vin, Tx, Rx és ismét GND. A hatodik érintkező nincs sehova csatlakoztatva. A GND pin az Arduinón a házhoz, a Vin az Arduinón a +5V-os buszhoz, a Tx az Arduino 10-es érintkezőjéhez, az Rx tű pedig nincs sehova, mivel nem küldünk üzenetet a GPS-modulhoz. A modulom az RS-232 interfészen keresztül 4800 bps sebességgel továbbítja a műholdadatokat, amit az Arduino a 10-es érintkezőn fogad.

Az alábbiakban egy fotó a GPS-modulról:

EM-411 GPS modul

A modul úgynevezett NMEA üzeneteket küld. Itt láthat egy példát egy NMEA üzenetre és annak magyarázatára (kivonat a technikai leírás):

$GPGGA,161229.487,3723.2475,N,12158.3416,W,1.07,1.0,9.0,M,0000*18

GGA adatformátum
NévPéldaEgységekLeírás
Üzenetazonosító$ GPGGA GGA protokoll fejléc
UTC idő161229.487 hhmmss.sss (két számjegyű óra, kétjegyű perc, majd másodpercek ezrelékig)
Szélességi kör3723.2475
N/S zászlóN É - észak, S - dél
Hosszúság12158.3416 ddmm.mmmm (az első két számjegy fok, majd perc tízezrelékig)
K/Ny zászlóW K - kelet, W - nyugat
Helyszínjelző1
  • 0 - a hely nem elérhető vagy helytelen;
  • 1 - GPS SPS mód, a hely megfelelő;
  • 2 - differenciál GPS, SPS mód, hely megfelelő;
  • 3 - GPS PPS mód, a hely megfelelő.
A használt műholdak száma07 0 és 12 között van
HDOP1.0 A vízszintes pontosság romlása
Magasság a tengerszinthez viszonyítva9.0 méter
EgységekMméter
Geoidális különbség A WGS-84 földellipszoid és a tengerszint (genoid) közötti különbség
EgységekMméter
A differenciális GPS adatok kora másodpercigNull mezők, ha nincs DGPS
A differenciális korrekciókat sugárzó állomás azonosítója0000
Ellenőrző összeg*18
Üzenet vége

Mindezeket az adatokat az Arduino a 10-es érintkezőn keresztül kapja. A TinyGPS könyvtár beolvassa a GPGGA és GPRMC üzeneteket (az részletes információk a GPRMC-ről lásd a műszaki leírást).

Az Arduino nem látható a diagramon. Csatlakozás perifériák aláírt kapcsolatok szerint.


Rendszer GPS óra arduino-n

Szoftver

Áramellátás esetén a GPS-modulnak egy kis időbe telik, amíg a műholdakról megállapítja a megfelelő pozíciót. Amikor egy hely érkezik, a modul NMEA üzeneteket küld az Arduino-nak. A TinyGPS könyvtár tartalmaz egy funkciót az idő és a dátum lekérésére egy GPRMC üzenetből. Ezt crack_datetime()-nek hívják, és hét változóra mutat paraméterként: év év , hónap hónap , hónap napja nap , óra óra , perc perc , másodperc másodperc és századmásodperc századok . A függvényhívás így néz ki:

GPS.crack_datetime(&év, &hónap, &nap, &óra, &perc, &másodperc, &század);

Ennek a függvénynek a meghívása visszaadja a megfelelő értékeket a változókban mindaddig, amíg minden rendben van a hardverrel.

A tartózkodási hely meghatározásához meghívhatja az f_get_position() függvényt. Ez a funkció paraméterként két változóra mutató mutatót vesz fel: szélességi szélességi és hosszúsági hosszúsági fokot. A függvény meghívása így néz ki:

Gps.f_get_position(&szélesség, &hosszúság);

A program forrásszövege:

#beleértve #beleértve #beleértve #define RXPIN 10 #define TXPIN 9 #define GPSBAUD 4800 #define RS 2 #define EN 3 #define D4 4 #define D5 5 #define D6 6 #define D7 7 TinyGPS gps; Szoftversoros uart_gps(RXPIN, TXPIN); LiquidCrystal lcd (RS, EN, D4, D5, D6, D7); // Változók int másodperc; int időeltolás = 1; // A felhasználónak módosítania kell az egységet a megfelelő időzónára. A példában +1 órás műszakot használunk. // Funkciók nyilatkozata. void getgps(TinyGPS &gps); // Beállítás funkció - csak akkor fut, ha be van kapcsolva a void setup() ( Serial.begin(115200); // A soros interfész indítása az uart_gps.begin(GPSBAUD) hibakereséshez; // Indítsa el az UART vevőt a GPS-hez lcd.begin(16 ,2) ; // LCD-bejelentés lcd.print("GPS óra" // Üdvözlő üzenet késleltetése(1000) // LCD törlése // Loop fő program- a void loop() mindig fut ( while(uart_gps.available()) ( int c = uart_gps.read(); if(gps.encode(c)) ( getgps(gps); ) ) ) /* * Ez a függvény adatokat fogad a GPS-modultól * és megjeleníti azokat az LCD-n */ void getgps(TinyGPS &gps) ( int év; lebegő szélesség, hosszúság; bájt hónap, nap, óra, perc, másodperc, századok; gps.f_get_position(&szélesség, &hosszúság ); : ") ; if (óra<= 9) { lcd.print("0"); lcd.print(hour, DEC); } else { lcd.print(hour, DEC); } lcd.print(":"); if (minute <=9) { lcd.print("0"); lcd.print(minute, DEC); } else { lcd.print(minute, DEC); } lcd.print(":"); if (second <= 9) { lcd.print("0"); lcd.print(second, DEC); } else { lcd.print(second, DEC); } lcd.setCursor(0,1); lcd.print("Date: "); if (day <= 9) { lcd.print("0"); lcd.print(day, DEC); } else { lcd.print(day, DEC); } lcd.print("-"); if (month <= 9) { lcd.print(month, DEC); } else { lcd.print(month, DEC); } lcd.print("-"); lcd.print(year, DEC); delay(2000); lcd.clear(); lcd.print("Lat: "); lcd.print(latitude, DEC); lcd.setCursor(0,1); lcd.print("Lon: "); lcd.print(longitude, DEC); delay(2000); // Debugging purpose only. Serial.print(latitude, DEC); Serial.print(" - "); Serial.println(longitude, DEC); }

Ma egy Arduino MKR FOX 1200 alapú GPS Trackert készítünk, amely pontos GPS adatokat küld a Sigfox hálózaton keresztül.

Ez sok országban még fontosabbá válik az importált műszaki eszközök – különösen a GPS-hez kapcsolódó – fokozott ellenőrzése miatt.

1. lépés Mire lesz szükségünk

A leckéhez tartozó alkatrészkészlet nem nagy:

  • Arduino MKR Fox 1200 × 1
  • GPS-modul (opcionális, de az ublox NEO6m (ATGM332D) × 1 másolatát használtuk
  • Általános célú NPN tranzisztor (mi BC548-at használtunk) × 1
  • Ellenállás 1 kOhm × 1

2. lépés: Projekt információk

A nyomkövető az ATGM332 GPS-modult használja a GPS-pozíció pontosabb meghatározására, mint a Sigfox által nyújtott helymeghatározó szolgáltatások. A cikkadatokat ezután "karakterláncként" küldik el a Sigfox hálózaton keresztül, és végül e-mailben kézbesítik.

Arduino MKR FOX 1200

Az alaplap hasonló az Arduino Zerohoz, amely a SAM D21-re épül, és egy ATA8520 Sigfox modult tartalmaz. Ez egy alacsony fogyasztású kártya, amely az alaplaphoz tartozik, ingyenes egyéves előfizetéssel a Sigfox hálózatra (akár napi 140 üzenet), valamint ingyenes hozzáféréssel a helymeghatározó szolgáltatáshoz. Szedd észre.

ATGM332 GPS modul

Ez az alacsony költségű, alacsony fogyasztású GPS-modul nagyon jól illeszkedik az Arduino MKR FOX 1200-hoz, mivel csak 2,7 V-tal (névleges 3,3 V) működik.

Kezdetben a NEO6m2 modult terveztem volna megvenni, amiben van készenléti mód, de a NEO6-ot kellett használnom. Valójában egy ATGM332 modul volt. Emiatt nem volt készenléti üzemmódja, így szükség esetén tranzisztorral kellett bekapcsolni a GPS-modult, majd kikapcsolni az akkumulátor kímélése érdekében. Célunk, hogy elég ritkán, azaz óránként 4 üzenet legyen helyinformációkkal, mivel a Sigfox csak napi 140 üzenetet engedélyez.

A TinyGPS könyvtárat (https://github.com/mikalhart/TinyGPS) használjuk a GPS keretek dekódolására.

Tranzisztoros kapcsoló

Szükség esetén be- és kikapcsolni kellett a GPS-t. A relémodulok túl terjedelmesek és erősek, ha csak 3 V-os terhelést és néhány milliampert kell kapcsolni. Ezenkívül a legtöbb relé modul 5 V-ot igényel, így a tranzisztor jobb megoldás lenne. Ezenkívül az MKR FOX 1200 csak 7 mA-t biztosít az I/O érintkezőn.

Egy BC548 NPN tranzisztor megteszi. Amikor a nulla jelet a tranzisztor alapjára vezetik, az kikapcsol, nyitott kapcsolóként működik, és nem folyik kollektoráram. Ha pozitív jelet adunk a tranzisztor alapjára, az „be” lesz, zárt kapcsolóként működik, és a maximális áramkör áramlik át az eszközön.

3. lépés Csatlakozási diagram

Az egyetlen áramforrás két 1,5 V-os AA elem, amelyek az Arduino MKR FOX 1200-at táplálják. A GPS-modul az Arduino kártyától kapja az áramot.

Az Arduino MKR FOX 1200 a második soros porton keresztül kommunikál a GPS-modullal, a kódban Serial1-nek nevezett 13-as és 14-es érintkezőkön keresztül. A GPS modul TX adatkimenete az Arduino kártya soros adatbemenetére (13-as érintkező) csatlakozik.

Ezenkívül az Arduino kártya PIN2 kódot használ a GPS-modul be- és kikapcsolására, a fent leírtak szerint.

4. lépés Projekt kód

Az alábbiakban letöltheti vagy másolhatja projektünk kódját:

#beleértve #beleértve #beleértve //incluimos TinyGPS #define VÁRAKOZÁSI IDŐ 15 #define GPS_PIN 2 #define GPS_INFO_BUFFER_SIZE 128 bool debug = false; TinyGPS gps;//GPS objektum //GPS adatváltozók int év; bájt hónap, nap, óra, perc, másodperc, századrész; előjel nélküli hosszú karakterek; aláíratlan rövid mondatok, failed_checksum; char GPS_info_char; char GPS_info_buffer; unsigned int Received_char; bool message_started = false; int i = 0; // GPS koordináta struktúra, 12 bájt méret 32 ​​bites platformokon struct gpscoord ( float a_latitude; // 4 byte float a_longitude; // 4 byte float a_altitude; // 4 byte ); lebegő szélesség = 0,0f; lebegő hosszúság = 0,0f; lebegő magasság = 0; //////////////////////////////////////////////// void Wait(int m, bool s) ( //m perc to wait //s lassú led impulzusok if (debug) ( Serial.print("Várakozás: "); Serial.print(m); Serial.println(" min."); ) digitalWrite(LED_BUILTIN, LOW s) ( int seg = m * 30; for (int i = 0; i< seg; i++) { digitalWrite(LED_BUILTIN, HIGH); //LED on delay(1000); digitalWrite(LED_BUILTIN, LOW); //LED off delay(1000); } } else { int seg = m * 15; for (int i = 0; i < seg; i++) { digitalWrite(LED_BUILTIN, HIGH); //LED on delay(1000); digitalWrite(LED_BUILTIN, LOW); //LED off delay(3000); } } } /////////////////// Sigfox Send Data function //////////////// void SendSigfox(String data) { if (debug) { Serial.print("Sending: "); Serial.println(data); if (data.length() >12) ( Serial.println("Az üzenet túl hosszú, csak az első 12 bájt kerül elküldésre"); ) ) // EOL eltávolítása //data.trim(); // Indítsa el a SigFox modult.begin(); // Várjon legalább 30 ms-ot az első konfiguráció után (100 ms előtt) delay(100); // Törli az összes függőben lévő megszakítást SigFox.status(); késleltetés(1); if (debug) SigFox.debug(); késleltetés(100); SigFox.beginPacket(); SigFox.print(data); if (debug) ( int ret = SigFox.endPacket(true); // puffer küldése a SIGFOX hálózatnak, és várjon a válaszra if (ret > 0) ( Serial.println("Nincs átvitel"); ) else ( Serial.println ("Transmission ok") Serial.print("0x"); Serial.println(SigFox.read(), HEX) ) else ( Serial.println("Nem sikerült választ kapni a szervertől"); Serial.println("Ellenőrizze a SigFoxot); lefedettség az Ön területén"); Serial.println("Ha beltérben tartózkodik, ellenőrizze a 20 dB-es lefedettséget, vagy menjen az ablak közelébe"); ) Serial.println(); ) else ( SigFox.endPacket(); ) SigFox.end( ); ) ///////////////////////////////////////////////////////////////////* A GPS float adatokat Char adatokká alakítja * / String ConvertGPSdata(const void* data, uint8_t len) ( uint8_t* bytes = (uint8_t*)data; String cadena ; if (debug) ( Serial.print("Length: "); Serial.println(len); ) for (uint8_t i = len - 1; i< len; --i) { if (bytes[i] < 12) { cadena.concat(byte(0)); // Not tested } cadena.concat(char(bytes[i])); if (debug) Serial.print(bytes[i], HEX); } if (debug) { Serial.println(""); Serial.print("String to send: "); Serial.println(cadena); } return cadena; } ////////////////////////// Get GPS position function///////////////////// String GetGPSpositon() { int messages_count = 0; String pos; if (debug) Serial.println("GPS ON"); digitalWrite(GPS_PIN, HIGH); //Turn GPS on Wait(1, false); while (messages_count < 5000) { while (Serial1.available()) { int GPS_info_char = Serial1.read(); if (GPS_info_char == "$") messages_count ++; // start of message. Counting messages. if (debug) { if (GPS_info_char == "$") { // start of message message_started = true; received_char = 0; } else if (GPS_info_char == "*") { // end of message for (i = 0; i < received_char; i++) { Serial.write(GPS_info_buffer[i]); // writes the message to the PC once it has been completely received } Serial.println(); message_started = false; // ready for the new message } else if (message_started == true) { // the message is already started and I got a new character if (received_char <= GPS_INFO_BUFFER_SIZE) { // to avoid buffer overflow GPS_info_buffer = GPS_info_char; received_char++; } else { // resets everything (overflow happened) message_started = false; received_char = 0; } } } if (gps.encode(GPS_info_char)) { gps.f_get_position(&latitude, &longitude); altitud = gps.altitude() / 100; // Store coordinates into dedicated structure gpscoord coords = {altitud, longitude, latitude}; gps.crack_datetime(&year, &month, &day, &hour, &minute, &second, &hundredths); if (debug) { Serial.println(); Serial.println(); Serial.print("Latitud/Longitud: "); Serial.print(latitude, 5); Serial.print(", "); Serial.println(longitude, 5); Serial.println(); Serial.print("Fecha: "); Serial.print(day, DEC); Serial.print("/"); Serial.print(month, DEC); Serial.print("/"); Serial.print(year); Serial.print(" Hora: "); Serial.print(hour, DEC); Serial.print(":"); Serial.print(minute, DEC); Serial.print(":"); Serial.print(second, DEC); Serial.print("."); Serial.println(hundredths, DEC); Serial.print("Altitud (metros): "); Serial.println(gps.f_altitude()); Serial.print("Rumbo (grados): "); Serial.println(gps.f_course()); Serial.print("Velocidad(kmph): "); Serial.println(gps.f_speed_kmph()); Serial.print("Satelites: "); Serial.println(gps.satellites()); Serial.println(); } gps.stats(&chars, &sentences, &failed_checksum); if (debug) Serial.println("GPS turned off"); digitalWrite(GPS_PIN, LOW); //GPS turned off pos = ConvertGPSdata(&coords, sizeof(gpscoord)); //Send data return pos; } } } pos = "No Signal"; } //////////////////SETUP/////////////////// void setup() { if (debug) { Serial.begin(9600); while (!Serial) {}// wait for serial port to connect. Needed for native USB port only Serial.println("Serial Connected"); } //Serial1 pins 13-14 for 3.3V connection to GPS. Serial1.begin(9600); while (!Serial1) {} if (debug) { Serial.println("GPS Connected"); } pinMode(GPS_PIN, OUTPUT); //pin de interruptor del GPS if (!SigFox.begin()) { Serial.println("Shield error or not present!"); return; } // Enable debug led and disable automatic deep sleep if (debug) { SigFox.debug(); } else { SigFox.end(); // Send the module to the deepest sleep } } //////////////////////LOOP//////////////////////// void loop() { String position_data; position_data = GetGPSpositon(); SendSigfox(position_data); Wait(WAITING_TIME, false); }

5. lépés: GPS-adatok küldése a Sigfoxon keresztül

GPS információkat szerettünk volna float adatokkal küldeni, de amikor megpróbáltuk, mindig null értékeket kaptunk.

Egy internetes keresés vezetett ehhez a projekthez a GitHubon – Nicolas Lisconi: https://github.com/nicolsc/SmartEverything_SigFox_GPS. AT parancsokat használ bármilyen típusú adat küldésére, és a "float"-ot "hexa"-ra alakítja. Az Arduino MKR FOX 1200 azonban nem rendelkezik AT móddal, és nem tudtuk működésre bírni.

Több tucat tesztet végeztek el, és Nichol kódjának módosításával módot találtak egy "karakterlánc" küldésére, amelyet a Sigfox "float: 32" platform elemzett, és minden átalakítás nélkül közvetlenül használható.

A Sigfox adatok 12 bájtra korlátozódnak. A SigFox hálózatba küldött adatok:

  • Szélesség, float: 32 típus (float:32type), 4 bájt.
  • Hosszúság, float: 32 típus (float:32type), 4 bájt.
  • Magasság, float: 32 típus (float:32type), 4 bájt.

6. lépés: Sigfox visszahívási konfiguráció

Sigfox egyéni visszahívási konfiguráció:

Szél.::float:32lng::float:32 alt::float:32

Kapsz egy e-mailt:

A pozíció egyszerű megjelenítése érdekében a lekért információk alapján az URL-t felvettük a Google Térképbe:

És végül az Arduino GPS nyomkövetőnk eredménye:

Ennyi, remek projekteket kívánok!

Az adatok adatGPS.csv táblázatban kerülnek mentésre, melynek formátuma megfelel a szolgáltatás követelményeinek Google Saját térképek.

    Programozási nyelv: Arduino (C++)

Videós utasítás

Amire szükséged van

Hogyan kell összeszerelni

gps-tracker.ino // könyvtár az eszközökkel való munkavégzéshez SPI-n keresztül#beleértve // könyvtár az SD-kártyával való munkavégzéshez#beleértve // könyvtár a GPS-eszközzel való munkavégzéshez#beleértve // hozzon létre egy objektumot a GPS osztályból, és adja át neki a Serial1 objektumot GPS gps (Serial1) ; // LED tű#define LED_PIN A0 // gombtüske #define BUTTON_PIN 13 // pin CS micro-sd kártya#define CHIP_SELECT_PIN 9 // időintervallum az adatok kártyára írásához#define INTERVAL 5000 // állítsa be a tömb méretét az időhöz, dátumhoz, szélességhez és hosszúsághoz#define MAX_SIZE_MASS 16 // tömb az aktuális idő tárolására char time[MAX_SIZE_MASS]; // rekord állapot bool stateRec = false ; // emlékszik az aktuális időre long startMillis = millis() ; void setup() ( // a soros port megnyitása a programban végzett műveletek figyeléséhez Serial.begin(115200); // várja meg, amíg a soros port monitor megnyílik // a program összes eseményének nyomon követéséhez// while (!Serial) ( // ) Serial.print ("Serial init OK \r\n") ; // soros kapcsolat megnyitása a GPS-modullal Serial1.begin(115200); // állítsa a LED-et kimeneti módba pinMode(LED_PIN, OUTPUT) ; // állítsa be a gombot bejelentkezési módba pinMode(BUTTON_PIN, INPUT_PULLUP) ; // az inicializálással kapcsolatos információkat ad ki a soros portra Serial.println("SD-kártya inicializálása...") ; // inicializálja az SD-kártyát while (! SD.begin (CHIP_SELECT_PIN) ) ( Serial.println ("A kártya meghiúsult, vagy nincs jelen" ) ; delay(1000 ) ; ) // információkat ad ki a soros portra Serial.println("A kártya inicializálva"); // hozzon létre egy dataFile objektumot a File osztályból a fájlokkal való munkához Fájl dataFile = SD.open("dataGPS.csv" , FILE_WRITE) ; // ha a fájl létezik if (adatfájl) ( // írja be a memóriakártyára a jövőbeli adatok nevét dataFile.println("Idő, koordináták, sebesség"); // zárja be a fájlt dataFile.close(); Serial.println("Mentés OK"); ) else ( Serial.println ("Hiba a teszt.csv megnyitásakor" ) ; ) ) void loop() ( // Rögzítse a gombnyomást if (! digitalRead(BUTTON_PIN) ) ( // módosítsa a „rögzítés” / „nem ír” állapotot a memóriakártyára stateRec = ! stateRec; // a jelző LED állapotának módosítása digitalWrite(LED_PIN, állapotRec) ; ) // ha a GPS-modulból érkeztek adatok if (gps.available()) ( // adatok olvasása és elemzése gps.readParsing(); // a GPS-modul állapotának ellenőrzése switch (gps.getState () ) ( // minden rendben van eset GPS_OK: Serial.println ("GPS rendben van" ) ; // ha a megadott időintervallum letelt if (millis() - startMillis > INTERVAL && stateRec) ( // adatok mentése memóriakártyára saveSD() ; // emlékszik az aktuális időre startMillis = millis() ; ) szünet ; // adathiba eset GPS_ERROR_DATA: Serial.println ("GPS hibaadatok" ) ; szünet ;// nincs kapcsolat a műholdakkal eset GPS_ERROR_SAT: Serial.println ("GPS nem csatlakozik műholdakhoz" ) ; szünet ;) ) ) // adatok memóriakártyára mentésének funkciója if (adatfájl) ( void saveSD() ( Fájl dataFile = SD.open("dataGPS.csv" , FILE_WRITE) ;// ha a fájl létezik és meg van nyitva // beolvassa az aktuális időt gps.getTime(idő, MAX_SIZE_MASS); \" " // írja be az időt a memóriakártyára \" " dataFile.print(" \" " ) ; ) ; dataFile.print(time); dataFile.print(") ; dataFile.print ("," ) ; dataFile.print(" \" " // szélességi és hosszúsági koordináták beolvasása és írása a memóriakártyára

dataFile.print(gps.getLatitudeBase10(), 6); dataFile.print ("," ) ; dataFile.print(gps.getLongitudeBase10(), 6); dataFile.print("

) ; dataFile.print ("," ) ; dataFile.print(gps.getSpeedKm()); dataFile.println("km/h"); dataFile.close(); Serial.println("Mentés OK"); ) else ( Serial.println ("Hiba a teszt.csv megnyitásakor" ) ; ) )


Jó napot (este/éjszaka opcionális).

Ma a GPS-vevő és gyakorlati alkalmazásának áttekintése lesz.

ELŐSZÓ

Általában mindig is szerettem volna foglalkozni az ilyen típusú eszközökkel, szerettem volna egy speciális nyomkövetőt, ami megírja a megtett távolságot, de volt egy dolog, azt akartam, hogy a nyomkövetőnek legyen kijelzője, általában szeretem a különféle kijelzőket és igyekszem becsavarja őket mindenbe, ami lehetséges, ez egy ilyen fétis.

Csak néhány a legszélesebb körű értékelés erről a GPS-vevőről - körülbelül 4, az egyik nagyon jó volt, a többit általánosságban leírták. Nem ismétlem magam túl sokat.

Szokásos figyelmeztetés:

Ennek a modulnak a méretei nem haladják meg a 35 x 24 mm-t, és nem csak a hordható elektronikában, hanem az RC eszközökben is megállja a helyét.

A készlet passzív antennát tartalmaz:

Kívánt esetben bármikor kicserélheti az aktívat, vagy saját maga készítheti el a következő módszerrel:

Ma a modul nem elavult modell, és aktívan használják, + van gyártói támogatás.

Az alábbi ábrán megmutattam, hogy mely vonalakat hova kell csatlakoztatni, hogy a GPS-t észlelni lehessen a számítógépben:

Valahogy így néz ki:

Ezután telepítse az U-center alkalmazást, a fenti hivatkozást, és válassza ki a portot:

Alapértelmezés szerint 9600 baudon kommunikálunk.

Általában így működik, minden, amit bentről fogtam:

A modul csatlakoztatása Arduinohoz

Készítsük fel a programozót a firmware-re:

Ezután ezt a vázlatot varrjuk Nano-ba:

további információ

// ArduinoISP // Copyright © 2008-2011 Randall Bohn // Ha licencre van szüksége, lásd: // http://www.opensource.org/licenses/bsd-license.php // // Ez a vázlat az Arduinót egy AVRISP a következő Arduino tűket használva: // // A 10-es tű a cél mikrokontroller alaphelyzetbe állítására szolgál. // // Alapértelmezés szerint a hardveres SPI MISO, MOSI és SCK lábak kommunikálnak // a céllal. Az összes Arduinoson ezek a tűk // az ICSP/SPI fejlécen találhatók: // // MISO °. . 5V (!) Kerülje el ezt a tűt a Due, Zero... // SCK-n. . MOSI // . . GND // // Egyes Arduinokon (Uno,...) a MOSI, MISO és SCK lábak ugyanazok, mint a // digitális 11, 12 és 13 lábak. Ezért sok oktatóprogram arra utasítja //, hogy a célpontot csatlakoztasd ezekhez a csapokhoz. Ha ezt a kábelezést praktikusabbnak találja //, adja meg a USE_OLD_STYLE_WIRING-et. Ez akkor is működik, ha nem // Uno-t használ. (Uno-n erre nincs szükség). // // Alternatív megoldásként bármilyen más digitális tűt használhat a szoftver ("BitBanged") SPI // konfigurálásával és megfelelő definíciókkal a PIN_MOSI, // PIN_MISO és PIN_SCK számára. // // FONTOS: Ha olyan Arduino-t használ, amely nem tolerálja az 5 V-ot (Due, Zero, ...) // programozóként, ügyeljen arra, hogy a programozó érintkezőit ne tegye ki 5 V-nak // Egy egyszerű módja ennek ez a teljes rendszer (programozó // és cél) tápellátása 3V3-on // // Tegyen egy LED-et (ellenállással) a következő érintkezőkre: // 9: Heartbeat - azt mutatja, hogy a programozó fut // 8: Hiba - Kigyullad, ha valami elromlik (használjon pirosat, ha van értelme) // 7: Programozás - Kommunikáció a slave-el // ​​#include "Arduino.h" #undef SERIAL #define PROG_FLICKER true // SPI óra konfigurálása (in Hz). // Például egy ATtiny @ 128 kHz: az adatlap azt írja, hogy a magas és az alacsony SPI órajelnek > 2 CPU-ciklusnak kell lennie, tehát vegyen 3 ciklust, azaz ossza el a cél // f_cpu-t 6-tal: // # define SPI_CLOCK (128000/6) // // Az óra elég lassú az ATtiny85-höz @ 1 MHz, ésszerű alapértelmezett: #define SPI_CLOCK (1000000/6) // Válassza ki a hardver vagy a szoftver SPI-t, az SPI órajelétől függően AVR-nél, más architektúráknál (Due, Zero,...) a hardveres SPI // valószínűleg amúgy is túl gyors. #if definiálva(ARDUINO_ARCH_AVR) #if SPI_CLOCK > (F_CPU / 128) #define USE_HARDWARE_SPI #endif #endif // A használandó lábak beállítása: // A szabványos tűkonfiguráció. #ifndef ARDUINO_HOODLOADER2 #define RESET 10 // Az SS helyett használja a 10-es tűt a cél visszaállításához #define LED_HB 9 #define LED_ERR 8 #define LED_PMODE 7 // Törölje a következő sor megjegyzését a régi Uno stílusú vezetékezés használatához // (a 11-es tű használatával, 12 és 13 az SPI fejléc helyett) a 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 // A HOODLOADER2 vázlatok futtatását jelenti az ATmega16U2 átalakító lapkán vagy Mega16U2 soros chipeken. Kitört tűket kell használnunk: #else #define RESET 4 #define LED_HB 7 #define LED_ERR 6 #define LED_PMODE 5 #endif // Alapértelmezés szerint használjon hardveres SPI-csapokat: #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 kényszerítése, ha nem használja a hardveres SPI lábakat: #if (PIN_MISO != MISO) || (PIN_MOSI != MOSI) || (PIN_SCK != SCK) #undef USE_HARDWARE_SPI #endif // A használandó soros port konfigurálása. // // Előnyben részesítsd az USB virtuális soros portot (más néven natív USB port), ha az Arduino rendelkezik ilyennel: // - nem indul automatikusan visszaállítás (kivéve az 1200-as mágikus adatátviteli sebességet). // - az USB-kézfogás miatt megbízhatóbb. // // A Leonardo és hasonlók USB virtuális soros porttal rendelkeznek: "Serial". // A Due és Zero rendelkezik egy USB virtuális soros porttal: "SerialUSB". // // A Due és Zero esetén a "Serial" is használható, feltéve, hogy letiltja az automatikus visszaállítást. // A "Serial" használatához: #define SERIAL Serial #ifdef SERIAL_PORT_USBVIRTUAL #define SERIAL SERIAL_PORT_USBVIRTUAL #else #define SERIAL Serial #endif // Az adatátviteli sebesség konfigurálása: #define BAUDRATE 19200 // #define1 BAUDRATE 19200 // #define1 BAUDRATE000/5 #define HWVER 2 #define SWMAJ 1 #define SWMIN 18 // STK definíciók #define STK_OK 0x10 #define STK_FAILED 0x11 #define STK_UNKNOWN 0x12 #define STK_INSYNC 0x14 #define 0x14 #define0 Cxx10 is tér... void pulse(int pin, int times); #ifdef USE_HARDWARE_SPI #include "SPI.h" #else #define SPI_MODE0 0x00 osztály SPISettings ( public: // az óra Hz-ben van SPISettings(uint32_t óra, uint8_t bitRend, uint8_t dataMode) (der;void(bit) void) dataMode); class BitBangedSPI ( public: 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 beállítások) ( pulseWidth = (500000 + settings.clock - 1) / settings.clock; if (impulzusszélesség == 0) impulzusszélesség = 1; ) void end() () uint8_t átvitel (uint8_t b) ( for (unsigned int i = 0;< 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; if (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() ( // Cél alaphelyzetbe állítása a PIN_SCK vagy PIN_MOSI futtatása előtt // Az SPI.begin() az SS-t konfigurálja kimenetként, tehát az SPI master mód van kiválasztva. // A RESET-et 10-es tűként határoztuk meg, ami sok Arduinos esetében nem az SS PIN-t // Itt a RESET-et kell beállítani, // (a reset_target() először beállítja a megfelelő szintet) reset_target(true) (SPISettings(SPI_CLOCK, MSBFIRST, SPI_MODE0)); , "SERIAL_PRG programozási algoritmus" fejezet: // Az impulzus RESET a PIN_SCK után alacsony: digitalWrite(PIN_SCK, LOW érték tetszőlegesen választott reset_target(false) // Az impulzusnak legalább 2 cél CPU órajelnek kell lennie, tehát a CPU-hoz 100 usec; // sebességek 20 KHz felett delayMicroseconds(100) // Engedélyezési parancs küldése: delay(50) // adatlap: > 20 msec spi_transaction(0xAC, 0x00, 0x00) (SPI); .end(); pinMode(PIN_SCK, INPUT); reset_target(false); pinMode(RESET, INPUT); 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) ( késleltetés (PTIME); prog_lamp(HIGH); ) ) unsigned int current_page() ( if (param.pagesize == 32) ( visszatér ide & 0xFFFFFFF0; ) if ( param.pagesize == 64) ( visszatér ide & 0xFFFFFFFE0; ) if (param.pagesize == 128) ( visszatér ide & 0xFFFFFFC0; ) if (param.pagesize == 256) ( visszatér ide & 0xFFFFFF80; ) visszatér ide 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 long) ( int x = 0; unsigned int page = current_page(); while(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; maradék -= EECHUNK; ) write_eeprom_chunk(kezdet, maradék); return STK_OK; ) // írás (hossz) byte, (start) egy bájtcím uint8_t write_eeprom_chunk(unsigned int start, unsigned int long) ( // ez byte-onként ír, az oldalírás gyorsabb lehet (egyszerre 4 bájt) fill(length); prog_lamp(LOW);< length; x++) { unsigned int addr = start + x; spi_transaction(0xC0, (addr >> 8) & 0xFF, addr & 0xFF, buff[x]); késleltetés(45); ) prog_lamp(HIGH); return STK_OK; ) void program_page() ( char eredmény = (char) STK_FAILED; előjel nélküli int hossz = 256 * getch(); hossz += getch(); char memtype = getch(); // flash memória @itt, (hossz) byte ha (memtype == "F") ( write_flash(length); return; ) if (memtype == "E") ( result = (char)write_eeprom(length); if (CRC_EOP == getch()) ( SERIAL.print ((char) STK_INSYNC(eredmény) else ( error++; SERIAL.print((char) STK_NOSYNC); ) SERIAL.print((char)STK_FAILED, return spi_transaction); (0x20 + hilo * 8, (addr >> 8) & 0xFF, addr & 0xFF, 0 ) char flash_read_page(int long) ( 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, addr & 0xFF, 0xFF); SERIAL.print((char)ee); ) return STK_OK; ) void read_page() ( char result = (char)STK_FAILED; int hossz = 256 * getch(); hossz += getch(); char memtype = getch(); if (CRC_EOP != getch()) ( error++; SERIAL .print((char) STK_NOSYNC ) SERIAL.print((char) STK_INSYNC) if (memtype == "F") eredmény = flash_read_page(length); (hosszúság SERIAL.print(eredmény) void read_signature() ( if (CRC_EOP != getch()) ( error++; SERIAL.print((char) STK_NOSYNC); return; ) SERIAL.print((char) STK_INSYNC uint8_t magas = spi_transaction(0x30, 0x00, 0x00, 0x00); ///////////////////////////////////////////////// //////////////////////////////////////////////// /// ////////////////////////////////// void avrisp() ( uint8_t ch = getch (); switch (ch) ( "0" eset: // bejelentkezési hiba = 0; empty_reply(); break; "1" eset: if (getch() == CRC_EOP) ( SERIAL.print((char) STK_INSYNC); SERIAL. print("AVR ISP"); else ( error++; SERIAL.print((char) STK_NOSYNC); ) case: get_version(getch()); ": fill(20); empty_reply(); "E" eset: // kiterjesztett paraméterek - most figyelmen kívül hagyja üres_reply(); (!pmode) start_pmode(); break; "U" kisbetű: // cím (szó) beállítása itt += getch() // high addr read_page(); eset 0x75: //STK_READ_SIGN "u" read_signature(); szünet;

Ezután válassza ki a Pro Mini vezérlőt, adja meg az ArduinoISP programozót, és varrja meg a vezérlőt a paranccsal Vázlat -> Feltöltés programozón keresztülés nyomja meg a Reset gombot a Pro minin, a vezérlő firmware-je villogni kezd (nekem csak a második próbálkozásra működik, türelmesnek kell lennem):

Ahogy fentebb is mondtam, nagyon szeretek kijelzőket rögzíteni mindenféle kütyühöz, hát ez hátborzongató, szóval ez "projekt" vágyam nem maradt észrevétlen.

Mi kell mindehhez:

Általában összeszedtem az összes ott heverő szemetet:

1. SD kártya modul, nagyon hatalmas, ezért igyekeztem minél előbb megszabadulni tőle.

2. PCD8544 vezérlőn alapuló kijelző, a jól ismert Nokia kijelző.

3. Egy 1GB-os memóriakártya, a nem népszerű MiniSD szabvánnyal, fogalmam sem volt hova kell bedugni, de mindent be akartam rakni, szóval hadd működjön a navigáció kedvéért.

4. Szükséged lesz egy agyra, egy nagy Pro Mini agyra egy 328P chipen.

Ahogy fentebb is írtam, egy Arduino Nanót fogunk átvarrni, amibe egy bootloadert varrunk.

Általában nagyon keményen igyekeztem az egész projektet nanoba illeszteni, nos, tényleg. Nem megy, vagy lemondunk a memóriakártyáról vagy a kijelzőről.

5. Természetesen maga a modul + antenna, ahogy fentebb is írtam, elkészítheted magad.

6. Ja igen, majdnem elfelejtettem, kell még egy tok, különben milyen készülék ez tok nélkül.

Esetünkben újra megvásárolták, de ezüst formában, tesztelés céljából. Megmondom, nekem abszolút nem tetszett az ezüst szín, a fekete jobban néz ki.

Ha az összes összetevő rendelkezésre áll, csatlakoztathatja és programozhatja az összeset.

A Pro Minihez a következő séma szerint csatlakozunk:

Kijelző:

RST-D6
CE - D7
DC-D5
DIN - D4
CLK-D3
VCC - 5 V (az én esetemben opcionális, másoknál 3,3 V)
Fény - GND
GND - GND

A háttérvilágításra nem volt szükségem, ezért nem kötöttem be.

CS-D10
MOSI-D11
MISO-D12
SCK-D13
GND - GND
5V - VCC (esetemben opcionális, némelyikben konverterrel 3,3V-ra csatlakozunk)

GPS modul:

RX-D8
TX-D2
GND - GND
VCC-3.3 (3.3 a határ!)

Az antennát ne felejtsd el csatlakoztatni a modulhoz, az áramot a Nano Tk-tól vettem. hibakereséshez volt csatlakoztatva, akkor minden át lesz konvertálva akkumulátorra.

Hozzávetőleges nézet:

A kód egyszerű és egyértelmű a használatához, valószínűleg szüksége lesz rá. Tovább . A többi beépített. A kód szerint a sor idő*0.000001+5, lényegében emészthető formába hoztam az időt és hozzáadtam egy időzónát. Ezt kihagyhatja, és tiszta eredményeket kaphat.

Egy másik árnyalat a kijelzőkönyvtárat illetően a következő: a kijelző, beleértve a nullavonalast is, összesen 6 soros. Ami meglehetősen kicsi, ezért azonnal el kell döntenie, hogy néhány információt szimbólumokkal kell megjeleníteni, így helyet takarít meg. A kijelző másodpercenként újrarajzolódik, miközben frissíti és rögzíti a műholdakról érkező információkat.

Ha hiba történik egy fájl olvasása közben, vagy nem fér hozzá az SD-kártyához, egy üzenet jelenik meg SD-, egyéb esetekben SD+.

#beleértve #beleértve #beleértve #beleértve //CS-D10, MOSI-D11, MISO-D12, SCK-D13, GND - GND, 5V - VCC (esetemben opcionális, bizonyos esetekben 3,3V-ra csatlakozunk, ha nincs konverter) Fájl GPS_file; TinyGPS gps; SoftwareSerial gpsSerial(2, 8);//RX - 8 tűs, TX - 2 tűs statikus PCD8544 lcd; //RST - D6, CE - D7, DC - D5, DIN - D4, CLK - D3, VCC - 5 V (opcionális, ha van konverter a 3,3 V-os vonalon), Light - GND, GND - GND bool newdata = hamis; aláírás nélküli hosszú indítás; long lat, lon; aláírás nélküli hosszú idő, dátum; 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-"); lcd.println("SD+"); .txt..."); GPS_file.print("LATITUDE"); GPS_file.print(","); GPS_file.print("HOSSZÚ"); GPS_file .print(","); GPS_file.print("DATE "); GPS_file.print("TIME"); GPS_file.close(); Serial.println("kész." "); ) lcd.setCursor(0,3) ; lcd.print("ALT: "); lcd.print("SPD: "); lcd.print("LAT: "); .setCursor(0,5) lcd.print("LON: "); &lon); gps.get_datetime(&date, &time); lcd.setCursor(55,0); lcd.print(idő*0,000001+5); lcd.setCursor(22, 4); lcd.print(lat); lcd.setCursor(22, 5); lcd.print(lon); 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", FÁJL_ÍRÁS); if(GPS_file)( GPS_file.print(lat); GPS_file.print(","); GPS_file.print(lon); GPS_file.print(","); GPS_file.print(date); 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;)

A firmware felvillantása után valami ilyesmit fog látni (a vázlaton a dátumkimenet a jobb szélre van szerkesztve az idő alatt):

Lehet játszani az elemek elrendezésével, volt ilyen lehetőség, de rájöttem, hogy a koordináták átlagolása óriási hibát produkál, és visszautasítottam.

Akkukhoz használom LI-ion akkumulátor. Akciókamerákba való elemeket ömlesztve veszek és használom a kézműves munkáim során, ráadásul mindig jól jöhetnek egy akciókamerához, amit túrázáskor használok. .

Használata kenyérdeszka, mindent összerakva:

A memóriakártya házára ragasztottam egy darab elektromos szalagot, mivel az érintkezik az akkumulátortöltő érintkezőivel. FAT16-ban flasheljük a memóriakártyát.

Ezután elindítjuk és ellenőrizzük, ne felejtsük el bekapcsolni a kapcsolót:

Az eredmények feldolgozása

Az eredmények szöveges fájlként jelennek meg:

Állítsa az oszlopelválasztót vesszőre:

Ezután az egészet betöltheti a szoftverbe Google Föld Pro a fül segítségével Fájl -> Megnyitás, nyissa meg a fájlunkat, és válassza ki a szélességért és hosszúságért felelős oszlopokat, és kap egy hasonló pályát (mióta egy helyen voltam, szórványos pontokat kaptam):

Kijelölhet egy pontot, és megjelenítheti a hozzá tartozó pontok teljes számát:

A lényeg

Általánosságban elmondható, hogy a logger működik, írhat egy pályát, majd szerkesztheti a térképen. Be is szoftver a Google-tól a pálya egy népszerűbb formátumban menthető, amelyet más térképek támogatnak.

Több mint kielégítettem a kíváncsiságomat.

Hátránya, hogy ez egy kis antenna, néha a hidegindítás akár 10 percig is eltarthat (attól függően, hogy mennyire felhős az idő és a napszak). Az antenna természetesen cserélhető házi készítésűre, vagy vásárolható hozzá, jó néhány aktív antenna van a piacon.

Köszönöm a rám szánt időt.

Frissítés 05/22/18

1. Cseréltem a házat és készítettem egy antennát az általam megadott linkről. (Csökkentett hidegindítási idő, gyorsabban, sokkal gyorsabban megtalálja a műholdakat.)

2. A debug csatlakozót kívülre helyeztem (kijátszás után írok még érdekesebb firmware-t, felteszem ide)

3. A helyigény csökkentése érdekében a kijelzőt szétszedtem és ráforrasztottam.

Eddig ez a kilátás.

Vásárlást tervez +129 Add hozzá a kedvencekhez Tetszett az értékelés +170 +299