How To Program ESP8266 in Lua Getting Started With ESP8266 (NodeMCU Dev Kit) in Lua - Magesh Jayakumar

Table
of Contents
INTRODUCTION
ESP8266 application subject
General Purpose IO
ESP8266 Modules:
Flashing ESP8266 or Nodemcu with latest lua firmware
Getting Started With ESPlorer
Nodemcu API for Lua
GPIO API
gpio.mode()
gpio.read():
gpio.write()
gpio.trig()
ADC API
adc.read() :
Bit API
Node API
FILE API
Wi-Fi API
wifi.getchannel()
wifi.setmode()
wifi.getmode()
wifi.setphymode()
wifi.getphymode()
wifi.sleeptype()
wifi.sta.config()
wifi.sta.connect()
Wifi.sta.disconnect()
wifi.sta.getbroadcast()
wifi.sta.getconfig()
wifi.sta.gethostname()
wifi.sta.getip()
wifi.sta.getmac()
Wifi.sta.sethostname()
wifi.sta.setip()
wifi.sta.setmac()
wifi.sta.status()
wifi.ap.config()
wifi.ap.getbroadcast()
wifi.ap.getclient()
wifi.ap.getip()
wifi.ap.getmac()
wifi.ap.setip()
wifi.ap.setmac()
wifi.ap.dhcip.config()
wifi.ap.dhcp.start()
wifi.ap.dhcp.stop()
Timer API
tmr.alarm()
tmr.delay()
tmr.interval()
tmr.now()
tmr.time()
tmr.wdclr()
tmr.unregister()
tmr.stop()
tmr.register()
tmr.softwd()
tmr.state()
tmr.start()
PWM API
pwm.setup()
pwm.start()
pwm.stop()
pwm.setduty()
NET API
Constants
net.createConnection()
net.createServer()
net.server.close()
net.server.listen()
net.socket.close()
net.socket.connect()
Net.socket.dns()
net.socket.on()
net.socket.send()
net.dns.resolve()
net.dns.setdnsserver()
HTTP API
http.delete()
http.get()
http.post()
http.put()
http.request()
Turn On and OFF an LED
Working with LED
Blink an LED
Using the PWM function for the LED
RGB LED with NodeMCU
Connect to WiFi Router
Simple Web Server
Blink LED through Web Server
Control Electrical devices from Webserver
Temperature and Humidity Sensor support in NodeMCU

DHT API
Sensors Data To Thingspeak
Working with I2C device.
I2C API
i2c.address()
i2c.read()
i2c.setup()
i2c.start()
i2c.write()
I2C Temperature and Pressure Sensor
Temperature and Pressure Sensor Web server
Lua basics
Variables
Numbers
Strings
Boolean
nil
Operators/ conditionals
If statements
Loops
While loop
For loop
Functions
Getting Started on OSX (solution by NodeMCU)
Port Forwarding Example
Building Custom Firmware for NodeMCU
Components Need for this book
Contact
INTRODUCTION
The ESP8266 is a highly integrated chip designed by Espressif Systems for the needs of
an increasingly demand for low cost IOT solutions. The manufacturer advertises it offers a
complete and self-contained Wi-Fi networking solution, allowing it to either host
applications or offload all Wi-Fi networking functions from another application processor.
The ESP8266 has powerful on-board processing and storage capabilities that allow it to be
used with sensor and other application specific devices through it GPIOs with minimal
development up-front and minimal loading during runtime. Its high degree of on-chip
integration allows for minimal external circuitry. The entire solution, including the
modules, is designed to occupy minimal PCB area.
The ESP8266 was originally marketed as a low cost add-on to Arduino boards which was
in need of such devices to connect to external world, when people started to work the low
cost chip with arduino they realised that they can eliminate the Arduino boards and
understand this chip can be used as a stand-alone device. In less than a year, the ESP8266
has rocketed in popularity, and is now so well supported and developed.
Technical Features
802.11 b/g/n
WiFi 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
+19.5dBm output power in 802.11b mode
Power down leakage current of <10uA
Integrated low power 32-bit CPU could be used as application processor
SDIO 1.1/2.0, SPI, UART
STBC, 11 MIMO, 21 MIMO
A-MPDU & A-MSDU aggregation & 0.4ms guard interval
Wake up and transmit packets in < 2ms
Standby power consumption of < 1.0mW (DTIM3)
Operating temperature range -40C ~ 125C.
The ESP8266 chip should be powered by a 3.3V Power supply, it can consume 10uA to
170mA, the vast difference can be explained, when transmitting at full power, it can
consume 170mA but when in a deep sleep, it only need 10uA. That is a difference between
current consumption. This means that the runtime of an ESP8266 on a fixed current
reservoir is not just a function of time but also of what it is doing during that time and it
depend upon on the function it is going to do during the run time of the device.
ESP8266 can be used as an external Wi-Fi module, using the standard AT command set
Firmware by connecting it to any microcontroller using the serial UART, or directly serves
as a Wi-Fi enabled microcontroller, by programming a new firmware using the SDK. The
ESP8266 is designed to be used with a partner memory module and this is most
commonly flash memory. Most of the modules come with some flash associated with
them.
ESP8266 application subject

Smart Power Plug
Home Automation
mesh network
industrial wireless control
Baby Monitor
Network Camera
sensor networks
wearable electronics
wireless location-aware devices
Security ID tag
wireless positioning system signals

General Purpose IO
A total of up to 16 GPIO pins. The firmware can assign them different functions. Each
GPIO can be configured internal pullup / pulldown resistors available software registers
sampled input, triggering edge or level CPU interrupt input, trigger level wake-up
interrupt input, open-drain or complementary push-pull output drivers, software register
output source or sigma-delta PWM DAC. These pins are multiplexed with other functions,
such as the main interface, UART, SI, Bluetooth co-existence and so on.

ESP8266 Modules:
However the first introduced board which not much breadboard friendly integrated circuit
comes in a small package. Obviously, unless you are a master in soldering you are not
going to do much with that. The good news is ESP8266-based boards are available from
several vendors with different breakout boards that make the job much easier for us. Here
is the list of some of the more common modules.
ESP-01

This is the first and simplest board using the ESP8266. It allows attaching serial lines, and
only breaks out two GPIO pins for native usage. This is also the cheapest and can be
purchased from many Chinese suppliers at $2
ESP-12
The current most popular and hot topic is the ESP-12 which has flexible configuration
available today. It exposes the most GPIO pins for use. The basic ESP-12 module really
needs its own expander module to make it breadboard and 0.1 strip board friendly. If you
are currently using Arduino, you need to stand up and take note. Buy a ESP8266 12 based
Wi-Fi module, I have used a board called NodeMCU development board, which has an on
board ESP8266 and everything we need to get started with awesome Wi-Fi chip, this
board eliminates the need to have external USB serialconvertor to connect with your PC
or Laptop to program it and also comes with on board 3.3v Voltage regulator.
There are many ESP 12 development kit available on the market, some of the other
development board from popular vendors are listed below.
Adafruit HUZZAH ESP8266 breakout
The Adafruit Huzzah is a breakout board for the ESP8266. This was designed to make
working with ESP8266 chip super easy. This device comes with an on-board antenna, and
plenty of pins.
Wemos D1
This board is like arduino breakout board for ESP8266, which looks like an Arduino and it
has got everything to get start with. The arduino like feature allows the user to use this
board easily; this board has the entire pin marking as Nodemcu boards. Behind the board
we can find the real GPIO pin number which makes very easy to use this board with any
compiler for programming.
I have used Nodemcu development kit for the experiments that done in this book, lets get
into deeper with this board, you can also use any other vendor board, I highly recommend
for the novice user to get start with development board, instead of generic chips, where the
generic chips needs proper regulated voltage and it also requires a USB programmer to
upload the program into its memory.
Pin Definition of Nodemcu Development kit

Nodemcu Development kit circuit

Flashing ESP8266 or Nodemcu with latest lua firmware

Step 1: open your web browser and type https://github.com/nodemcu/nodemcufirmware/releases or click on the link.
Step 2: Click on the firmware links to download, download both the firmware wire.
Step 3: download lua IDE from the link here , for this tutorial we going to use ESPlorer
one of the stable version for uploading lua files to ESP8266 chips, there are other lua
loaders available which are limited to windows or still in development, as the ESPlorer is
not a great IDE but it is most suitable for learning lua programming with ESP8266
devices.
Step 4: Extract the Nodemcu Flasher which downloaded in the first step, if you have yet to
download, download it first before proceeding with this tutorial.
Step 5: Connect your Nodemcu or ESP8266 to your laptop or PC, if you are using a
generic ESP8266 device you need to connected with FTDI USB to serial adapter or any
other USB to serial adapter devices, if you are a beginner it is not advisable to use a
generic module as it may frustrate some beginner if they want to quick start with this
device.
Step 6: Open the extracted nodemcu-flasher-master file and select Win64 or Win32 based
on your system configuration, I use windows x64, and I choose the folder Win64, open
ESP8266 Flasher.
Click on Config and click on the gear, and navigate to the bin file (lua latest firmware) that
you downloaded in the step 2,
In the step 2, we have downloaded 2 firmware one is float and another one is integer,
select the second one integer type and click open.
These two firmware should flash to the ESP8266 based on requirement , if you use Float
firmware DHT library will not work with ESP8266 device, thats the reason we are
choosing the integer type later on tutorials we will use the device with DHT sensor and
read temperature and humidity data.

Check on the Config tab, correct firmware has selected or not, if the firmware path is
correct it will display in green color else the color would turn to red.
On the advance tab restore it to default and dont change it unnecessary
Step 7: Click on the Operation tab and select the correct COM port, if you have connected
only one device it will automatically detect the COM port if there are any devices
connected to your computer make sure to select the correct COM port, if you are not sure
about which COM port your device is currently connected, right click on the My computer
icon and select properties, choose device manager and click on ports, it will display the
available or currently connected devices to your computer.
Click on Flash in the Operation tab, after you make sure that you selected correct COM
port in the ESP8266 flasher.
Once you hit the flash button in the Operation tab your ESP8266 Flasher will start to
upload the firmware to your Nodemcu device, you see this by checking the progress bar in
your ESP8266 Flasher screen.
Click on the log file and make sure you have successfully uploaded the firmware, and you
can also see a green color check arrow to indicate the successful upload of the firmware, if
there is a problem when uploading the firmware check the log file and check the reason
for uploading failed, mostly this problem occurs when the ESP8266 device not responding
when uploading firmware you can disconnect and reconnect the device and try to upload
the firmware again, if still the problem continues check your device as it may have fault. If
you are using generic type and getting problem when you upload your firmware, make
sure you are power supply is providing enough power and not oscillating.
Getting Started With ESPlorer

The ESPlorer is an IDE ESP8266 devices. Its a multiplatform IDE can be used in any
environment it is not developed for a target system as it was created in JAVA, this simply
means that it runs on Windows, Mac OS X or Linux.
Supported platforms:
Windows(x86, x86-64)
Linux(x86, x86-64, ARM soft & hard float)
Solaris(x86, x86-64)
Mac OS X(x86, x86-64, PPC, PPC64)
This software allows you to establish a serial communications with your ESP8266, send
commands, and upload code and much more.
Extract the files that you have downloaded previously and open Esplorere.jar file. If you
are using MAC or linux type the following command in your terminal to run ESPlorer.
Sudo java jar Esplorer.jar
As the ESPlorer Ide created using JAVA it requires a java run time environment for
working, if you have not installed JAVA on your computer, downloaded it and run the
ESPlorer IDE, in some cases the jar files will be opened with the WinRAR, in such cases
you need to change some settings in your computer.
Method 1:
Go to your control panel and select default programs, and click associate a file type or
protocol with specific a specific program and wait for the programs to get loaded in the
window.
Navigate to .jar and select change program and choose java from there.

Method 2:
Open your WinRAR, and select options and click on settings.
On the setting, click on the Integration tab and uncheck JAR in the Associate WinRAR
with.

ESPlorer IDE overview
When you first open the ESPlorer IDE, it looks exactly shown below.
On the top right of ESP8266 choose Nodemcu+MicroPython tab, as we going to use lua
program we need to choose this section when communicating with ESP8266 device or
Nodemcu dev kit. Under Nodemcu+MicroPython tab there are many sub tabs you can see,
Scripts tab is the place where all the Programming are done, program can be opened, save
and close using the functions available in the Scripts tab.
Next to this Main tab on the Left side you can see functions which enable serial
communication between Nodemcu dev kit and the IDE.
This functions allow to choose COM port

of the ESP8266 device that is currently
connected to your computer, after selecting
the Com port , Open button helps to
establish communication with the ESP8266
device that is associated with the selected
COM port, baud rate can also be choose by selecting the drop down button available next
to the Open button.
The window below the above functions tab is exactly work as the serial monitor, which
helps to visibly check communication with ESP8266 devices, display the output result and
also show the error if there is any during the execution of program.
Nodemcu API for Lua

GPIO API
This GPIO(General Purpose Input/Output) allows us to access to pins of ESP8266 , all the
pins of ESP8266 accessed using the command GPIO, all the access is based on the I/O
index number on the NoddMCU dev kits, not the internal GPIO pin, for example, the pin
D7 on the NodeMCU dev kit is mapped to the internal GPIO pin 13, if you want to turn
High or Low that particular pin you need to called the pin number 7 no the internal
GPIO of the pin. When you are programming with generic ESP8266 these confusion will
arise which pin needs to be called during programming, if you are using NodeMCU dev
kit, it has come prepared for working with Lua interpreter which can easily program by
looking the pin names associated on the lua board.
If you are using generic ESP8266 device or any other vendor boards please refer to the
table below to know which IO index is associated to the internal GPIO of ESP8266.
Nodemcu dev kit
ESP8266 Pin
Nodemcu dev kit
ESP8266 Pin
D0
GPIO16
D7
GPIO13
D1
GPIO5
D8
GPIO15
D2
GPIO4
D9
GPIO3
D3
GPIO0
D10
GPIO1
D4
GPIO2
D11
GPIO9
D5
GPIO14
D12
GPIO10
D6
GPIO12

D0 or GPIO16 can be used only as a read and write pin, no other options like PWM/I2C
are supported by this pin.
gpio.mode() : This command will initialize the GPIO mode and also used for setting the
input/output direction of the pin
Syntax : gpio.mode(pin, mode)
Pin : select any of the available gpio pins
Mode: set the selected pin mode to input or output.
Example: gpio.mode(7, gpio.OUTPUT)

gpio.read(): This command will read the pin value, whether the pin is in High state or
Low state will be returned when use this command.
Syntax: gpio.read(pin)
On the function type the pin number to read, this will return a number based on the High
or Low on the pin side, if the pin is in high state this will return 1 and if it is low state
this will return 0.
Example: gpio.read(7)
gpio.write() : This command will makes the pin to go High or Low, we use this
command to set a pin to go High or Low, if you want to turn on and off an LED this
command can be used in such situations.
Syntax: gpio.write(pin, state)
Pin : enter the pin that you want to change the state to high or Low
State: High or Low, gpio.HIGH or gpio.LOW
Example:
pin = 7
gpio.mode(pin, gpio.OUTPUT)
gpio.write(pin, gpio.HIGH)
above program will set the D7 pin of Nodemcu to go High, on the first line pin is
assigned to variable 7, and on the second line D7 pin as set to Output and on the third
line D7 pin has made to HIGH which will write value 1 to the pin, which will make to
to glow if you connect a LED to the pin D7,

gpio.trig() : This command act as interrupt function during programming, using this
command can cause the program to execute certain function when the particular pin is
triggered , this function will not be available if GPIO_INTERRPUT_ENABLE was
undefined at the time of compile.
Syntax: gpio.trig(pin, type [, function(level)])
Choose pin 1 to 12, as the pin D0 or GPIO16 is not support interrupt or any other
function.
Type: up, down, both, low, high which represent rising edge, falling edge,
both edge, low level, high level trigger mode, if you want to choose the interrupt to occur
when the pin goes low, you should choose low as type, which means the pin will be
actively high, when the pin goes to low state it should stop the function and call the
function to execute during interrupt.
Function(level) callback function when triggered.
Example:
local pin = 5
function pinValue ()
print(The pin value..gpio.read(pin))
end
gpio.mode(pin, gpio.INT)
gpio.trig(pin, HIGH, pinValue)
The above example will return the pin value if the pin D5 goes high, for example if you
connected a push button to the pin D7, and whenever you push the pushbutton, program
will call the function pinValue, the pinValue function executes the current value of the PIN
5, so it will return the value as 1 on the serial monitor.
ADC API
ADC API provides access to the inbuilt ADC, ESP-12 has an inbuilt ADC pin, only pin
is available and it is not much stable with the Generic ESP-12, you should also aware that
it can read only upto 1v. if you are using Generic ESP devices you should use voltage
divider in order to make it work, NodeMCU has inbuilt voltage divider for the ADC pin
and we can connected analog devices directly to this device.
The ESP8266 v7 and v12 include an ADC( analog to digital converter)pin. This means
that the ESP8266 module can process inputs from analog sensors. Light sensors, analog
temperature sensors, force sensor, sound sensors etc,. can be interfaced with ESP8266 but
the disadvantage is that it can support only one ADC which means only one analog pin is
available in ESP8266 v12 and Nodemcu. The ADC pin is having 10 bit resolution, which
can read 0 to 1024, you will get a value somewhere within this range. The ADC pin only
reads upto 1V only. Any reading over that, say 1.1V to Vcc of 3.3V will be maxed out to
1024.
The Nodemcu has inbuilt voltage divider that has connected to A0 pin, which means any
pin connected to this will be corrected automatically we dont need to provide any voltage
divider or any other resistor but if you are using any other ESP8266 make sure which has
inbuilt voltage divider or you need to make an voltage divider to make this example to
work with your ESP8266.
For R1, I used a 220R and for R2, I used 100R resistors. On my voltmeter the actual
resistance was 225 and 103.7 respectfully. The math indicates that 220R and 100R should
divide 3.3v to 1.03v. 225R and 103.7 should be ~1.04v. All very close. On the breadboard,
my voltmeter is reading .98v. This relationship should hold true for 22R and 10R as well
as 20K and 10K. However, caution! The small ones heat up.
adc.read() : samples the ADC.
Syntax : adc.read(channel)
There is only one channel available with esp devices so always choose 0, may in future
device we can expect more ADC with ESP chips. This will return the sampled value in
number.
Example : val = adc.read(0)
Bit API
NodeMCU supports Bit manipulation on 32bit integers.
bit.arshift() , bit.rshift(), bit.lshift()
Returns either the bitwise logical left-shift, bitwise logical right-shift, or
bitwisearithmetic right-shift of its first argument by the number of bits given by the
second argument.
Logical shifts treat the first argument as an unsigned number and shift in 0-bits.
Arithmetic right-shift treats the most-significant bit as a sign bit and replicates it.
Only the lower 5 bits of the shift count are used (reduces to the range [0..31]).
Syntax: bit.arshift(value,shift)
Enter value to shift and how many positions to shift, it returns the number shifted right
(arithmetically)
Syntax: bit.rshift(value,shift)
Enter a value to shift and how many positons to shift, it returns the number shifted right
(logically)
Syntax: bit.lshift(value,shift)
Enter a value to shift and how many positions to shift, it returns the number shifted to
left.
Example:
print(bit.lshift(1, 0))
256
256
print(bit.rshift(256, 8))
print(bit.rshift(-256, 8))
16777215
print(bit.arshift(256, 8))
print(bit.arshift(-256, 8))
-1
printx(bit.lshift(0x87654321, 12))
0x54321000
printx(bit.rshift(0x87654321, 12))
0x00087654
printx(bit.arshift(0x87654321, 12))
0xfff87654

bit.band(), bit.bor(), bit.bxor()
Returns either the bitwise or, bitwise and, or bitwise xor of all of its arguments. Note that
more than two arguments are allowed.
Syntax : bit.band(val1, val2 [,valn])
Val1 is the first AND argument Val2 is the Second AND argument and Valn is the Nth
AND argument, this will return the bitwise AND of all the arguments in number.
Syntax: bit.bor(val1, val2 [,.valn])
Val1 is the first OR argument Val2 is the Second OR argument and Valn is the Nth OR
argument, this will return the bitwise OR of all the arguments in number.
Syntax: bit.bxor(val1, val2 [,.valn])
Val1 is the first XOR argument Val2 is the Second XOR argument and Valn is the Nth
XOR argument, this will return the bitwise XOR of all the arguments in number.
Example:
print(bit.bor(1, 2, 4, 8))
15
printx(bit.band(0x12345678, 0xff))
0x00000078
printx(bit.bxor(0xa5a5f0f0, 0xaa55ff00))
0x0ff00ff0

bit.bit()
Generate a number with a 1 bit (used for mask generation).
Syntax: bit.bit(position)
Example:
bit.bit(3)
0x00000008
bit.clear()
Clear bits in a number
Syntax: bit.clear(value, pos1, pos2, . posn)
Value is the base number and pos1 is the first bit to clear and posn is the nth bit to clear
and this will return the number with the bits cleared in the given positions.
V1 = 0x000000ff
bit.clear(V1, 4, 5, 6, 7)
0x000000f
bit.isset() : This function will test if a given bit is set or not.

Syntax: bit.isset(value, position)
The value is to test the bit position. This will returns true if the bit at the given position is
0, else it will return as false if the bit at the position is non zero.
V1 = 0x000000ff
bit.clear(V1, 1)
result: true
Node API
Node APIs allow the user to provide access to system level features such as restart,
sleep and IDs, which include ESP chip ID, flash chip ID.
node.bootreason()
This functions inspect boot cause and returns the boot reason and extended rest info.
When you call this function this will return the raw code and the values are
Value
Reset Information
Power-On
Reset (software)
Hardware reset via reset pin
WDT reset (watchdog timeout)

Second value returned is the extended reset cause and the values are given below:
Value
Reset Information
Power on
Hardware watchdog reset
Exception reset
Software watchdog reset
Wake from deep sleep
External reset.

In general, the extended reset cause supercedes the raw code. The raw code is kept for
backwards compatibility only. For new applications it is highly recommended to use the
extended reset cause instead.
In case of extended reset cause 3 (exception reset), additional values are returned
containing the crash information. These are, in order, EXCCAUSE, EPC1, EPC2, EPC3,
EXCVADDR, and DEPC.
Syntax : node.bootreason()
It returns rawcode, reason [, exccause, epc1, epc2, epc3, excvaddr, depc]

Example:
flag=node.bootreason()
print(reasonis:)
print(flag)

This added to the firmware developed in the date 2015-06-27, Make sure you have
firmware which supports this function.

node.chipid()
This function returns the chip id, when you call this function in the program it will store
the chip id.
Syntax: node.chipid()
Example:
Chipid = node.chipid()
Print( chip id:..Chipid)
node.compile()
This functions compiles a Lua text file into Lua bytecode, and it also saves it as .lc file
extension.
Syntax: node.compile(filename.lua)
The filename should be the name that you saved your Lua file.
Example:
file.open(Myfile.lua, w+)
file.writeline([[print( Nodemcu)]])
file.writeline([[print(node.heap())]])
file.close()
node.compile(Myfile.lua)
dofile(Myfile.lua)
dofile(Myfile.lc)
Above example will create file called Myfile.lua in the file Nodemcu will be written and
in the next line it returns the heap size or the balance memory in your NodeMCU dev or
ESP8266 device, and the file will be closed.
node.compile command open the file name Myfile.lua and compiles the file and save the
file in the .lc extension format.
node.dsleep()
The above function will make the ESP8266 device to enter into deep sleep mode till the
device timed out. Maximum sleep time for the device is 70 minutes, you cannot extended
the time limit as it was the limitation in the software , if you have older Firmware the
maximum sleep is less than 35.
This function can use in ESP device when it meet certain conditions, esp8266 PIN (RST)
and PIN8 (GPIO16) should connected together. Using sleep (0) will make the device to set
no wake up timer, connect a GPIO to pin RST, the chip will wake up by falling-edge on
the RST pin. You should follow these steps for proper working of this function.
Syntax: node.dsleep(us, option)
us is the sleep time in microsecond, if us == 0, it will sleep forever, if us ==nil, will not
set sleep time.
Example:
sleep time is 10s
sleep_time = 10 * 1000 * 1000

Do not forget to connect PIN32 and PIN8
node.dsleep(sleep_time);
0, init data byte 108 is valuable
> 0, init data byte 108 is valueless
0, RF_CAL or not after deep-sleep wake up, depends on init data byte 108
1, RF_CAL after deep-sleep wake up, there will be large current
2, no RF_CAL after deep-sleep wake up, there will only be small current
4, disable RF after deep-sleep wake up, just like modem sleep, there will be the smallest
current
node.heap()
This function returns the current available heap size in bytes, this will not return exact
heap size due to fragmentation and actual allocation due to this this will return data but it
should not take it as an exact required information.
Syntax: node.heap()

node.flashid()
This function returns the ID of the flash chip.
Syntax: node.flashid()

node.info()
This function returns firmware version, chipid, flashid, flash size, flash mode and
flash speed.
Syntax: node.info()

node.restart()
This function allow the chip to restart
Syntax: node.restart()

node.setcpufreq()
This function will change the CPU working frequency.
Syntax: node.secpufreq(speed)
Speed should be constant either 80MHZ or 160MHZ, should be careful when changing
this function as it may affect the chip working behaviour during the execution of the
program.
Example:
node.setcpufreq(node.CPU80MHZ)
or
node.setcupfreq(node.CPU160MHZ)

FILE API
File API provides access to the file system and its individual files, this allows user to
create a file inside a program and edit information on the file and save the file using file
API, only one file is possible to open at a time and it will not allow to access multiple
files, the file system follows a flat file system with no notion of directories or folders.
file.open()
This function allows to open any file in the system for editing or creating a new file, this
function access to all the existing files in the system, if we want to create any new file
using this function can only be done, for creating a new file , we need to open a file in
write mode. All the file.open() function must be closed with file.close function.
Syntax: file.open(filename, mode)
Filename, the file to be opened. There are different mode available to work on the files.
r: read mode (default mode in the file access)
w: write mode
a : append mode ( adding data to existing file)
r+: update mode. All previous data are preserved
w+: update mode, all previous data is erased
a+: append update mode, previous data is preserved, writing is only allowed at the end
of file.
Example:
file.open(init.lua, r)
print(file.readline())
file.close()

file.close()
This function closes any of the opened file, this function should be used with the
function file.open() at the end.
Syntax: file.close()

file.flush()
Flushes any pending writes to the file system, ensuring no data is lost on a restart.
Syntax: file.flush()
Example:
file.open(script.lua, a+)
file.write( hello)
file.flush()
file.write(world)
file.close()

file.format()
This function will erases all the existing files in the system and writes a new one,
depending on the size of the available flash chip in the ESP, it takes time depend on its
flash ID.
Syntax: file.format()

file.fsinfo()
This returns the file size information for the file system, in bytes.
Syntax: file.fsinfo()

file.list()
This function lists all the available files in the system.
Syntax: file.list()

file.write()
This function writes a string to the open file.
Syntax: file.write(string)

file.writeline()
This function will write a string to the opened file and append \n at the end of the file
which will add a new line after append string.
Syntax: file.writeline(string)
Example:
file.open(newfile.lua, a+)
file.writeline( this will add a new line at the end)
file.close()

file.seek()
This function sets and gets the file position,
Syntax: file.seek([whence[, offset]])

file.rename()
Renames a file, if the file to be changed to some other name this function is used for such
cases.
Syntax: file.rename(oldname, newname)

file.remove()
This functions allows us to remove a file from system, to do this the file that needs to
remove should not be currently opened as a file anywhere.
Syntax: file.remove(filename)

Wi-Fi API
Very important APIs available with NodeMCU firmware, this allows NodeMCU dev kit
or ESP8266 chips to connect with other devices and access information from internet and
allow a user to control a device from any part of the world, on chip Wi-Fi SoC is what
made the ESP most popular among hobbyist and it grows to phenomenal rate at this time.
wifi.getchannel()
This function gets current wifi channel that is currently connected. When this function
called in program this will return the wifi channel name.
Syntax: wifi.getchannel()
Example:
print(wifi.getchannel())

wifi.setmode()
This function configures the Wi-Fi mode to use, NodeMCU can run in four different
modes:
1) Station mode, where the NodeMCU device joins an existing network
2) Access point mode, where it creates its own network that other can join, it
serves as the Wi-Fi router for other devices.
3) Station + Access point mode
4) WiFi off

Syntax: wifisetmode(mode)
Mode value should one of the mode as follows
I) wifi.STATION this will mode set it to the first available
mode, that is station mode which allow the device connected to a
WiFi router, this mode is often used to access internet with ESP
device.
II) wifi.SOFTAP this mode will set NodeMCU dev kit as an
access point.
III) wifi.STATIONAP this mode is the combination of both 1 and
2. When using the combined station + AP mode, the same channel
will be used for both networks as the radio can only listen on a single
channel.
IV) wifi.NULLMODE this mode will turn off WiFi.

wifi.getmode()
This function will gets wifi operation mode, this will make us to know which mode the
wifi has currently set to. Just above the screen you can see the number of available mode.
Syntax: wifi.getmode()
This will return as one of the following wifi.STATION, wifi.SOFTAP, wifi.STATIONAP
or wifi.NULLMODE constants.

wifi.setphymode()
This function will sets WiFi physical mode.
1) wifi.PHYMODE_B 802.11b, more range, llow Transfer rate, more current draw
2) wifi.PHYMODE_G 802.11g, medium range, medium transfer rate, medium
current draw
3) wifi.PHYMODE_N 802.11n, least range, fast transfer rate, least current draw
(STATION ONLY) information from the Espressif datasheet v4.3

Parameters
Typical Power Usage
Tx802.11b, CCK 11Mbps, P OUT= 170mA

+17dBm
Tx802.11g, OFDM 54Mbps, P OUT 140mA
= +15dBm
Tx802.11n, MCS7 65Mbps, P OUT 120mA
= +13dBm
Rx802.11b, 1024 bytes packet 50mA
length, -80dBm
Rx 802.11g, 1024 bytes packet 56 mA
length, - 70dBm
Rx802.11n, 1024 bytes packet 56mA
length, -65dBm

Syntax
wifi.setphymode(mode)
Mode one of the following parameters below
1) wifi.PHYMODE_B
2) wifi.PHYMODE_G
3) wifi.PHYMODE_N

wifi.getphymode()
This function returns WiFi physical mode that is currently set to the device.
Syntax: wifi.getpymode()
The above syntax will return wifi.PHYMODE_B, wifi.PHYMODE_G or
wifi.PHYMODE_N.

wifi.sleeptype()
This function configures the WiFi modem into sleep type.
Syntax: wifi.sleeptype(type_wanted)
Type wanted should be as follows
1) wifi.NONE_SLEEP to keep the modem on at all times
2) wifi.LIGHT_SLEEP to allow the modem to power down under some
circumstances.
3) wifi.MODEM_SLEEP to power down the modem as much as possible.

wifi.sta.config()
This function sets the WiFi station configuration.
Syntax: wifi.sta.config(ssid, password[, auto[, bssid]])
Ssid is the name of WiFi router and the string name should be less than 32 bytes.
Password is the wifi router password which is 8-64 or 0 bytes. Empty string indicates an
open WiFi access point.
Auto value of 0 or 1 (default value is 1)
0 will disable auto connect and remain disconnected from access point.
1 will enable auto connect and connect to access point.
bssid this string contains the MAC address of the access point and it is not mandotary it is
an option to be used.
You can set BSSID if you have multiple access points with the same SSID.
Note: if you set BSSID for a specific SSID and would like to configure station to connect
to the same SSID only without the BSSID requirement, you MUST first configure to
station to a different SSID first, then connect to the desired SSID

The following formats are valid:
DE-C1-A5-51-F1-ED
AC-1D-1C-B1-0B-22
DE AD BE EF 7A C0
Examples:
Connect to access point automatically when in range
wifi.sta.config(myssid, password)

Connect to Unsecured access point automatically when in range
wifi.sta.config(myssid, )

Connect to access point, User decides when to connect/disconnect to/from AP
wifi.sta.config(myssid, mypassword, 0)
wifi.sta.connect()
do some WiFi stuff
wifi.sta.disconnect()

Connect to specific access point automatically when in range
wifi.sta.config(myssid, mypassword, 12:34:56:78:90:12)

Connect to specific access point, User decides when to connect/disconnect to/from AP
wifi.sta.config(myssid, mypassword, 0, 12:34:56:78:90:12)
wifi.sta.connect()
do some WiFi stuff
wifi.sta.disconnect()

wifi.sta.connect()
This functions connect to access point in station mode.
Syntax: wifi.sta.connect()

Wifi.sta.disconnect()
This function disconnect from access point in station mode.
Syntax: wifi.sta.disconnect()

wifi.sta.getbroadcast()
This function gets the broadcast address in station mode.
Syntax: wifi.sta.getbroadcast()
This will broadcast the address as string, for example 192.168.0.105

wifi.sta.getconfig()
This function will gets the Wi-Fi station configuration.
Syntax: wifi.sta.getconfig()
When this function called in program this will return ssid, password, bssid_set, bssid, if
bssid_set is equal to 0 then bssid is irrelevant.
Example:
Get current Station configuration
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

wifi.sta.gethostname()
This function will returns the currently connected hostname station.
Syntax: wifi.sta.gethostname()
When this function called in program, this will returns currently configured hostname.
Example:
print(Current hostname is: \..wifi.sta.gethostname()..\)

wifi.sta.getip()
This function will gets IP address, netmask, and gateway address in station mode.
Syntax: wifi.sta.getip()
Example:
print current IP address, netmask, gateway
print(wifi.sta.getip())
192.168.0.111 255.255.255.0 192.168.0.1
ip = wifi.sta.getip()
print(ip)
192.168.0.111
ip, nm = wifi.sta.getip()
print(nm)
255.255.255.0

wifi.sta.getmac()
This function get mac address in station mode.
Syntax: wifi.sta.getmac()
The above syntax when called in program will returns MAC address as string.

Wifi.sta.sethostname()
This function will sets station hostname.
Syntax: wifi.sta.sethostname(hostname)
Hostname must only contain letters, numbers and hyphens(-) and be 32 characters or
less with first and last character being alphanumeric, and the function will return true if
the hostname has successfully set, else it will return false if the hostname was not
succeed.

Example:
if (wifi.sta.sethostname(NodeMCU) == true) then
print(hostname was successfully changed)
else
print(hostname was not changed)
end

wifi.sta.setip()
This function sets IP address, netmask, gateway address in station mode, if this function
has not used wifi router will automatically set the IP address, netmask and gateway
address, make sure the assigning IP address is not using by any other device that has
currently connected to the router.

Syntax: wifi.sta.setip(cfg)
Cfg table contain IP address, netmask and gateway
{
ip= 192.168.0.100
Netmask = 255.255.255.0,
gateway = 192.168.0.1
}
If the function is successful it returns true else it will return false.

wifi.sta.setmac()
This function sets MAC address in station mode.
Syntax: wifi.sta.setmac(mac)
MAC address should be in string, this function returns true if success else this will return
false if the address was not successfully assigned.

wifi.sta.status()
This function will get the current status in station mode.
Syntax: wifi.sta.status()
This will return the number 0-5.
0: STATION_IDLE
1: STATION_ CONNECTING
2: STATION_WRONG_PASSWORD
3: STATION_NO_AP_FOUND,
4: STATION_CONNECT_FAIL
5: STATION_GOT_IP.

wifi.ap.config()
This function will set SSID and password in Access Point mode, make sure to choose
password as 8 characters or more if you fail to do this, device will automatically set to
default mode where it will automatically assign SSID and password will be none.
Syntax: wifi.ap.config(cfg)
Ssid SSID chars should be 1-32 characters long.
Password should be more than 8 characters.
Authentication one of AUTH_OPEN, AUTH_WPA_PSK, AUTH_WPA2_PSK,
AUTH_WPA_WPA2_PSK, default = AUTH_OPEN
Channel number 1-14 default = 6
Hidden, if it is 0 then not hidden, if it is 1 it is set to hidden by default it is set to 0.
Maximum number of connections 1-4 by default = 4.
Beacon interval time in range 100 60000, default = 100.
Example:
Cfg ={}
Cfg.ssid = myssid
Cfg.pwd = mypassword
Wifi.ap.config(cfg)

wifi.ap.getbroadcast()
This function will gets broadcast address in access point mode.
Syntax: wifi.ap.getbroadcast()
This function will return broadcast address in string .
Example:
broadcast = wifi.ap.getbroadccast()
print(broadcast)

wifi.ap.getclient()
This function will get table of clients connected to the NodeMCU dev kit when the kit act
as an Access point to other devices.
Syntax: wifi.ap.getclient()
Examples:
table={}
table=wifi.ap.getclient()
for mac,ip in pairs(table) do
print(mac,ip)
end

or shorter
for mac,ip in pairs(wifi.ap.getclient()) do
print(mac,ip)
end

wifi.ap.getip()
This function will gets IP address, netmask and gateway in access point mode.
Syntax: wifi.ap.getip()
Example:
print current ip, netmask, gateway
print(wifi.ap.getip())
192.168.4.1 255.255.255.0 192.168.4.1
ip = wifi.ap.getip()
print(ip)
192.168.4.1
ip, nm = wifi.ap.getip()
print(nm)
255.255.255.0
ip, nm, gw = wifi.ap.getip()
print(gw)
192.168.4.1

wifi.ap.getmac()
This function will gets MAC address in access point mode.
Syntax: wifi.ap.getmac()

wifi.ap.setip()
This function will set IP address, gateway and netmask in access point mode.
Syntax: wifi.ap.setip(cfg)

wifi.ap.setmac()
This function will set MAC address in Access point mode.
Syntax: wifi.ap.setmac(mac)

wifi.ap.dhcip.config()
This function will configure the dhcp service.
Syntax: wifi.ap.dhcp.config(dhcp_config)
Example:
dhcp_config ={}
dhcp_config.start = 192.168.1.100
wifi.ap.dhcp.config(dhcp_config)

wifi.ap.dhcp.start()
This function will starts the DHCP service
Syntax: wifi.ap.dhcp.start()

wifi.ap.dhcp.stop()
This function will stops the DHCP service.
Syntax: wifi.ap.dhcp.stop()
Timer API
The lua firmware provides an API with which can be used to set timeouts and intervals,
functions that execute after a period of time, either once or over and over again. However,
the modules only have capacity to have seven timers or intervals running at the same time.
Therefore, you need to reference them by index (0 to 6) and make sure that different parts
of your program dont override the same timer.
tmr.alarm()
This is a convenience function combining tmr.register( ) and tmr.start( ) into a single call.
To free up the resources with this timer when done using it, call tmr.unregister( ) on it. For
one-shot timers this is not necessary, unless they were stopped before they expired. We
use the same function to create both timeouts and intervals, tmr.alarm(). We
differentiate which type of timer we want to create using the third argument; 0 =
timeout, 1 = interval:
Syntax: tmr.alarm(id, interval, mode, function do())
Id is the timer id (0-6)
interval is the timer interval in milliseconds, Maximum value is 12884901
mode timer mode:
tmr.ALARM_SINGLE a one-shot alarm (and no need to call tmr.unregister())
tmr.ALARM_SEMI manually repeating alarm (call tmr.start() to restart)
tmr.ALARM_AUTO automatically repeating alarm

Example:
function sayHello ()
print Hello
end
tmr.alarm(0, 2500, 0, sayHello)
Here we are creating a timeout at timer index zero and setting it to call the sayHello()
function after 2.5 seconds.
If we were to create another timeout (or interval) at index zero before this timer executed,
it would simply overwrite it and sayHello() would never be called.

tmr.delay()
Busyloops the processor for a specified number of microseconds.
This is in general a bad idea, because nothing else gets to run, and the networking stack
(and other things) can fall over as a result. The only time tmr.delay( ) may be appropriate to
use is if dealing with a peripheral device which needs a (very) brief delay between
commands, or similar. Use with caution!
Also note that the actual amount of time delayed for may be noticeably greater, both as a
result of timing inaccuracies as well as interrupts which may run during this time.
Syntax: tmr.delay(us)
us is the microseconds to delay the loop.

tmr.interval()
This function changes a registerd timers expiry interval.
Syntax: tmr.interval(id, interval)
Example:
tmr.register(0, 60000, tmr.ALARM_SINGLE, function() print ( Timer function) end)
tmr.inerval (0, 3000)

tmr.now()
This functions returns the system counter, which counts in microseconds. Limited to 31
bits, after that it wraps around back to zero.
Syntax: tmr.now()
Example:
Print(tmr.now)

tmr.time()
This function returns the system uptime, in seconds, limited to 31 bits after that it wraps
around back to zero
Syntax: tmr.time()
Example: print(uptime:, tmr.time())

tmr.wdclr()
This function feed the system watchdog.
In general, if you ever need to use this function, you are doing it wrong.
The event-driven model of NodeMCU means that there is no need to be sitting in hard
loops waiting for things to occur. Rather, simply use the callbacks to get notified when
somethings happens. With this approach, there should never be a need to manually feed
the system watchdog.
Syntax: tmr.wdclr()

tmr.unregister()
Stops the timer (if running) and unregisters the associated callback.
This isnt necessary for one-shot timers (tmr.ALARM_SINGLE), as those automatically
unregister themselves when fired.
Syntax: tmr.unregister(id)
Id is the timer id between (0-6)
Example: tmr.unregister(0)

tmr.stop()
This functions stops a running timer, but does not unregister it, A stopped timer can be
restarted with tmr.start()
Syntax: tmr.stop(id)
Example:
If not
tmr.stop(2)
Then
Print ( timer 2 not supped, not regisetered)
end
tmr.register()
Configures a timer and registers the callback function to call on expiry.
To free up the resources with this timer when done using it, call tmr.unregister() on it. For
one-shot timers this is not necessary, unless they were stopped before they expired.
Syntax: tmr.register(id, interval, mode, func)

tmr.softwd()
This function provides a simple software watchdog, which needs to be re-armed or
disabled before it expires, or the system will be restarted.
Syntax: tmr.softwd(timeout_s)
Timeout_s is the watchdog timeout, in seconds, to disable the watchdog use -1.
Example:
function on_success_callback()
tmr.softwd(-1)
print(Complex task done, soft watchdog disabled!)
end
tmr.softwd(5)
go off and attempt to do whatever might need a restart to recover from
complex_stuff_which_might_never_call_the_callback(on_success_callback

tmr.state()
This function checks the state of a timer.
Syntax: tmr.state(id)
This fucntions returns if the specified timer is registered, returns whether it is currently
started and its mode, if the timer is not registered, this function will return nil.
Example:
Running, mode = tmr.state(0)

tmr.start()
This functions starts or restarts a previously configured timer.
Syntax: tmr.start(id)
This function will return true if the timer was started and gives false if there is an error on
starting the timer.
Example:
Tmr.register(0, 500, tmr.ALARM_SINGLE, function() print( hello) end)
If not tmr.start(0) then print (yes)end

PWM API
Pulse Width Modulation APIs allows us to use any of the I/O pin as PWM pin except the
D0 pin of NodeMCU DEV KIT, this API will be very useful when controlling LEDs ,
Motors and many more devices which require PWM functions to do crazy things.
pwm.setup()
This function allows to set a pin to PWM mode, only 6 pins can be set to PWM mode at
the most case.
Syntax: pwm.setup(pin, clock, duty)
Pins from 1 to 12 can be choose for PWM
Clock frequency should be set between 1- 1000, pwm frequency.
Duty cycle should be between 0-1023 , max is 1023(10bit)
Example: pwm.setup(1, 100, 512) this example set the D1 pin as pwm output and
frequency is 100 hz and duty cycle is 512.

pwm.start()
This function starts the PWM, the waveform is applied to the GPIO pin.
Syntax: pwm.start(pin)

pwm.stop()
This function pause the output of the PWM waveform.
Syntax: pwm.stop(pin)

pwm.setduty()
This function allows to set the duty cycle for a pin.
Syntax: pwm.setduty(pin, duty)
Example:
pwm.setup(1, 500, 512)
pwm.setup(2, 500, 512)
pwm.setup(3, 500, 512)
pwm.start(1)
pwm.start(2)
pwm.start(3)
function led(r, g, b)
pwm.setduty(1, g)
pwm.setduty(2, b)
pwm.setduty(3, r)
end
led(512, 0, 0) set led to red
led(0, 0, 512) set led to blue.
NET API
Constants
net.TCP, net.UDP
net.createConnection()
This function creates a client connection.
Syntax: net.createConnection(type, secure)
Type must be net.TCP or net.UDP
Secure 1 for encrypted connection and 0 for plain connection.
Example:
net.createConnection(net.UDP,0)

net.createServer()
This function creates a server. Server is the base class for all the ESP8266 server calls.
Syntax: net.createServer(type, timeout)
Timeout for a TCP server timeout is 1-28,000 seconds ( for an inactive client to be
disconnected) this function will returns net.server sub module.
Example:
net.createServer(net.TCP, 30)
net.server.close()
This function closes the server.
Syntax: net.server.close()
Example:
Sc = net.createServer(net.TCP, 30)
Sc:close()

net.server.listen()
This function listen on port from IP address.
Syntax: net.server.listen(port, [ip], function (net.socket))
Port is the port number
Ip address string, this can be omitted
Function (net.socket) callback function, pass to caller function as param if a connection
is created successfully.
Example:
30s time out for a inactive client
sv = net.createServer(net.TCP, 30)
server listens on 80, if data received, print data to console and send hello world back to caller
sv:listen(80, function(c)
c:on(receive, function(c, pl)
print(pl)
end)
c:send(hello world)
end)

net.socket.close()
This function closes socket connection
Syntax: net.socket.close()

net.socket.connect()
This function connect to a remote server.
Syntax: connect(port, ip| domain)
Port is the port number and ip address or domain name string

Net.socket.dns()
This function provides DNS resolution for a hostname
Syntax: dns(domain, function(net.socket, ip))
Domain name is the domain for the host, function(net.socket,ip) callback function, this
first parameter is the socket, the second parameter is the IP address as a string.
Example:
sk = net.createConnection(net.TCP, 0)
sk:dns(www.nodemcu.com, function(conn, ip) print(ip) end)
sk = nil

net.socket.on()
This function register callback funtions for specific events.
Syntax: on(event, function())
Event is a string, which can be connection , reconnection, disconnection,
receive or sent . function(net.socket[, string]) callback function, the first parameter is
the socket, if event is receive the second parameter is the received data as string.
Example:
sk = net.createConnection(net.TCP, 0)
sk:on(receive, function(sck, c) print(c) end )
sk:connect(80,192.168.0.66)
sk:on(connection, function(sck,c)
Wait for connection before sending.
sk:send(GET / HTTP/1.1\r\nHost: 192.168.0.66\r\nConnection: keep-alive\r\nAccept: */*\r\n\r\n)
end)

net.socket.send()
This function sends data to server.
Syntax: send(string, function(sent))
String is the data in string which will be sent to server and function(sent) callback
function for sending string.
net.dns.getdnsserver()
This function gets the IP address of the DNS server used to resolve hostnames.
Syntax: net.dns.getdnsserver(dns_index)
dns_index which DNS server to get (range 0 -1) this function returns IP address(string)
on DNS server.
Example:
print(net.dns.getdnsserver(0)) 208.67.222.222
print(net.dns.getdnsserver(1)) nil

net.dns.setdnsserver(8.8.8.8, 0)
net.dns.setdnsserver(192.168.1.252, 1)


net.dns.resolve()
This function resolve a hostname to an IP address. Doesnt require a socket like
net.socket.dns()
Syntax: net.dns.resolve(host, function(ip))
Example:
net.dns.resolve(www.google.com, function(sk, ip)
if (ip == nil) then print(DNS fail!) else print(ip) end
end)

net.dns.setdnsserver()
sets the IP of the DNS server used to resolve hostnames.
Default:resolver1.opendns.com(208.67.222.222). you can specify up to 2 DNS servers.
Syntax: net.dns.setdnsserver(dns_ip_addr, dns_index)
dns_ip_addr is the IP address of a DNS server and dns_index is which DNS server to set
(range 0-1). Hence it supports max 2 servers.
HTTP API
Basic HTTP client module.
Provides an interface to do basic GET/POST/PUT/DELETE over HTTP(S), as well as
customized requests. Due to the memory constraints on ESP8266, the supported
page/body size is limited by available memory. Attempting to receive pages larger than
this will fail. If larger page/body sizes are necessary, consider
using net.createConnection() and stream in the data.
Each request method takes a callback which is invoked when the response has been
received from the server. The first argument is the status code, which is either a regular
HTTP status code, or -1 to denote a DNS, connection or out-of-memory failure, or a
timeout (currently at 10 seconds).
For each operation it is also possible to include custom headers. Note that following
headers cannot be overridden however: - Host - Connection - User-Agent
The Host header is taken from the URL itself, the Connection is always set to close, and
theUser-Agent is ESP8266.
Note that it is not possible to execute concurrent HTTP requests using this module.
Starting a new request before the previous has completed will result in undefined
behaviour.
http.delete()
This functions executes a HTTP delete request.
Syntax: http.delete(url, headers, body, callback)
The URL to fetch, including the http:// or https:// prefix
Headers are optional and additional headers to append, including \r \n;
The body to post, must already be encoded in the appropriate format, but may be empty
Callback function to be invoked when the response has been received. It is invoked with
arguments status_code and body.
Example:
http.delete(https://www.example.com/ask,
,
,
function(code, data)
if (code < 0) then
print(HTTP request failed)
else
print(code, data)
end
end)

http.get()
This function executes a HTTP get request to the server.
Syntax: http.get(url, headers, callback)
url to fetch including the http:// or https://
headers are optional, Callback function to be invoked when the response has been
received. It is invoked with arguments status_code and body.
Example:
http.get(https://www.vowstar.com/nodemcu/, nil, function(code, data)
if (code < 0) then
else
print(code, data)
end
end)

http.post()
This function executes a HTTP post request.
Syntax: http.post(url, headers, body, callback)
Exmple:
http.post(http://json.example.com/something,
Content-Type: application/json\r\n,
{hello:world},
if (code < 0) then
else
print(code, data)
end
end)

http.put()
This function executes a HTTP PUT request

Syntax: http.put(url, headers, body, callback)
Example:
http.put(http://db.example.com/items.php?key=deckard,
Content-Type: text/plain\r\n,
Hello!\nStay a while, and listen\n,
if (code < 0) then
else
print(code, data)
end
end)

http.request()
This function executes a custom HTTP request for any HTTP method.
Syntax: http.request(url, method, headers, body, callback)
Example:
http.request(https://www.example.com, HEAD, , , function(code, data)
if (code < 0) then
else
print(code, data)
end
end)
Turn On and OFF an LED

In this chapter we will see how to turn on and off an LED connected to NodeMCU dev kit
or an ESP8266 generic device.
Requirement for this project
1) an LED
2) NodeMCU or ESP8266 board
3) Connecting wires.
as you can see in your LED it has two

pins, the longer pin is known as Anode
and the shorter pin is known as cathode,
connect longer pin to the 7th pin of
Nodemcu dev kit, if you are using generic
ESP8266 module connect it to GPIO13, if
you still have not sure about GPIOs
available with generic ESP8266 chips
check the lookup table for the chip. It is not necessary to connect a resistor between the
NodeMCU dev kit and the LED.
Connect your NodeMCU to computer.
Open ESPlorer IDE.
Click on the refresh button, it will automatically detect the COM port your Nodemcu has
currently connected, set the baud rate to 9600 for communicating with your device check
the port currently connected which display at the top right of your ESPlorer, click the open
button to establish communication with your NodeMCU.

After clicking the Open button, check
on the serial monitor of the ESPlorer, if
the serial monitor displays continues
dots, without any message like the one
attached in the screen below.
Click on the reset button on your NodeMCU dev kit if your dev kit not connecting to your
ESPlorer.
Reset button available on the left side near the
USB connector, press it once and you can see your
device communicating with your ESPlorer.

Once the connection establish with the NodeMCU dev kit, you can see the same message
that appears in your ESPlorer serial monitor.
gpio.mode( 7, gpio.OUTPUT )
turn on
gpio.write( 7, gpio.LOW )
tmr.delay( 1500000 ) delay 1.5 second
gpio.write( 7, gpio.HIGH )

Type the above program in your ESPlorer
After completing the program click on the send to ESP button on the bottom left of your
ESPlorer.
When you click the send to ESP button , you can view on your serial monitor code is
sending to ESP line by line, when the first line send to ESP you can view on your
Nodemcu dev kit, the connected LED will go High and Low based on the line of code that
currently sending to the ESPlorer.

Lua program explanation:

gpio.mode(7,gpio.OUTPUT)
This command will initialize pin to GPIO mode, set the pin as Input or Output based on
our setting to the pin, the compiler will assign the state of the pin. When you using this
command the function should consist of pin to configure and the mode of the pin,
gpio.OUTPUT or gpio.INPUT, this command will also assign a pin as a pullup. , if we
not choose the pullup option by default all the gpio pin will set to Float.

gpio.write(7, gpio.LOW)
This command will set the digital GPIO pin value either high or low, based on the output
level selected by the programmer. In the above command digital pin D7 of NodeMCU
has assigned to LOW level, this will make the connected LED to go LOW or OFF state.

tmr.delay(1500000)
This command will delay the function for the period that is entered into the function ( )
1000000 which equals 1 sec.
As you can see the in the program same set of codes has repeated throughout the
completion of program, which is easy to understand by knowing the above command, the
program has not consist of any loop so the program will execute only a single time and
stops, if you see the LED connected to NodeMCU, LED will go High for 3 times and Low
for 4 times and stops forever.
To do:
Add more number of lines to the code and check how the process is going on, change the
delay timer and check the LED output and note how the delay function causing the
program to change.

Working with LED

Blink an LED
In the previous chapter we have seen how to turn on and off an LED, in this chapter we
will see how to blink an LED using NodeMCU,
Easy blink function make you cry
while 1 do
gpio.write(0, gpio.HIGH)
tmr.delay(1000000) wait 1,000,000 us = 1 second
tmr.delay(1000000) wait 1,000,000 us = 1 second
end)
The above is the simple blink function which can go wrong if you dont know what it can
done to your ESP8266, as the code is infinite loop and if you save the code to NodeMCU
or any other ESP8266 device, this code will run forever after uploading this code, your
NodeMCU will not respond to you if you try to establish communication with your
ESPlorer, if you ever happened to caught in a situation like this flash the firmware again
and do all the process from the beginning.
For this example we going to use the same setup which we have used for the previous
example.
Connect your LED to the 7th pin of NodeMCU and check you are connecting the LED pins
properly to the 7th pin and the ground, if you interchange your anode and cathode then it
may lead to damage your LED.
Connect NodeMCU to your computer using USB cable.
Open ESPlorer and start type your program to the ESPlorer.

LUA program:
lighton=0
pin=7
gpio.mode(pin,gpio.OUTPUT)
tmr.alarm(1,1000,1,function()
if lighton==0 then
lighton=1
gpio.write(pin,gpio.HIGH)
else
lighton=0
gpio.write(pin,gpio.LOW)
end
end)

After completing the program click on the send to ESP button on the bottom left of your
ESPlorer.
When you click the send to ESP button , you can view on your serial monitor code is
sending to ESP line by line, after sending the code to ESP8266 device or NodeMCU dev
kit you can see the LED goes On and Off between the 1sec interval.
Program Explanation:
lighton = 0
Lighton is a variable and you can use any of the name you would like for the variable
and the variable currently holds 0 as the value to its memory.

Pin = 7
This is also a variable, which we can assign a name to the pin number and instead of the
pin number we can call the pin number by the name that is assigned to the pin.

gpio.mode(pin, gpio.OUTPUT)
We have already seen about this function, this function will set a digital pin to either
input or output.

tmr.alarm (1, 1000, 1, function()
When using timer function we are limited to use only 7 timers in the function this is a
limitation when using tmr function in NodeMCU. , to keep track of how many functions
we are using in the program we can use timer ID, 1 in the begging of the function before
1000 is the track ID for the timer function, and the number 1000 is the time interval in
milliseconds, and call the function every 1 second.

if lighton==0 then
lighton=1
gpio.write(pin,gpio.HIGH)
else
lighton=0
gpio.write(pin,gpio.LOW)
end
command which follows the tmr.alram is the function inside the tmr.alram function(),
this code will execute the function , it will turn make the D7 pin to go high for 1 sec
and set the Lighton = 1 and this will make the D7 pin to go low when lighton = 0;

Init.lua
Save the above program as init.lua
After saving the file in the name init
and upload it to the ESP8266 or
NodeMCU dev kit. Whenever a file
named as init and uploaded to
ESP8266 that program will first run
when the ESP8266 booted up.
Usually this init function is used for
storing wifi ssid and password,
which will make this device
connected to a wifi when the ESP
booted up.

To do:
Try to change the timer interval in the tmr.alarm function and change the timer ID, and
check how it works, and also create another tmr.alarm with same ID and check whether
the tmr.alarm function with same ID is executing or not.
Connect another pin and write a program for 2 LEDs and also create two separate
functions and give different interval between these functions.
Using the PWM function for the LED

In this section we will look into the PWM options available with NodeMCU, Using
PWM function it is possible to control the brightness of the LED. Pins from 1 to 12 can be
used as a PWM pin. For this we going to use the same setup as we used for blinking an
LED.
Program to control brightness of LED connected to digital pin D7 of Nodemcu dev kit.
pwmpin=7
pwm.setup(pwmpin,500,1020)
pwm.start(pwmpin)
for i = 1020,0,-20 do
pwm.setduty(pwmpin,i)
tmr.delay(30000)
end
tmr.delay(1000000)
for i=0,1020,20 do
tmr.delay(30000)
end
pwm.setduty(pwmpin, 1023) turn off the ledpin
pwm.close(pwmpin)

Type the program into ESPlorer and send the program to NodeMCU dev kit and check
how the brightness of the LED pin changes, initially the brightness of the LED increase
and decrease and then increase and stands there, as this program doesnt contain any loop,
this function will run only once and stops.
Try interchanging the loop like the one below and save the program to ESP8266 device.
When you saving program, save it as pwm or any other name dont use init.lua,
Observe the changes between two program, and save this to NodeMCU dev kit. This time
we are not sending data, directly programming to ESP8266 flash memory.
Click reset button on the ESPlorer.
And wait for your device to restart and check what is happening with the LED.

Click on the run button on the ESPlorer

Now save the same file as init.lua and save it to ESP8266 and click the restart button on
the ESPlorer.
Now observer the difference between the file name you saved previously and now, you
need to manually click run when you save the file in different name, but if you save the
file name in init.lua the program will automatically executes.
Program Explanation.
pwmpin=7
pwmpin is the variable which holds the pin number, which help us to use pwmpin in the
program instead of directly inputting the pin number.

pwm.setup(pwmpin,500,1020)
This function will set the pin 7 to pwm mode, 500 followed by pin is the clock which
can be set from 1 to 1000, this is the PWM frequency, and the 1020 is the duty cycle and
max 1023 can be set as duty cycle.

pwm.start(pwmpin)
This function will starts the waveform to be applied to the GPIO pin.

for i = 0,1020,20 do
tmr.delay(30000)
end
This is for loop which will count the value of i from 0 to 1020 in the increment of 20
counts, initially the i is set to zero so the loop counts from 0. During the count it will
executes the following function under the loop.

Pwm.setduty(pwmpin,i)
This function set the duty cycle to the pin, here the pin D7 will be set initially to duty
cycle 0 and it will increment by 20 until 1020.
tmr.delay()
This function makes delay during the execution of the program.
end
which notifies the end of the for loop.
As the loop repeat again with decrement order and it does the same function
pwm.close(pwmpin)
This function will quit from the PWM mode

RGB LED with NodeMCU

In this section we will see how to use RGB led with NodeMCU, as we have seen in the
earlier section how to work with LEDs , RGB also an LED, it is like a combination of red
green and blue LED.

RGB LED used for this tutorial is common cathode which should be connected to GND of
NodeMCU, if you are using common anode type, program needs to be changed. Connect
R pin to 8th pin of NodeMCU and G pin to 6th pin of NodeMCU and the last B pin to 7th
pin of NodeMCU.
NodeMCU Program.
pwm.setup(8, 500, 512)
pwm.setup(6, 500, 512)
pwm.setup(7, 500, 512)
pwm.start(8)
pwm.start(6)
pwm.start(7)
led(512, 0, 0) red led, call the function and set pwm duty to pin 8
tmr.delay(1000000)
led(0, 0, 512) blue led, call the function and set pwm duty to pin 7
tmr.delay(1000000)
led(0,512,0) green led, call the function and set pwm duty to pin 6
tmr.delay(1000000)
led(0,0,0) set 0 pwm duty to all the pins

function led(r, g, b)
pwm.setduty(8, r)
pwm.setduty(6, g)
pwm.setduty(7, b)
end
Upload the program to Nodemcu from ESPlorer and check the result, this will turn On and
Off a single LED at a time, much like turning On and Off a led.
Most of the function used for this examples are previously discussed, if you have any
doubts please check the previous chapters.
Connect to WiFi Router

In this chapter we will see how to establish connection between router and ESP8266.
Simple Program to connect to router and return the IP address:
wifi.setmode(wifi.STATION)
wifi.sta.config(Magesh, jayakumar)
print(ip)
Type the program type your router name in the place magesh and your password to the
place jayakumar thats my router id and password, save the file to ESP8266, this
function will return ip address that as currently connected to your home router.
Wifi.setmode(wifi.STATION)
This function configures the wifi mode to use in program, NodeMCU supports 4 modes,
Station mode, Access point, Station + Access point and the last one Wifi off. In the
above function wifi mode is set to STATION, station mode should be choose when the
device is connected to a WiFi router.

Wifi.sta.config(ssid, password)
This function sets the Wifi station configuration. Ssid is the router Name and password is
the router password.
Wifi.sta.getip()
This function returns the Ip address that is currently connected.
Ip = wifi.sta.getip()
Ip address is stored in the variable ip, print(ip) , the value stored in the variable will print
on the serial monitor.
Simple Web Server

In this chapter we will create a simple webserver. We going to use the functions from
the previous connect WiFi router chapter. If you havent gone through the chapter, take a
look and come back here.
Program for webserver
print(ip)
srv=net.createServer(net.TCP)
srv:listen(80,function(conn)
conn:on(receive,function(conn,payload)
print(payload)
conn:send(<h1> Congrats, you have created a WebServer </h1>)
end)
conn:on(sent,function(conn) conn:close() end)
end)
Type the above code in your ESPlorer IDE and Save it to ESP8266 chip
When you save the code to NodeMCU dev kit or ESP8266 device check on the serial
monitor of your ESPlorer, it will return the ip address it has currently connected.
If you have not saved the file name as Init, click on the run command in the ESPlorer
window.
Copy and paste the IP address in your browser.

wifi.sta.config(Magesh, jayakumar54321)
print(ip)
we have already seen what is the function of above code in the previous chapter, check it
before you proceed further.
This function creates a server, and the type of server we have to define there are two type
one is net.TCP and another one net.UDP

server listens on port 80, if data received, print data to console
print(payload)
received data will be displayed on the Serial monitor of ESPlorer.
conn:send(<h1> Congrats, you have created a WebServer </h1>)
Blink LED through Web Server

In this chapter we will see how to control a LED from a web server, we use NodeMCU
to connect to an access point, by connecting the Nodemcu to an access point we can set up
the NodeMCU as a wireless access point and host a webserver on NodeMCU, that allow
device to connect to it through TCP/IP, and we can access it from any devices which are
currently connected to local router. You should go through previous chapters to complete
this tutorial as we going to use codes that we see in the last chapter.
Connect your LED to 7th pin of NodeMCU and connect your NodeMCU to computer.
Open your ESPlorer and type the code which shown below, dont copy past the code if
you want to understand the inner meaning of program.
print(Attempting connection)
print(Connected on .. wifi.sta.getip())
wifi.sta.connect()
tmr.alarm(0, 1000, 1, checkWifiStatus)

gpio.mode(7, gpio.OUTPUT)
Lets start off with the light off

srv=net.createServer(net.TCP, 3)
print(Server created on .. wifi.sta.getip())
conn:on(receive,function(conn,request)
print(request)
_, j = string.find(request, led_light_switch=)
if j ~= nil then
command = string.sub(request, j + 1)
if command == on then
gpio.write(7, gpio.HIGH)
else
end
end
conn:send(<!DOCTYPE html>)
conn:send(<html lang=en>)
conn:send(<head><meta charset=utf-8 />)
conn:send(<title>Hello, World!</title></head>)
conn:send(<body><h1>Hello, World!</h1>)
Send the current status of the LED
if gpio.read(7) == gpio.HIGH then
led = ON
else
led = OFF
end
conn:send(<p>The light is .. led .. </p>)
conn:send(<form method=post>)
conn:send(<input type=radio name=led_light_switch value=on>ON</input>
<br />)
conn:send(<input type=radio name=led_light_switch value=off>OFF</input>
<br />)
conn:send(<input type=submit value=Light Switch />)
conn:send(</form></body></html>)
end)
end)
above program is the combination of Connect to wifi router and Simple web server, in this
program we have added code to create html functions, and also we retrieve data from the
webserver and check for the command received from the webserver, if the command
matches with our predefined command then it should do some particular function, we
assigned value to the led_light_switch when button ON clicked it will assign to on
and if the button off clicked off value will be assigned to led_light_switch, we have also
included in the program that if we receive value on we have to turn on the LED
connected to pin D7 else the pin should be turned off.
After completion of program upload the file to ESP8266, if you are not assigning the
name as init.lua you have hit the run button to read the file by ESP8266 device. Press the
reset button on NodeMCU after you uploaded the code to your device. Make note of the
IP address returned in the Serial monitor of ESPlorer.
Control Electrical devices from Webserver

This is the extended version of last chapter, the same program can be used for
controlling electrical appliances like AC lights, fans, heater, thermostat etc., can be
controlled from a webserver. If you can port forward your IP address then you can control
the devices from any part of the world through webpage. Your local webserver will act as
a minimal webpage to control and monitor your things from any part of the world.

You should have enough experience before you doing this tutorial practically, if you
planning to control devices of high voltage, you should take all the precautions and
necessary knowledge about working of these high voltage devices.
We going to use an electrical device called relay to Turn on and off electrical appliances,
there is no change in the programming part of this tutorial, it is same as we turn on and off
LED in the previous chapter, instead of connecting the output pin to the LED we have to
connect to the relay to turn on and off high voltage devices. Connect the relay pins to
5,6,7,8 digital pins of NodeMCU dev kit, and upload the program to ESP8266, wait for
the IP address returned by the device on serial monitor and paste the IP address on your
web browser and control your electrical devices.
Program to control Electrical devices.
wifi.sta.config(Magesh,jayakumar)
conn:on(receive, function(client,request)
local buf = ;
local _, _, method, path, vars = string.find(request, ([A-Z]+) (.+)?(.+) HTTP);
if(method == nil)then
_, _, method, path = string.find(request, ([A-Z]+) (.+) HTTP);
end
local _GET = {}
if (vars ~= nil)then
for k, v in string.gmatch(vars, (%w+)=(%w+)&*) do
_GET[k] = v
end
end
buf = buf..<h1> Web Server</h1>;
buf = buf..<p>LIGHT 1 <a href=\?pin=ON1\><button>ON</button></a>
<a href=\?pin=OFF1\><button>OFF</button></a></p>;

local _on,_off = ,
if(_GET.pin == ON1)then
gpio.write(5, gpio.HIGH);
elseif(_GET.pin == OFF1)then
gpio.write(5, gpio.LOW);
elseif(_GET.pin == ON2)then
end
client:send(buf);
client:close();
collectgarbage();
end)
end)

after successful upload of your code to NodeMCU you can check in your browser to get
hold of control your electrical devices.
Temperature and Humidity Sensor support in NodeMCU

NodeMCU for Lua natively supports DHTxx sensors, in this chapter we going to use
DHT22 as it is more accurate and stable when compare to the DHT11 for measuring
Temperature and Humidity.
Connect the sensor as shown in the fritzing circuit, connect VCC to Vin pin of NodeMCU
, connect the signal pin to D5 pin of NodeMCU and connect sensor Gnd to Gnd of
NodeMCU.
Program to read Temperature and Humidity
pin = 5
status,temp,humi,temp_decimial,humi_decimial = dht.readxx(pin)
if( status == dht.OK ) then
Integer firmware using this example
print(
string.format(
DHT Temperature:%d.%03d;Humidity:%d.%03d\r\n,
math.floor(temp),
temp_decimial,
math.floor(humi),
humi_decimial
)
)
Float firmware using this example
print(DHT Temperature:..temp..;..Humidity:..humi)
elseif( status == dht.ERROR_CHECKSUM ) then
print( DHT Checksum error. );

elseif( status == dht.ERROR_TIMEOUT ) then
print( DHT Time out. );
end
Save the file into ESP flash memory, and click run button this will execute the program
and temperature and humidity results will be displayed on Serial monitor of ESPlorer.
Note: Make sure you have selected integer type firmware during the initial stage when
uploading the firmware to NodeMCU. As this example uses integer firmware for
calculating temperature and humidity data.
If using float firmware then temp and humi are floating point numbers. On an integer
firmware, the final values have to be concatenated from temp and temp_dec / humi and
hum_dec.
OUTPUT:
DHT API
Constants:
dht.ok, dht.ERROR_CHECKSUM, dht.ERROR_TIMEOUT, these represents the
potential values for the DHT read status.

dht.read()
This function read all kinds of DHT sensors, including DHT11,21,22,33,44 humidity
temperature and combo sensor.

Syntax: dht.read(pin)
This function returns status as defined in constants and temperature and humidity data.

dht.read11()
This function read dht11 humidity and temperature data.

dht.readxx()
This function reads all kind of DHT sensors, except DHT11, hence if you want to read
DHT11 sensor data, you should use dht.read11() function.

DHT11 sensor with NodeMCU
Program for DHT11 Sensor

pin = 5
status,temp,humi,temp_decimial,humi_decimial = dht.read11(pin)

print(
string.format(
math.floor(temp),
temp_decimial,
math.floor(humi),
humi_decimial
)
)
Float firmware using this example
print(DHT Temperature:..temp..;..Humidity:..humi)
elseif( status == dht.ERROR_CHECKSUM ) then
print( DHT Checksum error. );
elseif( status == dht.ERROR_TIMEOUT ) then
print( DHT Time out. );
end

OUTPUT:
Sensors Data To Thingspeak

ThingSpeak is an open source Internet of Things application and API to store and
retrieve data from things using HTTP over the Internet or via a Local Area Network.
With ThingSpeak, you can create sensor logging applications, location tracking
applications, and a social network of things with status updates. In this tutorial you going
to learn about how temperature data can be uploaded to thingspeak.com using Nodemcu.
We going to use only two components for this tutorial one is Nodemcu and other one is
DHT11 temperature and humidity sensor, One more thing you need to do for this tutorial
is to register to thingspeak.com to get your api key, the api key must to upload your data to
thingspeak.com

Steps to be followed to upload data to thingspeak.
1. Go to https://thingspeak.com/
2. Log in with your ID and Password.

3. Click the Create New channel Icon

4. Give Name to your new channel and edit the description for your channel and create the
Names for your field, fields are going to hold the sensor datas, if your uploading
temperature data give the name as temperature to the field and choose how many field you
require for your project.
5. After completing the above steps save your channel.

6. Go to API keys and copy the Write API key.

Replace the key with the newly created key.

Program to send Temperature and Humidity data to Thingspeak.com
print(Setting up WIFI)
wifi.sta.connect();

pin = 5

function getTemp()
status,temp,humi,temp_decimial,humi_decimial = dht.read11(pin)
print(
string.format(
math.floor(temp),
temp_decimial,
math.floor(humi),
humi_decimial
)
)

end
end

function sendData()
getTemp();
conection to thingspeak.com
print(Sending data to thingspeak.com)
conn=net.createConnection(net.TCP, 0)
conn:on(receive, function(conn, payload) print(payload) end)
api.thingspeak.com 184.106.153.149
conn:connect(80,184.106.153.149)
conn:send(GET
/update?
key=DBKBFHIR0L020NIQ&field1=..temp.....temp_decimial..&field2=..humi.....humi_d
HTTP/1.1\r\n)
conn:send(Host: api.thingspeak.com\r\n)
conn:send(Accept: */*\r\n)
conn:send(User-Agent: Mozilla/4.0 (compatible; esp8266 Lua; Windows NT 5.1)\r\n)
conn:send(\r\n)
conn:on(sent,function(conn)
print(Closing connection)
conn:close()
end)
conn:on(disconnection, function(conn)
print(Got disconnection)
end)
end
sendData();
send data every X ms to thing speak
tmr.alarm(2, 60000, 1, function() sendData() end )

before uploading the program to NodeMCU dev kit make sure to edit wifi name and
password and also the API key that you copied from Thingspeak.com , save the file as
init.lua and upload to NodeMCU dev kit.
You can check on your Serial monitor, when your Nodemcu trying to establish
communication with your router and send Temperature and Humidty data to
Thingspeak.com
If you getting any trouble during the process make sure to check whether you have entered
correct API key, if NodeMCU facing any trouble communicating with ESPlorer
disconnect and reconnect it this solve the problem.

Working with I2C device.

The Inter-integrated Circuit (I2C) Protocol developed by Philips and is a protocol
intended to allow multiple slave digital integrated circuits (chips) to communicate
with one or more master chips. Like the Serial Peripheral Interface (SPI), it is a twowire protocol where you can hook up multiple slaves to the same communication lines in
any order you want, since all the slaves are given an unique ID to keep track of them,
keeping track of the communication is the master job so no more than one slave can
communicate at a time. In the case of this example, we only have two devices, the
nodemcu which will be acting as a master and the LCD acting as a slave, this protocol
only intended for short distance communications within a single device. Like
Asynchronous Serial Interfaces (such as RS-232 or UARTs), it only requires two signal
wires to exchange information.
I2C API
i2c.address()
This functions setup I2C address and read/ write mode for the next transfer of data from
sensor.
Syntax: i2c.address(id,device_addr, direction)
id in the function should always be 0, followed by device_addr this you can find in the
device data sheet, and the device address followed by the direction either transmit data
(i2c.TRANSMITTER) that is writing mode or receive data (i2c.RECEIVER) also know
an reading mode.

i2c.read()
This function read number of bytes available in the i2c device that is currently called to
read by this function.
Syntax: i2c.read(id, len)
Id should always be 0 and it should be followed by the number of data bytes to read.
Thing function string of received data.

i2c.setup()
This function initialize the i2c function, this will let know the compiler that i2c function
is going to use in the program.
Syntax: i2c.setup(id, pinSDA, pinSCL, speed)
Id should always be 0, any pin from 0-12 can be used as SDA, and same as SDA any pin
can be used as SCL pin, make sure you are choosing different pins for SCL and SDA,
and speed of the i2c should be select i2c.slow that is the only function supported by the
nodemcu currently.

i2c.start()
This function send an i2c start condition.
Syntax: i2c.start(id)
Id should always be zero.

i2c.stop()
This function stops the i2c function, this function should always call when you complete
the i2c communication with device gets over.

i2c.write()
Write data to i2c bus, data items can be multiple numbers, strings or lua tables.
Syntax: i2c.write(id, data1, data2, .datan)
Id should always be zero, any data can be write into the bus.

I2C Temperature and Pressure Sensor

In this section we will see how to use a BMP085 pressure and temperature sensor with
NodeMCU dev kit, in NodeMCU it has a prebuilt library for this sensor, and this library
can also work with BMP180 type sensor.
Connect the BMP180 or BMP085 sensor to NodeMCU dev kit as follows.

SDA to D5 pin and SCL to D6 pin. Gnd to Gnd and Vcc pin to 3.3v of Nodemcu dev
kit.

Program to read Temperature data:
bmp085.init(5, 6)
local t = bmp085.temperature()
print(string.format(Temperature: %s.%s degrees C, t / 10, t % 10))
Program to read Pressure data:
bmp085.init(5, 6)
local p = bmp085.pressure()
print(string.format(Pressure: %s.%s mbar, p / 100, p % 100))

Program explanation:
Bmp085.init(5,6)
This function initialize the module and sets the pin configuration, 5 is the SDA pin and 6
is the SCL pin , any pin from 0 to 12 can be configured for SCA and SCL

Bmp.085.temperature()
This function samples the sensor and returns the temperature in Celsius as an integer
multiplied with 10(integer)

Bmp085.pressure()
This function samples the sensor and returns the pressure in Pascal as an integer.

The predefined library that comes with Nodemcu firmware will not give appropriate
results at times, which become a frustration when we need the most, when we call the
function it returns error to avoid that we can use a library for this function which is
available in the link here
Temperature and Pressure Sensor Web server

In this section we will create a temperature and pressure sensor webserver using the
library which we downloaded for BMP180 sensor in the previous section.
Use the same circuit connection in the previous section for this tutorial.
Library file for BMP180 or BMP085 sensor
***************************************************************************
BMP180 module for ESP8266 with nodeMCU
BMP085 compatible but not tested
Written by Javier Yanez
MIT license, http://opensource.org/licenses/MIT
***************************************************************************

local moduleName =
local M = {}
_G[moduleName] = M

local ADDR = 0x77 BMP180 address
local REG_CALIBRATION = 0xAA
local REG_CONTROL = 0xF4
local REG_RESULT = 0xF6

local COMMAND_TEMPERATURE = 0x2E
local COMMAND_PRESSURE = {0x34, 0x74, 0xB4, 0xF4}

calibration coefficients
local AC1, AC2, AC3, AC4, AC5, AC6, B1, B2, MB, MC, MD

temperature and pressure
local t,p

local init = false

i2c interface ID
local id = 0

16-bit twos complement
value: 16-bit integer
local function twoCompl(value)
if value > 32767 then value = -(65535 - value + 1)
end
return value
end

read data register
reg_addr: address of the register in BMP180
lenght: bytes to read
local function read_reg(reg_addr, length)
i2c.start(id)
i2c.address(id, ADDR, i2c.TRANSMITTER)
i2c.write(id, reg_addr)
i2c.stop(id)
i2c.start(id)
i2c.address(id, ADDR,i2c.RECEIVER)
c = i2c.read(id, length)
i2c.stop(id)
return c
end

write data register
reg_addr: address of the register in BMP180

reg_val: value to write to the register
local function write_reg(reg_addr, reg_val)
i2c.start(id)
i2c.address(id, ADDR, i2c.TRANSMITTER)
i2c.write(id, reg_addr)
i2c.write(id, reg_val)
i2c.stop(id)
end

initialize module
sda: SDA pin
scl SCL pin
function M.init(sda, scl)
i2c.setup(id, sda, scl, i2c.SLOW)
local calibration = read_reg(REG_CALIBRATION, 22)

AC1 = twoCompl(string.byte(calibration, 1) * 256 + string.byte(calibration, 2))
AC4 = string.byte(calibration, 7) * 256 + string.byte(calibration, 8)
B1 = twoCompl(string.byte(calibration, 13) * 256 + string.byte(calibration, 14))
B2 = twoCompl(string.byte(calibration, 15) * 256 + string.byte(calibration, 16))
MB = twoCompl(string.byte(calibration, 17) * 256 + string.byte(calibration, 18))
MC = twoCompl(string.byte(calibration, 19) * 256 + string.byte(calibration, 20))
MD = twoCompl(string.byte(calibration, 21) * 256 + string.byte(calibration, 22))

init = true
end

read temperature from BMP180
local function read_temp()
write_reg(REG_CONTROL, COMMAND_TEMPERATURE)
tmr.delay(5000)
local dataT = read_reg(REG_RESULT, 2)
UT = string.byte(dataT, 1) * 256 + string.byte(dataT, 2)
local X1 = (UT - AC6) * AC5 / 32768
local X2 = MC * 2048 / (X1 + MD)
B5 = X1 + X2
t = (B5 + 8) / 16
return(t)
end

read pressure from BMP180
must be read after read temperature
local function read_pressure(oss)
write_reg(REG_CONTROL, COMMAND_PRESSURE[oss + 1]);
tmr.delay(30000);
local dataP = read_reg(0xF6, 3)
local UP = string.byte(dataP, 1) * 65536 + string.byte(dataP, 2) * 256 + string.byte(dataP,
1)
UP = UP / 2 ^ (8 - oss)
local B6 = B5 - 4000
local X1 = B2 * (B6 * B6 / 4096) / 2048
local X2 = AC2 * B6 / 2048
local X3 = X1 + X2
local B3 = ((AC1 * 4 + X3) * 2 ^ oss + 2) / 4
X1 = AC3 * B6 / 8192
X2 = (B1 * (B6 * B6 / 4096)) / 65536
X3 = (X1 + X2 + 2) / 4
local B4 = AC4 * (X3 + 32768) / 32768
local B7 = (UP - B3) * (50000/2 ^ oss)

p = (B7 / B4) * 2
X1 = (p / 256) * (p / 256)
X1 = (X1 * 3038) / 65536
X2 = (-7357 * p) / 65536
p = p +(X1 + X2 + 3791) / 16
return (p)
end

read temperature and pressure from BMP180
oss: oversampling setting. 0-3
function M.read(oss)
if (oss == nil) then
oss = 0
end
if (not init) then
print(init() must be called before read.)
else
read_temp()
read_pressure(oss)
end
end;

get temperature
function M.getTemperature()
return t
end

get pressure
function M.getPressure()
return p
end

return M

Copy and paste the library file save the file as bmp180.lua and upload the file to Nodemcu
dev kit.
We have already created a webserver for controlling an LED in the past tutorials, this
webserver will display the Temperature and Pressure data, and we can view this by
looking into the Ip address of the webserver that is returned during the program.
Program for Temperature and Pressure Webserver
**************************************************************
alti=170 set correction for your altitude location in meters
**************************************************************

wifi.sta.connect()
print(Connected on .. wifi.sta.getip())
sda=2 GPIO2 connect to SDA BMP180
scl=1 GPIO0 connect to SCL BMP180
pres=0 pressure
temp=0 temperature
fare=0 temperature
oss=0 over sampling setting

load BMP module for reading sensor
function ReadBMP()
bmp180 = require(bmp180)
bmp180.init(sda, scl)
bmp180.read(oss)
pres = bmp180.getPressure()/100+alti/8.43
temp = bmp180.getTemperature()/10
fare=(temp*9/5+32)
print(Pressure: ..string.format(%.1f,pres).. hPa)
print(Temperature: ..string.format(%.1f,temp).. deg C)
print(Temperature: ..string.format(%.1f,fare).. deg F)
print( )
release module
bmp180 = nil
package.loaded[bmp180]=nil
end
First reading data
ReadBMP()
Periodic reading of the sensor
tmr.alarm(1,10000,1, function()ReadBMP()end)

conn:on(receive,function(conn,payload)
print(payload) for debugging only
strstr={string.find(payload,GET / HTTP/1.1)}
if(strstr[1]~=nil)then
generates HTML web site
conn:send(HTTP/1.1 200 OK\r\nConnection: keep-alive\r\nCache-Control: private,
no-store\r\n\r\n\
<!DOCTYPE HTML>\
<html><head><meta content=text/html;charset=utf-8><title>ESP8266</title>\
<meta http-equiv=refresh content=10;url=/></head>\
<body bgcolor=#ffe4c4><h2>Barometer with I2C sensor<br>BMP180 or
BMP85</h2>\
<h3><font color=green>\
<IMG SRC=http://esp8266.fancon.cz/bmp180/bar.gifWIDTH=64HEIGHT=64>
<br>\
<input
style=text-align:
centertype=textsize=6
name=jvalue=..string.format(%.1f,pres)..> Atmos. pressure hPa<br><br>\

<IMG
SRC=http://esp8266.fancon.cz/bmp180/tmp.gifWIDTH=64HEIGHT=64><br>\
<input
style=text-align:
name=pvalue=..string.format(%.1f,temp)..> Temperature grade C<br>\
<input
style=text-align:
name=svalue=..string.format(%.1f,fare)..> Temperature grade F</font></h3>\
<h6>Tested with Lua NodeMCU<br> 0.9.6 build 20150704 float!</h6>)
end
conn:on(sent,function(conn) conn:close() end)
end)
end)
Save the above program as init.lua file, first you should save the library file to NodeMCU
dev kit, then upload the init file. Make sure to edit your router name and password in the
program, you can also change the altitude based on the region, after uploading both
program press the reset button on the NodeMCU module.
After uploading two files to NodeMCU dev kit you can see the message like the one
attached above on your ESPlorer serial monitor. Copy the IP address and paste on your
browser.

You can open your browser to check your Temperature and Humidity data, Images in the
web browser are served from external sources you can use some other images to look
more attractive.
Lua basics
Variables
Variable names must be single words containing only characters, numbers or underscores.
They can be local or global. As Lua is type free, there is no need to specify a type before
the variable name (as in C languages). Lua supports the following variable types;
Numbers
As Lua is type free, you do not need to worry about ints or floats etc. Lua will handle the
precision as needed.
For negatives, use the -(minus) character BEFORE the number.
For decimals, use the .(dot) character at the decimal place, NOT the ,(comma)
character.
Strings
Strings, (a string). Using double or single quotes is fine, but end with the same one as
started with.
ESCAPE Sequence
Use
\a
Bell
\b
Backspace
\f
Formfeed
\n
New line
\r
Carriage return
\t
Tab
\v
Vertical tab
Backslash
Double quotes
Single quotes
Left square bracket
Right square bracket

String Methods
String.upper(argument)
Returns a capitalized representation

of the argument
String.lower(argument)
Returns a lower case representation

of the argument
String.gsub(mainString,
replaceString)
String.strfind(mainStr,
StartInd, EndInd)
finString, Returns a string by replacing

occurances of findingString with
replaceString
findStr, Returns the start index and end index
of the string in the main string and
nil if not found
String.reverse(arg)
Returns a string by reversing the

characters of the passed string.
String.format()
Returns a formatted string
String.char(arg)and stringbyte(arg)
Returns internal numeric and

character representations of input
argument
String.rep(string,n)
Returns a string by repeating the

same string n number of times
..
Thus operator concatenates two

strings.
Boolean
Boolean , a true of false variable. The keywords are lower case true and false4
nil
Nil means nothing, and as such you will get it back whenever you call something that
doesnt exist.
nil can be used to destroy a variable as well, in the following manner;
killMe = nil
Lua garbage collector will free the memory up on its next pass.
Operators/ conditionals
Arithmetic
Operator
Description
Addition
Subtraction
Multiplication
division
Modus operator
Exponent operator

Logical
Operator
Description
And
Logical AND operator ( A: &&)
Or
Logical OR operator (A: ||)
Not
Logical NOT operator (A:~)

Relational
Operator
Description
==
True if the value of the two operands

are the same
~=
True if the value of two operands are

different
>
True if the value of left operand is

greater than the value of right
operand
<
True if the value of the left operand

is less than the value of the right
operand
>=
True if the value of the left operand

is greater than or equal to the value
of right operand.
<=
True if the value of left operand is

less than or equal to the value of
right operand.
If statements
If a = = 1 then
logic
Elseif op ==2 then
logic.
Else
..logic..
End
Loops
While loop
While (true)
do
print(Nodemcu)
end

For loop
for i=10,1,-1
do
print(i)
end
lua has a for iterator, which will simply iterate, it takes 3 parameters
1) The starting or counter usually followed by a variable in the above example it is
i=10
2) The end place inclusive, given as a number.
3) The incremental operator, how much the initial counter should increase or
decrease
Functions
Function sum(num1,num2)
return num1+num2
end
function has the ability to assign pass variable to and fro in the program, you dont need to
write certain steps repetitive in the program.

Example:
Function multiply(num1, num2, fun)
a = 0
for i=num2, i, -1
do
a = a + fun(num1, num1)
end
return a
end
function calling
func = sum ()
a = multiply(2,2,func)
Getting Started on OSX (solution by NodeMCU)

Getting started with NodeMCU devkit on OSX, if you are using NodeMCU it uses a serial
driver from SiLabs you need to download it , if you have used any Arduino clones before
you would have known about this serial driver chip software , it can be downloaded from
the link here.
ESPlorer works well with OSX, apart from that there are many other software you can use
it.
To flash the firmware you need special flags:
Download the nodemcu firmware,
Install esptool:
Follow the command in your terminal window.
git clone https://github.com/themadinventor/esptool.git
cd esptool
sudo python ./setup.py install

Hold down the FlASH button on the device and hit theRST button while doing so.
Substituing in the correct path to the firmware file you downloaded, run
python ./esptool.py port=/dev/cu.SLAB_USBtoUART write_flash -fm=dio -fs=32m 0x00000 ../nodemcu-master-8modules-2015-09-01-02-42-13-float.bin

Unplug the device and replug it.
Port Forwarding Example

We have seen how to control and upload data to webserver, when you are accessing data
from webserver it can be done only when your device are connected to same access point,
what if you want to control and access data from any part of the world, you need to do
port forwarding your IP address so that you can control and access your ESP8266 or
Nodemcu from any part of the world.
For this example I am using TP-Link router, I use this modem for my Wi-Fi, if you are
using different router you can check it out to know how to port forward with your router,
if you are using the same router then you can follow this tutorial.
Step 1: Log into the routers web management page: This can be done by typing
192.168.0.1 in your browser and type admin and admin for user name and password.
Step 2: Click forwarding > Virtual servers on the left side, and then click add new button
Step 3: after clicking the Add new button, Add or Modify a virtual Server Entry page will
be opened , in this you have to enter the details of Service port, Internal Port, Ip address
Service port is the Server port number you have entered in the Lua program, usually this
will be 80 by default,
leave the internal port blank and type the IP address as the ESP8266 connected with your
router this is the IP address each time when a ESP8266 connected to your router leave a
local IP which can be find from the serial monitor.

Click the Save button to save the setting you have done previously
Step 5: Go to Status Page and check the WAN IP Address of the router. Copy the WAN IP
and port number to access the service from outside the network. Now you can access your
ESP8266 from any part of the world, you can control your Home lights from anywhere by
calling the IP address in your web browser or mobile browser.
For the above example I used port number 80 which is the default number for my router
management, which should be changed to use the port number 80 by the ESP8266 this can
be done by clicking the Security tab on the left side of the router management page.
If the WAN IP Address of the router is not a public IP Address, but a Private IP Address,
that means there is another NAT device connected to the WAN Port of the TP-LINK
router, you need open the service ports on that device as well.

Building Custom Firmware for NodeMCU

Nodemcu firmware which consist of all the functions in some cases we never require all
the functional capabilities of the NodMCU in such cases, external community members
have built a website where anyone can build a custom firmware by choosing their required
API for their project.
Go to website http://nodemcu-build.com/
Select the modules that you want to include in the custom firmware for your project.
Click on the start build button on the bottom of the page, NodeMCU dev kits may come
with 4MB memory flash, if you are using other generic devices it will run out of the
memory if we use all of the modules.
Components Need for this book

Esp8266 development kit or Nodemcu or any other development kit using Esp8266
LED
RELAY
BMP180 (I2C) sensor
DHT22 Temperature and humidity sensor
DHT11 Temperature and humidity sensor

Contact
For suggestions and queries you can always mail me at jayakumarmagesh@gmail.com
all the code and necessary documents for this book can be find here.

How To Program ESP8266 in Lua Getting Started With ESP8266 (NodeMCU Dev Kit) in Lua - Magesh Jayakumar

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

How To Program ESP8266 in Lua Getting Started With ESP8266 (NodeMCU Dev Kit) in Lua - Magesh Jayakumar

Hochgeladen von

Copyright:

Verfügbare Formate

Table

Temperature and Humidity Sensor support in NodeMCU

ESP8266 application subject

Flashing ESP8266 or Nodemcu with latest lua firmware

Getting Started With ESPlorer

This functions allow to choose COM port

Nodemcu API for Lua

Nodemcu dev kit

bit.isset() : This function will test if a given bit is set or not.

Hardware reset via reset pin

WDT reset (watchdog timeout)

Hardware watchdog reset

Software watchdog reset

Wake from deep sleep

It returns rawcode, reason [, exccause, epc1, epc2, epc3, excvaddr, depc]

Typical Power Usage

Tx802.11b, CCK 11Mbps, P OUT= 170mA

station to a different SSID first, then connect to the desired SSID

currently connected to the router.

Port is the port number and ip address or domain name string

This function executes a HTTP PUT request

Turn On and OFF an LED

as you can see in your LED it has two

Lua program explanation:

Working with LED

Using the PWM function for the LED

RGB LED with NodeMCU

Connect to WiFi Router

Simple Web Server

Copy and paste the IP address in your browser.

conn:send(<h1> Congrats, you have created a WebServer </h1>)

Blink LED through Web Server

Control Electrical devices from Webserver

buf = buf..<p>LIGHT 3 <a href=\?pin=ON3\><button>ON</button></a>&nbsp;

Temperature and Humidity Sensor support in NodeMCU

print( DHT Checksum error. );

Program for DHT11 Sensor

Integer firmware using this example

Sensors Data To Thingspeak

5. After completing the above steps save your channel.

Replace the key with the newly created key.

Working with I2C device.

the i2c communication with device gets over.

I2C Temperature and Pressure Sensor

Connect the BMP180 or BMP085 sensor to NodeMCU dev kit as follows.

Temperature and Pressure Sensor Web server

Written by Javier Yanez

MIT license, http://opensource.org/licenses/MIT

reg_addr: address of the register in BMP180

local B7 = (UP - B3) * (50000/2 ^ oss)

name=jvalue=..string.format(%.1f,pres)..> Atmos. pressure hPa<br><br>\

Left square bracket

Right square bracket

Returns a capitalized representation

Returns a lower case representation

finString, Returns a string by replacing

Returns a string by reversing the

Returns a formatted string

Returns internal numeric and

Returns a string by repeating the

Thus operator concatenates two

Logical AND operator ( A: &&)

Logical OR operator (A: ||)

buf = buf..<p>LIGHT 3 <a href=\?pin=ON3\><button>ON</button></a>