echo '' ;

Category Archives: Embedded

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

Read more… →

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

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. 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.
  7. 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 using WiFi.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 variable n.
  • 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.

Read more… →

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.”

Read more… →

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

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. 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.
  7. 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.

Read more… →

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.

Read more… →

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

Read more… →

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.

Read more… →

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.
Read more… →

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.
ESPressif ESP-WROOM Modules List

ESP-WROOM-02

ESP-WROOM-02 Front View
Front View
ESP-WROOM-02 Back View
Back View
  • 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”

Summary of All AI-Tinkers ESP8266 Module Boards

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-01 Front View (Black Board)
ESP-01 Back View (Blackboard)
ESP-01 Front View (Blue Board)

ESP-02

ESP-02 Front View
  • SMD package for the commit limit, the antenna can be used IPX End leading housing.
ESP-02 Back View

ESP-03

ESP-03 Front View
  • SMD package,
  • Built-in ceramic antenna technology
  • All available IO Leads.
ESP-03 Back View

ESP-04

ESP-04 Front View
  • SMD package
  • Customers can custom antenna types
  • Flexible design and all available IO Leads.
ESP-04 Back View

ESP-05

ESP-05 Front View
  • SMD package,
  • Only leads to serial RST Feet,
  • Small size,
  • External antenna.

ESP-06

ESP-06 Front View
  • Bottom mount technology
  • All IO Mouth leads with metal shielding shell, can be had FCC CE Certification is recommended.
ESP-06 Back View

ESP-07

ESP-07 Front View
  • 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-07 Back View

ESP-07S

ESP-07S Front View

Same ESP-07 with 4MB Flash

  • Size 16mm*17mm*3mm
  • Pads:1mmx1.2mm
  • Pads Spacing: 2mm
ESP-07S Back View

ESP-08

ESP-08 Front View

With ESP-07 the antenna customers can define their form.

ESP-08 Back View

ESP-09

ESP-09 Front View
  • Ultra-small size package
  • Only 10 * 10 Mm
  • Four-layer board technology
  • 1M byte.
ESP-09 Back View

ESP-10

ESP-10 Front View
ESP-10 Back View

ESP-11

ESP-11 Front View
  • Chip interfaces
  • Ceramic antenna
  • Small volume.
ESP-11 Back View

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

ESP-12E Front View
  • 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

ESP8266 NodeMCU DEv Board Pin Details

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

Differences between Olimex MOD_WIFI-ESP8266 and DEV Boards
Olimex MOD-WIFI-ESP8266
Olimex MOD-WIFI-ESP8266-DEV


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

  • 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

WT8266-S1
WT8266-S1
WT8266-DK V2
WT8266-S2
WT8266-DK

Next Topic

More Topics

ESP8266 Get Start
ESP8266 Various Boards
ESP8266 Programming Methods
ESP8266 Various Programmer
ESP8266 Build&Flash Firmware
ESP8266 Resource
ESP8266 FQA
ESP8266 MQTT broker BONDAR.
ESP8266 Platforms
ESP8266 Arduino-Core
ESP8266 AT-Commands
ESP8266 Mongoose OS
ESP8266 NodeMCU
Others
ESP8266 Sitemap
ESP8266 All post

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

 

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


Next topic

ESP8266 Get Start
ESP8266 Various Boards
ESP8266 Programming Methods
ESP8266 Various Programmer
ESP8266 Build&Flash Firmware
ESP8266 Resource
ESP8266 FQA
ESP8266 MQTT broker BONDAR.
ESP8266 Platforms
ESP8266 Arduino-Core
ESP8266 AT-Commands
ESP8266 Mongoose OS
ESP8266 NodeMCU
Others
ESP8266 Sitemap
ESP8266 All post


 

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”

Read more… →