Category Archives: Embedded
Embedded Protocol – I2C
I²C (Inter-Integrated Circuit) is a bi-directional two wires and serial data transmission communication protocol developed by Philips (Now NXP Semiconductor) in 1982. I2C is a Half-duplex communication protocol – (I2c can’t send and receive same time in the bus-data line). Multi-master can communicate with multi-salve. (Note: Communication is restricted between two masters; however, a single master can communicate with either a single slave or multiple slaves.) I2C is a Level Triggering. A device that sends data onto the bus is defined as a transmitter, and a device receiving data is defined as a receiver.
The bus must be controlled by a master device, responsible for generating the Start and Stop conditions. In contrast, certain devices such as LCDs, EEPROMs, and RTCs function as slaves. It’s important to note that both master and slave devices can operate as either transmitters or receivers. However, the master device plays a pivotal role in determining which mode is activated.
ESP32 Mongoose OS – Basic Examples
This article is about ESP32 Mongoose OS – Basic Examples, Let’s go through a basic example of using UART (Universal Asynchronous Receiver-Transmitter), Button and blinking an LED using an ESP32 by Mongoose OS.
Mongoose OS is an open-source IoT operating system designed for low-power, connected microcontrollers. Below is a basic example to get you started with Mongoose OS on an ESP32. This example demonstrates how to create a simple firmware that blinks an LED.
This is a basic example to help you get started with Mongoose OS on an ESP32. It blinks an LED using the GPIO capabilities provided by Mongoose OS. From here, you can explore additional features and libraries provided by Mongoose OS to build more sophisticated IoT applications. Refer to the Mongoose OS documentation for detailed information and advanced usage.
Setup Required
- PC
- UART Terminal (Putty, Visual Studio Serial Terminal, DockLight)
- LEDs
UART Serial
Print words, string, text, symbols
print('------------****************----------------'); print('ArunEworld');
ESP32 Mongoose OS – Basic Examples of UART Communication
// https://github.com/cesanta/mongoose-os/blob/master/fw/examples/mjs_uart/init.js // Load Mongoose OS API load('api_timer.js'); load('api_uart.js'); load('api_sys.js'); // Uart number used for this example let uartNo = 1; // Accumulated Rx data, will be echoed back to Tx let rxAcc = ""; let value = false; // Configure UART at 115200 baud UART.setConfig(uartNo, { baudRate: 115200, esp32: { gpio: { rx: 16, tx: 17, }, }, }); // Set dispatcher callback, it will be called whenver new Rx data or space in // the Tx buffer becomes available UART.setDispatcher(uartNo, function(uartNo, ud) { let ra = UART.readAvail(uartNo); if (ra > 0) { // Received new data: print it immediately to the console, and also // accumulate in the "rxAcc" variable which will be echoed back to UART later let data = UART.read(uartNo); print("Received UART data:", data); rxAcc += data; } }, null); // Enable Rx UART.setRxEnabled(uartNo, true); // Send UART data every second Timer.set(1000 /* milliseconds */, true /* repeat */, function() { value = !value; UART.write( uartNo, "Hello UART! " + (value ? 'Tick' : 'Tock') + " uptime: " + JSON.stringify(Sys.uptime()) + " RAM: " + JSON.stringify(Sys.free_ram()) + (rxAcc.length > 0 ? (" Rx: " + rxAcc) : "") + "\n" ); rxAcc = ""; }, null);
GPIO Module
- View On GitHub : api_gpio.js
ESP32 ArduinoCore Interface – Wi-Fi
The ESP32 ArduinoCore interface for Wi-Fi provides a straightforward and flexible way to enable Wi-Fi connectivity in projects developed using the ESP32 microcontroller platform with the Arduino IDE. With this interface, developers can easily incorporate Wi-Fi functionality into their projects, enabling devices to connect to wireless networks, access the internet, and communicate with other devices over Wi-Fi.
Features and Capabilities
- Access Point (AP) Mode: The ESP32 can act as an access point, allowing other devices to connect to it and access resources or services hosted by the ESP32.
- Station (STA) Mode: The ESP32 can connect to existing Wi-Fi networks as a client, enabling devices to access the internet or communicate with other networked devices.
- Soft Access Point (SoftAP) Mode: This mode enables the ESP32 to simultaneously act as both an access point and a station, allowing it to connect to an existing Wi-Fi network while also providing Wi-Fi access to other devices.
- Wi-Fi Protected Setup (WPS): The ESP32 supports WPS, a method for easily configuring Wi-Fi network security settings without needing to enter a password manually.
- Advanced Configuration Options: The interface provides access to advanced configuration options for fine-tuning Wi-Fi settings, such as specifying static IP addresses, setting up captive portals, and configuring Wi-Fi sleep modes to optimize power consumption.
- Event Handling: Developers can implement event handlers to respond to Wi-Fi-related events, such as successful connections, disconnections, or errors, allowing for more robust and responsive Wi-Fi functionality.
- Security Features: The ESP32 ArduinoCore interface supports various Wi-Fi security protocols, including WPA and WPA2, to ensure secure communication over Wi-Fi networks.
Overall, the ESP32 ArduinoCore interface for Wi-Fi simplifies the process of adding Wi-Fi connectivity to ESP32-based projects, making it easier for developers to create IoT devices, home automation systems, and other wireless applications.
Scan WiFi
Note: You can use Arduino example code instead of the below code because both are the same (File > Example > WiFi> WiFiScan)
/* https://aruneworld.com/embedded/espressif/esp32 * Tested By : Arun(20170429) * Example Name : AEW_WiFi_Scan.ino * This sketch demonstrates how to scan WiFi networks. * The API is almost the same as with the WiFi Shield library, * the most obvious difference being the different file you need to include: */ #include "WiFi.h" void setup() { Serial.begin(115200); // Set WiFi to station mode and disconnect from an AP if it was previously connected WiFi.mode(WIFI_STA); WiFi.disconnect(); delay(100); Serial.println("Setup done"); } void loop() { Serial.println("scan start"); // WiFi.scanNetworks will return the number of networks found int n = WiFi.scanNetworks(); Serial.println("scan done"); if (n == 0) { Serial.println("no networks found"); } else { Serial.print(n); Serial.println(" networks found"); for (int i = 0; i < n; ++i) { // Print SSID and RSSI for each network found Serial.print(i + 1); Serial.print(": "); Serial.print(WiFi.SSID(i)); Serial.print(" ("); Serial.print(WiFi.RSSI(i)); Serial.print(")"); Serial.println((WiFi.encryptionType(i) == WIFI_AUTH_OPEN)?" ":"*"); delay(10); } } Serial.println(""); // Wait a bit before scanning again delay(5000); }
Serial Terminal Output
scan start scan done 5 networks found 1: ArunEworld (-34)* 2: Exuber_365 (-59)* 3: Bangalore Police (-66)* 4: Tagos-2.4 (-80)* 5: RRL_Internet (-93)*
Code Explanation
Certainly! Here’s the code with explanations provided as snippets:
#include "WiFi.h"
This line includes the WiFi library necessary for working with WiFi on the ESP32.
void setup() { Serial.begin(115200); WiFi.mode(WIFI_STA); WiFi.disconnect(); delay(100); Serial.println("Setup done"); }
In the setup()
function:
- The code initializes serial communication at a baud rate of 115200.
- The WiFi mode is set to station mode (
WIFI_STA
) and any previous connection is disconnected usingWiFi.disconnect()
. - The code adds a delay of 100 milliseconds.
- The code prints “Setup done” to the serial monitor.
void loop() { Serial.println("scan start"); int n = WiFi.scanNetworks(); Serial.println("scan done"); if (n == 0) { Serial.println("no networks found"); } else { Serial.print(n); Serial.println(" networks found"); for (int i = 0; i < n; ++i) { Serial.print(i + 1); Serial.print(": "); Serial.print(WiFi.SSID(i)); Serial.print(" ("); Serial.print(WiFi.RSSI(i)); Serial.print(")"); Serial.println((WiFi.encryptionType(i) == WIFI_AUTH_OPEN)?" ":"*"); delay(10); } } Serial.println(""); delay(5000); }
In the loop()
function:
- The code begins by printing “scan start” to the serial monitor.
- Next, the ESP32 scans for nearby WiFi networks using the
WiFi.scanNetworks()
function, storing the number of networks found in variablen
. - After completing the scan, the code prints “scan done” to the serial monitor.
- The code prints the number of networks found when it detects networks, followed by details of each network, including index, SSID (network name), RSSI (signal strength), and encryption type.
- If no networks are found (when
n == 0
), the message “no networks found” is printed. - When networks are found, the code prints the number of networks found, followed by details of each network, including index, SSID (network name), RSSI (signal strength), and encryption type.
- Finally, the code adds a delay of 5 seconds before initiating the next scan.
These snippets provide an overview of how the code initializes WiFi and continuously scans for nearby networks, printing details to the serial monitor.
ESP32 ArduinoCore Project – WiFi Web Server LED Blink
This article is a continuation of the series on the ESP32 ArduinoCore Project using the ESP32 Dev board and carries the discussion on WiFi Web Server LED Blink. This series aims to provide easy and practical examples that anyone can understand. In our previous tutorial, we saw how to use the inbuilt code to toggle the onboard LED. This is the ESP32 LED Blinky in Wifi Webserver In this tutorial
A simple web server that lets you blink an LED via the web.
Wifi Web Server Info
- This code will print the IP address of your WiFi Module (ESP32) (once connected) to the Serial monitor.
- From that IP Address, you can open that address in a web browser to turn on and off the LED on pin-5.
- If the IP address of your ESP32 is 192.168.1.143:
- http://192.168.1.143/H turns the LED on
- http://192.168.1.143/L turns it off
- This example is written for a network using WPA encryption.
- For WEP or WPA, change the Wifi.begin() call accordingly.
ESP32 ArduinoCore Interface – Basic Example
When programming the ESP32 using the Arduino IDE, you typically use the ESP32 Arduino core, which provides a set of libraries and APIs to facilitate development. In this tutorial, we can discuss ESP32 ArduinoCore Interface Basic Example of Serial, GPIO, Timer, etc
Explore the fundamental features of the ESP32 microcontroller through an introductory example utilizing the ArduinoCore interface. This tutorial covers Serial communication, GPIO configuration for digital input and output, and Timer usage for precise timing operations. Ideal for beginners and hobbyists, this basic example demonstrates how to implement essential functionalities such as blinking an LED, reading button inputs, and handling timer interrupts, providing a solid foundation for further exploration and development with the ESP32 platform.”
ESP32 Lua-RTOS Module – PIO
The PIO (Programmable Input/Output) module in the ESP32 Lua-RTOS is a versatile feature that allows users to configure and control the GPIO pins of the ESP32 microcontroller dynamically. It provides an interface for performing various operations such as digital input, digital output, and pulse-width modulation (PWM) generation, among others.
Functionalities and Capabilities
- Digital Input/Output: The PIO module allows users to configure GPIO pins as digital inputs or outputs. Digital inputs can be used to read the state of external sensors or switches, while digital outputs can drive external devices such as LEDs, relays, or motors.
- Interrupt Handling: It supports interrupt handling on GPIO pins, allowing users to trigger actions based on changes in pin states. This feature is useful for implementing event-driven applications where real-time responses to external events are required.
- Pull-up/Pull-down Resistors: The PIO module enables users to enable or disable the internal pull-up or pull-down resistors on GPIO pins, ensuring stable and reliable signal readings.
- Pulse-Width Modulation (PWM): It provides support for generating PWM signals on GPIO pins, allowing users to control the intensity of analog devices such as LEDs, motors, or servos.
- Pin Configuration: Users can dynamically configure the functionality and characteristics of GPIO pins using the PIO module, including setting pin modes (input/output), configuring interrupt triggers, and adjusting PWM parameters.
- Low-Level Access: The PIO module offers low-level access to GPIO pins, allowing users to directly manipulate pin states and registers for advanced control and customization.
- Resource Management: It provides mechanisms for managing GPIO pin resources efficiently, preventing conflicts and ensuring proper allocation of resources across different tasks or modules.
Overall, the PIO module in the ESP32 Lua-RTOS enhances the flexibility and versatility of the ESP32 microcontroller, enabling users to implement a wide range of GPIO-based applications with ease and efficiency. Whether for simple digital I/O tasks or more complex PWM generation and interrupt handling, the PIO module offers powerful capabilities for interacting with external devices and sensors in Lua-RTOS projects.
ESP32 – Board Types
The ESP32 is a versatile microcontroller with a variety of development boards available. Different ESP32 various board types have different features, pin configurations, and capabilities.
When working with an ESP32 board, make sure to select the appropriate board type in the Arduino IDE or the other platform you are using. This ensures that the correct pin configurations and settings are applied during programming. The availability of features can vary between different boards, so it’s essential to choose a board that aligns with the requirements of your project.
ESP32 – Various Platforms Supports
The ESP32, a popular microcontroller developed by Espressif Systems, is supported by various platforms, enabling developers to program and interact with it using different programming languages and frameworks. Here are some platforms that support the ESP32:
ESP8266 NodeMCU – Getting Started
NodeMCU Introduction
ESP8266 NodeMCU Platform is really very good platform for beginners, you don’t need to remember all ESP8266 registers, address, and so on. You just call the lua function and make your DIY application very quick and easily. Frequently updating thier firmware based on new sensors, and many interfaces. Here below discussed many things and you can lean all the followings
FAQ,
- what are the different IDE’s are available for ESP8266 NodeMCU Platform?
- How to build a firmware for ESP8266?
- How to upload the firmware in to ESP8266 chip?
- Hello world examples : Printing letters in Serial (UART) and LED Blink.
- Reference Links
ESP8266 – Programmer and Flasher IDE
The programmer also in-builds design when you buy a NodeMCU Dev board, Sparkfun Thing Dev Board, and some other boards. Three more ways to program and flash firmware to ESP8266. Mostly using CP2102 USB-TTL UART or PL2303 USB-TTL programmer. you can use your Arduino board as an ESP8266 programmer. But you can also use your Arduino board as an ESP8266 Programmer (like another Programmer).
Ai-thinkers Modules: Ai-Thinkers modules are designed with external flash memory. so need a serial programmer to upload and flash the program into it. you can use any one of the serial USB to UART programmer.
ESP8266 – How to build and flash firmware?
ESP8266 Build and flash the firmware is a very easy job. before that, you need to choose the correct esp8266 platform (Arduino Core, AT Command, NodeMCU, Mangoes OS, Micro-python) for your requirements. First, you should know,
- What is esp8266 firmware? esp8266 Firmware contains a collection of library files or binary files.
- Why need to flash Firmware into esp8266? like when we think, we can’t able to write all the code ourselves. so we will follow some open source. if you use open source you need to flash the selected open source library file into esp8266 before starting your application.
ESP8266 – Boards Types
The ESP8266 is a popular Wi-Fi module that enables microcontrollers to connect to Wi-Fi networks and communicate with the Internet. Nowadays this wifi chip-based various kinds of modules are available, we are discussing ESP8266 Boards Types and those specifications, which you can select for your requirements.
ESPressif ESP-WROOM Modules
The ESP-WROOM-x is a module developed by Espressif. Four different types of ESP WROOM Modules are available.
- All the board’s pitch is 1.5mm.
- All the Boards are shielded.
- All the Boards do not have LEDs.
Module Name | Dimensions (mm) | Pins | Antenna |
---|---|---|---|
ESP-WROOM-02 | 18 × 20 | 18 | PCB trace |
ESP-WROOM-02D | 18 × 20 | 18 | PCB trace |
ESP-WROOM-02U | 18 × 20 | 18 | U.FL socket |
ESP-WROOM-S2 | 16 × 23 | 20 | PCB trace |
ESP-WROOM-02
- Fully Certified: Wi-Fi Alliance, SRRC, FCC, CE, TELEC, IC & KCC Certified
- Interfaces: Network Communication Protocol: TCP/IP network stacks,
- Interfaces: Wired Communication Protocols: HSPI, UART, PWM, I2C, I2S
- Fully Certified: RoHS, Halogen Free, REACH & CFSI Compliant
- Fully Certified: HTOL, ESD-HM, MSL, μHAST, HTSL
- Fully Certified: Output Power: +22dBm peak power in FCC certification
- This Module can be easily integrated into space-limited devices, it’s small size.
- PCB Design and Module Placement Guide
- Data Sheet:
ESP WROOM-S2
- The ESP-WROOM-S2 is part of the ESP32 series, which is a family of low-cost, low-power system-on-chip (SoC) microcontrollers with integrated Wi-Fi and Bluetooth capabilities.
- Dual-Core Processor: Xtensa LX6 processor,
- Peripheral Interfaces: GPIO pins, I2C, SPI, UART, and more
- Datasheets by Espressif for ESP-WROOM-S2
Ai-Thinker’s ESP8266 Modules
The AI-Thinker modules are sequentially labeled ESP-01 through ESP-13. NodeMCU boards extend upon the AI-Thinker modules. Here below tables about”Summary of All AI-Tinkers ESP8266 Module Boards”
Variant | Dimension (mm) | Antenna Type | Flash Memory | GPIO | Metal Shield Claim |
---|---|---|---|---|---|
ESP-01 Blue | 14.3*24.8 | PCB | 0.5MB (500kb) | GPIO0/2/16 | No |
ESP-01 Black | 14.3*24.8 | PCB | 1MB | GPIO0/2/16 | No |
ESP-02 | 14.2*14.7 | U-FL Connector | 1MB | GPIO0/2/15 | No |
ESP-03 | 17.4*12.2 | Ceramic Antenna | GPIO0/2/12/13/14/15/16 | No | |
ESP-04 | 14.7*12.1 | None | GPIO0/2/12/13/14/15/16 | No | |
ESP-05 | 14.2*14.7 | U-FL Connector | 3 Pins | No | |
ESP-06 | 14.2*14.7 | None | GPIO0/2/12/13/14/15/16 | Metal Shield Claims FCC | |
ESP-07 | 22*16 | Ceramic & U-FL Connector | GPIO0/2/4/5/12/13/14/15/16 | Metal Shield Claims FCC | |
ESP-07S | 17.0*16.0 | U-FL Connector | 14 Pins | Metal Shield Claims FCC | |
ESP-08 | 17*16 | None | GPIO0/2/12/13/14/15/16 | Metal Shield Not Claims FCC | |
ESP-09 | 10*10 | None | 1MB | GPIO0/2/12/13/14/15 | No |
ESP-10 | 14.2*10 | None | 3 Pins | No | |
ESP-11 | 14.2*10 | Ceramic | GPIO0/1 | No | |
ESP-12 | 24*16 | PCB | ADC + GPIO0/2/4/5/12/13/14/15/16 | Yes | |
ESP-12E | 24*16 | PCB | 20 Pins | Yes | |
ESP-12F | 24*16 | PCB | 20 Pins | Yes | |
ESP-12S | 24*16 | PCB | 14 Pins | Yes | |
ESP-13 | 18.0*20.0 | PCB | 16 Pins | Yes | |
ESP-14 | 24.3 × 16.2 | PCB | 22 Pins | Yes | |
DWA8 | 17*27.1 | PCB Antenna | ADC + GPIO0/2/12/13/14/15/16 | Yes |
ESP-01
- PCB Antenna, through matching, distance open 400 Meters, easy to use
- This Module does not Support PWM hardware.
- You can able to use the software PWM feature in the “NodeMCU” Platform.
ESP-02
- SMD package for the commit limit, the antenna can be used IPX End leading housing.
ESP-03
- SMD package,
- Built-in ceramic antenna technology
- All available IO Leads.
ESP-04
- SMD package
- Customers can custom antenna types
- Flexible design and all available IO Leads.
ESP-05
- SMD package,
- Only leads to serial RST Feet,
- Small size,
- External antenna.
ESP-06
- Bottom mount technology
- All IO Mouth leads with metal shielding shell, can be had FCC CE Certification is recommended.
ESP-07
- Half-hole chip technology,
- All IO Leads with metal shielding shell,
- Can be had FCE Certification,
- External IPX Antenna,
- The built-in ceramic antenna can be used.
ESP-07S
Same ESP-07 with 4MB Flash
- Size 16mm*17mm*3mm
- Pads:1mmx1.2mm
- Pads Spacing: 2mm
ESP-08
With ESP-07 the antenna customers can define their form.
ESP-09
- Ultra-small size package
- Only 10 * 10 Mm
- Four-layer board technology
- 1M byte.
ESP-10
ESP-11
- Chip interfaces
- Ceramic antenna
- Small volume.
ESP-12
- Semi-hole patch process, all IO Leads, with metal shielding shell, passed FCE Certification, built PCB On board antenna, 4M byte Flash.
ESP-12E
- On the top of the ESP-12 leads to 6 feet and more
- Greatly enhanced anti-jamming capability,
- The main recommendation of this section!
ESP-12F
ESP-12S
- ESP-12S Datasheet
- Size: 24mm*16mm*3mm, Weight: 0.01kg.
- 16pins count based On ESP8266 WiFi IC
- Fully compatible with forecast version ESP-12E or ESP12F
- FCC and CE & RHOS all passed
- Improved antenna design
- Better signal performance
- Note: ESP-12S does not have an SPI pin at the bottom of the board
ESP-13
The 4-layer design, semi-hole chip technology, all IO leads, with metal shielding shell, the antenna redesigned, RF performance!
ESP-14
- In ESP-12E prototype design,
- Interior adds STM8S003F3P6, and by STM8S ESP8266 AT commands to control the module is a complete STM8S micro-controller can operate via WIFI STM8 micro-controller programming.
NodeMCU DEVKIT
- ESP8266 NodeMCU Dev has an Ai-thinkers ESP8266 module on it
- The module comes with the latest version of AT Firmware.
- Make sure to refer to the image above to determine which pins are which On top it has a micro-USB socket, for connecting to the computer.
- Next to it are two buttons, one for reset and one for flashing.
NodeMCU DevKit Pin Details
PIN | Note |
---|---|
3V3 | Tthis is a fancy way to write 3.3V, which is the voltage that the board runs on internally. You can think about this pin like the plus side of a battery. There are several pins like this, they are all connected inside. |
GND | This is the ground. Think about it like the minus side of the battery. |
gpioXX- | “gpio” stands for “general purpose input output”. Those are the pins we will be using for sending and receiving signals to and from various devices that we will connect to them. They can act as output – pretty much like a switch that you can connect to plus or to minus with your program Or they can act as input, telling your program whether they are connected to plus or minus. |
A0 | a0- This is the analog pin. It has limitation to handle up to 1V. |
Vin | This pin is connected to the 5V from your computer. When it’s not connected to the computer, you can also use it to power your board with a battery The voltage applied here will be internally converted to the 3.3V that the board needs. |
FLASH | Hold down this button, while resetting the module and bring the board into programming mode (also known as flashing mode) |
RST | this is a reset button (and a corresponding pin, to which you can connect the external button). |
The other pins are used internally by the board, and we will not be connecting anything to them.
Difference in Ai Thinker’s ESP8266 Boards
Difference Between ESP-01 Blue Board and ESP-01S Black Board
Memory Flash Size is differ
- ESP-01 Blue Board – 500Kb
- ESP-01S Black Board – 1Mb
Difference Between ESP-07 and ESP-07S?
- PCB Layers
- ESP-07S – 4 Layers of PCB
- ESP-07 – 2 Layer of PCB
- Flash Memory
- ESP-07S – 4M
- ESP-07 – 1M
- IPEX Connector and Ceramic Antenna
- ESP-07S – Only have IPEX Connector and not have ceramic antenna
- ESP-07 – Have IPEX Connector and ceramic antenna
- Certification
- ESP-07S -Have FCC, CE, ROSH Certification
- ESP-07 – 1M – Not have certification
- Note :
- ESP-07S is upgraded from ESP-07.
- Both are same pins
Difference Between ESP-12E and ESP12F?
- Please refer to the antenna design in the below ESP-12E and ESP-12F images.
- PCB Layers
- ESP-12F – 4 Layers of PCB
- ESP-12E – 2 Layer of PCB
- Certification
- ESP-12F -Have FCC, CE, ROSH Certification
- ESP-12E – 1M – Not have certification
- Note
- ESP-12F is upgraded from ESP-12E.
- Both are the same pins
Olimex ESP8266 Module
Olimex provides two different types of ESP8266-based boards.
The below list is common for both boards
- Both boards of the Main chip are EPS8266 from ESPressif
- 2MB (16MB) SPI Flash Memory
- Power LED
- User-programmable LED
- SMT jumpers for different boot modes (FLASH, UART, SDO)
- PCB antenna
- OSHW design
- Pads for a U.FL antenna connector (if you want to use an external antenna)
The below table about differences between Olimex MOD_WIFI-ESP8266 and DEV Boards
Olimex MOD-WIFI-ESP8266 | Olimex MOD-WIFI-ESP8266-DEV |
---|---|
Button to swap between FLASH and UART mode UEXT connector | Button for UART mode (since hardware revision B) UEXT pads for easier access to UART interface 22 pin holes @ 0.1″ step for easier access to processor pins |
Dimensions: (1.38 x 0.69)” ~ (3.50 x 1.75)cm | Dimensions: (1.3 x 0.9)” ~ (3.3 x 2.3)cm |
Adafruit Huzzah ESP8266 Modules
Adafruits has two diffrent ESp8266 Boards “Adafruit Feather HUZZAH with ESP8266” and “Adafruit HUZZAH ESP8266 Breakout”. The Below list is common specs for both boards
- Reset button
- 9 x GPIO (3.3V logic), which can be used for I2C or SPI
- 1 x Analog input (1.0V max)
Adafruit Feather HUZZAH with ESP8266
It’s along with Ai-Thinker’s boards
- Measures 2.0″ x 0.9″ x 0.28″ (51mm x 23mm x 8mm) without headers soldered-in
- Light as a (large?) feather – 9.7 grams
- 3.3V regulator with 500mA peak current output
- CP2104 USB-Serial converter onboard with 921600 max baud rate for speedy uploading
- Auto-reset support for getting into bootloader mode.
- Built-in 100mA LiPoly charger pin available. Charging Status indicator LED is available. This can cut a trace to disable the charger.
- Pin #0 red LED for general purpose blinking.
- Pin #2 blue LED for boot loading debug & general purpose blinking
- Power/enable pin
- 4 mounting holes
Adafruit HUZZAH ESP8266 Breakout
Its Just breakout board on top of the Ai-Thinker’s boards
- 3.3V out, 500mA regulator (you need to assume the ESP8266 can draw up to 250mA.)
- User button that can use the chip in bootloader mode,
- Red LED you can blink
- Level shifting on the UART and resetting the pin
- Two diode-protected power inputs (USB cable and battery)
- Two parallel, breadboard-friendly breakouts on either side give you access to: 2 x UART pins and 2 x 3-6V power inputs, reset, enable, LDO-disable, 3.3V output
SparkFun ESP8266 Boards
SparkFun ESP8266 Thing
- All module pins breakout
- On-board LiPo charger/power supply
- 802.11 b/g/n
- Wi-Fi Direct (P2P), soft-AP
- Integrated TCP/IP protocol stack
- Integrated TR switch, balun, LNA, power amplifier, and matching network
- Integrated PLLs, regulators, DCXO, and power management units
- Integrated low-power 32-bit CPU could be used as an application processor
- +19.5dBm output power in 802.11b mode
SparkFun WiFi Shield – ESP8266
- Arduino R3 Layout
- 802.11 b/g/n
- Wi-Fi Direct (P2P), soft-AP
- Integrated TCP/IP protocol stack
- Integrated TR switch, balun, LNA, power amplifier, and matching network
- Integrated PLLs, regulators, DCXO, and power management units
- Integrated low-power 32-bit CPU could be used as an application processor
- +19.5dBm output power in 802.11b mode
Other ESP8266 Boards
KNEWRON Technologies smartWIF
- GitHub: KNEWRON Technologies smartWIF
- Arduino-like hardware IO: The board allows you to code like Arduino in an interactive manner with Lua scripting language.
- NodeJS style network API: The firmware provides event-driven API for network applications, which facilitates developers writing code running this tiny little board in NodeJS style. Greatly speed up your Wi-Fi / IOT application development process.
- Reprogramming possibility: The IO button available on the kit also functions as a re-flashing button.
- Multiple uses: serial to USB converter as well as 3.7V LiPo battery charger.
WeMos
These WeMos boards work with Arduino and NodeMCU firmware
WEMos D1 Mini
- 11 digital IO, interrupt/PWM/I2C/one-wire supported(except D0)
- 1 analog input(3.2V max input)
- Type-C USB Port
- LOLIN I2C Port
- Compatible with MicroPython, Arduino, nodemcu
WEMos D1 mini Pro
- 11 digital input/output pins
- Interrupt/pwm/I2C/one-wire
- 1 analog input(3.2V max input)
- 16M bytes(128M bit) Flash
- External antenna connector
- Built-in PCB antenna
- Lithium battery interface, 500mA Max charging current
- LOLIN I2C Port
- Compatible with Arduino, MicroPython, NodeMCU
- Default firmware: latest MicroPython
WEMos D1 mini Lite
- 11 digital IO, interrupt/pwm/I2C/one-wire supported(except D0)
- 1 analog input(3.2V max input)
- a Micro USB connection
- 1M Bytes FLASH inside
- Compatible with MicroPython, Arduino, nodemcu
Sweetpea ESP-210 Module
- Flash 4MB
- Total Pins 14
- Programmable Pins 11
Wireless-Tag
Next Topic
- See Also ESP32 – Boards Types
More Topics
ESP8266 – Resource
ESP8266 Resources : Here you can get all resources of ESP8266 Books and useful website. Keep learn about ESP8266 using this blog. Everyday updating new projects and tutorials about ESP8266 so keep on this site .
ESP8266 Books
Useful Links
- http://www.ebook777.com/?s=ESP8266
- Kolbans ESP8266 and ESP32 Books : Library
Agus Kurniawan : SparkFun ESP8266 Thing Development Workshop
: MicroPython for ESP8266 Development Workshop
Agus Kurniawan : NodeMCU Development Workshop
Kolban’s book on ESP32 –
Kolban’s Book on the ESP32 & ESP8266
Marco Schwartz : Home Automation With The Esp8266
Websites
- http://esp8266.ru/
- Wikipedia – ESP8266
- https://www.esp8266basic.com/
- http://www.esp8266.com/
- https://github.com/esp8266/esp8266-wiki/wiki
- https://nurdspace.nl/ESP8266
- https://www.openhomeautomation.net/choose-esp8266-module/
- http://benlo.com/esp8266/
- NodeMCU
- ESP-14 Useful Websites.
Next topic
ESP8266 – Platforms
ESP8266 is a powerful microcontroller with built-in Wi-Fi. You can program the ESP8266 using various languages such as C, C++, Lua, MicroPython, JavaScript, and AT Command as well. It depends on your requirements. If you are a beginner, my suggestion is C++ and Lua. This is because, with the Arduino Core for ESP8266, you can utilize your Arduino C++ library for the ESP8266. Additionally, with the NodeMCU Core for ESP8266, you can use the eLua Embedded Module Library for the ESP8266. These Arduino and Lua methods have a lot of built-in library files, making it easy for beginners and learners. Also will discuss “ESP8266 Platforms”