// https://www.aruneworld.com/
// Tested By : Arun(20170430)
// Example Name : AEW_Button_Message.js
// Firmware : Mongoose OS for ESP32
//*******************************//
// This example demonstrates how to react on a button press
// by printing a message on a console.
//
// To try this example,
// 1. Download <code>{{EJS0}}</code> tool from https://mongoose-os.com/software.html
// 2. Run <code>{{EJS1}}</code> tool and install Mongoose OS
// 3. In the UI, navigate to the <code>{{EJS2}}</code> tab and load this example
// Load Mongoose OS API
load('api_gpio.js');
let pin = 0; // GPIO 0 is typically a 'Flash' button
GPIO.set_button_handler(pin, GPIO.PULL_UP, GPIO.INT_EDGE_NEG, 200, function(x) {
print('Button press, pin: ', x);
}, true);
print('Flash button is configured on GPIO pin ', pin);
print('Press the flash button now!');
Welcome to the ESP8266 Mongoose-OS Tutorials on the TCP Web Server. In this series of tutorials, we will explore how to create a TCP Web Server using the ESP8266 microcontroller and the Mongoose-OS firmware.
The ESP8266 is a powerful microcontroller known for its built-in WiFi capability, making it suitable for IoT (Internet of Things) projects. Mongoose-OS is an open-source firmware for microcontrollers that provides a development environment for building IoT applications. “ESP8266 Mongoose OS Tutorials TCP Web Server”
In this tutorial series, we will demonstrate how to create a TCP Web Server using Mongoose-OS on the ESP8266. We will cover topics such as setting up the development environment, writing code to create a TCP server, handling incoming connections, and sending data over the network.
Whether you’re a beginner or an experienced developer, these tutorials will provide you with the knowledge and skills to create your own TCP Web Server on the ESP8266 using Mongoose-OS.
Let’s get start!
TCP Web Server Uses
Use
Description
Data Logging
Logging data received from clients, such as sensor readings or system status updates, for later analysis or archival purposes.
Remote Monitoring
Providing remote access to real-time data, allowing users to monitor and control devices or systems from anywhere with an internet connection.
Home Automation
Controlling smart home devices remotely, such as lights, thermostats, or security cameras, to manage home environments more conveniently.
Industrial Control
Monitoring and controlling machinery, production processes, or environmental conditions in industrial settings, enabling remote access for maintenance.
IoT Applications
Exchanging data between connected IoT devices, gathering sensor data from remote locations, or controlling IoT devices remotely.
Communication
Facilitating communication between devices on a network, allowing them to exchange data, synchronize operations, or coordinate tasks.
Remote Configuration
Remotely configuring devices or systems, updating settings, adjusting parameters, or performing firmware upgrades without physical access to the device.
Real-Time Notifications
Sending real-time notifications to connected clients, such as alerts, alarms, or status updates, to keep users informed of important events.
Custom Applications
Building custom applications tailored to specific needs, such as remote control interfaces, monitoring dashboards, or interactive user interfaces.
Distributed Systems
Integrating into distributed systems or networked applications to enable communication and data exchange between multiple nodes or components.
Code
// https://www.aruneworld.com/embedded/espressif/esp8266/esp8266_mongoose-os/
// Tested By : Arun(20170430)
// Example Name : AEW_TCP_Web_Server.js
// Firmware : Mongoose OS for ESP32
//*******************************//
// This example demonstrates how to create a TCP echo server.
//
// To try this example,
// 1. Download mos tool from https://mongoose-os.com/software.html
// 2. Run mos tool and install Mongoose OS
// 3. In the UI, navigate to the Examples tab and load this example
// Load Mongoose OS API
load('api_net.js');
let port = '1234';
Net.bind(port, function(conn, ev, ev_data) {
if (ev !== Net.EV_ACCEPT) return;
Net.send(conn, JSON.stringify({a: 1, b: 'hey!'}));
Net.close(conn);
}, true);
print('TCP server is listening on port ', port);
Code Explanation
Line(s)
Explanation
1-4
Comments providing information about the source of the code, the tester, example name, and firmware used.
7
Load the Mongoose OS API module to enable network functionality.
9
Define the port number (e.g., ‘1234’) on which the TCP server will listen for incoming connections.
11-18
Bind a TCP server to the specified port. When a connection is accepted, send a JSON-encoded message {a: 1, b: 'hey!'} to the client and close the connection.
15
Check if the event received is an accept event.
16
Send a JSON-encoded message {a: 1, b: 'hey!'} to the client.
17
Close the connection after sending the message.
19
Print a message indicating that the TCP server is listening on the specified port.
To turn on the led you need to load the gpio_api.js file.
LED Turn ON/OFF
Note : This below example was tested mongoose os with java script app demo-js in ESP8266 NodeMCU Dev Board(ESP-12E)
This below example turn on the LED GPIO-4 (NodeMCU Dev Board digital pin 2)
Set the GPIO pin mode as OUPUT uisng gpio set mode function ex: GPIO.set_mode(led, GPIO.MODE_OUTPUT)
Turn off the LED call the gpio write function with low-0 ex : GPIO.write(led, 0) .
Turn on the LED call the gpio write function with low-1 ex : GPIO.write(led, 1) .
Code
load('api_gpio.js');
// Configure LED
let led = 4; //lde pin GPIO04
GPIO.set_mode(led, GPIO.MODE_OUTPUT);
GPIO.write(led,1);
LED turn ON/OFF using button
Use Boot button(GPIO-0)
The example code used blink in-build LED, It’s connected to GPIO-10.
You can change any other pin Ex : led = 4; // Get LED GPIO-04 pin;
Note : Code 1 and Two are same application and functionality. Main difference is calling function.
Code 1 :
Used GPIO-0 pin (Boot button in NodeMCU Dev Board), as interrupt and used Button interrupt handler function.
// http://www.ArunEworld.com/Embedded/ESPressif/ESP8266/ESP8266_Mongoose-os/
// Tested By : Arun(20170430)
// Example Name : AEW_LED-Blink_Using_Button.js
// Firmware : Mongoose OS for ESP32
//*******************************//
// This example demonstrates how to react on a button press by toggling LED.
//
// To try this example,
// 1. Download <code>{{EJS7}}</code> tool from https://mongoose-os.com/software.html
// 2. Run <code>{{EJS8}}</code> tool and install Mongoose OS
// 3. In the UI, navigate to the <code>{{EJS9}}</code> tab and load this example
// Load Mongoose OS API
load('api_gpio.js');
// Configure LED
let led = ffi('int get_led_gpio_pin()')(); // Get built-in LED GPIO pin
GPIO.set_mode(led, GPIO.MODE_OUTPUT);
let pin = 0; // GPIO 0 is typically a 'Flash' button
GPIO.set_button_handler(pin, GPIO.PULL_UP, GPIO.INT_EDGE_NEG, 200, function(x) {
let value = GPIO.toggle(led);
print('Button press, pin:', x, 'LED pin:', led, ' Value: ', value);
}, true);
print('Flash button is configured on GPIO pin ', pin);
print('Press the flash button now!');
Code 2:
In this code i was used GPIO-0 pin (Boot button in NodeMCU dev Kit) as interrupt and used interrupt handler function.
If your using interruot handler function then you need o enable the interrupt using GPIO.enable_int(pin) function
This code provides basic functionality for interfacing with a 16×2 HD44780 LCD using an ESP8266 NodeMCU board. Adjustments may be needed based on your specific hardware setup and requirements.
-- Define GPIO pins for LCD connections
local PIN_RS = 1 -- GPIO5
local PIN_EN = 2 -- GPIO4
local PIN_D4 = 3 -- GPIO0
local PIN_D5 = 4 -- GPIO2
local PIN_D6 = 5 -- GPIO14
local PIN_D7 = 6 -- GPIO12
-- Function to send a command to LCD
local function lcd_command(cmd)
gpio.write(PIN_RS, gpio.LOW) -- Set RS pin LOW for command mode
-- Send high nibble
gpio.write(PIN_D4, bit.isset(cmd, 4) and gpio.HIGH or gpio.LOW)
gpio.write(PIN_D5, bit.isset(cmd, 5) and gpio.HIGH or gpio.LOW)
gpio.write(PIN_D6, bit.isset(cmd, 6) and gpio.HIGH or gpio.LOW)
gpio.write(PIN_D7, bit.isset(cmd, 7) and gpio.HIGH or gpio.LOW)
gpio.write(PIN_EN, gpio.HIGH)
gpio.write(PIN_EN, gpio.LOW)
-- Send low nibble
gpio.write(PIN_D4, bit.isset(cmd, 0) and gpio.HIGH or gpio.LOW)
gpio.write(PIN_D5, bit.isset(cmd, 1) and gpio.HIGH or gpio.LOW)
gpio.write(PIN_D6, bit.isset(cmd, 2) and gpio.HIGH or gpio.LOW)
gpio.write(PIN_D7, bit.isset(cmd, 3) and gpio.HIGH or gpio.LOW)
gpio.write(PIN_EN, gpio.HIGH)
gpio.write(PIN_EN, gpio.LOW)
-- Delay for command execution
tmr.delay(2000) -- Adjust delay as needed
end
-- Function to send data to LCD
local function lcd_data(data)
gpio.write(PIN_RS, gpio.HIGH) -- Set RS pin HIGH for data mode
-- Send high nibble
gpio.write(PIN_D4, bit.isset(data, 4) and gpio.HIGH or gpio.LOW)
gpio.write(PIN_D5, bit.isset(data, 5) and gpio.HIGH or gpio.LOW)
gpio.write(PIN_D6, bit.isset(data, 6) and gpio.HIGH or gpio.LOW)
gpio.write(PIN_D7, bit.isset(data, 7) and gpio.HIGH or gpio.LOW)
gpio.write(PIN_EN, gpio.HIGH)
gpio.write(PIN_EN, gpio.LOW)
-- Send low nibble
gpio.write(PIN_D4, bit.isset(data, 0) and gpio.HIGH or gpio.LOW)
gpio.write(PIN_D5, bit.isset(data, 1) and gpio.HIGH or gpio.LOW)
gpio.write(PIN_D6, bit.isset(data, 2) and gpio.HIGH or gpio.LOW)
gpio.write(PIN_D7, bit.isset(data, 3) and gpio.HIGH or gpio.LOW)
gpio.write(PIN_EN, gpio.HIGH)
gpio.write(PIN_EN, gpio.LOW)
-- Delay for data transfer
tmr.delay(2000) -- Adjust delay as needed
end
-- Function to initialize the LCD
local function lcd_init()
-- Set GPIO pins as outputs
gpio.mode(PIN_RS, gpio.OUTPUT)
gpio.mode(PIN_EN, gpio.OUTPUT)
gpio.mode(PIN_D4, gpio.OUTPUT)
gpio.mode(PIN_D5, gpio.OUTPUT)
gpio.mode(PIN_D6, gpio.OUTPUT)
gpio.mode(PIN_D7, gpio.OUTPUT)
-- Initialization sequence
tmr.delay(15000) -- Wait for power-up
lcd_command(0x33) -- Initialize
lcd_command(0x32) -- Set to 4-bit mode
lcd_command(0x28) -- 2 lines, 5x8 font
lcd_command(0x0C) -- Display on, cursor off, blink off
lcd_command(0x01) -- Clear display
lcd_command(0x06) -- Increment cursor
end
-- Function to clear the LCD
local function lcd_clear()
lcd_command(0x01) -- Clear display
end
-- Function to set cursor position
local function lcd_set_cursor(row, col)
local offset = {0x00, 0x40}
lcd_command(0x80 + offset[row] + col - 1)
end
-- Function to write a string to the LCD
local function lcd_write_string(str)
for i = 1, #str do
lcd_data(string.byte(str, i))
end
end
-- Example usage
lcd_init() -- Initialize the LCD
lcd_clear() -- Clear the LCD
lcd_set_cursor(1, 1) -- Set cursor to first row, first column
lcd_write_string("Hello, World!") -- Write a string to the LCD
Code Explanation
Section
Explanation
Initialization
– The code initializes the LCD module by setting up the GPIO pins for communication and configuring the LCD settings.
Function Definitions
– Defines helper functions for sending commands and data to the LCD, such as lcd_send_command and lcd_send_data. These functions handle the low-level communication with the LCD module.
LCD Initialization
– Initializes the LCD by sending a sequence of commands to configure its display settings, such as the number of lines, cursor behavior, and display on/off settings.
Clearing the Display
– Sends a command to clear the display and return the cursor to the home position.
Setting Cursor
– Sets the cursor position on the LCD. The lcd_set_cursor function takes the row and column numbers as parameters and calculates the corresponding position based on the LCD’s row length.
Writing Characters
– Writes characters to the LCD at the current cursor position. The lcd_write_char function sends data to the LCD to display the specified character.
Writing Strings
– Writes strings to the LCD. The lcd_write_string function iterates over each character in the string and calls lcd_write_char to display them sequentially.
Main Function
– Demonstrates how to use the defined functions to interact with the LCD. It initializes the LCD, clears the display, sets the cursor to the first position, and writes a string to the LCD.
Nokia-5110 PCD8544 Display interface
Required NodeMCU Modules (Firmware): GPIO Module
Required hardware: ESP8266 with Programmer (or) NodeMCU Dev Kit, Nokia 5110 PCD8544 LCD Display,
Required software tools: ESPlorer IDE Tool
Code
`lua
-- https://www.aruneworld.com/embedded/esp8266/esp8266-nodemcu/
-- Tested By : Arun(20170212)
-- Example Name : AEW_LCD_Nokia-5110_PCD8544.lua
-- Reference data sheet: https://www.sparkfun.com/datasheets/LCD/Monochrome/Nokia5110.pdf
--------------------------------------------------------------------------------
-- The following code referred by this post: http://playground.arduino.cc/Code/PCD8544
-- You need to configure the pins you are using here
PIN_RESET = 0
PIN_SCE = 1
PIN_DC = 2
PIN_SDIN = 3
PIN_SCLK = 4
local LCD_D = gpio.HIGH
local LCD_C = gpio.LOW
local LCD_X = 84
local LCD_Y = 48
local chars = "\0\0\0\0\0\0\0\95\0\0\0\7\0\7\0\20\127\20\127\20\36\42\127\42\18\35\19\8\100\98\54\73\85\34\80\0\5\3\0\0\0\28\34\65\0\0\65\34\28\0\20\8\62\8\20\8\8\62\8\8\0\80\48\0\0\8\8\8\8\8\0\96\96\0\0\32\16\8\4\2\62\81\73\69\62\0\66\127\64\0\66\97\81\73\70\33\65\69\75\49\24\20\18\127\16\39\69\69\69\57\60\74\73\73\48\1\113\9\5\3\54\73\73\73\54\6\73\73\41\30\0\54\54\0\0\0\86\54\0\0\8\20\34\65\0\20\20\20\20\20\0\65\34\20\8\2\1\81\9\6\50\73\121\65\62\126\17\17\17\126\127\73\73\73\54\62\65\65\65\34\127\65\65\34\28\127\73\73\73\65\127\9\9\9\1\62\65\73\73\122\127\8\8\8\127\0\65\127\65\0\32\64\65\63\1\127\8\20\34\65\127\64\64\64\64\127\2\12\2\127\127\4\8\16\127\62\65\65\65\62\127\9\9\9\6\62\65\81\33\94\127\9\25\41\70\70\73\73\73\49\1\1\127\1\1\63\64\64\64\63\31\32\64\32\31\63\64\56\64\63\99\20\8\20\99\7\8\112\8\7\97\81\73\69\67\0\127\65\65\0\2\4\8\16\32\0\65\65\127\0\4\2\1\2\4\64\64\64\64\64\0\1\2\4\0\32\84\84\84\120\127\72\68\68\56\56\68\68\68\32\56\68\68\72\127\56\84\84\84\24\8\126\9\1\2\12\82\82\82\62\127\8\4\4\120\0\68\125\64\0\32\64\68\61\0\127\16\40\68\0\0\65\127\64\0\124\4\24\4\120\124\8\4\4\120\56\68\68\68\56\124\20\20\20\8\8\20\20\24\124\124\8\4\4\8\72\84\84\84\32\4\63\68\64\32\60\64\64\32\124\28\32\64\32\28\60\64\48\64\60\68\40\16\40\68\12\80\80\80\60\68\100\84\76\68\0\8\54\65\0\0\0\127\0\0\0\65\54\8\0\16\8\8\16\8\120\70\65\70\120"
local function shiftOut(d, cl, data)
for index = 0, 7 do
if bit.isset(data, 7 - index) then
gpio.write(d, gpio.HIGH)
else
gpio.write(d, gpio.LOW)
end
gpio.write(cl, gpio.HIGH)
tmr.delay(5)
gpio.write(cl, gpio.LOW)
end
end
local function LCDWrite(dc, data)
gpio.write(PIN_DC, dc)
gpio.write(PIN_SCE, gpio.LOW)
shiftOut(PIN_SDIN, PIN_SCLK, data)
gpio.write(PIN_SCE, gpio.HIGH)
end
function LcdSetPins(sclk, sdin, dc, sce, reset)
PIN_SCLK = sclk
PIN_SDIN = sdin
PIN_DC = dc
PIN_SCE = sce
PIN_RESET = reset
end
function LcdLocate(x, y)
LCDWrite(LCD_C, 64 + x)
LCDWrite(LCD_C, 128 + y)
end
function LcdCharacter(character)
LCDWrite(LCD_D, 0x00)
for index = 0, 5 do
LCDWrite(LCD_D, character)
end
LCDWrite(LCD_D, 0x00)
end
function LcdClear()
local c = 84 * 6
for index = 0, c do
tmr.delay(5)
LCDWrite(LCD_D, 0)
end
end
function LcdPrintChar(c)
LCDWrite(LCD_D, 0)
local char_index = 1 + (string.byte(c) - 32) * 5
for index = 0, 4 do
LCDWrite(L
Code Explanation
This Lua code initializes and interacts with a Nokia 5110 LCD module (PCD8544 controller) using an ESP8266 NodeMCU board. The code provides a basic framework for interfacing with the Nokia 5110 LCD module using the ESP8266 NodeMCU board, allowing for the display of text and basic graphics. Here’s the explanation:
Section
Explanation
Initialization and Pins
– Pins for interfacing with the LCD module are configured (RESET, SCE, DC, SDIN, SCLK). – References and credits are provided in the comments.
LCD Character Data
– Character data for the LCD is defined in the chars variable. Each character is represented by a series of bytes.
Shift Out Function
– Sends data to the LCD module by shifting bits out through a specified pin.
LCD Write Function
– Writes data to the LCD. Sets the appropriate data/command mode and then uses shiftOut to send the data.
Setting Pin Configuration
– Allows setting the pins used for communication with the LCD dynamically.
LCD Cursor Positioning
– Positions the cursor at the specified coordinates on the LCD.
Writing a Character
– Writes a single character to the LCD at the current cursor position.
Clearing the LCD
– Clears the entire LCD display.
Printing a Character
– Prints a character to the LCD, advancing the cursor position accordingly.
Initialization
– Initializes the LCD module with the appropriate settings.
Test Function
– A test function that initializes the LCD and prints some sample text.
The ESP8266 Arduino Core is a software framework that enables developers to program ESP8266 microcontrollers using the Arduino programming language and environment. This core provides a set of libraries and tools that simplify the development process for projects involving the ESP8266 chip. Here will discuss ESP8266 Arduino-Core Basics.
ESP8266 Arduino Core serves as a powerful tool for developing IoT (Internet of Things) applications, home automation systems, sensor networks, and more, using the ESP8266 microcontroller platform with the simplicity and flexibility of the Arduino ecosystem.
/*
https://www.aruneworld.com/embedded/espressif/esp8266/esp8266_arduino-core/esp8266_arduino-core-basics/
Tested By : Arun(20170219)
Example Name : AEW_RTCUserMemory.ino
*/
// Example: Storing struct data in RTC user rtcDataory
//
// Struct data with the maximum size of 512 bytes can be stored
// in the RTC user rtcDataory using the ESP-specifc APIs.
// The stored data can be retained between deep sleep cycles.
// However, the data might be lost after power cycling the ESP8266.
//
// This example uses deep sleep mode, so connect GPIO16 and RST
// pins before running it.
//
// Created Mar 30, 2016 by Macro Yau.
//
// This example code is in the public domain.
// CRC function used to ensure data validity
uint32_t calculateCRC32(const uint8_t *data, size_t length);
// helper function to dump memory contents as hex
void printMemory();
// Structure which will be stored in RTC memory.
// First field is CRC32, which is calculated based on the
// rest of structure contents.
// Any fields can go after CRC32.
// We use byte array as an example.
struct {
uint32_t crc32;
byte data[508];
} rtcData;
void setup() {
Serial.begin(115200);
Serial.println();
delay(1000);
// Read struct from RTC memory
if (ESP.rtcUserMemoryRead(0, (uint32_t*) &rtcData, sizeof(rtcData))) {
Serial.println("Read: ");
printMemory();
Serial.println();
uint32_t crcOfData = calculateCRC32(((uint8_t*) &rtcData) + 4, sizeof(rtcData) - 4);
Serial.print("CRC32 of data: ");
Serial.println(crcOfData, HEX);
Serial.print("CRC32 read from RTC: ");
Serial.println(rtcData.crc32, HEX);
if (crcOfData != rtcData.crc32) {
Serial.println("CRC32 in RTC memory doesn't match CRC32 of data. Data is probably invalid!");
}
else {
Serial.println("CRC32 check ok, data is probably valid.");
}
}
// Generate new data set for the struct
for (int i = 0; i < sizeof(rtcData); i++) {
rtcData.data[i] = random(0, 128);
}
// Update CRC32 of data
rtcData.crc32 = calculateCRC32(((uint8_t*) &rtcData) + 4, sizeof(rtcData) - 4);
// Write struct to RTC memory
if (ESP.rtcUserMemoryWrite(0, (uint32_t*) &rtcData, sizeof(rtcData))) {
Serial.println("Write: ");
printMemory();
Serial.println();
}
Serial.println("Going into deep sleep for 5 seconds");
ESP.deepSleep(5e6);
}
void loop() {
}
uint32_t calculateCRC32(const uint8_t *data, size_t length)
{
uint32_t crc = 0xffffffff;
while (length--) {
uint8_t c = *data++;
for (uint32_t i = 0x80; i > 0; i >>= 1) {
bool bit = crc & 0x80000000;
if (c & i) {
bit = !bit;
}
crc <<= 1;
if (bit) {
crc ^= 0x04c11db7;
}
}
}
return crc;
}
void printMemory() {
char buf[3];
for (int i = 0; i < sizeof(rtcData); i++) {
sprintf(buf, "%02X", rtcData.data[i]);
Serial.print(buf);
if ((i + 1) % 32 == 0) {
Serial.println();
}
else {
Serial.print(" ");
}
}
Serial.println();
}
Flash real id: 001640E0
Flash real size: 4194304
Flash ide size: 524288
Flash ide speed: 40000000
Flash ide mode: DIO
Flash Chip configuration wrong!
Check Flash Configuration
This Arduino sketch tests whether the ESP8266 microcontroller’s hardware configuration matches the EEPROM settings of the Integrated Development Environment (IDE).
Here’s a breakdown of what the code does:
Setup Function: The setup function is executed once when the microcontroller starts up. In this sketch, it initializes serial communication with a baud rate of 115200.
Loop Function: The loop function is executed repeatedly as long as the microcontroller is powered on. Inside the loop, it performs the following actions:
ESP.getFlashChipRealSize(): Retrieves the actual size of the flash memory chip.ESP.getFlashChipSize(): Retrieves the size of the flash memory chip as defined in the IDE settings.ESP.getFlashChipMode(): Retrieves the flash mode of the chip as defined in the IDE settings.
The sketch then prints out the retrieved values via serial communication, along with additional information about the flash chip configuration.
If the actual size of the flash memory chip (realSize) differs from the size defined in the IDE settings (ideSize), it indicates a configuration mismatch, and a corresponding error message is printed.
If the sizes match, the sketch prints a message indicating that the flash chip configuration is correct.
Delay: After printing the flash chip configuration, the loop waits for 5 seconds before repeating the process.
This sketch is useful for verifying that the EEPROM settings in the IDE match the actual hardware configuration of the ESP8266 chip. It can help troubleshoot issues related to flash memory configuration mismatches.
Code
/*
https://www.aruneworld.com/embedded/espressif/esp8266/esp8266_arduino-core/esp8266_arduino-core-basics/
Tested By : Arun(20170219)
Example Name : AEW_CheckFlashConfiguration.ino
ESP8266 CheckFlashConfig by Markus Sattler
This sketch tests if the EEPROM settings of the IDE match to the Hardware
*/
void setup(void) {
Serial.begin(115200);
}
void loop() {
uint32_t realSize = ESP.getFlashChipRealSize();
uint32_t ideSize = ESP.getFlashChipSize();
FlashMode_t ideMode = ESP.getFlashChipMode();
Serial.printf("Flash real id: %08X\n", ESP.getFlashChipId());
Serial.printf("Flash real size: %u\n\n", realSize);
Serial.printf("Flash ide size: %u\n", ideSize);
Serial.printf("Flash ide speed: %u\n", ESP.getFlashChipSpeed());
Serial.printf("Flash ide mode: %s\n", (ideMode == FM_QIO ? "QIO" : ideMode == FM_QOUT ? "QOUT" : ideMode == FM_DIO ? "DIO" : ideMode == FM_DOUT ? "DOUT" : "UNKNOWN"));
if(ideSize != realSize) {
Serial.println("Flash Chip configuration wrong!\n");
} else {
Serial.println("Flash Chip configuration ok.\n");
}
delay(5000);
}
Required Hardware – ESP8266 with Programmer (or) NodeMCU Dev Kit
Required Software Tools – Arduino IDE with ESP8266 Core
Circuit
Code
/*
http://www.ArunEworld.com/Embedded/ESPressif/ESP8266/ESP8266_Arduino-Core/
Tested By : Arun(20170219)
Example Name : AEW_ADC-Interface.ino
*/
/*
AnalogReadSerial
Reads an analog input on pin 0, prints the result to the serial monitor.
Graphical representation is available using serial plotter (Tools > Serial Plotter menu)
Attach the center pin of a potentiometer to pin A0, and the outside pins to +5V and ground.
This example code is in the public domain.
*/
// the setup routine runs once when you press reset:
void setup() {
// initialize serial communication at 9600 bits per second:
Serial.begin(9600);
}
// the loop routine runs over and over again forever:
void loop() {
// read the input on analog pin 0:
int sensorValue = analogRead(A0);
// print out the value you read:
Serial.println(sensorValue);
delay(1); // delay in between reads for stability
}
The analog-to-digital converter (ADC) converts the continuous analog signal into a flow of digital values. To achieve this, the converter must establish the rate at which new digital values sample from the analog signal. This rate is termed the sampling rate or sampling frequency of the converter.
A successive approximation ADC uses a comparator to narrow the input voltage range. Digital systems store values in binary format, with resolution usually in bits, often a power of two. Furthermore, one can define resolution electrically and represent it in volts. Consequently, we call the smallest voltage change needed to alter the output code level the least significant bit.
ADC Advantage:
Aspect
Description
High Precision
ADCs provide high precision in converting analog signals into digital form, thereby ensuring an accurate representation of the original signal. Consequently, this precision allows for reliable data processing and analysis.
Compatibility
Modern digital systems find digital signals more compatible, as they can easily process, transmit, and store them using digital devices. Additionally, this compatibility enhances the efficiency and effectiveness of digital systems in various applications.
Noise Immunity
Digital signals are less susceptible to noise interference during transmission or processing compared to analog signals. Consequently, this leads to better signal integrity and more reliable data transmission in digital communication systems.
Signal Processing
Digital signals allow for advanced signal processing techniques such as filtering, modulation, and encryption. As a result, this enhances the versatility of digital systems, enabling them to adapt to a wide range of applications and requirements.
Ease of Integration
ADCs can be integrated into various electronic devices, providing a seamless interface between analog sensors or sources and digital processing units. Consequently, this integration enhances the functionality and performance of electronic systems by enabling accurate and efficient conversion of analog signals into digital data.
Disadvantage:
Aspect
Description
Sampling Rate Limitations
ADCs are limited by their sampling rate, which determines the maximum frequency of signals they can accurately capture. Consequently, inadequate sampling rates can lead to aliasing and loss of signal fidelity, compromising the accuracy of the digital representation of analog signals.
Quantization Error
During the analog-to-digital conversion process, quantization error can occur. Consequently, this can lead to inaccuracies in the representation of the original analog signal, affecting the fidelity of the digital output.
Complexity and Cost
High-resolution ADCs, capable of accurately capturing fine details in analog signals, can be complex and expensive. Consequently, for applications demanding high-speed or high-precision conversion, these ADCs may pose challenges due to their complexity and cost.
Conversion Time
ADCs require a finite amount of time to convert analog signals into digital form. As a result, this causes latency in real-time systems or applications that demand rapid signal processing.
Dynamic Range Limitations
ADCs have a limited dynamic range, which can affect their ability to accurately capture signals with a wide range of amplitudes. Consequently, this limitation can potentially cause distortion or loss of information in the converted signal, particularly when dealing with signals of varying amplitudes.
Features of ADC
Resolution: This refers to the number of bits used to represent the analog input in digital form. Higher resolution ADCs can represent smaller voltage changes, providing greater precision.
Sampling Rate: The rate at which the ADC samples the analog input signal and converts it into digital form. It is typically measured in samples per second (SPS) or Hertz (Hz).
Input Range: The range of analog input voltages that this can accurately convert into digital values without distortion or clipping.
Accuracy: This refers to how closely the digital output of the ADC matches the true analog input signal.
Speed: The time taken by the ADC to complete one conversion cycle, including sampling and conversion.
ADC Application
Application
Description
Industrial Automation
ADCs monitor and control analog sensors like temperature, pressure, and flow sensors in industrial automation systems.
Medical Instrumentation
ADCs convert signals from medical sensors like ECG or blood pressure monitors into digital data for analysis in medical instrumentation.
Audio Processing
ADCs convert analog audio signals from microphones or musical instruments into digital format for storage or processing in audio applications.
Automotive Systems
ADCs are integrated into automotive systems for functions like engine control, airbag deployment, and sensor data acquisition for driver assistance systems.
Communication Systems
ADCs convert analog signals, such as voice or data, into digital format for transmission over digital communication networks in communication systems.
Test and Measurement
ADCs capture and analyze analog signals with high precision in test and measurement equipment, supporting applications like oscilloscopes and data loggers.
Consumer Electronics
ADCs in consumer electronics, like smartphones and digital cameras, convert various analog signals into digital data for processing or display.
Renewable Energy Systems
ADCs monitor and control the generation and distribution of electrical power in renewable energy systems like solar or wind power inverters.
Required Hardware ESP8266 with Programmer (or) NodeMCU Dev Kit
Required Software Tools Arduino IDE with ESP8266 Core
Code
/*
http://www.ArunEworld.com/Embedded/ESPressif/ESP8266/ESP8266_Arduino-core/ESP8266-Arduino-Core-Interface-Button
Tested By : Arun(20170219)
Example Name : AEW_ADC-Interface.ino
*/
/*
AnalogReadSerial
Reads an analog input on pin 0, prints the result to the serial monitor.
Graphical representation is available using serial plotter (Tools > Serial Plotter menu)
Attach the center pin of a potentiometer to pin A0, and the outside pins to +5V and ground.
This example code is in the public domain.
*/
// the setup routine runs once when you press reset:
void setup() {
// initialize serial communication at 9600 bits per second:
Serial.begin(9600);
}
// the loop routine runs over and over again forever:
void loop() {
// read the input on analog pin 0:
int sensorValue = analogRead(A0);
// print out the value you read:
Serial.println(sensorValue);
delay(1); // delay in between reads for stability
}
Required Hardware ESP8266 with Programmer (or) NodeMCU Dev Kit, LED- 3v3 or 5v,
Required Software Tools ESPlorer IDE Tool
ESP8266 with LED Connection Diagram
Will Add Soon
NodeMCU Lua code
-- http://www.ArunEworld.com/embedded/ESPressif/ESP8266/ESP82266_NodeMCU
--[[ Required NodeMCU Modules
Timer Module
GPIO Module
]]--
LED_Pin = 1 -- GPIO-5
LED_Blink_Time = 1000 -- ms
gpio.mode(LED_Pin, gpio.OUTPUT)
local function Blink()
if ( 0 == gpio.read(LED_Pin)) then
gpio.write(LED_Pin, gpio.HIGH)
elseif( 1 == gpio.read(LED_Pin)) then
gpio.write(LED_Pin, gpio.LOW)
end
end
tmr.alarm(0,LED_Blink_Time,1,function() Blink() end)
Follow steps
Connect the circuit as per the connection diagram
Save the above code as “AEW_LED-Blink.lua”
Open ESPlorer and upload the file “AEW_LED-Blink.lua”
Run the file [ dofile(“AEW_LED-Blink.lua”) ]
Done.!(LED will Blink based on blink time)
LED Blink uisng While loop and Timer delay function
Use
-- http://www.ArunEworld.com/embedded/ESPressif/ESP8266/ESP82266_NodeMCU
--[[ Required NodeMCU Modules Timer Module GPIO Module ]]--
LED_Pin = 1 -- GPIO-5
LED_Blink_Time = 1000 -- ms
gpio.mode(LED_Pin, gpio.OUTPUT)
while true do
tmr.delay(1000000)
if ( 0 == gpio.read(LED_Pin)) then
gpio.write(LED_Pin, gpio.HIGH)
elseif( 1 == gpio.read(LED_Pin)) then
gpio.write(LED_Pin, gpio.LOW)
end
end
LED Fade using PWM
Use this code
pin = 1
------ PWM setup --------------
pwm.setup(pin, 999, 512) -- pwm.setup(pin, clock, duty) | set pin index 1 as pwm output, frequency is 100Hz, duty cycle is half.
pwm.start(pin) -- pwm.start(pin)
duty = 1000
for i=1000,0,-1 do
--print(i)
duty = i
pwm.setduty(pin, duty) -- pwm.setduty(pin, duty)
tmr.delay(1000)
end
Playing the Imperial March ringtone on an ESP8266 NodeMCU involves using the NodeMCU’s capabilities to generate sound or control an external sound module. One common method is using a piezo buzzer to generate tones. Here’s a basic example of “ESP8266 Imperial March Ringtone play” using the NodeMCU and a piezo buzzer to play the Imperial March:
The ESP8266 NodeMCU Tutorial – Web Server provides a comprehensive guide on how to set up a web server using the NodeMCU development board powered by the ESP8266 microcontroller.
Simple web server display heap, ip, mac address some other details ..
First need to connect ESP8266 with WiFi Router. then access the web server using ip address
print("****** Wifi data's Initializing *********")
mode = wifi.STATION
ssid = "ArunEworld"
password = "Arun"
print("****** Setup Wifi Settings *********")
wifi.setmode(mode)
wifi.sta.config(ssid, password)
function Wif_Connect()
WC = wifi.sta.status() --WC Wifi_Connect
print("Wifi Status is : " .. WC)
if WC == 0 then
print("0.Satation is Idle ??")
wifi.sta.autoconnect(auto)
elseif WC == 1 then
print("1.Satation Connecting....Wait a moment")
elseif WC == 2 then
print("2.password is wrong !")
elseif WC == 3 then
print("3.No Access Point Found !")
elseif WC == 4 then
print("4.Station connecting fail !")
elseif WC == 5 then
print("IP :" .. wifi.sta.getip())
tmr.stop(0)
-- dofile("AEW_Webserver.lua")
-- print("IP :"..wifi.sta.getip())
-- dofile("File_name.lua")
-- please write your file name
end
end
print("**** Webserver Running........ ****")
srv = net.createServer(net.TCP)
srv:listen(80, function(conn)
conn:on("receive", function(client, request)
buf = buf .. "<h1>Arun Eworld</h1>"
buf = buf .. "Chip ID :<b>" .. node.chipid() .. "</b><BR>"
--[[
buf = buf.."Heap :<b>".. node.heap() .. "</b><BR>";
buf = buf.."Station Mac Address :<b>".. wifi.sta.getmac() .. "</b><BR>";
buf = buf.."AP Mac Address :<b>".. wifi.ap.getmac() .. "</b><BR>";
buf = buf.."GetMode :<b>".. wifi.getmode() .. "</b><BR>";
buf = buf.."Status :<b>".. wifi.sta.status() .. "</b><BR>";
--buf = buf.."AP IP Address :<b>".. wifi.ap.getip() .. "</b><BR>";
buf = buf.."Station IP Address :<b>".. wifi.sta.getip() .. "</b><BR>";
buf = buf.."TMR.NOW :<b>" .. tmr.now() .. "</b><BR<BR><BR>";
]]--
client:send(buf)
client:close()
collectgarbage()
end)
end)
tmr.alarm(0, 5000, 1, Wif_Connect)
Code Explanation
Sure, here’s an explanation of the provided Lua code:
Wifi Initialization:
The code begins by printing a message indicating the initialization of WiFi data.
It sets the WiFi mode to Station mode.
Defines the SSID and password for the WiFi connection.
WiFi Connection Function (Wif_Connect):
This function is responsible for handling the WiFi connection process.
It retrieves the current WiFi connection status using wifi.sta.status().
Depending on the status, it performs different actions:
If the status is 0, it indicates that the station is idle, and it attempts to autoconnect.
If the status is 1, it indicates that the station is connecting.
If the status is 2, it indicates that the password is incorrect.
If the status is 3, it indicates that no Access Point (AP) is found.
If the status is 4, it indicates that the connection to the AP failed.
If the status is 5, it indicates a successful connection, and it prints the assigned IP address.
It also stops the timer (tmr.stop(0)), which triggers the connection attempt.
Webserver Setup:
The code prints a message indicating that the web server is running.
It creates a TCP server (srv) that listens on port 80.
Upon receiving a connection, it defines a callback function to handle incoming requests.
The callback function constructs an HTML response (buf) containing the header <h1>Arun Eworld</h1> and the chip ID.
The response is sent back to the client, and the connection is closed.
Timer Initialization:
A timer (tmr) is set to call the Wif_Connect function every 5 seconds (tmr.alarm(0, 5000, 1, Wif_Connect)).
This code initializes the WiFi connection, continuously attempts to connect to the configured network, and sets up a basic web server to handle incoming requests. (ESP8266 NodeMCU Tutorial Web Server)
TCP Server Listener
This code given below will configure the ESP to act as an Access Point and it has its own SSID=”ArunEworld” and Password=”Arun” and also act as the server which will continuously listen for a connection.
Code
This code initializes the ESP8266 module as an access point with the SSID “ArunEworld” and password “Arun”. It then creates a TCP server that listens on port 80. When a connection is established, it prints any received data and releases resources after sending a response.
This code initializes the ESP8266 module as an access point with the SSID “ArunEworld” and password “Arun”, creates a TCP server listening on port 80, and defines callback functions to handle received and sent data.
Line
Code
Explanation
1
print("ArunEworld - ESP8266 Server")
Prints a message indicating the initialization of the ESP8266 server.
2
wifi.setmode(wifi.STATIONAP)
Sets the mode of the WiFi module to STATIONAP, enabling it to function as both a station and an access point.
3
wifi.ap.config({ssid="ArunEworld", pwd="Arun"})
Configures the access point with the SSID “ArunEworld” and password “Arun”.
4
print("Server IP Address:", wifi.ap.getip())
Prints the IP address assigned to the ESP8266 access point.
6
sv = net.createServer(net.TCP)
Creates a TCP server object.
7
sv:listen(80, function(conn)
Starts the server and listens for connections on port 80.
8
conn:on("receive", function(conn, receivedData)
Sets up a callback function to handle received data.
Welcome to the ESP8266 NodeMCU WiFi End User Module! The ESP8266 NodeMCU is a versatile and powerful microcontroller board that features built-in WiFi connectivity. This module aims to offer a user-friendly platform for IoT (Internet of Things) projects, facilitating the connection of devices to the Internet and enabling remote interaction with them.
With the ESP8266 NodeMCU, you can quickly prototype and deploy WiFi-enabled projects without the need for extensive hardware or networking expertise. Whether you’re a hobbyist, maker, or professional developer, this module offers a convenient solution for adding wireless connectivity to your applications.
In this module, we’ll explore the capabilities of the ESP8266 NodeMCU, learn how to configure WiFi settings, connect to wireless networks, and develop IoT applications. By the end of this module, you’ll have the knowledge and skills to create your own WiFi-enabled projects using the ESP8266 NodeMCU.
Let’s dive into the world of WiFi and IoT with the ESP8266 NodeMCU End User Module!
This table provides a comprehensive overview of the various functions available for configuring and interacting with WiFi on the ESP8266 module.
Note: ESP8266 does not support numbers as passwords in NodeMCU firmware
General Functions:
Function
Description
wifi.getchannel()
Gets the current WiFi channel.
wifi.getdefaultmode()
Gets default WiFi operation mode.
wifi.getmode()
Gets WiFi operation mode.
wifi.getphymode()
Gets WiFi physical mode.
wifi.nullmodesleep()
Configures whether or not WiFi automatically goes to sleep in NULL_MODE.
wifi.resume()
Wake up WiFi from suspended state or cancel pending wifi suspension.
wifi.setmode()
Configures the WiFi mode to use.
wifi.setphymode()
Sets WiFi physical mode.
wifi.startsmart()
Starts auto configuration, if successful sets up SSID and password automatically.
wifi.stopsmart()
Stops the smart configuring process.
wifi.suspend()
Suspend Wifi to reduce current consumption.
wifi.eventmon.register()
Register/unregister callbacks for WiFi event monitor.
wifi.eventmon.unregister()
Unregister callbacks for WiFi event monitor.
wifi.eventmon.reason
Table containing disconnect reasons.
Station Functions:
Function
Description
wifi.sta.autoconnect()
Auto connects to AP in station mode.
wifi.sta.changeap()
Select Access Point from list returned by wifi.
wifi.sta.clearconfig()
Clears the currently saved WiFi station configuration, erasing it from the flash.
wifi.sta.config()
Sets the WiFi station configuration.
wifi.sta.connect()
Connects to the configured AP in station mode.
wifi.sta.disconnect()
Disconnects from AP in station mode.
wifi.sta.eventMonReg()
Registers callbacks for WiFi station status events.
wifi.sta.eventMonStart()
Starts WiFi station event monitor.
wifi.sta.eventMonStop()
Stops WiFi station event monitor.
wifi.sta.getap()
Scans AP list as a Lua table into callback function.
wifi.sta.getapindex()
Get index of current Access Point stored in AP cache.
wifi.sta.getapinfo()
Get information of APs cached by ESP8266 station.
wifi.sta.getbroadcast()
Gets the broadcast address in station mode.
wifi.sta.getconfig()
Gets the WiFi station configuration.
wifi.sta.getdefaultconfig()
Gets the default WiFi station configuration stored in flash.
wifi.sta.gethostname()
Gets current station hostname.
wifi.sta.getip()
Gets IP address, netmask, and gateway address in station mode.
wifi.sta.getmac()
Gets MAC address in station mode.
wifi.sta.getrssi()
Gets the RSSI (Received Signal Strength Indicator) of the Access Point which ESP8266 station connected to.
wifi.sta.setaplimit()
Set Maximum number of Access Points to store in flash.
wifi.sta.sethostname()
Sets station hostname.
wifi.sta.setip()
Sets IP address, netmask, gateway address in station mode.
wifi.sta.setmac()
Sets MAC address in station mode.
wifi.sta.sleeptype()
Configures the WiFi modem sleep type to be used while station is connected to an Access Point.
wifi.sta.status()
Gets the current status in station mode.
Access Point Functions:
Function
Description
wifi.ap.config()
Sets SSID and password in AP mode.
wifi.ap.deauth()
Deauths (forcibly removes) a client from the ESP access point by sending a corresponding IEEE802.
wifi.ap.getbroadcast()
Gets broadcast address in AP mode.
wifi.ap.getclient()
Gets table of clients connected to device in AP mode.
wifi.ap.getconfig()
Gets the current SoftAP configuration.
wifi.ap.getdefaultconfig()
Gets the default SoftAP configuration stored in flash.
wifi.ap.getip()
Gets IP address, netmask and gateway in AP mode.
wifi.ap.getmac()
Gets MAC address in AP mode.
wifi.ap.setip()
Sets IP address, netmask and gateway address in AP mode.
wifi.ap.setmac()
Sets MAC address in AP mode.
wifi.ap.dhcp.config()
Configure the DHCP service.
wifi.ap.dhcp.start()
Starts the DHCP service.
wifi.ap.dhcp.stop()
Stops the DHCP service.
wifi.eventmon.register()
Register/unregister callbacks for WiFi event monitor.
wifi.eventmon.unregister()
Unregister callbacks for
Examples
Scan for available all station networks
Scans AP list as a Lua table into callback function. wifi.sta.getap()
This Lua code includes various functions related to scanning and retrieving information about available WiFi access points (APs) and their configurations. Each function defines itself separately for different purposes and formats itself for readability.
-- Print AP list in old format (format not defined)
function listap(t)
for k, v in pairs(t) do
print(k .. " : " .. v)
end
end
wifi.sta.getap(listap)
-- Print AP list that is easier to read
function listap(t)
-- (SSID : Authmode, RSSI, BSSID, Channel)
print("\n" .. string.format("%32s", "SSID") .. "\tBSSID\t\t\t\t RSSI\t\tAUTHMODE\tCHANNEL")
for ssid, v in pairs(t) do
local authmode, rssi, bssid, channel = string.match(v, "([^,]+),([^,]+),([^,]+),([^,]+)")
print(string.format("%32s", ssid) .. "\t" .. bssid .. "\t " .. rssi .. "\t\t" .. authmode .. "\t\t\t" .. channel)
end
end
wifi.sta.getap(listap)
-- Print AP list in new format
function listap(t)
for k, v in pairs(t) do
print(k .. " : " .. v)
end
end
wifi.sta.getap(1, listap)
-- Print AP list that is easier to read
function listap(t)
-- (SSID : Authmode, RSSI, BSSID, Channel)
print("\n\t\t\tSSID\t\t\t\t\tBSSID\t\t\t RSSI\t\tAUTHMODE\t\tCHANNEL")
for bssid, v in pairs(t) do
local ssid, rssi, authmode, channel = string.match(v, "([^,]+),([^,]+),([^,]+),([^,]*)")
print(string.format("%32s", ssid) .. "\t" .. bssid .. "\t " .. rssi .. "\t\t" .. authmode .. "\t\t\t" .. channel)
end
end
wifi.sta.getap(1, listap)
-- Check for specific AP
function listap(t)
print("\n\t\t\tSSID\t\t\t\t\tBSSID\t\t\t RSSI\t\tAUTHMODE\t\tCHANNEL")
for bssid, v in pairs(t) do
local ssid, rssi, authmode, channel = string.match(v, "([^,]+),([^,]+),([^,]+),([^,]*)")
print(string.format("%32s", ssid) .. "\t" .. bssid .. "\t " .. rssi .. "\t\t" .. authmode .. "\t\t\t" .. channel)
end
end
scan_cfg = {}
scan_cfg.ssid = "myssid"
scan_cfg.bssid = "AA:AA:AA:AA:AA:AA"
scan_cfg.channel = 0
scan_cfg.show_hidden = 1
wifi.sta.getap(scan_cfg, 1, listap)
-- Get RSSI for currently configured AP
function listap(t)
for bssid, v in pairs(t) do
local ssid, rssi, authmode, channel = string.match(v, "([^,]+),([^,]+),([^,]+),([^,]*)")
print("CURRENT RSSI IS: " .. rssi)
end
end
ssid, tmp, bssid_set, bssid = wifi.sta.getconfig()
scan_cfg = {}
scan_cfg.ssid = ssid
if bssid_set == 1 then
scan_cfg.bssid = bssid
else
scan_cfg.bssid = nil
end
scan_cfg.channel = wifi.getchannel()
scan_cfg.show_hidden = 0
ssid, tmp, bssid_set, bssid = nil, nil, nil, nil
wifi.sta.getap(scan_cfg, 1, listap)
Sets the WiFi station configuration.
This Lua code demonstrates various configurations for connecting the ESP8266 to an access point (AP) using the wifi.sta.config() function. You can choose whether to save the configuration to flash memory, specify a MAC address for the AP, or configure the station without immediately connecting to an AP.
-- Connect to Access Point (DO NOT save config to flash)
station_cfg = {}
station_cfg.ssid = "NODE-AABBCC"
station_cfg.pwd = "password"
wifi.sta.config(station_cfg)
-- Connect to Access Point (DO save config to flash)
station_cfg = {}
station_cfg.ssid = "NODE-AABBCC"
station_cfg.pwd = "password"
station_cfg.save = true
wifi.sta.config(station_cfg)
-- Connect to Access Point with specific MAC address
station_cfg = {}
station_cfg.ssid = "NODE-AABBCC"
station_cfg.pwd = "password"
station_cfg.bssid = "AA:BB:CC:DD:EE:FF"
wifi.sta.config(station_cfg)
-- Configure station but don't connect to Access point
station_cfg = {}
station_cfg.ssid = "NODE-AABBCC"
station_cfg.pwd = "password"
station_cfg.auto = false
wifi.sta.config(station_cfg)
Connect ESP8266 to WiFi Router
This Lua code initializes the WiFi module, sets it to both station and access point mode, and then connects to a specified access point with the provided SSID and password without saving the configuration to flash memory.
print("wifi init")
wifi.set.mode(wifi.STATIONAP)
-- Connect to Access Point (DO NOT save config to flash)
station_cfg = {}
station_cfg.ssid = "ArunEworld"
station_cfg.pwd = "Arun"
wifi.sta.config(station_cfg)
wifi.sta.connect()
Disconnect ESP8266 from WiFi Router
Disconnects from AP in station mode. wifi.sta.disconnect()
View the ESP8266 Stored Access Point information
Retrieve information about the Access Points cached by the ESP8266 station using the function wifi.sta.getapinfo().
This Lua code prints the stored access point information obtained from the ESP8266 module in both a non-formatted and formatted manner.
-- Print stored access point info
do
for k, v in pairs(wifi.sta.getapinfo()) do
if (type(v) == "table") then
print(" " .. k .. " : " .. type(v))
for k, v in pairs(v) do
print("\t\t" .. k .. " : " .. v)
end
else
print(" " .. k .. " : " .. v)
end
end
end
-- Print stored access point info (formatted)
do
local x = wifi.sta.getapinfo()
local y = wifi.sta.getapindex()
print("\n Number of APs stored in flash:", x.qty)
print(string.format(" %-6s %-32s %-64s %-18s", "index:", "SSID:", "Password:", "BSSID:"))
for i = 1, x.qty, 1 do
print(string.format(" %s%-6d %-32s %-64s %-18s", (i == y and ">" or " "), i, x[i].ssid, x[i].pwd and x[i].pwd or type(nil), x[i].bssid and x[i].bssid or type(nil)))
end
end
Gets the WiFi station configuration.
This Lua code retrieves and prints the current station configuration of the ESP8266 module, both in new and old formats. It displays the SSID, password, and BSSID settings if available.
-- Get current Station configuration (NEW FORMAT)
do
local def_sta_config = wifi.sta.getconfig(true)
print(string.format("\tDefault station config\n\tssid:\"%s\"\tpassword:\"%s\"%s",
def_sta_config.ssid, def_sta_config.pwd,
(type(def_sta_config.bssid) == "string" and "\tbssid:\"" .. def_sta_config.bssid .. "\"" or "")))
end
-- Get current Station configuration (OLD FORMAT)
ssid, password, bssid_set, bssid = wifi.sta.getconfig()
print("\nCurrent Station configuration:\nSSID : " .. ssid .. "\nPassword : " .. password ..
"\nBSSID_set : " .. bssid_set .. "\nBSSID: " .. bssid .. "\n")
ssid, password, bssid_set, bssid = nil, nil, nil, nil
Clears the currently saved WiFi station configuration
Clears the currently saved WiFi station configuration, erasing it from the flash. This action may be useful for certain factory-reset scenarios when a full node.restore() is not desired, or to prepare for using End-User Setup so that the SoftAP can lock onto a single hardware radio channel.
Ex : wifi.sta.clearconfig()
WiFi station status events
This Lua code registers event callbacks for various WiFi states, starts and stops the WiFi event monitor with different intervals, and unregisters callbacks as needed.
-- Register callbacks
wifi.sta.eventMonReg(wifi.STA_IDLE, function() print("STATION_IDLE") end)
wifi.sta.eventMonReg(wifi.STA_CONNECTING, function() print("STATION_CONNECTING") end)
wifi.sta.eventMonReg(wifi.STA_WRONGPWD, function() print("STATION_WRONG_PASSWORD") end)
wifi.sta.eventMonReg(wifi.STA_APNOTFOUND, function() print("STATION_NO_AP_FOUND") end)
wifi.sta.eventMonReg(wifi.STA_FAIL, function() print("STATION_CONNECT_FAIL") end)
wifi.sta.eventMonReg(wifi.STA_GOTIP, function() print("STATION_GOT_IP") end)
-- Register callback: use previous state
wifi.sta.eventMonReg(wifi.STA_CONNECTING, function(previous_State)
if (previous_State == wifi.STA_GOTIP) then
print("Station lost connection with access point\n\tAttempting to reconnect...")
else
print("STATION_CONNECTING")
end
end)
-- Start WiFi event monitor with default interval
wifi.sta.eventMonStart()
-- Start WiFi event monitor with 100ms interval
wifi.sta.eventMonStart(100)
-- Stop WiFi event monitor
wifi.sta.eventMonStop()
-- Stop WiFi event monitor and unregister all callbacks
wifi.sta.eventMonStop(1)
-- Unregister callback
wifi.sta.eventMonReg(wifi.STA_IDLE)
Gets current station hostname.
Ex : print(“Current hostname is: \””..wifi.sta.gethostname()..”\””)
Sets station hostname.
This Lua code checks if the hostname was successfully changed using the wifi.sta.sethostname() function and prints the corresponding message.
if (wifi.sta.sethostname("ArunEworld") == true) then
print("hostname was successfully changed")
else
print("hostname was not changed")
end
Gets IP address, netmask, and gateway address in station mode.
This Lua code retrieves and prints the current IP address, netmask, and gateway information using the wifi.sta.getip() function. It demonstrates different ways to handle the returned values.
-- Print current IP address, netmask, gateway
print(wifi.sta.getip()) -- Output: 192.168.0.111 255.255.255.0 192.168.0.1
ip = wifi.sta.getip()
print(ip) -- Output: 192.168.0.111
ip, nm = wifi.sta.getip()
print(nm) -- Output: 255.255.255.0
Gets IP address, netmask and gateway in AP mode.
This Lua code retrieves and prints the current IP address, netmask, and gateway information for the Access Point (AP) mode using the wifi.ap.getip() function. It demonstrates different ways to handle the returned values.
Retrieve the RSSI (Received Signal Strength Indicator).
Retrieve the RSSI (Received Signal Strength Indicator) from the Access Point to which the ESP8266 station is currently connected.
RSSI=wifi.sta.getrssi() print(“RSSI is”, RSSI)
Retrieves a table of clients connected to the device in AP mode.
This Lua code retrieves the client MAC addresses and IPs connected to the Access Point (AP) and prints them. It demonstrates two ways to iterate over the table returned by wifi.ap.getclient().
-- Get client MAC addresses and IPs connected to the AP
table = wifi.ap.getclient()
-- Iterate over the table to print MAC addresses and IPs
for mac, ip in pairs(table) do
print(mac, ip)
end
-- Alternatively, using a shorter loop syntax
for mac, ip in pairs(wifi.ap.getclient()) do
print(mac, ip)
end
Gets the current SoftAP configuration.
This Lua code retrieves and prints the SoftAP configuration in both new and old formats. It demonstrates two different ways of handling the configuration data returned by wifi.ap.getconfig().
-- Get SoftAP configuration table (NEW FORMAT)
do
print("\n Current SoftAP configuration:")
for k, v in pairs(wifi.ap.getconfig(true)) do
print(" "..k.." :", v)
end
end
-- Get current SoftAP configuration (OLD FORMAT)
do
local ssid, password = wifi.ap.getconfig()
print("\n Current SoftAP configuration:\n SSID : "..ssid.. "\n Password :", password)
ssid, password = nil, nil
end
Retrieve the default SoftAP configuration stored in flash.
This Lua code retrieves and prints the default SoftAP configuration in both new and old formats. It demonstrates two different ways of handling the configuration data returned by wifi.ap.getdefaultconfig().
-- Get default SoftAP configuration table (NEW FORMAT)
do
print("\n Default SoftAP configuration:")
for k, v in pairs(wifi.ap.getdefaultconfig(true)) do
print(" "..k.." :", v)
end
end
-- Get default SoftAP configuration (OLD FORMAT)
do
local ssid, password = wifi.ap.getdefaultconfig()
print("\n Default SoftAP configuration:\n SSID : "..ssid.. "\n Password :", password)
ssid, password = nil, nil
end
End User Setup NodeMCU Lua
ESP8266 NodeMCU WiFi End User Module
Function
Description
enduser_setup.manual()
Controls whether manual AP configuration is used.
enduser_setup.start()
Starts the captive portal.
enduser_setup.stop()
Stops the captive portal.
Example
This Lua code sets up the ESP8266 to operate in both station and access point modes, configures the access point with the SSID “ArunEworld” and no password (open authentication), enables manual end-user setup, and starts the setup process with callbacks for success and failure.
//Configure the End User Setup
wifi.setmode(wifi.STATIONAP)
wifi.ap.config({ ssid = "ArunEworld", auth = wifi.OPEN })
enduser_setup.manual(true)
enduser_setup.start(
function()
print("Connected to wifi as: " .. wifi.sta.getip())
--enduser_setup.stop()
end,
function(err, str)
print("enduser_setup: Err #" .. err .. ": " .. str)
end
);
LCD stands for Liquid Crystal Display. It’s a type of flat-panel display technology commonly used in TVs, computer monitors, smartphones, and other electronic devices. This work by sandwiching a layer of liquid crystals between two transparent electrodes and two polarizing filters. When an electric current passes through the liquid crystals, they align to allow varying amounts of light to pass through, creating images or text on the screen. LCDs are known for their sharp image quality, energy efficiency, and relatively low cost compared to other display technologies like OLED (Organic Light Emitting Diode).
Sure, here are some advantages and disadvantages of LCD displays:
Advantages:
Energy Efficiency: LCDs typically consume less power compared to older display technologies like CRTs (Cathode Ray Tubes), making them more energy-efficient.
Slim Profile: LCD panels are generally thin and lightweight, making them suitable for slim and portable devices such as laptops, tablets, and smartphones.
Sharp Image Quality: LCDs can produce high-resolution images with excellent clarity and color accuracy, providing a visually pleasing viewing experience.
Versatility: LCD technology is versatile and can be used in various applications, including TVs, computer monitors, digital signage, and automotive displays.
Longevity: LCD panels have a relatively long lifespan compared to some other display technologies when properly maintained, providing years of reliable use.
Disadvantages:
Limited Viewing Angles: LCDs may exhibit color distortion or brightness loss when viewed from extreme angles, making them less suitable for applications where multiple viewers may be viewing the screen from different angles.
Potential Motion Blur: Some LCD displays, especially those with slower response times, may suffer from motion blur, resulting in less-than-optimal performance for fast-moving content such as gaming or sports.
Backlight Uniformity Issues: LCDs rely on a backlight source to illuminate the screen, and sometimes there can be issues with backlight uniformity, leading to uneven brightness or “clouding” in certain areas of the display.
Limited Contrast Ratio: While modern LCDs have improved contrast ratios, they may still not match the deep blacks and high contrast levels achievable with technologies like OLED.
Risk of Dead Pixels: LCD panels may develop dead pixels over time, resulting in small, permanently lit or unlit spots on the screen, which can be distracting, especially in high-resolution displays.
Despite these disadvantages, LCD technology remains widely used and continues to be improved upon with advancements in backlighting, panel technology, and image processing algorithms.
The ESP32 NodeMCU Module is a versatile development board known for its robust capabilities in IoT projects. With built-in Wi-Fi and Bluetooth connectivity, it offers seamless integration into networked environments. Its compact size and powerful features make it a preferred choice for various IoT applications, from home automation to industrial monitoring. here will discuss ESP32 NodeMCU Net Module.
Throttles data reception by placing a request to block the TCP receive function.
net.socket:on()
Registers callback functions for specific events.
net.socket:send()
Sends data to the remote peer.
net.socket:ttl()
Changes or retrieves the Time-To-Live value on the socket.
net.socket:unhold()
Unblocks TCP receiving data by revoking a preceding hold().
net.udpsocket:close()
Closes a UDP socket.
net.udpsocket:listen()
Listens on a port from an IP address.
net.udpsocket:on()
Registers callback functions for specific events.
net.udpsocket:send()
Sends data to a specific remote peer.
net.udpsocket:dns()
Provides DNS resolution for a hostname.
net.udpsocket:getaddr()
Retrieves the local port and IP of the socket.
net.udpsocket:ttl()
Changes or retrieves the Time-To-Live value on the socket.
net.dns.getdnsserver()
Gets the IP address of the DNS server used to resolve hostnames.
net.dns.resolve()
Resolves a hostname to an IP address.
net.dns.setdnsserver()
Sets the IP of the DNS server used to resolve hostnames.
Ex : Create a server Connection
The function net.createServer([type[, timeout]]) is used to create a server with an optional timeout parameter. When you specify a timeout value, it determines the duration for which the server will wait for activity from a client before considering it inactive and closing the connection.
For example, if you create a TCP server with a timeout of 30 seconds using
-- 30s time out for a inactive client
net.createServer(net.TCP, 30) -- 30s timeout
it means that if a client connects to this server but does not send any data within 30 seconds, the server will automatically close the connection to that client.
This timeout functionality is useful for managing server resources efficiently. It allows servers to automatically clean up inactive connections, preventing them from occupying resources indefinitely. In scenarios where maintaining active connections is crucial, such as in real-time communication applications, setting a timeout ensures that resources are available for active clients and that inactive ones do not unnecessarily consume server resources.
Ex : Receive function
function receiver(sck, data)
print(data)
sck:close()
end
Ex : Web server function
-- server listens on 80, if data received, print data to console and send "hello world" back to caller
if sv then
sv:listen(80, function(conn)
conn:on("receive", receiver)
conn:send("Arunworld")
end)
end
TCP Server Connection(Client)
here the code for ESP32 NodeMCU Net Module example
Connect the WiFi Station
Once got IP address then run Server_Run() Function
You must be logged in to post a comment.