# AvantMaker.com > Your Premier Hub for DIY, AI, IoT, and STEM Innovation. ## Posts - [ESP32_AI_Connect v0.5.16 Released – Now with xAI Grok Support and Improved Reliability](https://avantmaker.com/esp32_ai_connect-v0-5-16-released-now-with-xai-grok-support-and-improved-reliability/): We’re excited to announce the release of ESP32_AI_Connect v0.5.16 – another step forward in making powerful AI services easily accessible from your ESP32 projects! This update brings official support for xAI’s Grok LLM platform, along with a new automatic retry mechanism that significantly improves connection stability in real-world IoT scenarios. What’s New in v0.5.16 Why This Matters for ESP32 Developers With Grok support, you now have access to one of the most capable and efficient large language models available today – all while keeping your ESP32 code lightweight and memory-efficient. Combined with the new retry mechanism, the library is better […] - [Advanced Analog Input Management for ESP32, Now Available!](https://avantmaker.com/advanced-analog-input-management-for-esp32-now-available/): We’re excited to announce the launch of our latest library, AvantAnalogRead! Following the release of our digital input library, AvantDigitalRead, we’re taking another step forward in simplifying and enhancing your ESP32 projects. This time, we’re focusing on the often complex world of analog inputs. Just like AvantDigitalRead made handling buttons and digital sensors a breeze, AvantAnalogRead is here to transform how you work with potentiometers, analog sensors, and variable resistors. Say goodbye to messy analog input code and hello to clean, reliable, and feature-rich data acquisition! Why AvantAnalogRead? If you’ve ever tried to read data from a potentiometer or an […] - [AvantDigitalRead: Elevate Your ESP32 Projects with Smart Input Handling](https://avantmaker.com/avantdigitalread-elevate-your-esp32-projects-with-smart-input-handling/): We are excited to unveil the latest addition to the AvantMaker family of ESP32 Arduino libraries: AvantDigitalRead, a powerful and versatile library designed to revolutionize digital input management on the ESP32. Crafted with makers, hobbyists, and developers in mind, AvantDigitalRead enhances the standard Arduino digitalRead functionality, offering advanced features like multi-pin management, event detection, and sophisticated gesture recognition. What’s AvantDigitalRead All About? AvantDigitalRead is a comprehensive solution for managing digital inputs on the ESP32. Whether you’re building interactive user interfaces, handling sensor data, or creating complex IoT devices, this library simplifies the process with a clean, intuitive interface. It takes the hassle out […] - [Announcing AvantPinSet: The Ultimate ESP32 Pin Control Library for Makers](https://avantmaker.com/announcing-avantpinset-the-ultimate-esp32-pin-control-library-for-makers/): We are thrilled to introduce the newest addition to the AvantMaker family of libraries: AvantPinSet, a powerful and intuitive Arduino library designed to simplify GPIO pin management for the ESP32. AvantPinSet is engineered to make your projects more responsive, dynamic, and easier to code. What’s AvantPinSet All About? AvantPinSet is a comprehensive solution for managing multiple ESP32 pins with a wide range of functionalities. It provides a clean, unified interface for digital I/O, PWM control, and sophisticated timed and fading operations. Say goodbye to complex millis() logic and tangled code—AvantPinSet handles the low-level details so you can focus on bringing your creative ideas […] - [AvantMaker’s AvantLumi: Light Up Your ESP32 and Arduino Projects with Stunning LED Control!](https://avantmaker.com/avantmakers-avantlumi-light-up-your-esp32-and-arduino-projects-with-stunning-led-control/): Hey Makers, Get Ready to Shine! We’re absolutely thrilled to unveil the latest gem in the AvantMaker lineup: AvantLumi, a dazzling Arduino library crafted to elevate your LED strip projects on ESP32, Arduino, and compatible microcontrollers! What’s AvantLumi All About? Built on the robust FastLED library, AvantLumi is your ultimate tool for creating breathtaking LED effects with a user-friendly, feature-rich interface. From colorful palettes to smooth fade animations, this library is designed to ignite your creativity in IoT and DIY projects. It’s perfect for both beginners and experienced makers, offering a seamless way to bring your lighting visions to life. […] - [ESP32_AI_Connect: Version 0.5.1 Released](https://avantmaker.com/esp32_ai_connect-version-0-5-0-12-release-notes/): We are excited to announce the first official release of ESP32_AI_Connect, an Arduino library that makes it easy to connect your ESP32 projects to powerful AI APIs. This library is designed for IoT applications, providing a unified and memory-efficient way to integrate AI into your devices. ESP32_AI_Connect library is available on GitHub. Visit the ESP32_AI_Connect GitHub repository to download the latest version, explore the documentation, and try out example codes that showcase streaming in action. Key Features in This Release Getting Started To begin using ESP32_AI_Connect, please refer to the detailed User Guide available in the project’s README. Important Dependency: This library requires the ArduinoJson library […] - [ESP32_AI_Connect Library Adds Streaming Support for Real-Time AI Interaction](https://avantmaker.com/esp32_ai_connect-library-adds-streaming-support-for-real-time-ai-interaction/): The AvantMaker team has just rolled out an exciting update to the ESP32_AI_Connect library, introducing streaming support for real-time communication with large language models like OpenAI, DeepSeek, Gemini, and Claude. This update brings a dynamic, conversation-like experience to ESP32-based projects, making AI integration more responsive and engaging. What is Streaming Chat? Streaming chat enables real-time interaction with AI models by delivering responses as they are generated, rather than waiting for the entire output. This creates a more natural and engaging user experience, mimicking the flow of a live conversation. With this update, the ESP32_AI_Connect library leverages streaming to bring cutting-edge AI […] - [ESP32_AI_Connect Library Unveils New Tool Calling Features](https://avantmaker.com/esp32_ai_connect-library-unveils-new-tool-calling-features/): Our ESP32_AI_Connect library has just received an update, introducing new tool calling features that significantly enhance its capabilities. This open-source library, designed to integrate AI functionalities into ESP32 microcontrollers. What’s New: Tool Calling Features The latest update to the ESP32_AI_Connect library adds robust tool calling capabilities, allowing developers to seamlessly integrate external functions and tools into their AI-driven ESP32 projects. This feature enables the ESP32 to dynamically interact with APIs, control hardware peripherals, or execute custom functions based on AI model outputs, making it easier to create sophisticated, responsive applications. With tool calling, developers can now: This addition makes the library […] - [AvantMaker’s ESP32_AI_Connect: Unleashing AI Power on Your ESP32!](https://avantmaker.com/avantmakers-esp32_ai_connect-unleashing-ai-power-on-your-esp32/): Hey Friends, We’ve Got Big News! We’re super excited to share this news with you all—our team at AvantMaker has just dropped a brand-new Arduino library for the ESP32! Say hello to ESP32_AI_Connect, the library for bringing AI magic to your ESP32 projects. 🎉 What’s ESP32_AI_Connect All About? Picture this: your ESP32 microcontroller chatting with some of the coolest AI platforms out there, like OpenAI, Google Gemini, all with a single, easy-to-use interface. That’s what ESP32_AI_Connect does! Whether you’re building a smart IoT gadget, a voice-activated gizmo, or something totally out-of-the-box, this library makes it a breeze to connect your ESP32 to powerful […] - [ESP32-WebFS Gets a Shiny New Upgrade: More Space, Style, and Stability!](https://avantmaker.com/esp32-webfs-gets-a-shiny-new-upgrade-more-space-style-and-stability/): Hello, makers, tinkerers, and IoT enthusiasts! The AvantMaker Team is buzzing with excitement because we’ve just rolled out a fresh update to our beloved ESP32-WebFS. If you’re new to this tool, it’s like turning your ESP32 into a mini web server with a slick interface that makes managing files on SPIFFS (that’s the flash storage on your ESP32) as easy as organizing your toolbox—minus the rusty screws. This update brings some neat improvements to make your projects smoother and, dare we say, a tad more stylish. Let’s dive into what’s new! SPIFFS Check: Know Your Storage Like the Back of Your […] - [Unlock ESP32 Web Power: Dive Deep into HTTP POST Requests with Our New Article!](https://avantmaker.com/unlock-esp32-web-power-dive-deep-into-http-post-requests-with-our-new-article/): Hey Makers, Learners, and Innovators! Exciting news from the AvantMaker team! We know many of you are harnessing the power of the ESP32 to create amazing connected projects. A core part of many IoT applications is sending data from your ESP32 to a web server – whether it’s logging sensor readings, controlling a device remotely, or interacting with an online API. Often, this involves using the HTTP POST method via the ESP32’s HTTPClient library. But have you ever stopped to wonder what’s really happening under the hood when you call http.POST() in your Arduino sketch? What does that data packet […] - [ESP32-WebFS: Simplifying SPIFFS File Management for Your ESP32 Projects](https://avantmaker.com/esp32-webfs-simplifying-esp32-spiffs-file-management-for-your-iot-projects/): Introducing ESP32-WebFS If you’ve ever worked with an ESP32 microcontroller, you’ve likely come across SPIFFS—short for Serial Peripheral Interface Flash File System. It’s like a tiny digital filing cabinet built into your ESP32, perfect for storing files like web pages, sensor data, or configuration settings. For makers, SPIFFS is a game-changer because it lets your projects do more—like serving up a webpage or saving logs—without needing extra hardware. Enter ESP32-WebFS, a fresh tool from the AvantMaker Team. It turns your ESP32 into a web server with a simple but not simplistic interface, making it a breeze to upload and manage […] - [New ESP32 LittleFS Tutorial Article Released!](https://avantmaker.com/new-esp32-littlefs-tutorial-article-released/): Are you looking to expand the capabilities of your ESP32 projects? Do you want to store web pages, images, or sensor data directly on your ESP32’s SPI Flash? Then this tutorial is for you! In this comprehensive guide, we walk you through the process of uploading files to the ESP32’s SPI Flash Memory using the LittleFS file system. We cover everything from understanding SPI Flash and why LittleFS is superior to SPIFFS, to step-by-step instructions on setting it up in the Arduino IDE. What You’ll Learn: Whether you’re a beginner or an experienced maker, this guide will equip you with […] - [Expand Your ESP32 Knowledge: New Network Tutorials Added to Our Essential Guide!](https://avantmaker.com/expand-your-esp32-knowledge-new-network-tutorials-added-to-our-essential-guide/): We’re excited to announce that we’ve just added new tutorial articles to our ESP32 Essential Guide! If you’re looking to master the networking capabilities of your ESP32, you’re in the right place. These new additions focus on the crucial network section of the ESP32, specifically diving deep into WiFi functionalities. Whether you’re a beginner looking to connect your ESP32 to a wireless network or an experienced maker wanting to explore advanced WiFi features, these tutorials provide clear, step-by-step instructions and practical examples. What can you expect to learn? We’ve designed these tutorials to be easy to follow, ensuring you can […] - [CA Certificates, Client Certificates, and Private Keys: Your Network's Bouncers](https://avantmaker.com/ca-certificates-client-certificates-and-private-keys-your-networks-bouncers/): Hey there, makers, tinkerers, and curious minds! If you’ve ever hooked up an IoT gadget, built a DIY server, or dabbled in AI projects, you’ve probably stumbled across terms like “CA Certificate,” “Client Certificate,” and “Private Key.” They sound like the secret ingredients to a tech potion, don’t they? Well, they kind of are! These armored guardians of secure network communication keep your data safe from prying eyes. Let’s break them down in a way that won’t make your brain feel like it’s rebooting. What Are These Things, Anyway? Picture the internet as a bustling marketplace. You’re selling your latest […] - [Creating Your Own Private Key and Certificate: It's Easier Than You Think!](https://avantmaker.com/creating-your-own-private-key-and-certificate-its-easier-than-you-think/): Welcome, fellow tinkerers, to the wild world of digital security! If you’re building an IoT gadget, a DIY server, or just want to flex your maker muscles, you’ve probably stumbled across terms like “private key” and “certificate.” They sound like something out of a spy movie, but they’re actually the unsung heroes keeping your projects safe from digital ne’er-do-wells. Today, we’re diving into how to create them—without needing a PhD or a secret handshake. What Are We Even Talking About? A private key and certificate are like the lock and key to your digital front door. The private key is […] - [So, What Exactly IS a CA Certificate Anyway?](https://avantmaker.com/so-what-exactly-is-a-ca-certificate-anyway/): So, you’re building an IoT gadget, tinkering with a DIY server, or maybe just trying to figure out why your browser keeps yelling about “secure connections.” Somewhere along the line, you’ve stumbled across the term CA Certificate. It sounds official, maybe even a little intimidating—like something a stern librarian would demand before letting you borrow a book. But don’t worry, it’s not that complicated. Let’s break it down together and figure out why it’s a big deal for keeping your network safe. CA Certificate: The Internet’s Trusty Hall Monitor CA stands for Certificate Authority. Think of it as the internet’s version of […] - [Level Up Your IoT Security: Server Authentication vs. Mutual Authentication](https://avantmaker.com/level-up-your-iot-security-server-authentication-vs-mutual-authentication/): In the world of IoT and secure communication, understanding different levels of security is crucial, especially when you’re building projects that handle sensitive data. When it comes to secure connections for your ESP32 projects, you’ll often hear about “Server Authentication” and “Mutual Authentication.” But what do these terms really mean, and how do they impact the security of your DIY creations? Let’s break it down in a way that’s easy for every maker to grasp! What is Secure Connection and Why Does it Matter? Imagine sending a secret message. You wouldn’t want just anyone to read it, right? Secure connections […] - [Why We Call It the "WiFiClientSecure Library"](https://avantmaker.com/why-we-call-it-the-wificlientsecure-library-and-why-its-no-big-deal/): Hey, makers, tinkerers! Welcome to AvantMaker.com, your go-to spot for all things DIY, AI, IoT, Smart Home, and STEM. Today, we’re pausing the soldering irons to tackle a tiny question you might’ve had: why do we call it the “WiFiClientSecure Library”? Spoiler: it’s not technically a library. Cue the suspenseful violin sting! The Geeky Lowdown Let’s nerd out for a sec. In the ESP32 Arduino core, there’s a library folder called NetworkClientSecure. Inside that lives a class—also named NetworkClientSecure—which gets a snazzy alias: WiFiClientSecure. So, yep, WiFiClientSecure is a class, not a library. Meanwhile, stuff like the WiFi library, HTTPClient library, and even good ol’ WiFiClient library? Those are all called libraries too, even though they’ve […] - [Progress Update: New Guides for the ESP32 WiFi Library](https://avantmaker.com/progress-update-new-guides-for-the-esp32-wifi-library/): We’ve been working hard on expanding our ESP32 WiFi Library section, and we’re excited to share some progress with you. We’ve just wrapped up detailed guides on the WiFi Station and WiFi AP Class functions, and they’re ready for you to check out! You can dive into the guides right here:ESP32 WiFi Library – WiFi Station and WiFi AP Class These guides break down all the essential functions for using the ESP32 in both Station and Access Point modes. Whether you’re looking to connect your ESP32 to a WiFi network or set it up as an Access Point, these guides […] - [ESP32 Arduino Core Library Documentation: Your Ultimate Guide to Getting Started](https://avantmaker.com/esp32-arduino-core-library-documentation-your-ultimate-guide-to-getting-started/): Welcome to AvantMaker! If you’re diving into the world of IoT, AI, or Smart Home projects, you’ve probably heard of the ESP32. It’s one of the most powerful and flexible microcontrollers on the market, offering wireless connectivity, low power consumption, and endless possibilities. Here at AvantMaker, we’re excited to share that we’re currently building a Comprehensive Guide to the ESP32 Arduino Core Library to help you make the most of this amazing tool! What We’re Working On Our goal is to provide you with a complete guide to the ESP32 Arduino Core Library. This guide will be packed with useful […] ## Pages - [ESP32 AsyncUDP Library - peek()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-asyncudp-library/esp32-asyncudp-library-peek/): Description The peek() method is a fundamental function of the AsyncUDPPacket class that provides non-destructive access to the next byte in the received UDP packet data. This method allows developers to examine the next byte in the packet buffer without actually consuming or removing it from the data stream. Unlike the read() method which advances the internal buffer position, peek() leaves the buffer position unchanged, enabling repeated examination of the same byte or look-ahead operations. This functionality is essential for protocol parsing, data validation, and decision-making processes where you need to examine data before committing to processing it. Syntax and Usage The peek() method can be used in the following […] - [ESP32 AsyncUDP Library - read()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-asyncudp-library/esp32-asyncudp-library-read/): Description The read() method is a fundamental function of the AsyncUDPPacket class that provides two distinct ways to read data from incoming UDP packets. This method is inherited from the Arduino Stream class and offers both single-byte and multi-byte reading capabilities. The method allows developers to extract data from the packet buffer sequentially, making it essential for parsing and processing UDP packet contents. As data is read using this method, the internal read index advances, ensuring that subsequent calls return the next unread bytes. The read() method works in conjunction with the available() method to implement safe and efficient data reading strategies that prevent buffer overruns and enable […] - [ESP32 AsyncUDP Library - available()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-asyncudp-library/esp32-asyncudp-library-available/): Description The available() method is a fundamental function of the AsyncUDPPacket class that returns the number of bytes available for reading from the current UDP packet. This method is essential for determining how much data remains to be read from the packet buffer before processing or parsing the packet content. The method is inherited from the Arduino Stream class and provides a standard way to check the remaining unread data in the packet, allowing developers to implement efficient data reading strategies and avoid buffer overruns. Syntax and Usage The available() method can be used in the following way: Argument(s) This method does not require any arguments. […] - [ESP32 AsyncUDP Library - length()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-asyncudp-library/esp32-asyncudp-library-length/): Description The length() method is a fundamental function of the AsyncUDPPacket class that returns the size of the received UDP packet data in bytes. This method is essential for determining how much data was received in a UDP packet, enabling developers to properly process and parse the packet contents. The length() method works in conjunction with the data() method to provide complete access to received packet information – while data() provides a pointer to the packet content, length() tells you exactly how many bytes are available to read. This is crucial for safe memory operations and proper data processing in UDP communication. Syntax and Usage The length() method can be used in the following […] - [ESP32 AsyncUDP Library - data() ](https://avantmaker.com/esp32-asyncudp-library-data/): Description The data() method is a fundamental function of the AsyncUDPPacket class that provides direct access to the raw packet data received via UDP communication. This method returns a pointer to the beginning of the packet’s payload, allowing developers to read and process the actual data content that was transmitted over the network. The method is essential for accessing the received UDP packet data in its raw byte format, enabling flexible data processing and parsing operations. Syntax and Usage The data() method can be used in the following way: Basic Usage: uint8_t* dataPtr = packet.data();  – Retrieves a pointer to the packet data buffer without any arguments […] - [ESP32 AsyncUDP Library - remoteMac()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-asyncudp-library/esp32-asyncudp-library-remotemac/): Description The remoteMac() method is used to retrieve the MAC (Media Access Control) address of the sender of a UDP packet. This method is part of the AsyncUDPPacket class and copies the 6-byte MAC address of the device that sent the UDP packet into a provided buffer. It’s particularly useful for device identification and authentication, implementing MAC-based access control and filtering, creating wake-on-LAN applications, building network security protocols that validate sender hardware addresses, and developing network diagnostic tools that analyze device-specific communication patterns. The method works at the data link layer and provides hardware-level identification of the sending device, making it essential for applications […] - [ESP32 AsyncUDP Library - listenIP()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-asyncudp-library/esp32-asyncudp-library-listenip/): Description The listenIP() method is used to retrieve the remote IP address that the AsyncUDP object is currently connected to or listening for. This method is part of the AsyncUDP class and returns the IP address of the remote endpoint when the UDP socket is in a connected state. It’s particularly useful for UDP client applications that have established a connection to a specific remote server, for debugging and logging network connections, verifying connection targets in client-server communications, and implementing connection-aware UDP protocols. The method automatically handles both IPv4 and IPv6 addresses when IPv6 support is enabled, making it versatile for modern network applications. […] - [ESP32 AsyncUDP Library - remoteIP()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-asyncudp-library/esp32-asyncudp-library-remoteip/): Description The remoteIP() method is used to retrieve the remote IP address of the sender of a UDP packet. This method is part of the AsyncUDPPacket class and returns the IP address of the device that sent the UDP packet. It’s particularly useful for identifying packet sources in network applications, implementing client-server communication patterns, creating UDP-based communication protocols, and building network monitoring and logging systems. The method automatically handles both IPv4 and IPv6 addresses when IPv6 support is enabled, providing seamless compatibility across different network configurations. This makes it an essential tool for any UDP-based application that needs to track or respond to packet […] - [ESP32 AsyncUDP Library - localPort()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-asyncudp-library/esp32-asyncudp-library-localport/): Description The localPort() method is used to retrieve the local port number where a UDP packet was received. This method is part of the AsyncUDPPacket class and returns the destination port number that was used when the packet was sent to the ESP32. It’s particularly useful for applications that listen on multiple ports simultaneously, for implementing port-based routing and filtering, debugging network communications to verify correct port targeting, implementing protocol multiplexing where different services use different ports, and creating flexible server applications that can handle requests on various ports. The method provides essential information for understanding the network communication flow and implementing port-aware packet […] - [ESP32 AsyncUDP Library - localIP()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-asyncudp-library/esp32-asyncudp-library-localip/): Description The localIP() method is used to retrieve the local IP address of the device that received a UDP packet. This method is part of the AsyncUDPPacket class and returns the IP address of the network interface where the packet was received. It’s particularly useful for multi-homed devices (devices with multiple network interfaces) to determine which interface received the packet, for logging and debugging UDP communications, implementing network diagnostics, and handling packets differently based on the receiving interface. The method automatically handles both IPv4 and IPv6 addresses when IPv6 support is enabled, making it versatile for modern network applications. Syntax and Usage The localIP() method has […] - [ESP32 AsyncUDP Library - onPacket()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-asyncudp-library/esp32-asyncudp-library-onpacket/): Description The onPacket() method is used to register a callback function that will be called automatically whenever a UDP packet is received by the AsyncUDP object. This is the primary mechanism for handling incoming UDP data in an asynchronous, non-blocking manner. When a packet arrives, the registered callback function is invoked with an AsyncUDPPacket object containing all the packet information including data, source/destination addresses, ports, and network interface details. The method supports two different callback function signatures: a simple callback that takes only the packet parameter, and an extended callback that includes a user-defined argument pointer for additional context. This event-driven approach allows for […] - [ESP32 AsyncUDP Library - isMulticast()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-asyncudp-library/esp32-asyncudp-library-ismulticast/): Description The isMulticast() method is used to determine whether a received UDP packet was sent as a multicast message. This method examines the local IP address of the received packet and checks if it matches multicast address patterns. A multicast packet is sent to a specific group of devices that have joined the multicast group, and is typically used for streaming media, group communications, network protocols like mDNS (Multicast DNS), service discovery, and distributed applications. The method returns true if the packet was sent to a multicast address such as IPv4 multicast addresses in the range 224.0.0.0 to 239.255.255.255, or IPv6 multicast addresses that […] - [ESP32 AsyncUDP Library - isBroadcast()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-asyncudp-library/esp32-asyncudp-library-isbroadcast/): Description The isBroadcast() method is used to determine whether a received UDP packet was sent as a broadcast message. This method examines the local IP address of the received packet and checks if it matches broadcast address patterns. A broadcast packet is sent to all devices on the network segment and is typically used for device discovery, network announcements, service advertisements, and group communications. The method returns true if the packet was sent to a broadcast address such as the limited broadcast address (255.255.255.255), the network broadcast address, or a directed broadcast address. This functionality is essential for implementing protocols like DHCP, ARP, network […] - [ESP32 AsyncUDP Library - broadcastTo()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-asyncudp-library/esp32-asyncudp-library-broadcastto/): Description The broadcastTo() method is used to send UDP broadcast packets to all devices on a specific network segment or interface. This method allows you to transmit data to multiple receivers simultaneously without needing to specify individual IP addresses. Broadcast communication is essential for device discovery protocols, network announcements, configuration distribution, and real-time data sharing across local networks. The method internally uses the broadcast address (255.255.255.255 for IPv4) to ensure packets reach all devices within the network broadcast domain. It supports both raw byte data and string data transmission, with optional network interface specification for multi-interface devices. The broadcastTo() method is particularly useful in […] - [ESP32 AsyncUDP Library - broadcast()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-asyncudp-library/esp32-asyncudp-library-broadcast/): Description The broadcast() method is used to send UDP packets to all devices on the local network using the broadcast address. This method transmits data to the special broadcast IP address (255.255.255.255), which allows all devices on the same network segment to receive the packet simultaneously. The method requires that the AsyncUDP object has been previously bound to a local port using the listen() method, as it uses the local port number as the destination port for the broadcast transmission. This is particularly useful for network discovery protocols, service announcements, device enumeration, and group messaging applications where you need to communicate with all devices […] - [ESP32 AsyncUDP Library - printf()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-asyncudp-library/esp32-asyncudp-library-printf/): Description The printf() method is an advanced formatted data transmission function in the AsyncUDP library that provides C-style formatted printing capabilities for ESP32 UDP communication. Inherited from the Arduino Print class, this method enables developers to send precisely formatted text, numbers, and data to UDP endpoints using familiar printf-style format specifiers and syntax. The method is available in both the AsyncUDP class and the AsyncUDPPacket class, offering powerful options for sending structured, formatted data over UDP networks. The printf() method supports comprehensive format specifiers including %d, %i, %u, %x, %X, %o, %f, %e, %E, %g, %G, %c, %s, and %p, along with field width, precision, and […] - [ESP32 AsyncUDP Library - print()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-asyncudp-library/esp32-asyncudp-library-print/): Description The print() method is a high-level data transmission function in the AsyncUDP library that provides Arduino-style printing capabilities for ESP32 UDP communication. Inherited from the Arduino Print class, this method enables developers to send formatted text, numbers, and strings to UDP endpoints using familiar Arduino printing syntax. The method is available in both the AsyncUDP class and the AsyncUDPPacket class, offering convenient options for sending human-readable data over UDP networks. The print() method automatically converts various data types to their string representations before transmission, making it ideal for debugging output, sensor data logging, status messages, configuration updates, and user-friendly communication protocols. It supports multiple data […] - [ESP32 AsyncUDP Library - writeTo()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-asyncudp-library/esp32-asyncudp-library-writeto/): Description The writeTo() method is a powerful and flexible data transmission function in the AsyncUDP library that enables ESP32 devices to send UDP packets to any specified remote IP address and port without requiring a prior connection. Unlike the write() method which requires a connected UDP socket, writeTo() operates independently and can send data to different destinations on each call. This method is available in the AsyncUDP class and provides direct point-to-point UDP communication capabilities. It’s particularly useful for implementing distributed communication systems, multi-target broadcasting, dynamic peer-to-peer networks, IoT sensor networks with multiple data collectors, load balancing across multiple servers, and flexible communication architectures where destinations may change […] - [ESP32 AsyncUDP Library - sendTo()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-asyncudp-library/esp32-asyncudp-library-sendto/): Description The sendTo() method is a versatile data transmission function in the AsyncUDP library that enables ESP32 devices to send UDP packets using the AsyncUDPMessage buffer system to any specified IP address and port. Unlike the send() method which requires a pre-established connection, sendTo() provides the flexibility to transmit data to any network endpoint without needing to call connect() first. This method is available in the AsyncUDP class and accepts both IPv4 and IPv6 addresses, making it perfect for one-shot transmissions, broadcast scenarios, multi-destination messaging, and dynamic target communications. The method works with pre-constructed AsyncUDPMessage objects that contain the data to be transmitted, offering efficient buffer management and structured data organization. It’s particularly useful […] - [ESP32 AsyncUDP Library - send()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-asyncudp-library/esp32-asyncudp-library-send/): Description The send() method is a specialized data transmission function in the AsyncUDP library that enables ESP32 devices to send UDP packets using the AsyncUDPMessage buffer system. This method is available in both the AsyncUDP class and the AsyncUDPPacket class, providing structured and efficient UDP communication. The method works with pre-constructed message objects that contain the data to be transmitted, offering a higher-level abstraction compared to direct write operations. It’s particularly useful for implementing complex messaging protocols, multi-part data transmission, structured communication systems, IoT data logging, and applications requiring message queuing or buffering. The send() method leverages the AsyncUDPMessage buffer to organize data before transmission, making it ideal […] - [ESP32 AsyncUDP Library - write()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-asyncudp-library/esp32-asyncudp-library-write/): Description The write() method is a fundamental data transmission function in the AsyncUDP library that enables ESP32 devices to send UDP packets to connected remote endpoints. This method is available in both the AsyncUDP class and the AsyncUDPPacket class, providing flexible options for UDP communication. The method works with established UDP connections and automatically sends data to the previously connected remote IP address and port. It’s particularly useful for implementing real-time communication protocols, IoT sensor data transmission, remote control systems, telemetry applications, and bi-directional communication between ESP32 devices. The write() method supports both single-byte and multi-byte data transmission, making it versatile for various data types including […] - [ESP32 AsyncUDP Library - close()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-asyncudp-library/esp32-asyncudp-library-close/): This webpage is part of the Comprehensive Guide to the ESP32 Arduino Core Library, accessible on AvantMaker.com. Description The close() method is used to terminate and clean up an existing UDP connection or binding. When called, this method disconnects any active UDP connection established by the connect() method and resets the internal connection state to disconnected. The method performs essential cleanup operations including disconnecting the UDP protocol control block (PCB) if a connection exists, setting the internal connection flag to false, and preparing the AsyncUDP object for reuse. This method is automatically called internally by other methods like connect() and listen() before establishing new connections to ensure clean state […] - [ESP32 AsyncUDP Library - listen()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-asyncudp-library/esp32-asyncudp-library-listen/): This webpage is part of the Comprehensive Guide to the ESP32 Arduino Core Library, accessible on AvantMaker.com. Description The listen() method is used to bind the AsyncUDP object to a specific port and optionally to a specific IP address, enabling it to receive incoming UDP packets. When called, this method initializes the internal UDP control block, starts the UDP task, closes any existing connections, and binds the socket to the specified address and port. Unlike the connect() method which sets a default destination for outgoing packets, the listen() method configures the UDP socket to act as a server that can receive packets from any client. The method […] - [ESP32 AsyncUDP Library - connected()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-asyncudp-library/esp32-asyncudp-library-connected/): Description The connected() method is used to check the current connection or binding status of an AsyncUDP object. This method returns a boolean value indicating whether the UDP object is currently active and ready for communication. The connection status is automatically managed by the library and is set to true when the connect() or listen() methods successfully establish a UDP endpoint, and set to false when the object is first constructed or when the close() method is called. This method is essential for verifying that UDP operations can be performed before attempting to send or receive data. It provides a reliable way to monitor the operational state of the UDP object, ensuring […] - [ESP32 AsyncUDP Library - connect()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-asyncudp-library/esp32-asyncudp-library-connect/): Description The connect() method is used to establish a connection to a specific remote UDP endpoint. When called, this method configures the AsyncUDP object to send data to a specific IP address and port combination. The method initializes the internal UDP control block, starts the UDP task, closes any existing connections, and establishes the new connection parameters. This is particularly useful for UDP client applications that need to send data to a single remote server repeatedly, as it simplifies data transmission by eliminating the need to specify the destination address and port for each packet. Syntax and Usage The connect() method has two overloaded […] - [ESP32 AsyncUDP Library](https://avantmaker.com/references/esp32-arduino-core-index/esp32-asyncudp-library/): Home / References / ESP32 Library  The ESP32 AsyncUDP library provides a powerful and efficient way to handle UDP (User Datagram Protocol) communication asynchronously on ESP32 microcontrollers. This library is designed to work seamlessly with the ESP32 Arduino Core and offers high-performance, non-blocking UDP operations for both client and server applications. Unlike traditional blocking UDP implementations, AsyncUDP operates asynchronously, allowing your ESP32 to handle multiple UDP connections and operations simultaneously without blocking the main execution thread. This is particularly beneficial for IoT applications, real-time data streaming, sensor networks, and communication protocols that require low latency and high throughput. The library supports both IPv4 and […] - [ESP32 WebServer Library - urlDecode()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-webserver-library/esp32-webserver-library-urldecode/): Description The urlDecode() method decodes a URL-encoded string into plain text. This static utility method converts percent-encoded characters (like %20 for space) and plus signs (+) back to their original characters, making it essential for processing URL parameters, form data, and query strings received from HTTP requests. The method handles standard URL encoding where special characters are represented as percent signs followed by their hexadecimal ASCII values. This guide is part of the Comprehensive Guide to the ESP32 Arduino Core Library, accessible on AvantMaker.com. Syntax and Usage The urlDecode() method can be used in one way: For practical applications and examples of this method, please […] - [ESP32 WebServer Library - removeMiddleware()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-webserver-library/esp32-webserver-library-removemiddleware/): Description The removeMiddleware() method removes a previously added middleware instance from the WebServer’s middleware chain. This method allows you to dynamically unregister middleware during runtime, providing flexibility to modify the request/response processing pipeline based on changing application requirements. When a middleware is removed, it will no longer be executed for incoming requests, and if the middleware was created with automatic memory management, it will be properly deallocated. This guide is part of the Comprehensive Guide to the ESP32 Arduino Core Library, accessible on AvantMaker.com. Syntax and Usage The removeMiddleware() method can be used in one way: For practical applications and examples of this method, please […] - [ESP32 WebServer Library - addMiddleware()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-webserver-library/esp32-webserver-library-addmiddleware/): Description The addMiddleware() method adds a middleware instance or function to process HTTP requests and responses. Middleware provides a powerful way to implement cross-cutting concerns such as authentication, logging, CORS handling, and request/response modification in a reusable and composable manner. Middleware functions are executed in the order they are added and can intercept requests before they reach the handler or modify responses before they are sent to the client. This method is part of the Comprehensive Guide to the ESP32 Arduino Core Library, accessible on AvantMaker.com. Syntax and Usage The addMiddleware() method can be used in two different ways: Arguments Return Value Returns a reference […] - [ESP32 WebServer Library - enableETag()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-webserver-library/esp32-webserver-library-enableetag/): Description The enableETag() method is used to enable or disable ETag (Entity Tag) support on the ESP32 WebServer with an optional custom ETag generation function. When ETag support is enabled, the server automatically generates and sends ETag headers for served files, allowing clients (browsers) to cache resources efficiently and reduce bandwidth usage. This method is particularly valuable for serving static files like HTML, CSS, JavaScript, and images, as it enables smart caching mechanisms that only re-download files when they have actually changed. The method supports both built-in MD5-based ETag generation and custom ETag generation functions, providing flexibility for different caching strategies based […] - [ESP32 WebServer Library - enableCORS()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-webserver-library/esp32-webserver-library-enablecors/): Description The enableCORS() method is used to enable or disable Cross-Origin Resource Sharing (CORS) support on the ESP32 WebServer. When CORS is enabled, the server automatically adds the necessary HTTP headers to allow web browsers to make cross-origin requests to your ESP32 server from web pages hosted on different domains, ports, or protocols. This method is essential for modern web applications that need to communicate with IoT devices from browser-based interfaces. By default, CORS is disabled for security reasons, but enabling it allows your ESP32 to serve APIs and resources that can be accessed by web applications running on different origins, making […] - [ESP32 WebServer Library -enableDelay()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-webserver-library/esp32-webserver-library-enabledelay/): Description The enableDelay() method is used to enable or disable a small delay in the ESP32 WebServer’s client handling loop. This method controls whether the server introduces a 1-millisecond delay when no clients are available for processing, which helps prevent excessive CPU usage and allows other tasks to run. By default, the delay is enabled (true), which is recommended for most applications. Disabling the delay can be useful for performance testing, debugging timing-sensitive applications, or when you need maximum server responsiveness at the cost of higher CPU usage. This method is particularly valuable for developers who need to fine-tune server performance or […] - [ESP32_AI_Connect Constructor](https://avantmaker.com/home/avantmaker-toolbox/esp32_ai_connect-library/esp32_ai_connect-api-reference/esp32_ai_connect-constructor/): Description The ESP32_AI_Connect constructor is the primary method for creating and initializing an instance of the ESP32_AI_Connect library. This constructor establishes the connection parameters for communicating with various AI platforms including OpenAI, Claude, DeepSeek, and Gemini. It automatically configures the WiFi client for secure connections and initializes the appropriate platform handler based on the specified platform identifier. Syntax and Usage The ESP32_AI_Connect constructor offers two different usage patterns: 1. Standard Constructor For connecting to official AI platform endpoints: ESP32_AI_Connect(const char* platformIdentifier, const char* apiKey, const char* modelName) 2. Constructor with Custom Endpoint For connecting to custom or self-hosted AI endpoints: ESP32_AI_Connect(const char* […] - [ESP32_AI_Connect API Reference](https://avantmaker.com/home/avantmaker-toolbox/esp32_ai_connect-library/esp32_ai_connect-api-reference/): Introduction This comprehensive API reference provides detailed documentation for all methods available in the ESP32_AI_Connect library. Each method includes syntax examples, parameter explanations, return values, and practical code samples to help you integrate AI capabilities into your ESP32 projects effectively. 📚 What You’ll Find Here: API Methods by Category Explore our detailed API documentation with syntax examples, parameter explanations, return values, and practical code samples for every method. Each function is thoroughly documented with security considerations and best practices. 🔧 Library Initialization Core setup and configuration methods for initializing the library with your chosen AI platform. 💬 Standard Chat Operations […] - [ESP32_AI_Connect Library](https://avantmaker.com/home/avantmaker-toolbox/esp32_ai_connect-library/): Introduction to ESP32_AI_Connect Library The ESP32_AI_Connect library is a comprehensive Arduino library that enables seamless integration of AI platforms with ESP32 microcontrollers. Designed with a unified interface, this library allows developers to easily switch between different AI services while maintaining consistent code structure and functionality. 🚀 Why Choose ESP32_AI_Connect? Supported AI Platforms OpenAI GPT models including GPT-4, GPT-3.5-turbo, and OpenAI-compatible APIs Google Gemini Gemini Pro and other Google AI models with advanced multimodal capabilities DeepSeek DeepSeek’s powerful language models optimized for coding and reasoning Anthropic Claude Claude models with enhanced safety and reasoning capabilities OpenAI Compatible Any API service that follows OpenAI’s […] - [ESP32 WebServer Library -  responseCodeToString()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-webserver-library/esp32-webserver-library-responsecodetostring/): Description The responseCodeToString() method is a static utility function used to convert HTTP response status codes to their corresponding descriptive string representations. This method takes an integer HTTP status code and returns a human-readable string that describes the meaning of that status code (e.g., 200 returns “OK”, 404 returns “Not Found”). It’s particularly useful for logging, debugging, error reporting, creating custom response messages, and building comprehensive HTTP status monitoring systems. The method supports all standard HTTP status codes from 1xx (informational) through 5xx (server error) series, making it an essential tool for HTTP response handling and user-friendly error reporting in web server […] - [ESP32 WebServer Library -  hasResponseHeader()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-webserver-library/esp32-webserver-library-hasresponseheader/): Description The hasResponseHeader() method is used to check if a specific response header exists in the current HTTP response before it is sent to the client. This method returns a boolean value indicating whether the specified header name has been added to the response using the sendHeader() method. It’s particularly useful for conditional header logic, debugging HTTP responses, implementing dynamic header management, and ensuring that required headers are properly set before sending responses. The method provides a reliable way to verify header presence without retrieving the header value, making it ideal for validation workflows and security checks where header existence is more important than […] - [ESP32 WebServer Library - responseHeaderName()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-webserver-library/esp32-webserver-library-responseheadername/): Description The responseHeaderName() method is used to retrieve the name of a response header by its index position. This method returns the header name as a String from the list of HTTP response headers that have been added to the current response using the sendHeader() method. It’s particularly useful for debugging HTTP responses, logging server activity, implementing dynamic header inspection, and iterating through all response headers to validate their presence. The method works in conjunction with responseHeaders() to provide complete access to response header information, enabling developers to inspect, log, or process all headers being sent to clients. Syntax and Usage The responseHeaderName() method has a simple syntax: […] - [ESP32 WebServer Library - responseHeader()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-webserver-library/esp32-webserver-library-responseheader/): Description The responseHeader() method is used to retrieve HTTP response header values that have been previously set using the sendHeader() method. This method allows you to access specific header information that will be sent to clients in the HTTP response. It’s particularly useful for debugging HTTP responses, implementing conditional logic based on response headers, logging server activity, and validating that the correct headers are being sent to clients. The method provides two ways to access headers: by name (case-insensitive) or by index position, making it flexible for different programming scenarios. This functionality is essential for creating robust web applications that need to inspect or […] - [ESP32 WebServer Library - responseHeaders()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-webserver-library/esp32-webserver-library-responseheaders/): Description The responseHeaders() method is used to get the number of headers that have been added to the current HTTP response. This method returns an integer count of all response headers that have been set using the sendHeader() method before sending the response to the client. It’s particularly useful for debugging HTTP responses, logging server activity, implementing dynamic header management, and validating that the correct number of headers are being sent. The method provides insight into the response structure and can be used to ensure that security headers, caching directives, and custom headers are properly included in the server’s responses. Syntax and Usage The responseHeaders() method […] - [ESP32 WebServer Library - headers()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-webserver-library/esp32-webserver-library-headers/): Description The headers() method is used to retrieve the total number of HTTP request headers that have been collected by the ESP32 WebServer from the current client request. This method returns an integer value representing the count of headers that were successfully parsed and stored by the server. The count only includes headers that have been explicitly configured for collection using either the collectHeaders() method for specific headers or the collectAllHeaders() method for comprehensive header collection. This method is essential for iterating through headers, implementing dynamic header processing, and validating that the expected number of headers have been received. It’s commonly used in conjunction with header() and headerName() methods to […] - [ESP32 WebServer Library - collectAllHeaders()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-webserver-library/esp32-webserver-library-collectallheaders/): Description The collectAllHeaders() method is used to configure the ESP32 WebServer to automatically collect all HTTP request headers from incoming client requests. Unlike the collectHeaders() method which requires you to specify individual header names, this method sets the server to capture every header sent by the client. This is particularly useful for debugging purposes, comprehensive request logging, security analysis, or when you need to access any header without knowing in advance which headers clients might send. While convenient, this method consumes more memory than selective header collection, so it should be used judiciously in memory-constrained applications. The method internally sets a flag that instructs […] - [ESP32 WebServer Library -hasHeader()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-webserver-library/esp32-webserver-library-hasheader/): Description The hasHeader() method is used to check if a specific HTTP request header exists in the request received by the ESP32 WebServer. This method provides a boolean response indicating whether a particular header was sent by the client. It’s particularly useful for implementing conditional logic based on the presence of headers before attempting to access their values. The method checks headers that have been previously configured for collection using collectHeaders() or collectAllHeaders() methods. This is essential for creating robust web applications that need to verify the existence of authentication tokens, content types, custom headers, or any other HTTP headers before processing them. Syntax and Usage […] - [ESP32 WebServer Library -headerName()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-webserver-library/esp32-webserver-library-headername/): Description The headerName() method is used to retrieve the names of HTTP request headers that have been collected by the ESP32 WebServer. This method provides access to header names based on their index position in the collected headers list. It works in conjunction with the header() method to enable complete header inspection – while header() returns header values, headerName() returns the corresponding header names. This method is particularly useful for iterating through all collected headers when you need to examine both names and values, or when implementing debugging and logging functionality. Syntax and Usage The headerName() method has only one usage pattern: Arguments Return Value The headerName() method returns a String containing the name […] - [ESP32 WebServer Library - header()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-webserver-library/esp32-webserver-library-header/): Description The header() method is used to retrieve HTTP request header values that have been previously collected by the ESP32 WebServer. This method allows you to access specific header information sent by clients in their HTTP requests. The headers must first be configured for collection using the collectHeaders() or collectAllHeaders() methods before they can be accessed with header(). This method is essential for implementing authentication, content negotiation, and other HTTP protocol features that rely on header information. Syntax and Usage The header() method can be used in two different ways: Arguments Return Value The header() method returns a String containing the value of the requested header. If the header is not found (when […] - [ESP32 WebServer Library -collectHeaders()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-webserver-library/esp32-webserver-library-collectheaders/): Description The collectHeaders() method is used to specify which HTTP request headers should be collected and made available for processing when a client sends a request to the ESP32 WebServer. By default, the WebServer only collects a limited set of headers for performance reasons. This method allows you to explicitly define which additional headers you want to capture and access in your request handlers. The method works by setting up a list of header names that the server should parse and store from incoming HTTP requests, making them accessible through the header() method. Syntax and Usage The collectHeaders() method can be used in two different ways: […] - [ESP32 WebServer Library - responseCode()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-webserver-library/esp32-webserver-library-responsecode/): Description The responseCode() method of the ESP32 WebServer library is used to retrieve the HTTP status code that has been set for the current response. This is helpful for debugging or for conditional logic based on the response status before it’s sent to the client. When a client makes a request to the ESP32 web server, the server processes the request and prepares a response. Part of this response is an HTTP status code (e.g., 200 for OK, 404 for Not Found). While methods like send() implicitly set a status code (usually 200 if not specified otherwise), the responseCode() method allows you to check what this code is […] - [ESP32 WebServer Library - upload()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-webserver-library/esp32-webserver-library-upload/): Description The ESP32 WebServer library includes robust features for handling HTTP file uploads. When a client sends a file through an HTML form (using the POST method with enctype="multipart/form-data" – which is crucial for file uploads), the library automatically parses the incoming request. Instead of loading the entire file into memory, the library processes the uploaded file in chunks. It provides access to information about the file (like name, type, size) and the data chunks as they arrive via a special HTTPUpload structure. This streaming approach makes it possible to handle large file uploads efficiently, even on memory-constrained devices like the ESP32, by writing data directly […] - [ESP32 WebServer Library - client()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-webserver-library/esp32-webserver-library-client/): Description The client() method is a member function of the ESP32 WebServer class. It provides access to the underlying WiFiClient object that represents the network connection of the client currently making a request to the web server. This allows for more direct interaction with the client connection, such as reading raw request data, checking connection status, or getting client IP information, beyond the standard handling provided by the WebServer library’s argument parsing and response methods. This method is typically used within the handler functions that you register with the server using methods like server.on() or server.onNotFound(). Syntax and Usage The client() method is called on an instance of the WebServer class. It does […] - [ESP32 WebServer Library - version()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-webserver-library/esp32-webserver-library-version/): Description The version() method is used within a request handler function to determine the HTTP protocol version specified by the web client (like a browser or another application) in its request to the ESP32 web server. When a client sends an HTTP request, the first line typically includes the method (GET, POST, etc.), the URI, and the HTTP version it supports (e.g., “HTTP/1.1” or “HTTP/1.0”). The version() method allows your server code to access this specific piece of information from the parsed request. This can be useful for logging request details, debugging, or understanding the capabilities of the clients interacting with your ESP32 server. […] - [ESP32 WebServer Library - hostHeader()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-webserver-library/esp32-webserver-library-hostheader/): Description The hostHeader() method of the ESP32 WebServer Library is used to retrieve the value of the Host header from an incoming HTTP request. The Host header is a standard HTTP request header field that specifies the domain name of the server (for virtual hosting) and optionally the TCP port number on which the server is listening. This information is sent by the client (such as a web browser) as part of the request headers to indicate which host they are trying to reach, especially when multiple websites are hosted on the same IP address. Syntax and Usage The hostHeader() method is called on the WebServer object within […] - [AvantMaker ToolBox](https://avantmaker.com/home/avantmaker-toolbox/) - [ESP32 WebServer Library - hasArg()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-webserver-library/esp32-webserver-library-hasarg/): Description The hasArg() method is a member function of the ESP32 WebServer class. Its primary purpose is to check whether a specific argument (parameter) exists within the data received from an HTTP client request. This function is crucial for validating input; before attempting to read the value of an argument using methods like arg(), you can use hasArg() to ensure the argument was actually provided by the client. This helps prevent errors and allows your code to handle missing parameters gracefully. It checks for arguments passed via GET (in the URL query string) or POST (in the request body, typically from form submissions). Syntax and Usage To […] - [ESP32 WebServer Library - argName()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-webserver-library/esp32-webserver-library-argname/): Description The argName() method is part of the ESP32 WebServer library for Arduino. It is used to retrieve the name (or key) of a specific argument that was passed in an HTTP request (either GET or POST) to the ESP32 web server. Arguments are identified by their index number, starting from zero. This method is essential for parsing incoming request parameters, allowing your ESP32 application to understand and react to the specific data sent by a client. Syntax and Usage The argName() method is called on an instance of the WebServer class. It requires a single argument: the index of the parameter whose name you want […] - [ESP32 WebServer Library - args()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-webserver-library/esp32-webserver-library-args/): Description The args() method is a member function of the ESP32 WebServer class. It is used within request handler functions to determine the total number of arguments (also known as parameters or query string variables) that were sent by the client in an HTTP request. This method counts arguments received via both GET (typically in the URL’s query string) and POST (typically in the request body from form submissions) methods. Knowing the number of arguments is often the first step before iterating through them using methods like argName() and arg() to process the data sent by the client. Syntax and Usage To use the args() method, you simply call it […] - [ESP32 WebServer Library - arg()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-webserver-library/esp32-webserver-library-arg/): Description The arg() method is used within the ESP32 WebServer library to retrieve the value of an argument passed in an HTTP request (either GET or POST). You can access these arguments either by specifying the argument’s name or by its numerical index (position) in the list of received arguments. This is essential for processing data submitted through web forms or parameters included in the URL’s query string. Syntax and Usage The arg() method can be used in two ways: – By Argument Name: Retrieves the value of the argument whose name matches the provided name string. This is the most common and readable way to […] - [ESP32 WebServer Library - clientContentLength()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-webserver-library/esp32-webserver-library-clientcontentlength/): Description The clientContentLength() method is a member function of the ESP32 WebServer class. It returns the value specified in the Content-Length HTTP header of the incoming client request. This header tells the server the size, in bytes, of the request body that follows the headers. It’s particularly relevant for handling HTTP methods like POST or PUT, where clients send data (the request body) to the server. Knowing the content length can be useful for validating requests (e.g., checking if the size exceeds a limit) or for preparing to read the request body data. Syntax and Usage The clientContentLength() method is called on an instance of the WebServer object, typically from […] - [ESP32 WebServer Library - method()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-webserver-library/esp32-webserver-library-method/): Description The method() method is a member function of the ESP32 WebServer class. It is used within a request handler function to identify the HTTP method associated with the incoming client request. Knowing the method is crucial for processing requests correctly, as different methods imply different actions (e.g., GET for retrieving data, POST for submitting data). Syntax and Usage The method() method is called on an instance of the WebServer object, typically from within a function designated to handle incoming client requests. Argument(s) This method does not require any arguments. Return Value The method() method returns a value of the enumeration type HTTPMethod. This enumeration defines constants representing standard HTTP request […] - [ESP32 WebServer Library - uri()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-webserver-library/esp32-webserver-library-uri/): Description The uri() method is a member function of the ESP32 WebServer class. When a client makes an HTTP request to the ESP32 server, this method is used within a request handler function to retrieve the Uniform Resource Identifier (URI) path specified in that request. The URI is the part of the URL that identifies the specific resource being requested (e.g., “/”, “/data”, “/index.html”). Syntax and Usage The uri() method is called on an instance of the WebServer object, typically from within a function designated to handle incoming client requests. For practical applications and examples of this method, please consult the “Example Code” section on this page. This […] - [ESP32 WebServer Library - requestAuthentication()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-webserver-library/esp32-webserver-library-requestauthentication/): Description The requestAuthentication() method is part of the ESP32 WebServer library and is used to trigger the HTTP authentication dialog in a client’s browser. This method is typically called after an authentication check has failed, prompting the user to enter valid credentials. It works in conjunction with authentication methods like authenticate() and authenticateBasicSHA1() to implement secure access control for your ESP32 web server applications. Syntax and Usage The requestAuthentication() method can be used in three different ways: Argument(s) When used without arguments, the method uses HTTP Basic Authentication with default realm and failure message. Return Value The requestAuthentication() method does not return a value. It sends the HTTP authentication request […] - [ESP32 WebServer Library - authenticateBasicSHA1()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-webserver-library/esp32-webserver-library-authenticatebasicsha1/): Description The authenticateBasicSHA1() method provides a way to verify client credentials submitted via HTTP Basic Authentication, similar to the standard authenticate() method. The key difference lies in how the password is verified: instead of comparing the plaintext password sent by the client against a plaintext password stored in your code, authenticateBasicSHA1() calculates the SHA1 hash of the password sent by the client and compares it against a pre-calculated SHA1 hash stored in your code. This approach avoids storing the actual password in plaintext within your ESP32 firmware, offering a minor security enhancement for the stored credentials. However, it’s crucial to understand that this method still relies […] - [ESP32 WebServer Library - authenticate()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-webserver-library/esp32-webserver-library-authenticate/): Description The authenticate() method is part of the ESP32 WebServer library and is used to implement HTTP Basic Authentication in your web server applications. This method verifies user credentials against predefined username and password combinations, allowing you to protect specific pages or resources on your ESP32 web server from unauthorized access. Syntax and Usage The authenticate() method can be used in two different ways: Argument(s) When used without arguments, the method simply checks if the client has provided any authentication credentials. For practical applications and examples of this method, please consult the “Example Code” section on this page. This section provides comprehensive guidance to […] - [ESP32 WebServer Library - removeHandler()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-webserver-library/esp32-webserver-library-removehandler/): Description The removeHandler() method is used to dynamically remove a specific request handler that was previously registered with the WebServer instance using methods like on(). Once a handler is removed, the server will no longer execute its associated function when a matching request (URI and HTTP method) is received. This is particularly useful in scenarios where certain API endpoints or web pages need to be disabled or modified during runtime without restarting the ESP32. Syntax and Usage The removeHandler() method is called on an instance of the WebServer class. It requires a pointer to the specific RequestHandler object that you wish to remove. For practical applications and examples of […] - [ESP32 WebServer Library - addHandler()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-webserver-library/esp32-webserver-library-addhandler/): Description The addHandler() method is a powerful function provided by the ESP32 WebServer library that allows you to register custom request handlers for your web server. This method enables you to define specialized behaviors for specific URL patterns or HTTP request types, giving you full control over how your ESP32 web server responds to incoming requests. Custom handlers are particularly useful when you need to implement complex routing logic, handle specific file types, or process particular API endpoints in your web applications. Syntax and Usage The addHandler() method can be used in the following way: Where: The method must be called after initializing the […] - [ESP32 WebServer Library - serveStatic()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-webserver-library/esp32-webserver-library-servestatic/): Description The serveStatic() method in the ESP32 WebServer Library enables your ESP32 to serve static files—such as HTML, CSS, JavaScript, or images—stored in a filesystem like SPIFFS or LittleFS. This method simplifies the process of delivering web content to clients, making it ideal for building responsive web interfaces for your projects. By mapping a URI to a filesystem path, it allows seamless access to preloaded files, enhancing the functionality of your ESP32-based web server. Syntax and Usage The serveStatic() method is called on a WebServer object to configure static file serving. Below is the basic syntax, followed by its usage variations: Here are the different ways […] - [ESP32 WebServer Library - onFileUpload()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-webserver-library/esp32-webserver-library-onfileupload/): Description The onFileUpload() method in the ESP32 WebServer Library allows you to register a callback function that handles file uploads sent to your ESP32-based web server. This method is essential for projects requiring file transfer functionality, such as uploading configuration files, images, or other data to the ESP32’s filesystem. By defining a handler, you can process incoming file data efficiently, making it a powerful tool for interactive IoT applications. Syntax and Usage The onFileUpload() method is used to specify a function that will be called when a file upload is detected. Below is the basic syntax, followed by its usage variations: The method can […] - [ESP32 WebServer Library - onNotFound()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-webserver-library/esp32-webserver-library-onnotfound/): Description The onNotFound() method in the ESP32 WebServer Library is a powerful tool for handling HTTP requests that do not match any predefined routes in your web server. When a client attempts to access a URL that hasn’t been explicitly registered using methods like on(), this method triggers a custom callback function. It’s an essential feature for creating robust web servers, allowing you to define fallback behavior—such as returning a “404 Not Found” message or redirecting users—making it ideal for debugging or enhancing user experience in IoT projects. Syntax and Usage The onNotFound() method is straightforward to implement. It registers a callback function that executes […] - [Understanding How Your ESP32 Sends the HTTP POST Request](https://avantmaker.com/references/esp32-arduino-core-index/esp32-httpclient-library/understanding-how-your-esp32-sends-the-http-post-request/): Introduction: A Deeper Look at ESP32 Web Communication Welcome! This page expands on the example code presented in our main reference about the ESP32 HTTPClient Library’s POST method on AvantMaker.com. If you’ve ever wondered exactly *what* your ESP32 sends to a web server when you use the `POST()` method, you’re in the right place. Understanding the structure of these web requests is crucial for anyone building connected projects. It helps you troubleshoot issues when things don’t work as expected, design more efficient communication protocols for your IoT devices, and interact correctly with various web services and APIs. By breaking down […] - [ESP32 WebServer Library - on()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-webserver-library/esp32-webserver-library-on/): Description The on() method in the ESP32 WebServer Library is used to register a handler function that responds to specific HTTP requests made to the ESP32 web server. By associating a URL path (URI) and an HTTP method (e.g., GET, POST) with a callback function, this method enables you to define how the server processes incoming requests. It’s a fundamental building block for creating interactive web applications with the ESP32. Syntax and Usage The on() method can be used in multiple ways depending on your needs. Below are the different syntaxes available, each with a brief description: – Basic Usage with URI and Handler:  […] - [ESP32 WebServer Library - streamFile()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-webserver-library/esp32-webserver-library-streamfile/): Description The streamFile() method in the ESP32 WebServer Library allows you to stream a file directly from a filesystem (like SPIFFS or SD) to a connected client over HTTP. This method is ideal for serving large files, such as HTML pages, images, or other resources, without loading them entirely into memory, making it memory-efficient and practical for resource-constrained ESP32 projects. Syntax and Usage The streamFile() method has a single, flexible syntax that supports streaming files with a specified content type and optional HTTP status code. Here’s how to use it: – Basic Usage with Default Status Code (200 OK): Streams a file with the […] - [ESP32 WebServer Library - sendContent_P()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-webserver-library/esp32-webserver-library-sendcontent_p/): Description The sendContent_P() method is a powerful function in the ESP32 WebServer Library designed to send content stored in PROGMEM (program memory) to a client as part of an HTTP response. This method is particularly useful for serving static content, such as HTML, CSS, or JavaScript, efficiently by leveraging the ESP32’s flash memory, reducing RAM usage. It is ideal for projects where memory optimization is key, allowing makers to deliver web content seamlessly. Syntax and Usage The sendContent_P() method can be used in two distinct ways depending on whether you need to specify the content length explicitly. Below are the available syntaxes: Here’s how […] - [ESP32 WebServer Library - sendContent()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-webserver-library/esp32-webserver-library-sendcontent/): Description The sendContent() method in the ESP32 WebServer Library is used to send chunks of content as part of an HTTP response to a client. This method is particularly useful when you need to send data incrementally, such as when streaming large content or building a response dynamically. It is often used in conjunction with the send() method to handle the body of the HTTP response after headers have been set. Syntax and Usage The sendContent() method can be invoked in different ways depending on the type and size of the content you want to send. Below are the available usages: For practical applications and examples […] - [ESP32 WebServer Library - sendHeader()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-webserver-library/esp32-webserver-library-sendheader/): Description The sendHeader() method in the ESP32 WebServer Library is used to add custom HTTP headers to the response sent by the ESP32 web server. HTTP headers provide additional metadata about the response, such as content type, caching instructions, or custom information required by the client. This method is essential for fine-tuning the behavior of your web server and ensuring compatibility with various clients, making it a powerful tool for creating dynamic and responsive web applications on the ESP32. Syntax and Usage The sendHeader() method is called on a WebServer object and allows you to specify a header name, its value, and an optional flag to […] - [ESP32 WebServer Library - setContentLength()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-webserver-library/esp32-webserver-library-setcontentlength/): Description The setContentLength() method in the ESP32 WebServer Library is used to specify the length of the content that will be sent in an HTTP response. By setting the content length explicitly, you inform the client (e.g., a web browser) about the exact size of the data to expect, which can improve performance and ensure proper handling of the response. This method is particularly useful when you know the size of the content in advance and want to optimize the communication process. Please note that if the content length is not set correctly, or is set to the wrong value, […] - [Mastering File Uploads to ESP32 SPI Flash with LittleFS: A Maker’s Guide](https://avantmaker.com/references/esp32-arduino-core-index/esp32-littlefs-library/mastering-file-uploads-to-esp32-spi-flash-with-littlefs-a-makers-guide/): Home / References / ESP32 Library  Getting Started with ESP32 File Uploads Ever wanted to store webpages, images, or data files directly on your ESP32 microcontroller? In this tutorial, we’ll dive into uploading files to the ESP32’s SPI Flash Memory using the LittleFS file system. Whether you’re building a web server, logging sensor data, or creating an IoT project, this guide will equip you with the know-how to make it happen. We’ll cover what SPI Flash Memory is, why LittleFS is a great choice, and walk you through a hands-on setup using the Arduino IDE. Let’s get those files onto your ESP32! Understanding SPI […] - [ESP32 LittleFS Library](https://avantmaker.com/references/esp32-arduino-core-index/esp32-littlefs-library/): Home / References / ESP32 Library  LittleFS Library References Documents are under constructions. In the mean time if you need to find out how to use LittleFS to upload files to ESP32 SPI Flash Memory, then this tutorial is for you. In this comprehensive guide, we walk you through the process of uploading files to the ESP32’s SPI Flash Memory using the LittleFS file system. We cover everything from understanding SPI Flash and why LittleFS is superior to SPIFFS, to step-by-step instructions on setting it up in the Arduino IDE. Read the full article: Mastering File Uploads to ESP32 SPI Flash with LittleFS: A […] - [ESP32 WebServer Library - send_P()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-webserver-library/esp32-webserver-library-send_p/): Description The send_p() method is a powerful function in the ESP32 WebServer Library that allows you to send HTTP responses containing data stored in PROGMEM (Program Memory). This method is particularly useful for serving static content like HTML, CSS, or JavaScript files efficiently, as it leverages the flash memory of the ESP32 to reduce RAM usage. It’s an essential tool for building lightweight web servers on resource-constrained devices like the ESP32. Syntax and Usage The send_p() method can be used in different ways depending on whether you need to specify a content length. Below are the available syntaxes: For practical applications and examples of […] - [ESP32 WebServer Library - send()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-webserver-library/esp32-webserver-library-send/): Description The send() method is a key function in the ESP32 WebServer Library, used to transmit HTTP responses to connected clients. It allows you to send a status code, content type, and response body in a single call, making it an efficient way to deliver web content such as HTML pages, JSON data, or plain text from your ESP32-based server. Syntax and Usage The send() method can be used in multiple ways depending on the content you want to send and the level of customization required. Here are the different ways to use this method: For practical applications and examples of this method, please […] - [ESP32 WebServer Library - handleClient()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-webserver-library/esp32-webserver-library-handleclient/): Description The handleClient() method is a crucial function in the ESP32 WebServer library that processes incoming client requests. It checks for new client connections, parses HTTP requests, routes them to the appropriate handler functions, and sends back responses. This method must be called repeatedly in the main loop of your ESP32 program to maintain a responsive web server. Syntax and Usage The handleClient() method is called on an instance of the WebServer class. There is only one way to use this method: Where server is your initialized WebServer object. This method must be called frequently within the loop() function of your sketch to process incoming client requests in […] - [ESP32 WebServer Library - stop ()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-webserver-library/esp32-webserver-library-stop/): Description The stop() method of the ESP32 WebServer Library is used to stop the web server from listening for new client connections. When this method is called, the server will no longer accept incoming requests. However, any existing connections that are currently being handled will continue to run until they are either completed or explicitly closed. Differences Between the stop() and close() Methods The key difference between the ESP32 WebServer Library’s stop() and close() methods lies in their scope and immediacy. The stop() method halts the server from accepting new connections but leaves existing client connections intact, allowing them to finish their tasks. In contrast, the close() method goes further by not only stopping […] - [ESP32 WebServer Library - close()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-webserver-library/esp32-webserver-library-close/): Description The close() method in the ESP32 WebServer Library is used to terminate the web server’s operation, closing all active client connections and stopping the server from listening for new requests. This method is essential when you need to free up resources for other tasks or prepare your ESP32 for a reset or deep sleep. Differences Between the stop() and close() Methods The key difference between the ESP32 WebServer Library’s stop()and close() methods lies in their scope and immediacy. The close() method is designed to provide a comprehensive shutdown, halting the server’s listener and terminating all active client connections instantly, making it ideal for situations where an immediate and complete stop […] - [ESP32 WebServer Library - begin()](https://avantmaker.com/references/esp32-arduino-core-index/esp32-webserver-library/esp32-webserver-library-begin/): Description The begin() method is a fundamental part of the ESP32 WebServer Library, used to initialize and start the web server on your ESP32. This method prepares the server to listen for incoming HTTP requests on a specified port, enabling your ESP32 to serve web pages, handle client requests, and interact with connected devices. Whether you’re building a simple control interface or a complex IoT application, begin() is your starting point for web server functionality. Syntax and Usage The begin() method can be called in two ways, depending on whether you need to specify a custom port. Below are the available usages: Here’s how you can […] - [How to Copy Codes from AvantMaker.com](https://avantmaker.com/home/frequently-asked-questions/how-to-copy-codes-from-avantmaker-com/): If you are experiencing trouble trying to copy the code from AvantMaker.com’s webpages, please check the following image for instructions. - [Which ESP32 Boards are Recommended for Learners](https://avantmaker.com/home/frequently-asked-questions/recommended-esp32-boards-for-avantmaker-tutorials/): 1 – Introduction Welcome to AvantMaker.com, your online hub dedicated to empowering makers, learners, and enthusiasts in the exciting world of IoT, DIY, and AI. We are passionate about helping you turn your innovative ideas into tangible realities. To achieve this, we offer comprehensive tutorials and development resource references, especially for the popular ESP32 microcontroller. At AvantMaker.com, we’ve had the opportunity to work with numerous ESP32 development boards. For those eager to dive into our ESP32 tutorials, we highly recommend the following two boards. Unless explicitly stated otherwise in our guides, all our tutorials and references are primarily based on […] - [Frequently Asked Questions](https://avantmaker.com/home/frequently-asked-questions/): Got questions? We’ve got answers! Welcome to the FAQ page of AvantMaker.com, your go-to spot for turning creative sparks into real-world projects. Whether you’re troubleshooting an ESP32 setup, curious about our tutorials, or just figuring out where to start, we’re here to help makers, learners, and enthusiasts like you get unstuck and keep building. Dive in below! FAQ for AvantMaker Website How to Copy Codes from AvantMaker.com FAQ for Tutorials Which ESP32 Boards are Recommended for Learners FAQ for ESP32 File System What is SPIFFS and how to upload files to it? What is LIttleFS and how to upload files […] - [ESP32 WebServer Library](https://avantmaker.com/references/esp32-arduino-core-index/esp32-webserver-library/): Home / References / ESP32 Library  The ESP32 WebServer Library provides a comprehensive set of methods for creating and managing web servers on ESP32 microcontrollers. This reference guide categorizes these methods based on their functionality to help you quickly find the methods you need for your IoT projects. Server Operation Client Handling Routing and Handlers Authentication Request Information Request Header Management Response Information Server Configuration Middleware Utility - [ESP32 Essential Guide - Network Section - WiFi Chapter - 0 - 2 - Fetching Essential Online Data with the ESP32](https://avantmaker.com/tutorials/esp32-tutorials/esp32-arduino-core-essential-guide/esp32-essential-guide-network-section-index/esp32-essential-guide-network-section-wifi-chapter/esp32-essential-guide-network-section-wifi-chapter-0-2-fetching-essential-online-data-with-the-esp32/): 1 – Introduction In our previous article, “How to Connect ESP32 to WiFi” we explored the steps to get your ESP32 board connected to WiFi. However, simply being connected to WiFi isn’t enough to unlock the full potential of this powerful microcontroller. For the ESP32 to shine in real-world projects, it needs to interact with the online world and fetch useful data. In this third installment of the ESP32 WiFi Chapter from the ESP32 Essential Guide, we’ll dive into a practical example: using the ESP32 to retrieve one of the most fundamental pieces of information for many IoT projects—time. 2 – […] - [ESP32 Essential Guide - Network Section - WiFi Chapter - 0 - 0 - What Can ESP32 Do Online?](https://avantmaker.com/tutorials/esp32-tutorials/esp32-arduino-core-essential-guide/esp32-essential-guide-network-section-index/esp32-essential-guide-network-section-wifi-chapter/esp32-essential-guide-network-section-wifi-chapter-0-0-what-can-esp32-do-online/): 1 – Introduction The ESP32 is more than just a microcontroller—it’s a gateway to the online world. Once connected to the internet, this tiny powerhouse unlocks a ton of possibilities for your projects. In this article, we’ll introduce what the ESP32 can do online and explore some exciting things you can achieve with it. 2 – So What Can ESP32 Do Online? With internet access, the ESP32 transforms from a standalone board into a connected device ready to tackle all sorts of tasks. Here’s a rundown of what it can do once it’s online! 2.1 – Web and Cloud Integration […] - [ESP32 Essential Guide - Network Section - WiFi Chapter - 0 - 1 - How to Connect ESP32 to WiFi](https://avantmaker.com/tutorials/esp32-tutorials/esp32-arduino-core-essential-guide/esp32-essential-guide-network-section-index/esp32-essential-guide-network-section-wifi-chapter/esp32-essential-guide-network-section-wifi-chapter-0-1-how-to-connect-esp32-to-wifi/): 1 – Introduction The ESP32 Development Board (ESP32) stands out from traditional development boards, such as the Arduino Uno, due to its built-in WiFi capabilities. This allows the ESP32 to connect to wireless networks, making it an excellent choice for IoT projects. In this article, we’ll walk you through the steps to connect, disconnect, and reconnect the ESP32 to a WiFi network. By the end, you’ll have a solid starting point for adding WiFi features to your projects. 2 – Connect ESP32 to WiFi To get started, we’ll use a simple example code that connects the ESP32 to a WiFi […] - [All About ESP32 Resources Hub](https://avantmaker.com/home/all-about-esp32-arduino-core-library/): Below are your resources for mastering this silicon sorcery. We invite you, brave maker, to explore, experiment, and weave your own innovations. Happy making, as you embark on this grand adventure with the ESP32! ESP32 Tutorial Our hands-on ESP32 Tutorials aim to transform curious makers into digital wizards, empowering them to command the ESP32 with practical skills rather than mere theory. ESP32 Reference We’ve crafted a comprehensive collection of references for the ESP32 Arduino Core Library to aid you in forging innovative projects. - [ESP32 Essential Guide - Network Section - WiFi Chapter](https://avantmaker.com/tutorials/esp32-tutorials/esp32-arduino-core-essential-guide/esp32-essential-guide-network-section-index/esp32-essential-guide-network-section-wifi-chapter/): Home / Tutorial / ESP32 Tutorials / ESP32 Essential Guide / Network / WiFi Chapter Introduction The ESP32 is like a WiFi wizard—it can shapeshift into three primary modes to suit your project’s needs, each with its own superpower: Attention: This chapter is under construction. Stay Tuned! 0 – What Can ESP32 Do Online? The ESP32 is more than just a microcontroller—it’s a gateway to the online world. Once connected to the internet, this tiny powerhouse unlocks a multitude of possibilities for your projects. Before we delve further, let’s discuss what the ESP32 can do online and explore some exciting […] - [ESP32 Essential Guide - Network Section](https://avantmaker.com/tutorials/esp32-tutorials/esp32-arduino-core-essential-guide/esp32-essential-guide-network-section-index/): Home / Tutorial / ESP32 Tutorials / ESP32 Essential Guide / Network Section Introduction This section reveals the ESP32’s magical networking abilities – its most powerful feature that transforms simple projects into internet-connected wonders. Here, you’ll find chapters that guide you through the arts of configuring wireless connections, crafting web client applications to fetch distant data, and even conjuring web servers to command your creations from anywhere. For those new to the network kingdom, this section provides the foundational knowledge needed to navigate this domain with confidence. We at AvantMaker have carefully arranged these chapters in a progression that builds […] - [ESP32 Arduino Core Essential Guide](https://avantmaker.com/tutorials/esp32-tutorials/esp32-arduino-core-essential-guide/): Home / Tutorial / ESP32 Tutorials / ESP32 Essential Guide Introduction Welcome to the ESP32 Arduino Core Essential Guide! Or you could call it ESP32 Essential Guide for short. Within this guide lies the key to crafting enchantments for the Internet of Things, conjuring marvels for the Smart Home, and even dabbling in the burgeoning magic of Artificial Intelligence and the STEM crafts! We at AvantMaker team have organized the vast knowledge of the ESP32 into distinct sections, much like the carefully curated chambers of a grand magical library. You shall find dedicated areas for the Fundamentals; journeys into the […] - [ESP32 Tutorials](https://avantmaker.com/tutorials/esp32-tutorials/): Home / Tutorial ESP32 Arduino Core Essential Guide Here, within these digital pages, we shall embark on a profound exploration into the enchanting world of ESP32  Arduino Core. Prepare yourselves to grasp the essential knowledge, for within this guide lies the key to crafting enchantments for the Internet of Things, conjuring marvels for the Smart Home, and even dabbling in the burgeoning magic of Artificial Intelligence and the STEM crafts!(Read More →) - [ESP32 WiFiClientSecure Library - setPrivateKey](https://avantmaker.com/references/esp32-arduino-core-index/esp32-wificlientsecure-library/esp32-wificlientsecure-library-setprivatekey/): Description The setPrivateKey method in the ESP32 WiFiClientSecure Library enables you to set the private key for a secure SSL/TLS connection. This method is critical when a server requires client authentication, pairing with a client certificate to prove the ESP32’s identity. At AvantMaker.com, we’re committed to empowering makers, learners, and enthusiasts by providing the tools and knowledge to secure your IoT projects effectively. Syntax and Usage The setPrivateKey method sets the private key used during the SSL/TLS handshake. Below is the syntax and a code snippet showing its usage: Here’s how to use it in your code: There is only one way to use this method—by […] - [ESP32 WiFiClientSecure Library - setCertificate](https://avantmaker.com/references/esp32-arduino-core-index/esp32-wificlientsecure-library/esp32-wificlientsecure-library-setcertificate/): Description The setCertificate method in the ESP32 WiFiClientSecure Library allows you to specify a client certificate for establishing a secure SSL/TLS connection. This method is essential when a server requires client authentication in addition to server verification, ensuring a mutually authenticated, encrypted communication channel. Syntax and Usage The setCertificate method is used to set the client certificate before initiating a secure connection. Below is the syntax and a code snippet demonstrating its usage: Here’s how to use it in your code: There is only one way to use this method—by providing the client certificate as an argument. It must be called before connect() to ensure the certificate is […] - [ESP32 WiFiClientSecure Library - setCACert](https://avantmaker.com/references/esp32-arduino-core-index/esp32-wificlientsecure-library/esp32-wificlientsecure-library-setcacert/): Description The setCACert() method in the ESP32 WiFiClientSecure Library sets the Certificate Authority (CA) certificate for a secure network connection. This method is essential for makers and enthusiasts building secure IoT projects with the ESP32, as it enables verification of a server’s identity during an SSL/TLS handshake. By providing a trusted CA certificate, you ensure encrypted communication is both safe and reliable, empowering you to create robust, secure applications. Syntax and Usage The setCACert() method has a single usage with one argument. Here’s how to incorporate it into your ESP32 sketches: This method is called on a WiFiClientSecure object before establishing a secure connection. It configures […] - [ESP32 WiFiClientSecure Library - flush](https://avantmaker.com/references/esp32-arduino-core-index/esp32-wificlientsecure-library/esp32-wificlientsecure-library-flush/): Description The flush method in the WiFiClientSecure library ensures that any buffered data in the outgoing secure stream (e.g., an HTTPS connection) is fully transmitted before proceeding. This method is useful when you need to guarantee that all data written to the secure client has been sent to the server, such as before closing a connection or awaiting a response. It blocks until the transmission is complete. Syntax and Usage The flush method has a single usage with no arguments. Below is the syntax: For practical applications and examples of this method, please consult the “Example Code” section on this page. This section provides comprehensive guidance […] - [ESP32 WiFiClientSecure Library - peek](https://avantmaker.com/references/esp32-arduino-core-index/esp32-wificlientsecure-library/esp32-wificlientsecure-library-peek/): Description The peek method in the WiFiClientSecure library allows you to look at the next byte of data in a secure network stream (e.g., an HTTPS connection) without removing it from the buffer. This is particularly useful for checking incoming data before deciding how to process it, such as verifying a header or delimiter in a secure communication. Unlike reading methods, peek leaves the data intact for subsequent operations. Syntax and Usage The peek method has a single usage with no arguments. Below is the syntax: For practical applications and examples of this method, please consult the “Example Code” section on this page. This section provides comprehensive guidance […] - [ESP32 WiFiClientSecure Library - readStringUntil](https://avantmaker.com/references/esp32-arduino-core-index/esp32-wificlientsecure-library/esp32-wificlientsecure-library-readstringuntil/): Description The readStringUntil method in the WiFiClientSecure library reads characters from a secure network stream (e.g., an HTTPS connection) into a String object until a specified terminator character is encountered. This method is useful for parsing text data from a secure server, such as HTTP headers or delimited responses, allowing you to process data line-by-line or segment-by-segment. It blocks until the terminator is found or the stream ends. Syntax and Usage The readStringUntil method has a single usage that requires a terminator character as an argument. Below is the syntax: Note: There is no argument-free variant of readStringUntil in the WiFiClientSecure library—it always requires a terminator character to define the stopping point. […] [comment]: # (Generated by Hostinger Tools Plugin)