Skip to content
This repository was archived by the owner on Apr 20, 2026. It is now read-only.
BranchesTags

Repository files navigation

AsyncTCP

Build StatusCodacy Badge

Build Options

The following symbols can be defined to change the configuration

NameDescriptionDefault
CONFIG_ASYNC_TCP_EVENT_QUEUE_SIZEThe size of the queue string TCP events to processCONFIG_LWIP_MAX_ACTIVE_TCP * 2 == 32
CONFIG_ASYNC_TCP_RUNNING_COREThe CPU core to run the async task on-1 (any cpu)
CONFIG_ASYNC_TCP_USE_WDTIf the watchdog timer should be enabled while processing TCP messages. Set to 0 to disable1 (enabled)
CONFIG_ASYNC_TCP_TASK_STACK_SIZEThe number of 32-bit words (not bytes!) to allocate for use as the task's stack.8192
CONFIG_ASYNC_TCP_TASK_PRIORITYThe priority at which the created task will execute.3
CONFIG_ASYNC_TCP_DIAGNOSTICSEnable diagnostic functionsdisabled

Other Parameters

NameDescriptionDefault
CONFIG_LWIP_MAX_ACTIVE_TCPhttps://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/kconfig.html#config-lwip-max-active-tcp16

Diagnostics Functions

Stack Highwater Mark

AsyncTCP creates a task to handle the TCP messages. This task needs to be initialize with stack space. See How big should the stack be?

This function gets the async_tcp task's minimum amount of remaining stack space that was available to the task since the task started executing - - that is the amount of stack that remained unused when the task stack was at its greatest (deepest) value. This is what is referred to as the stack 'high water mark'. For more information on the stack high water mark, see See https://www.freertos.org/uxTaskGetStackHighWaterMark.html

If the value from this function is close to zero, increasing CONFIG_ASYNC_TCP_TASK_STACK_SIZE can help.

static UBaseType_t AsyncClient::getStackHighWaterMark()

Async TCP Library for ESP32 Arduino

Join the chat at https://gitter.im/me-no-dev/ESPAsyncWebServer

This is a fully asynchronous TCP library, aimed at enabling trouble-free, multi-connection network environment for Espressif's ESP32 MCUs.

This library is the base for ESPAsyncWebServer

AsyncClient and AsyncServer

The base classes on which everything else is built. They expose all possible scenarios, but are really raw and require more skills to use.

About

Async TCP Library for ESP32

Resources

Readme
LGPL-3.0 license
Activity

Stars

4 stars

Watchers

1 watching

Forks

6 forks
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 - pbolduc/AsyncTCP: Async TCP Library for ESP32 · GitHub
Skip to content

This repository was archived by the owner on Apr 20, 2026. It is now read-only.

BranchesTags
Repository files navigation
AsyncTCP
Build StatusCodacy Badge
Build Options
The following symbols can be defined to change the configuration
NameDescriptionDefault
CONFIG_ASYNC_TCP_EVENT_QUEUE_SIZEThe size of the queue string TCP events to processCONFIG_LWIP_MAX_ACTIVE_TCP * 2 == 32
CONFIG_ASYNC_TCP_RUNNING_COREThe CPU core to run the async task on-1 (any cpu)
CONFIG_ASYNC_TCP_USE_WDTIf the watchdog timer should be enabled while processing TCP messages. Set to 0 to disable1 (enabled)
CONFIG_ASYNC_TCP_TASK_STACK_SIZEThe number of 32-bit words (not bytes!) to allocate for use as the task's stack.8192
CONFIG_ASYNC_TCP_TASK_PRIORITYThe priority at which the created task will execute.3
CONFIG_ASYNC_TCP_DIAGNOSTICSEnable diagnostic functionsdisabled
Other Parameters
NameDescriptionDefault
CONFIG_LWIP_MAX_ACTIVE_TCPhttps://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/kconfig.html#config-lwip-max-active-tcp16
Diagnostics Functions
Stack Highwater Mark
AsyncTCP creates a task to handle the TCP messages. This task needs to be initialize
with stack space. See How big should the stack be?
This function gets the async_tcp task's minimum amount of remaining stack space that was
available to the task since the task started executing - - that is the amount
of stack that remained unused when the task stack was at its greatest (deepest)
value. This is what is referred to as the stack 'high water mark'. For more information
on the stack high water mark, see See https://www.freertos.org/uxTaskGetStackHighWaterMark.html
If the value from this function is close to zero, increasing CONFIG_ASYNC_TCP_TASK_STACK_SIZE can help.
static UBaseType_t AsyncClient::getStackHighWaterMark()
Async TCP Library for ESP32 Arduino
Join the chat at https://gitter.im/me-no-dev/ESPAsyncWebServer
This is a fully asynchronous TCP library, aimed at enabling trouble-free, multi-connection network environment for Espressif's ESP32 MCUs.
This library is the base for ESPAsyncWebServer
AsyncClient and AsyncServer
The base classes on which everything else is built. They expose all possible scenarios, but are really raw and require more skills to use.
About
Async TCP Library for ESP32
Resources
Readme
LGPL-3.0 license
Activity
Stars
4 stars
Watchers
1 watching
Forks
6 forks
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 - pbolduc/AsyncTCP: Async TCP Library for ESP32 · GitHub
Skip to content

This repository was archived by the owner on Apr 20, 2026. It is now read-only.

BranchesTags
Repository files navigation
AsyncTCP
Build StatusCodacy Badge
Build Options
The following symbols can be defined to change the configuration
NameDescriptionDefault
CONFIG_ASYNC_TCP_EVENT_QUEUE_SIZEThe size of the queue string TCP events to processCONFIG_LWIP_MAX_ACTIVE_TCP * 2 == 32
CONFIG_ASYNC_TCP_RUNNING_COREThe CPU core to run the async task on-1 (any cpu)
CONFIG_ASYNC_TCP_USE_WDTIf the watchdog timer should be enabled while processing TCP messages. Set to 0 to disable1 (enabled)
CONFIG_ASYNC_TCP_TASK_STACK_SIZEThe number of 32-bit words (not bytes!) to allocate for use as the task's stack.8192
CONFIG_ASYNC_TCP_TASK_PRIORITYThe priority at which the created task will execute.3
CONFIG_ASYNC_TCP_DIAGNOSTICSEnable diagnostic functionsdisabled
Other Parameters
NameDescriptionDefault
CONFIG_LWIP_MAX_ACTIVE_TCPhttps://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/kconfig.html#config-lwip-max-active-tcp16
Diagnostics Functions
Stack Highwater Mark
AsyncTCP creates a task to handle the TCP messages. This task needs to be initialize
with stack space. See How big should the stack be?
This function gets the async_tcp task's minimum amount of remaining stack space that was
available to the task since the task started executing - - that is the amount
of stack that remained unused when the task stack was at its greatest (deepest)
value. This is what is referred to as the stack 'high water mark'. For more information
on the stack high water mark, see See https://www.freertos.org/uxTaskGetStackHighWaterMark.html
If the value from this function is close to zero, increasing CONFIG_ASYNC_TCP_TASK_STACK_SIZE can help.
static UBaseType_t AsyncClient::getStackHighWaterMark()
Async TCP Library for ESP32 Arduino
Join the chat at https://gitter.im/me-no-dev/ESPAsyncWebServer
This is a fully asynchronous TCP library, aimed at enabling trouble-free, multi-connection network environment for Espressif's ESP32 MCUs.
This library is the base for ESPAsyncWebServer
AsyncClient and AsyncServer
The base classes on which everything else is built. They expose all possible scenarios, but are really raw and require more skills to use.
About
Async TCP Library for ESP32
Resources
Readme
LGPL-3.0 license
Activity
Stars
4 stars
Watchers
1 watching
Forks
6 forks
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 - pbolduc/AsyncTCP: Async TCP Library for ESP32 · GitHub
Skip to content

This repository was archived by the owner on Apr 20, 2026. It is now read-only.

BranchesTags
Repository files navigation
AsyncTCP
Build StatusCodacy Badge
Build Options
The following symbols can be defined to change the configuration
NameDescriptionDefault
CONFIG_ASYNC_TCP_EVENT_QUEUE_SIZEThe size of the queue string TCP events to processCONFIG_LWIP_MAX_ACTIVE_TCP * 2 == 32
CONFIG_ASYNC_TCP_RUNNING_COREThe CPU core to run the async task on-1 (any cpu)
CONFIG_ASYNC_TCP_USE_WDTIf the watchdog timer should be enabled while processing TCP messages. Set to 0 to disable1 (enabled)
CONFIG_ASYNC_TCP_TASK_STACK_SIZEThe number of 32-bit words (not bytes!) to allocate for use as the task's stack.8192
CONFIG_ASYNC_TCP_TASK_PRIORITYThe priority at which the created task will execute.3
CONFIG_ASYNC_TCP_DIAGNOSTICSEnable diagnostic functionsdisabled
Other Parameters
NameDescriptionDefault
CONFIG_LWIP_MAX_ACTIVE_TCPhttps://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/kconfig.html#config-lwip-max-active-tcp16
Diagnostics Functions
Stack Highwater Mark
AsyncTCP creates a task to handle the TCP messages. This task needs to be initialize
with stack space. See How big should the stack be?
This function gets the async_tcp task's minimum amount of remaining stack space that was
available to the task since the task started executing - - that is the amount
of stack that remained unused when the task stack was at its greatest (deepest)
value. This is what is referred to as the stack 'high water mark'. For more information
on the stack high water mark, see See https://www.freertos.org/uxTaskGetStackHighWaterMark.html
If the value from this function is close to zero, increasing CONFIG_ASYNC_TCP_TASK_STACK_SIZE can help.
static UBaseType_t AsyncClient::getStackHighWaterMark()
Async TCP Library for ESP32 Arduino
Join the chat at https://gitter.im/me-no-dev/ESPAsyncWebServer
This is a fully asynchronous TCP library, aimed at enabling trouble-free, multi-connection network environment for Espressif's ESP32 MCUs.
This library is the base for ESPAsyncWebServer
AsyncClient and AsyncServer
The base classes on which everything else is built. They expose all possible scenarios, but are really raw and require more skills to use.
About
Async TCP Library for ESP32
Resources
Readme
LGPL-3.0 license
Activity
Stars
4 stars
Watchers
1 watching
Forks
6 forks
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 - pbolduc/AsyncTCP: Async TCP Library for ESP32 · GitHub
Skip to content

This repository was archived by the owner on Apr 20, 2026. It is now read-only.

BranchesTags
Repository files navigation
AsyncTCP
Build StatusCodacy Badge
Build Options
The following symbols can be defined to change the configuration
NameDescriptionDefault
CONFIG_ASYNC_TCP_EVENT_QUEUE_SIZEThe size of the queue string TCP events to processCONFIG_LWIP_MAX_ACTIVE_TCP * 2 == 32
CONFIG_ASYNC_TCP_RUNNING_COREThe CPU core to run the async task on-1 (any cpu)
CONFIG_ASYNC_TCP_USE_WDTIf the watchdog timer should be enabled while processing TCP messages. Set to 0 to disable1 (enabled)
CONFIG_ASYNC_TCP_TASK_STACK_SIZEThe number of 32-bit words (not bytes!) to allocate for use as the task's stack.8192
CONFIG_ASYNC_TCP_TASK_PRIORITYThe priority at which the created task will execute.3
CONFIG_ASYNC_TCP_DIAGNOSTICSEnable diagnostic functionsdisabled
Other Parameters
NameDescriptionDefault
CONFIG_LWIP_MAX_ACTIVE_TCPhttps://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/kconfig.html#config-lwip-max-active-tcp16
Diagnostics Functions
Stack Highwater Mark
AsyncTCP creates a task to handle the TCP messages. This task needs to be initialize
with stack space. See How big should the stack be?
This function gets the async_tcp task's minimum amount of remaining stack space that was
available to the task since the task started executing - - that is the amount
of stack that remained unused when the task stack was at its greatest (deepest)
value. This is what is referred to as the stack 'high water mark'. For more information
on the stack high water mark, see See https://www.freertos.org/uxTaskGetStackHighWaterMark.html
If the value from this function is close to zero, increasing CONFIG_ASYNC_TCP_TASK_STACK_SIZE can help.
static UBaseType_t AsyncClient::getStackHighWaterMark()
Async TCP Library for ESP32 Arduino
Join the chat at https://gitter.im/me-no-dev/ESPAsyncWebServer
This is a fully asynchronous TCP library, aimed at enabling trouble-free, multi-connection network environment for Espressif's ESP32 MCUs.
This library is the base for ESPAsyncWebServer
AsyncClient and AsyncServer
The base classes on which everything else is built. They expose all possible scenarios, but are really raw and require more skills to use.
About
Async TCP Library for ESP32
Resources
Readme
LGPL-3.0 license
Activity
Stars
4 stars
Watchers
1 watching
Forks
6 forks
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 - pbolduc/AsyncTCP: Async TCP Library for ESP32 · GitHub
Skip to content

This repository was archived by the owner on Apr 20, 2026. It is now read-only.

BranchesTags
Repository files navigation
AsyncTCP
Build StatusCodacy Badge
Build Options
The following symbols can be defined to change the configuration
NameDescriptionDefault
CONFIG_ASYNC_TCP_EVENT_QUEUE_SIZEThe size of the queue string TCP events to processCONFIG_LWIP_MAX_ACTIVE_TCP * 2 == 32
CONFIG_ASYNC_TCP_RUNNING_COREThe CPU core to run the async task on-1 (any cpu)
CONFIG_ASYNC_TCP_USE_WDTIf the watchdog timer should be enabled while processing TCP messages. Set to 0 to disable1 (enabled)
CONFIG_ASYNC_TCP_TASK_STACK_SIZEThe number of 32-bit words (not bytes!) to allocate for use as the task's stack.8192
CONFIG_ASYNC_TCP_TASK_PRIORITYThe priority at which the created task will execute.3
CONFIG_ASYNC_TCP_DIAGNOSTICSEnable diagnostic functionsdisabled
Other Parameters
NameDescriptionDefault
CONFIG_LWIP_MAX_ACTIVE_TCPhttps://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/kconfig.html#config-lwip-max-active-tcp16
Diagnostics Functions
Stack Highwater Mark
AsyncTCP creates a task to handle the TCP messages. This task needs to be initialize
with stack space. See How big should the stack be?
This function gets the async_tcp task's minimum amount of remaining stack space that was
available to the task since the task started executing - - that is the amount
of stack that remained unused when the task stack was at its greatest (deepest)
value. This is what is referred to as the stack 'high water mark'. For more information
on the stack high water mark, see See https://www.freertos.org/uxTaskGetStackHighWaterMark.html
If the value from this function is close to zero, increasing CONFIG_ASYNC_TCP_TASK_STACK_SIZE can help.
static UBaseType_t AsyncClient::getStackHighWaterMark()
Async TCP Library for ESP32 Arduino
Join the chat at https://gitter.im/me-no-dev/ESPAsyncWebServer
This is a fully asynchronous TCP library, aimed at enabling trouble-free, multi-connection network environment for Espressif's ESP32 MCUs.
This library is the base for ESPAsyncWebServer
AsyncClient and AsyncServer
The base classes on which everything else is built. They expose all possible scenarios, but are really raw and require more skills to use.
About
Async TCP Library for ESP32
Resources
Readme
LGPL-3.0 license
Activity
Stars
4 stars
Watchers
1 watching
Forks
6 forks
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 - pbolduc/AsyncTCP: Async TCP Library for ESP32 · GitHub
Skip to content

This repository was archived by the owner on Apr 20, 2026. It is now read-only.

BranchesTags
Repository files navigation
AsyncTCP
Build StatusCodacy Badge
Build Options
The following symbols can be defined to change the configuration
NameDescriptionDefault
CONFIG_ASYNC_TCP_EVENT_QUEUE_SIZEThe size of the queue string TCP events to processCONFIG_LWIP_MAX_ACTIVE_TCP * 2 == 32
CONFIG_ASYNC_TCP_RUNNING_COREThe CPU core to run the async task on-1 (any cpu)
CONFIG_ASYNC_TCP_USE_WDTIf the watchdog timer should be enabled while processing TCP messages. Set to 0 to disable1 (enabled)
CONFIG_ASYNC_TCP_TASK_STACK_SIZEThe number of 32-bit words (not bytes!) to allocate for use as the task's stack.8192
CONFIG_ASYNC_TCP_TASK_PRIORITYThe priority at which the created task will execute.3
CONFIG_ASYNC_TCP_DIAGNOSTICSEnable diagnostic functionsdisabled
Other Parameters
NameDescriptionDefault
CONFIG_LWIP_MAX_ACTIVE_TCPhttps://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/kconfig.html#config-lwip-max-active-tcp16
Diagnostics Functions
Stack Highwater Mark
AsyncTCP creates a task to handle the TCP messages. This task needs to be initialize
with stack space. See How big should the stack be?
This function gets the async_tcp task's minimum amount of remaining stack space that was
available to the task since the task started executing - - that is the amount
of stack that remained unused when the task stack was at its greatest (deepest)
value. This is what is referred to as the stack 'high water mark'. For more information
on the stack high water mark, see See https://www.freertos.org/uxTaskGetStackHighWaterMark.html
If the value from this function is close to zero, increasing CONFIG_ASYNC_TCP_TASK_STACK_SIZE can help.
static UBaseType_t AsyncClient::getStackHighWaterMark()
Async TCP Library for ESP32 Arduino
Join the chat at https://gitter.im/me-no-dev/ESPAsyncWebServer
This is a fully asynchronous TCP library, aimed at enabling trouble-free, multi-connection network environment for Espressif's ESP32 MCUs.
This library is the base for ESPAsyncWebServer
AsyncClient and AsyncServer
The base classes on which everything else is built. They expose all possible scenarios, but are really raw and require more skills to use.
About
Async TCP Library for ESP32
Resources
Readme
LGPL-3.0 license
Activity
Stars
4 stars
Watchers
1 watching
Forks
6 forks
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 - pbolduc/AsyncTCP: Async TCP Library for ESP32 · GitHub
Skip to content

This repository was archived by the owner on Apr 20, 2026. It is now read-only.

BranchesTags
Repository files navigation
AsyncTCP
Build StatusCodacy Badge
Build Options
The following symbols can be defined to change the configuration
NameDescriptionDefault
CONFIG_ASYNC_TCP_EVENT_QUEUE_SIZEThe size of the queue string TCP events to processCONFIG_LWIP_MAX_ACTIVE_TCP * 2 == 32
CONFIG_ASYNC_TCP_RUNNING_COREThe CPU core to run the async task on-1 (any cpu)
CONFIG_ASYNC_TCP_USE_WDTIf the watchdog timer should be enabled while processing TCP messages. Set to 0 to disable1 (enabled)
CONFIG_ASYNC_TCP_TASK_STACK_SIZEThe number of 32-bit words (not bytes!) to allocate for use as the task's stack.8192
CONFIG_ASYNC_TCP_TASK_PRIORITYThe priority at which the created task will execute.3
CONFIG_ASYNC_TCP_DIAGNOSTICSEnable diagnostic functionsdisabled
Other Parameters
NameDescriptionDefault
CONFIG_LWIP_MAX_ACTIVE_TCPhttps://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/kconfig.html#config-lwip-max-active-tcp16
Diagnostics Functions
Stack Highwater Mark
AsyncTCP creates a task to handle the TCP messages. This task needs to be initialize
with stack space. See How big should the stack be?
This function gets the async_tcp task's minimum amount of remaining stack space that was
available to the task since the task started executing - - that is the amount
of stack that remained unused when the task stack was at its greatest (deepest)
value. This is what is referred to as the stack 'high water mark'. For more information
on the stack high water mark, see See https://www.freertos.org/uxTaskGetStackHighWaterMark.html
If the value from this function is close to zero, increasing CONFIG_ASYNC_TCP_TASK_STACK_SIZE can help.
static UBaseType_t AsyncClient::getStackHighWaterMark()
Async TCP Library for ESP32 Arduino
Join the chat at https://gitter.im/me-no-dev/ESPAsyncWebServer
This is a fully asynchronous TCP library, aimed at enabling trouble-free, multi-connection network environment for Espressif's ESP32 MCUs.
This library is the base for ESPAsyncWebServer
AsyncClient and AsyncServer
The base classes on which everything else is built. They expose all possible scenarios, but are really raw and require more skills to use.
About
Async TCP Library for ESP32
Resources
Readme
LGPL-3.0 license
Activity
Stars
4 stars
Watchers
1 watching
Forks
6 forks
Report repository
Releases
Packages
Contributors
Languages