Skip to content
BranchesTags

Repository files navigation

GPS Library

A small GPS library written in C and designed for use in embedded systems. The goal of this project is to produce a minimal library for both decoding and encoding NMEA strings quickly on systems which lack a floating point coprocessor. This library was also designed to be fast and safe. It's fast in the sense that the decoder functions try and execute as few instructions as possible when parsing a NMEA sentence. It's safe in the sense that all received input is validated against some hard-coded regular expression.

Features

Here are the major features which this library provides.

Decoder

The decoder is the main feature of this library. It takes in a complete NMEA sentence, dollar sign, checksum, CRLF, and all, and decodes the sentence into a time-position-velocity record. You may then check to see if the values stored are valid and, if they are, you may proceed to make use of the data.

Encoder

This is a utility function. Use it to compose commands intended for sending to the GPS device as valid NMEA sentences.

Installation

This library is composed of only three files; gps.c and gps.h. If you are developing a bare metal application (i.e. Arduino), then feel free to copy the source files directly into your project. Just take care not to modify the copyright statements at the top of each source file.

For users who wish to generate a static or shared libgps library, API documentation, example programs, or unit tests, then use CMake. The following Boolean variables can be switched on or off in order to control what gets built. Their names should be self-explanatory.

  • BUILD_EXAMPLES
  • BUILD_DOCUMENTATION
  • BUILD_UNIT_TESTS
  • BUILD_STATIC_LIB

Note that building the documentation requires Doxygen and building the unit tests requires cmocka.

Simple API

The entire API is made up of only four functions. Please refer to the Doxygen documentation for more detailed information on how to use the API.

  • gps_init_tpv()
  • gps_encode()
  • gps_decode()
  • gps_error_string()

Embedded System Notes

This code was written with embedded systems (and all-around good software design practices) in mind. There is no use of dynamic memory (i.e. malloc) in this library. The only external dependancy which this library has is on the C standard library. All real number data values stored in this library are scaled up by some factor in order to maintain a certain level of accuracy. This way, the use of floating point data types is avoided.

About

A small GPS library designed for use in embedded systems

Resources

Readme
MIT license
Activity

Stars

1 star

Watchers

0 watching

Forks

1 fork
Report repository

Releases

Packages

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all 
 blocks
(function() {
function addCopyButtons() {
document.querySelectorAll('pre code').forEach(function(codeBlock) {
if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
codeBlock.parentElement.setAttribute('data-copy-added', 'true');
var btn = document.createElement('button');
btn.textContent = 'Copy';
btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';
btn.onmouseover = function() { this.style.opacity = '1'; };
btn.onmouseout = function() { this.style.opacity = '0.7'; };
btn.onclick = function() {
navigator.clipboard.writeText(codeBlock.textContent).then(function() {
btn.textContent = 'Copied!';
setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
});
};
codeBlock.parentElement.style.position = 'relative';
codeBlock.parentElement.appendChild(btn);
});
}
addCopyButtons();
// Re-run on dynamic content
var observer = new MutationObserver(addCopyButtons);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '
GitHub - rodrigocelmer/libgps: A small GPS library designed for use in embedded systems · GitHub
Skip to content
BranchesTags
Repository files navigation
GPS Library
A small GPS library written in C and designed for use in embedded systems. The
goal of this project is to produce a minimal library for both decoding and
encoding NMEA strings quickly on systems which lack a floating point
coprocessor. This library was also designed to be fast and safe. It's fast in
the sense that the decoder functions try and execute as few instructions as
possible when parsing a NMEA sentence. It's safe in the sense that all received
input is validated against some hard-coded regular expression.
Features
Here are the major features which this library provides.
Decoder
The decoder is the main feature of this library. It takes in a complete NMEA
sentence, dollar sign, checksum, CRLF, and all, and decodes the sentence into a
time-position-velocity record. You may then check to see if the values stored
are valid and, if they are, you may proceed to make use of the data.
Encoder
This is a utility function. Use it to compose commands intended for sending to
the GPS device as valid NMEA sentences.
Installation
This library is composed of only three files; gps.c and gps.h. If you are
developing a bare metal application (i.e. Arduino), then feel free to copy the
source files directly into your project. Just take care not to modify the
copyright statements at the top of each source file.
For users who wish to generate a static or shared libgps library, API
documentation, example programs, or unit tests, then use CMake. The following
Boolean variables can be switched on or off in order to control what gets
built. Their names should be self-explanatory.
  • BUILD_EXAMPLES
  • BUILD_DOCUMENTATION
  • BUILD_UNIT_TESTS
  • BUILD_STATIC_LIB
Note that building the documentation requires Doxygen and building the
unit tests requires cmocka.
Simple API
The entire API is made up of only four functions. Please refer to the Doxygen
documentation for more detailed information on how to use the API.
  • gps_init_tpv()
  • gps_encode()
  • gps_decode()
  • gps_error_string()
Embedded System Notes
This code was written with embedded systems (and all-around good software
design practices) in mind. There is no use of dynamic memory (i.e. malloc) in
this library. The only external dependancy which this library has is on the C
standard library. All real number data values stored in this library are scaled
up by some factor in order to maintain a certain level of accuracy. This way,
the use of floating point data types is avoided.
About
A small GPS library designed for use in embedded systems
Resources
Readme
MIT license
Activity
Stars
1 star
Watchers
0 watching
Forks
1 fork
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Force GitHub README to respect dark mode
(function() {
var style = document.createElement('style');
style.textContent = '
.markdown-body {
color-scheme: dark light;
}
.markdown-body pre { background: #161b22 !important; }
.markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }
.markdown-body table th, .markdown-body table td { border-color: #30363d !important; }
.markdown-body img { background: #0d1117; }
.markdown-body blockquote { border-left-color: #8b949e; }
.markdown-body hr { border-color: #30363d; }
';
document.head.appendChild(style);
})();
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - rodrigocelmer/libgps: A small GPS library designed for use in embedded systems · GitHub
Skip to content
BranchesTags
Repository files navigation
GPS Library
A small GPS library written in C and designed for use in embedded systems. The
goal of this project is to produce a minimal library for both decoding and
encoding NMEA strings quickly on systems which lack a floating point
coprocessor. This library was also designed to be fast and safe. It's fast in
the sense that the decoder functions try and execute as few instructions as
possible when parsing a NMEA sentence. It's safe in the sense that all received
input is validated against some hard-coded regular expression.
Features
Here are the major features which this library provides.
Decoder
The decoder is the main feature of this library. It takes in a complete NMEA
sentence, dollar sign, checksum, CRLF, and all, and decodes the sentence into a
time-position-velocity record. You may then check to see if the values stored
are valid and, if they are, you may proceed to make use of the data.
Encoder
This is a utility function. Use it to compose commands intended for sending to
the GPS device as valid NMEA sentences.
Installation
This library is composed of only three files; gps.c and gps.h. If you are
developing a bare metal application (i.e. Arduino), then feel free to copy the
source files directly into your project. Just take care not to modify the
copyright statements at the top of each source file.
For users who wish to generate a static or shared libgps library, API
documentation, example programs, or unit tests, then use CMake. The following
Boolean variables can be switched on or off in order to control what gets
built. Their names should be self-explanatory.
  • BUILD_EXAMPLES
  • BUILD_DOCUMENTATION
  • BUILD_UNIT_TESTS
  • BUILD_STATIC_LIB
Note that building the documentation requires Doxygen and building the
unit tests requires cmocka.
Simple API
The entire API is made up of only four functions. Please refer to the Doxygen
documentation for more detailed information on how to use the API.
  • gps_init_tpv()
  • gps_encode()
  • gps_decode()
  • gps_error_string()
Embedded System Notes
This code was written with embedded systems (and all-around good software
design practices) in mind. There is no use of dynamic memory (i.e. malloc) in
this library. The only external dependancy which this library has is on the C
standard library. All real number data values stored in this library are scaled
up by some factor in order to maintain a certain level of accuracy. This way,
the use of floating point data types is avoided.
About
A small GPS library designed for use in embedded systems
Resources
Readme
MIT license
Activity
Stars
1 star
Watchers
0 watching
Forks
1 fork
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Highlight search terms from Google/DuckDuckGo/Bing referrer
(function() {
var ref = document.referrer;
var terms = [];
if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {
var url = new URL(ref);
var q = url.searchParams.get('q') || url.searchParams.get('p');
if (q) {
terms = q.split(/\s+/).filter(function(t) { return t.length > 2; });
}
}
if (terms.length === 0) return;
var style = document.createElement('style');
style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';
document.head.appendChild(style);
function highlight(node) {
if (node.nodeType === 3) { // text node
var text = node.textContent;
var found = false;
terms.forEach(function(term) {
var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi');
if (regex.test(text)) {
found = true;
var frag = document.createDocumentFragment();
var parts = text.split(regex);
parts.forEach(function(part, i) {
if (i % 2 === 0) {
frag.appendChild(document.createTextNode(part));
} else {
var span = document.createElement('span');
span.className = 'userscript-highlight';
span.textContent = part;
frag.appendChild(span);
}
});
node.parentNode.replaceChild(frag, node);
}
});
} else if (node.nodeType === 1 && node.childNodes) { // element
var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];
if (!skipTags.includes(node.tagName)) {
Array.from(node.childNodes).forEach(highlight);
}
}
}
highlight(document.body);
// Re-highlight on dynamic content
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1 || node.nodeType === 3) highlight(node);
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - rodrigocelmer/libgps: A small GPS library designed for use in embedded systems · GitHub
Skip to content
BranchesTags
Repository files navigation
GPS Library
A small GPS library written in C and designed for use in embedded systems. The
goal of this project is to produce a minimal library for both decoding and
encoding NMEA strings quickly on systems which lack a floating point
coprocessor. This library was also designed to be fast and safe. It's fast in
the sense that the decoder functions try and execute as few instructions as
possible when parsing a NMEA sentence. It's safe in the sense that all received
input is validated against some hard-coded regular expression.
Features
Here are the major features which this library provides.
Decoder
The decoder is the main feature of this library. It takes in a complete NMEA
sentence, dollar sign, checksum, CRLF, and all, and decodes the sentence into a
time-position-velocity record. You may then check to see if the values stored
are valid and, if they are, you may proceed to make use of the data.
Encoder
This is a utility function. Use it to compose commands intended for sending to
the GPS device as valid NMEA sentences.
Installation
This library is composed of only three files; gps.c and gps.h. If you are
developing a bare metal application (i.e. Arduino), then feel free to copy the
source files directly into your project. Just take care not to modify the
copyright statements at the top of each source file.
For users who wish to generate a static or shared libgps library, API
documentation, example programs, or unit tests, then use CMake. The following
Boolean variables can be switched on or off in order to control what gets
built. Their names should be self-explanatory.
  • BUILD_EXAMPLES
  • BUILD_DOCUMENTATION
  • BUILD_UNIT_TESTS
  • BUILD_STATIC_LIB
Note that building the documentation requires Doxygen and building the
unit tests requires cmocka.
Simple API
The entire API is made up of only four functions. Please refer to the Doxygen
documentation for more detailed information on how to use the API.
  • gps_init_tpv()
  • gps_encode()
  • gps_decode()
  • gps_error_string()
Embedded System Notes
This code was written with embedded systems (and all-around good software
design practices) in mind. There is no use of dynamic memory (i.e. malloc) in
this library. The only external dependancy which this library has is on the C
standard library. All real number data values stored in this library are scaled
up by some factor in order to maintain a certain level of accuracy. This way,
the use of floating point data types is avoided.
About
A small GPS library designed for use in embedded systems
Resources
Readme
MIT license
Activity
Stars
1 star
Watchers
0 watching
Forks
1 fork
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Strip utm_, fbclid, gclid, etc. from all links on page
(function() {
var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',
'ref', 'ref_src', 'source', 'medium', 'campaign'];
function cleanUrl(url) {
try {
var u = new URL(url, window.location.origin);
var changed = false;
trackingParams.forEach(function(p) {
if (u.searchParams.has(p)) {
u.searchParams.delete(p);
changed = true;
}
});
return changed ? u.toString() : url;
} catch (e) {
return url;
}
}
function cleanLinks() {
document.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
cleanLinks();
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
if (node.tagName === 'A') cleanLinks();
node.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '
GitHub - rodrigocelmer/libgps: A small GPS library designed for use in embedded systems · GitHub
Skip to content
BranchesTags
Repository files navigation
GPS Library
A small GPS library written in C and designed for use in embedded systems. The
goal of this project is to produce a minimal library for both decoding and
encoding NMEA strings quickly on systems which lack a floating point
coprocessor. This library was also designed to be fast and safe. It's fast in
the sense that the decoder functions try and execute as few instructions as
possible when parsing a NMEA sentence. It's safe in the sense that all received
input is validated against some hard-coded regular expression.
Features
Here are the major features which this library provides.
Decoder
The decoder is the main feature of this library. It takes in a complete NMEA
sentence, dollar sign, checksum, CRLF, and all, and decodes the sentence into a
time-position-velocity record. You may then check to see if the values stored
are valid and, if they are, you may proceed to make use of the data.
Encoder
This is a utility function. Use it to compose commands intended for sending to
the GPS device as valid NMEA sentences.
Installation
This library is composed of only three files; gps.c and gps.h. If you are
developing a bare metal application (i.e. Arduino), then feel free to copy the
source files directly into your project. Just take care not to modify the
copyright statements at the top of each source file.
For users who wish to generate a static or shared libgps library, API
documentation, example programs, or unit tests, then use CMake. The following
Boolean variables can be switched on or off in order to control what gets
built. Their names should be self-explanatory.
  • BUILD_EXAMPLES
  • BUILD_DOCUMENTATION
  • BUILD_UNIT_TESTS
  • BUILD_STATIC_LIB
Note that building the documentation requires Doxygen and building the
unit tests requires cmocka.
Simple API
The entire API is made up of only four functions. Please refer to the Doxygen
documentation for more detailed information on how to use the API.
  • gps_init_tpv()
  • gps_encode()
  • gps_decode()
  • gps_error_string()
Embedded System Notes
This code was written with embedded systems (and all-around good software
design practices) in mind. There is no use of dynamic memory (i.e. malloc) in
this library. The only external dependancy which this library has is on the C
standard library. All real number data values stored in this library are scaled
up by some factor in order to maintain a certain level of accuracy. This way,
the use of floating point data types is avoided.
About
A small GPS library designed for use in embedded systems
Resources
Readme
MIT license
Activity
Stars
1 star
Watchers
0 watching
Forks
1 fork
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Auto-enable theater mode on YouTube
(function() {
function tryTheater() {
var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]');
if (btn && !btn.classList.contains('activated')) {
btn.click();
}
}
// Try immediately
tryTheater();
// Try after navigation (SPA)
var lastUrl = location.href;
setInterval(function() {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(tryTheater, 500);
}
}, 1000);
// Also try on player load
var observer = new MutationObserver(tryTheater);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - rodrigocelmer/libgps: A small GPS library designed for use in embedded systems · GitHub
Skip to content
BranchesTags
Repository files navigation
GPS Library
A small GPS library written in C and designed for use in embedded systems. The
goal of this project is to produce a minimal library for both decoding and
encoding NMEA strings quickly on systems which lack a floating point
coprocessor. This library was also designed to be fast and safe. It's fast in
the sense that the decoder functions try and execute as few instructions as
possible when parsing a NMEA sentence. It's safe in the sense that all received
input is validated against some hard-coded regular expression.
Features
Here are the major features which this library provides.
Decoder
The decoder is the main feature of this library. It takes in a complete NMEA
sentence, dollar sign, checksum, CRLF, and all, and decodes the sentence into a
time-position-velocity record. You may then check to see if the values stored
are valid and, if they are, you may proceed to make use of the data.
Encoder
This is a utility function. Use it to compose commands intended for sending to
the GPS device as valid NMEA sentences.
Installation
This library is composed of only three files; gps.c and gps.h. If you are
developing a bare metal application (i.e. Arduino), then feel free to copy the
source files directly into your project. Just take care not to modify the
copyright statements at the top of each source file.
For users who wish to generate a static or shared libgps library, API
documentation, example programs, or unit tests, then use CMake. The following
Boolean variables can be switched on or off in order to control what gets
built. Their names should be self-explanatory.
  • BUILD_EXAMPLES
  • BUILD_DOCUMENTATION
  • BUILD_UNIT_TESTS
  • BUILD_STATIC_LIB
Note that building the documentation requires Doxygen and building the
unit tests requires cmocka.
Simple API
The entire API is made up of only four functions. Please refer to the Doxygen
documentation for more detailed information on how to use the API.
  • gps_init_tpv()
  • gps_encode()
  • gps_decode()
  • gps_error_string()
Embedded System Notes
This code was written with embedded systems (and all-around good software
design practices) in mind. There is no use of dynamic memory (i.e. malloc) in
this library. The only external dependancy which this library has is on the C
standard library. All real number data values stored in this library are scaled
up by some factor in order to maintain a certain level of accuracy. This way,
the use of floating point data types is avoided.
About
A small GPS library designed for use in embedded systems
Resources
Readme
MIT license
Activity
Stars
1 star
Watchers
0 watching
Forks
1 fork
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Remove or un-stick sticky/fixed headers that block content
(function() {
function unstick() {
document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) {
if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {
el.style.position = 'static';
el.style.top = 'auto';
el.style.zIndex = 'auto';
}
});
}
unstick();
var observer = new MutationObserver(unstick);
observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });
})();
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - rodrigocelmer/libgps: A small GPS library designed for use in embedded systems · GitHub
Skip to content
BranchesTags
Repository files navigation
GPS Library
A small GPS library written in C and designed for use in embedded systems. The
goal of this project is to produce a minimal library for both decoding and
encoding NMEA strings quickly on systems which lack a floating point
coprocessor. This library was also designed to be fast and safe. It's fast in
the sense that the decoder functions try and execute as few instructions as
possible when parsing a NMEA sentence. It's safe in the sense that all received
input is validated against some hard-coded regular expression.
Features
Here are the major features which this library provides.
Decoder
The decoder is the main feature of this library. It takes in a complete NMEA
sentence, dollar sign, checksum, CRLF, and all, and decodes the sentence into a
time-position-velocity record. You may then check to see if the values stored
are valid and, if they are, you may proceed to make use of the data.
Encoder
This is a utility function. Use it to compose commands intended for sending to
the GPS device as valid NMEA sentences.
Installation
This library is composed of only three files; gps.c and gps.h. If you are
developing a bare metal application (i.e. Arduino), then feel free to copy the
source files directly into your project. Just take care not to modify the
copyright statements at the top of each source file.
For users who wish to generate a static or shared libgps library, API
documentation, example programs, or unit tests, then use CMake. The following
Boolean variables can be switched on or off in order to control what gets
built. Their names should be self-explanatory.
  • BUILD_EXAMPLES
  • BUILD_DOCUMENTATION
  • BUILD_UNIT_TESTS
  • BUILD_STATIC_LIB
Note that building the documentation requires Doxygen and building the
unit tests requires cmocka.
Simple API
The entire API is made up of only four functions. Please refer to the Doxygen
documentation for more detailed information on how to use the API.
  • gps_init_tpv()
  • gps_encode()
  • gps_decode()
  • gps_error_string()
Embedded System Notes
This code was written with embedded systems (and all-around good software
design practices) in mind. There is no use of dynamic memory (i.e. malloc) in
this library. The only external dependancy which this library has is on the C
standard library. All real number data values stored in this library are scaled
up by some factor in order to maintain a certain level of accuracy. This way,
the use of floating point data types is avoided.
About
A small GPS library designed for use in embedded systems
Resources
Readme
MIT license
Activity
Stars
1 star
Watchers
0 watching
Forks
1 fork
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Universal Dark Mode - works on any site
(function() {
var enabled = true;
function applyDarkMode() {
if (!enabled) return;
// Create style element if it doesn't exist
var style = document.getElementById('universal-dark-mode-style');
if (!style) {
style = document.createElement('style');
style.id = 'universal-dark-mode-style';
document.head.appendChild(style);
}
// Dark mode CSS - inverts colors but preserves images/video
style.textContent = '
/* Invert everything except media */
html {
filter: invert(1) hue-rotate(180deg) !important;
background: #1a1a2e !important;
}
/* Restore images, videos, iframes, canvas */
img, video, iframe, canvas, svg, picture, [style*="background-image"] {
filter: invert(1) hue-rotate(180deg) !important;
}
/* Preserve specific elements that should not be inverted */
.no-dark-mode, .no-dark-mode *,
[data-theme="light"], [data-theme="light"],
.ace_editor, .ace_editor *,
.CodeMirror, .CodeMirror *,
.monaco-editor, .monaco-editor *,
.markdown-body pre, .markdown-body pre *,
.highlight, .highlight *,
pre code, pre code * {
filter: none !important;
}
/* Fix common UI elements */
.modal, .popup, .dropdown-menu, .tooltip, .popover {
filter: invert(1) hue-rotate(180deg) !important;
background: #2d2d44 !important;
border-color: #444 !important;
}
/* Scrollbars */
::-webkit-scrollbar { background: #1a1a2e !important; }
::-webkit-scrollbar-thumb { background: #444 !important; }
::-webkit-scrollbar-thumb:hover { background: #555 !important; }
/* Selection */
::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
';
}
function removeDarkMode() {
var style = document.getElementById('universal-dark-mode-style');
if (style) style.remove();
}
// Toggle with Alt+Shift+D
document.addEventListener('keydown', function(e) {
if (e.altKey && e.shiftKey && e.key === 'D') {
e.preventDefault();
enabled = !enabled;
if (enabled) {
applyDarkMode();
console.log('[Universal Dark Mode] Enabled');
} else {
removeDarkMode();
console.log('[Universal Dark Mode] Disabled');
}
}
});
// Apply on load
applyDarkMode();
// Re-apply on dynamic content
var observer = new MutationObserver(function(mutations) {
if (enabled && !document.getElementById('universal-dark-mode-style')) {
applyDarkMode();
}
});
observer.observe(document.head, { childList: true });
console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');
})();
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();
GitHub - rodrigocelmer/libgps: A small GPS library designed for use in embedded systems · GitHub
Skip to content
BranchesTags
Repository files navigation
GPS Library
A small GPS library written in C and designed for use in embedded systems. The
goal of this project is to produce a minimal library for both decoding and
encoding NMEA strings quickly on systems which lack a floating point
coprocessor. This library was also designed to be fast and safe. It's fast in
the sense that the decoder functions try and execute as few instructions as
possible when parsing a NMEA sentence. It's safe in the sense that all received
input is validated against some hard-coded regular expression.
Features
Here are the major features which this library provides.
Decoder
The decoder is the main feature of this library. It takes in a complete NMEA
sentence, dollar sign, checksum, CRLF, and all, and decodes the sentence into a
time-position-velocity record. You may then check to see if the values stored
are valid and, if they are, you may proceed to make use of the data.
Encoder
This is a utility function. Use it to compose commands intended for sending to
the GPS device as valid NMEA sentences.
Installation
This library is composed of only three files; gps.c and gps.h. If you are
developing a bare metal application (i.e. Arduino), then feel free to copy the
source files directly into your project. Just take care not to modify the
copyright statements at the top of each source file.
For users who wish to generate a static or shared libgps library, API
documentation, example programs, or unit tests, then use CMake. The following
Boolean variables can be switched on or off in order to control what gets
built. Their names should be self-explanatory.
  • BUILD_EXAMPLES
  • BUILD_DOCUMENTATION
  • BUILD_UNIT_TESTS
  • BUILD_STATIC_LIB
Note that building the documentation requires Doxygen and building the
unit tests requires cmocka.
Simple API
The entire API is made up of only four functions. Please refer to the Doxygen
documentation for more detailed information on how to use the API.
  • gps_init_tpv()
  • gps_encode()
  • gps_decode()
  • gps_error_string()
Embedded System Notes
This code was written with embedded systems (and all-around good software
design practices) in mind. There is no use of dynamic memory (i.e. malloc) in
this library. The only external dependancy which this library has is on the C
standard library. All real number data values stored in this library are scaled
up by some factor in order to maintain a certain level of accuracy. This way,
the use of floating point data types is avoided.
About
A small GPS library designed for use in embedded systems
Resources
Readme
MIT license
Activity
Stars
1 star
Watchers
0 watching
Forks
1 fork
Report repository
Releases
Packages
Contributors
Languages