Tag Archives: wifi

Compilation, Development, Software

ESP32 – IDF Sdk with Eclipse

2019-04-29 admin

After configuring the IDF development environment in the previous article

ESP32 – IDF Sdk

let’s see now how to use Eclipse as IDE for code development. Instructions are available at the link

Eclipse Setup

Download the C/C++ Eclipse for Linux

Eclipse Download

Unpack the file and move it to /opt/

tar -zxvf eclipse-cpp-2019-03-R-linux-gtk-x86_64.tar.gz
sudo mkdir /opt 
sudo mv eclipe /opt/

tar -zxvf eclipse-cpp-2019-03-R-linux-gtk-x86_64.tar.gz

sudo mkdir /opt

sudo mv eclipe /opt/

Run ecplise

/opt/eclipse/ecplise

1	/opt/eclipse/ecplise

Set the workspace for eclipse

Once the IDE is open, select File -> Import -> C / C ++ – -> Existing Code as Makefile Project

Press Next; on the next screen select the folder containing the Makefile of a sample project in the “Existing Code Location” field and choose CrossGcc as “Toolchain for indexer settings” as shown below

Once the project is loaded, using the mouse right button on the project name, select the properties option

Under C / C ++ Build -> Envinronment add the variable

BATCH_BUILD = 1

1	BATCH_BUILD = 1

Add the IDF_PATH variable pointing to the downloaded IDF SDK in the same section

IDF_PATH=~/Esp32/espressif/esp-idf

1	IDF_PATH=~/Esp32/espressif/esp-idf

Edit the PATH variable and add the path to the bin folder of the cross compiler /home/sviluppo/Esp32/espressif/esp/xtensa-esp32-elf/bin

Access “C / C ++ General” -> “Preprocessor Include Paths”; choose the Providers tab and click on “CDT Cross GCC Built-in Compiler Settings”

Replace $ {COMMAND}

with xtensa-esp32-elf-gcc

Choose now, always in the providers section, “CDT GCC Build Output Parser”

and insert at the beginning of the “Compiler command pattern” xtensa-esp32-elf-

Save the configurations.

The project settings should always be made by make menuconfig in the unix shell. Access the shell and set the LED to be switched on/off the value 2 as GPIO; this is because in our case the card is a doit whose design is illustrated in this document

SchematicsforESP32

cd ~/Esp32/espressif 
export PATH=$PATH:$HOME/Esp32/espressif/esp/xtensa-esp32-elf/bin 
export IDF_PATH=~/Esp32/espressif/esp-idf 
cd projects/blink 
make menuconfig

cd ~/Esp32/espressif

export PATH=$PATH:$HOME/Esp32/espressif/esp/xtensa-esp32-elf/bin

export IDF_PATH=~/Esp32/espressif/esp-idf

cd projects/blink

make menuconfig

Access to Example configuration

and set the gpio value to 2

Save the configuration. Go back to Eclipse and proceed with cleaning with

and subsequent compilation with Project -> Build

To run firmware flash from eclipse;, select the project and with the right button choose Build Targets -> Create …

Enter flash as value in the target name field, leaving everything else as default

At this point we proceed to upload the image by double-clicking on the new flash item within the project targets

The settings to run the flash must be set with make menuconfig, as seen in the previous article

ESP32 – IDF Sdk

Compilation, Software

ESP32 – IDF Sdk

2019-04-07 admin

This article describes how to set the Espressif development environment for the ESP32.

From the link to the resources for the soc

https://www.espressif.com/en/products/hardware/esp32/resources

we access the guide for compiling the firmware on the Windows, OSX and Linux platforms

http://esp-idf.readthedocs.io/en/latest/get-started/index.html

In this article we use Linux Debian 9 as operating system, configured as described previously here

MicroPython – Python ib embedded devices

We use the IDF github. On Debian 9, with the user used to connect to the system, we create the Esp32 folder under the user’s Home and the espressif folder inside it

cd
mkdir Esp32
cd Esp32
mdkir espressif
cd espressif

mkdir Esp32

cd Esp32

mdkir espressif

cd espressif

Install the prerequisites

sudo apt-get install git wget make libncurses-dev flex bison gperf python python-serial

1	sudo apt-get install git wget make libncurses-dev flex bison gperf python python-serial

Download the cross compiler

wget https://dl.espressif.com/dl/xtensa-esp32-elf-linux64-1.22.0-80-g6c4433a-5.2.0.tar.gz

1	wget https://dl.espressif.com/dl/xtensa-esp32-elf-linux64-1.22.0-80-g6c4433a-5.2.0.tar.gz

Create the esp folder and unpack the toolchain

mkdir esp 
cd esp 
tar -zxvf ../xtensa-esp32-elf-linux64-1.22.0-80-g6c4433a-5.2.0.tar.gz

mkdir esp

cd esp

tar -zxvf ../xtensa-esp32-elf-linux64-1.22.0-80-g6c4433a-5.2.0.tar.gz

Add the bin folder of the cross compiler to the PATH

export PATH=$PATH:$HOME/Esp32/espressif/esp/xtensa-esp32-elf/bin

1	export PATH=$PATH:$HOME/Esp32/espressif/esp/xtensa-esp32-elf/bin

Add the user used for the operations to the dialout group

sudo usermod -a -G dialout USER

1	sudo usermod -a -G dialout USER

Clone the IDF repository from $HOME/Esp32/espressif

cd $HOME/Esp32/espressif
git clone --recursive https://github.com/espressif/esp-idf.git

1 2	cd $HOME/Esp32/espressif git clone --recursive https://github.com/espressif/esp-idf.git

Add the IDF_PATH environment variable

export IDF_PATH=~/Esp32/espressif/esp-idf

1	export IDF_PATH=~/Esp32/espressif/esp-idf

Create the project folder under $HOME/Esp32/espressif and copy an example from di IDF examples

cd $HOME/Esp32/espressif
mkdir projects
cd projects
cp -r $IDF_PATH/examples/get-started/hello_world . 
cd hello_world

cd $HOME/Esp32/espressif

mkdir projects

cd projects

cp -r $IDF_PATH/examples/get-started/hello_world .

cd hello_world

Run the configuration

make menuconfig

1	make menuconfig

Access Serial flasher config -> and set the connection parameters; in our case we leave the default

Save the configuration and build the firmware

make

make

To upload the firmware on the device run

make flash

1	make flash

To upload only the application run

make app-flash

1	make app-flash

while to build only the application run

make app

make app

To run the program monitor run

make monitor

1	make monitor

Here are the other examples available with sdk

https://github.com/espressif/esp-idf/tree/f586f5e/examples

The following link contains the references of the IDF API

http://esp-idf.readthedocs.io/en/latest/api-reference/index.html

You can also generate documentation from the github source. Go into ~/Esp32/espressif/esp-idf/docs/en

cd ~/Esp32/espressif/esp-idf/docs/en

1	cd ~/Esp32/espressif/esp-idf/docs/en

Install the prerequisites

sudo apt-get install python-pip python-sphinx doxygen

1	sudo apt-get install python-pip python-sphinx doxygen

sudo pip install sphinx_rtd_theme breathe sphinxcontrib.blockdiag sphinxcontrib.seqdiag sphinxcontrib.actdiag sphinxcontrib.nwdiag recommonmark

1	sudo pip install sphinx_rtd_theme breathe sphinxcontrib.blockdiag sphinxcontrib.seqdiag sphinxcontrib.actdiag sphinxcontrib.nwdiag recommonmark

Generate documentantion in html format

make html

make html

The documentation is available under _build / html.

In the next article we will configure Eclipse as IDE to build our applications

ESP32 -IDF Sdk with Eclipse

Compilation, Software

ESP32 – Nodemcu firmware compiling

2018-08-17 admin

After the compilation of the MicroPython firmware for ESP32

ESP32 – MicroPython compiling for ESP32

this article shows how to generate the Nodemcu firmware for the ESP32 MCU.

The firmware is not yet complete as the one existing for ESP8266.

The instructions can be found on the github at the link

https://github.com/nodemcu/nodemcu-firmware/tree/dev-esp32

The compilation documentation is available at the link

https://nodemcu.readthedocs.io/en/dev-esp32/en/build/

The operating system used is Debian 9 previously encountered for the esptool and Adafruit-ampy utilities

MicroPython – Python on embedded devices

Log on with the operating system user on Debian 9, sviluppo in our case; under the home folder create the Esp32 folder and inside this folder the nodemcu folder

cd
mkdir Esp32
cd Esp32
mkdir nodemcu
cd nodemcu

mkdir Esp32

cd Esp32

mkdir nodemcu

cd nodemcu

Clone the repository

git clone --branch dev-esp32 --recurse-submodules https://github.com/nodemcu/nodemcu-firmware.git nodemcu-firmware-esp32

1	git clone --branch dev-esp32 --recurse-submodules https://github.com/nodemcu/nodemcu-firmware.git nodemcu-firmware-esp32

To update the cloned repository follow the description on the compilation link, i.e.

cd nodemcu-firmware-esp32 
git pull origin dev-esp32 
git submodule init #only if repo was cloned w/o submodules init 
git submodule update --recursive

cd nodemcu-firmware-esp32

git pull origin dev-esp32

git submodule init #only if repo was cloned w/o submodules init

git submodule update --recursive

Go into nodemcu-firmware-esp32 folder and run

cd nodemcu-firmware-esp32
make menuconfig

1 2	cd nodemcu-firmware-esp32 make menuconfig

Enable the bluetooth in Component config–>Bluetooth

Enable various modules in Component config–>Nodemcu modules

In the flash settings we set the default values for our ESP32, Serial flasher config->

Save the configuration and exit. To build the firmware run

make

make

At the end of the compilation the command to upload the firmware is shown; the same operation is executed by simply running

make flash

1	make flash

For informations about the partitions of the various ESP32 versions, refer to the documentation

http://api-guides/partition-tables.html

In the next article we’ll show how to make an application using the Espressif SDK

ESP32 – IDF Sdk

Compilation, Software

ESP32 – MicroPython compiling for ESP32

2018-08-08 admin

We begin now a series of articles about the Espressif ESP32 MCU

ESP32 Wifi-Bluetooth Module

After having analyzed in the previous articles MicroPython for ESP8266, in this we start to treat MicroPython on ESP32.

The following shows how to generate the MicroPython image from the source code for the ESP32 board.

The operating system is Debian 9, previously encountered for the esptool and Adafruit-ampy utilities

MicroPython – Python on embedded devices

Log on with the operating system user on Debian 9, sviluppo in our case; under the home folder create the Micropython folder and inside this folder the esp32 folder

mkdir Micropython
cd Micropython
mkdir esp32
cd esp32

mkdir Micropython

cd Micropython

mkdir esp32

cd esp32

The MicroPython source code is available at the following link

Github Micropython

Instructions to build the firmware for the ESP32 are available at the link

MicroPython esp32

Clone the repository

git clone https://github.com/micropython/micropython

1	git clone https://github.com/micropython/micropython

Go into micropython/ports/esp32 folder

cd micropython/ports/esp32

1	cd micropython/ports/esp32

Run

make

make

The command releases the git hash for the supported espidf

At the time of our compilation the result is as follows

sviluppo@debian9:~/Micropython/esp32/micropython/ports/esp32$ make
Use make V=1 or set BUILD_VERBOSE in your environment to increase build verbosity.
The ESPIDF variable has not been set, please set it to the root of the esp-idf repository.
See README.md for installation instructions.
Supported git hash: 3ede9f011b50999b0560683f9419538c066dd09e
Makefile:34: *** ESPIDF not set.  Stop.

sviluppo@debian9:~/Micropython/esp32/micropython/ports/esp32$ make

Use make V=1 or set BUILD_VERBOSE in your environment to increase build verbosity.

The ESPIDF variable has not been set, please set it to the root of the esp-idf repository.

See README.md for installation instructions.

Supported git hash: 3ede9f011b50999b0560683f9419538c066dd09e

Makefile:34: *** ESPIDF not set. Stop.

Go into /home/sviluppo/Micropython/esp32 folder and clone ESPIDF

git clone https://github.com/espressif/esp-idf.git
cd esp-idf

1 2	git clone https://github.com/espressif/esp-idf.git cd esp-idf

Checkout with the hash obtained above

git checkout 3ede9f011b50999b0560683f9419538c066dd09e

1	git checkout 3ede9f011b50999b0560683f9419538c066dd09e

Run

git submodule update --init

1	git submodule update --init

We follow the instructions at the link

Cross compiler

to install the cross compiler; install the prerequisites for building

sudo apt-get install git wget make libncurses-dev flex bison gperf python python-serial

1	sudo apt-get install git wget make libncurses-dev flex bison gperf python python-serial

Download the cross compiler

cd /home/sviluppo/Micropython/esp32
wget https://dl.espressif.com/dl/xtensa-esp32-elf-linux64-1.22.0-80-g6c4433a-5.2.0.tar.gz

1 2	cd /home/sviluppo/Micropython/esp32 wget https://dl.espressif.com/dl/xtensa-esp32-elf-linux64-1.22.0-80-g6c4433a-5.2.0.tar.gz

Create the esp folder under /home/sviluppo/Micropython/esp32

cd /home/sviluppo/Micropython/esp32
mkdir esp
cd esp

cd /home/sviluppo/Micropython/esp32

mkdir esp

cd esp

Unpack the cross compiler in esp

tar -zxvf ../xtensa-esp32-elf-linux64-1.22.0-80-g6c4433a-5.2.0.tar.gz

1	tar -zxvf ../xtensa-esp32-elf-linux64-1.22.0-80-g6c4433a-5.2.0.tar.gz

Add the binary folder of the cross compiler to the PATH envinronment variable

export PATH=/home/sviluppo/Micropython/esp32/esp/xtensa-esp32-elf/bin:$PATH

1	export PATH=/home/sviluppo/Micropython/esp32/esp/xtensa-esp32-elf/bin:$PATH

Go into the following folder

/home/sviluppo/Micropython/esp32/micropython/ports/esp32/

1	/home/sviluppo/Micropython/esp32/micropython/ports/esp32/

and create the makefile file with the following code inside

ESPIDF = /home/sviluppo/Micropython/esp32/esp-idf
#PORT = /dev/ttyUSB0
#FLASH_MODE = qio
#FLASH_SIZE = 4MB
#CROSS_COMPILE = xtensa-esp32-elf-

include Makefile

ESPIDF = /home/sviluppo/Micropython/esp32/esp-idf

#PORT = /dev/ttyUSB0

#FLASH_MODE = qio

#FLASH_SIZE = 4MB

#CROSS_COMPILE = xtensa-esp32-elf-

include Makefile

Go into the micropython folder available in /home/sviluppo/Micropython/esp32

cd micropython

1	cd micropython

Run

git submodule update --init

1	git submodule update --init

to add external dependencies.

Next step is the MicroPython cross compiler build

make -C mpy-cross
git submodule init lib/berkeley-db-1.xx
git submodule update

make -C mpy-cross

git submodule init lib/berkeley-db-1.xx

git submodule update

Finally we can build the ESP32 firmware with the following commands

cd ports/esp32
make

1 2	cd ports/esp32 make

The firmware is generated under ports/esp32/build with the name firmware.bin.

Proceed to load the firmware with the commands

make erase

1	make erase

In our case, the firmware upload was successful with the command

make deploy

1	make deploy

It is also possible to load the firmware.bin image with the commands

esptool.py --chip esp32 --port /dev/ttyXXX --baud 921600 erase_flash

1	esptool.py --chip esp32 --port /dev/ttyXXX --baud 921600 erase_flash

esptool.py --chip esp32 --port /dev/ttyXXX --baud 921600  write_flash -z --flash_mode "dio" --flash_freq "40m" --flash_size detect 0x1000 firmware.bin

1	esptool.py --chip esp32 --port /dev/ttyXXX --baud 921600 write_flash -z --flash_mode "dio" --flash_freq "40m" --flash_size detect 0x1000 firmware.bin

where /dev/ttyXXX is replaced with the actual serial port to which we connect the ESP32 board.

In the next article we’ll compile the nodemcu firmware for ESP32

ESP32 – Nodemcu firmware compiling

Compilation, Software

MicroPython – MicroPython compiling for ESP8266 with additional modules

2018-07-04 admin

After the firmware build of the MicroPython firmware for esp8266 in the previous article

MicroPython – MicroPython compiling for ESP8266

we now show how build a module inside the firmware; this option optimizes the module execution and minimizes the size of the same on the device; the module is frozen into the firmware.

With the firmware compiled with the defaults, the following modules are available, listed in the REPL console with the command

help('modules')

1	help('modules')

Now let’s try to compile the firmware with the mqtt modules already inside. For this purpose, the module sources are copied to the umqtt folder under modules

micropython/ports/esp8266/modules/umqtt/simple.py
micropython/ports/esp8266/modules/umqtt/robust.py

1 2	micropython/ports/esp8266/modules/umqtt/simple.py micropython/ports/esp8266/modules/umqtt/robust.py

We proceed to recompile the firmware. From micropython/ports/esp8266 we run the following commands

make clean
make

1 2	make clean make

We can see from the compilation log, that these modules are placed in the frozen state

After uploading this firmware we obtain the following list of modules inside the firmware

It is also possible to create the firmware with the modules not compiled and optimized, by copying the sources in the scripts folder under esp8266; in the specific case the sources must be placed as shown below

micropython/ports/esp8266/scripts/umqtt/simple.py
micropython/ports/esp8266/scripts/umqtt/robust.py

1 2	micropython/ports/esp8266/scripts/umqtt/simple.py micropython/ports/esp8266/scripts/umqtt/robust.py

The modules are always visible in the firmware, but not optimized, so if you need some module it is convenient to copy it on the device during the coding and in the last phase of the project compile the firmware with the frozen modules.

Compilation, Software

MicroPython – MicroPython compiling for ESP8266

2018-06-25 admin

After using in some examples the MicroPython firmware on the ESP8266 board

MicroPython – Nodes examples with DHT11, Relay and MQTT

this article shows how to generate the MicroPython firmware for the ESP8266 board.

The operating system used for this task is Debian 9, already encountered when we analyzed the esptool utility

MicroPython – Python on embedded devices

Log on with the operating system user on Debian 9, sviluppo in our case; under the home folder create the Micropython folder and inside this folder the esp8266 folder

mkdir Micropython
cd Micropython
mkdir esp8266
cd esp8266

mkdir Micropython

cd Micropython

mkdir esp8266

cd esp8266

The MicroPython source code is available at the following link

Github Micropython

Instructions to build the firmware for the ESP8266 are available at the link

MicroPython esp8266

Clone the repository

git clone https://github.com/micropython/micropython

1	git clone https://github.com/micropython/micropython

Download the cross compiler, as described here

Cross compiler

As indicated in the link above, download the source of the cross compiler always from the folder esp8266

git clone --recursive  https://github.com/pfalcon/esp-open-sdk

1	git clone --recursive https://github.com/pfalcon/esp-open-sdk

Install the prerequisites for building

sudo apt-get install make unrar-free autoconf automake libtool gcc g++ gperf flex bison texinfo gawk ncurses-dev libexpat-dev python-dev python python-serial sed git unzip bash help2man wget bzip2 libtool-bin

1	sudo apt-get install make unrar-free autoconf automake libtool gcc g++ gperf flex bison texinfo gawk ncurses-dev libexpat-dev python-dev python python-serial sed git unzip bash help2man wget bzip2 libtool-bin

Proceed to the build of the cross compiler with the following commands

cd esp-open-sdk
make STANDALONE=y |& tee make0.log

1 2	cd esp-open-sdk make STANDALONE=y \|& tee make0.log

At the end of the build add the binary folder of the cross compiler to the PATH envinronment variable

export PATH=/home/sviluppo/Micropython/esp8266/esp-open-sdk/xtensa-lx106-elf/bin:$PATH

1	export PATH=/home/sviluppo/Micropython/esp8266/esp-open-sdk/xtensa-lx106-elf/bin:$PATH

Go into the micropython folder available under ~/Micropython/esp8266

cd ~/Micropython/esp8266/micropython

1	cd ~/Micropython/esp8266/micropython

Run

git submodule update --init

1	git submodule update --init

to add external dependencies.

Next step is the MicroPython cross compiler build

make -C mpy-cross

1	make -C mpy-cross

Finally we can build the ESP8266 firmware with the following commands

cd ports/esp8266
make axtls
make

cd ports/esp8266

make axtls

make

The firmware is generated under ports/esp8266/build folder with the name firmware_combined.bin.

Proceed to load the firmware with the command

esptool.py --port /dev/ttyXXX erase_flash

1	esptool.py --port /dev/ttyXXX erase_flash

where /dev/ttyXXX is repalced with the actual serial port to which we connect the ESP8266 board.

In our case, the firmware upload was successful with the command

make PORT=/dev/ttyUSB0 deploy

1	make PORT=/dev/ttyUSB0 deploy

It is also possible to load the firmware_combined.bin image with the command

esptool.py --port /dev/ttyUSBX --baud 460800 write_flash --flash_size=detect 0 firmware-combined.bin

1	esptool.py --port /dev/ttyUSBX --baud 460800 write_flash --flash_size=detect 0 firmware-combined.bin

In the next article we’ll analyze how to build the MicroPython firmware adding into the image additional MicroPython modules

MicroPython – MicroPython compiling for ESP8266 with additional modules

Hardware

ESP32 Wifi-Bluetooth Module

2018-04-23 admin

In this article we describe briefly the ESP32 chip from Espressif

ESP32

This lower power SOC contains a 32 bit MCU with bluetooth and wifi modules. At the Espressif web site we can find the detailed informations about the ESP32

ESP32 Resources

The device datasheet is available in the following pdf document

ESP32 Datasheet

The ESP32 modules are available individually or in a development kits; the last system simplifies its usage as the development kit contains all the hardware to use rapidly the soc device; we are already ready to load the firmware and use the device.

On internet various web sites describe home automation or iot projects using this soc.

A reference site for the ESP32 is

esp32

At above link we can find the various development platforms utilized for the ESP32. The most relevant are

Arduino Ide

ESP32 Arduino

ESP-IDF

ESP32 IDF

Micropython

MicroPython

PlatformIO

PlatformIO

Firmware Lua

LuaNode

Lua-RTOS-ESP32

Nodemcu Development

We can buy the ESP32 modules/dev kits from various internet online websites, for example ebay

ESP32 on ebay

Different ESP32 modules are available from different vendors

Espressif esp-wroom-32

AI-Thinker esp32s

At the link

http://esp32.net/

different hardware configurations available are listed.

As development kits we report

AI-Thinker NodeMCU-32S

DoIT ESP32 Dev Kit

There are development kits based on esp32 that also integrate a LORA wireless module internally

Lora

We report for example the following

Heltec Wifi LoRa 32

TTGO LoRa32

In the next articles we’ll describe how to build firmwares and use the ESP32 MCU.

Development, Software

Nodemcu Enduser_setup module lua sample(part2)

2016-11-28 admin

After the firmware build and its upload to the nodemcu dev kit, we connected a switch to pin D5, as shown in the previous article

Nodemcu Enduser_setup module lua sample(part1)

We finally can upload some sample code in which we use the enduser_setup module

Open ESPlorer and load the following sample code

webserver.lua

-- webserver.lua
--webserver sample from the nodemcu github
if srv~=nil then
 srv:close()
end

gpio.mode(1, gpio.OUTPUT)
srv=net.createServer(net.TCP)
srv:listen(80,function(conn)
    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> Hello, NodeMcu.</h1><form src=\"/\">Turn PIN1 <select name=\"pin\" onchange=\"form.submit()\">"
        local _on,_off = "",""
        if(_GET.pin == "ON")then
              _on = " selected=true"
              gpio.write(1, gpio.HIGH)
        elseif(_GET.pin == "OFF")then
              _off = " selected=\"true\""
              gpio.write(1, gpio.LOW)
        end
        buf = buf.."<option".._on..">ON</opton><option".._off..">OFF</option></select></form>"
        client:send(buf)
    end)
    conn:on("sent", function (c) c:close() end)
end)

-- webserver.lua

--webserver sample from the nodemcu github

if srv~=nil then

srv:close()

end

gpio.mode(1, gpio.OUTPUT)

srv=net.createServer(net.TCP)

srv:listen(80,function(conn)

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

buf = buf.."<h1> Hello, NodeMcu.</h1><form src=\"/\">Turn PIN1 <select name=\"pin\" onchange=\"form.submit()\">"

local _on,_off = "",""

if(_GET.pin == "ON")then

_on = " selected=true"

gpio.write(1, gpio.HIGH)

elseif(_GET.pin == "OFF")then

_off = " selected=\"true\""

gpio.write(1, gpio.LOW)

end

buf = buf.."<option".._on..">ON</opton><option".._off..">OFF</option></select></form>"

client:send(buf)

end)

conn:on("sent", function (c) c:close() end)

end)

riasserawifi.lua

--riazzerawifi.lua
-- Starts the portal to choose the wi-fi router to which we have
-- to associate
wifi.sta.disconnect()
wifi.setmode(wifi.STATIONAP)
--ESP SSID generated wiht its chipid
wifi.ap.config({ssid="Mynode-"..node.chipid()
, auth=wifi.OPEN})
enduser_setup.manual(true)
enduser_setup.start(
  function()
    print("Connected to wifi as:" .. wifi.sta.getip())
  end,
  function(err, str)
    print("enduser_setup: Err #" .. err .. ": " .. str)
  end
);

--riazzerawifi.lua

-- Starts the portal to choose the wi-fi router to which we have

-- to associate

wifi.sta.disconnect()

wifi.setmode(wifi.STATIONAP)

--ESP SSID generated wiht its chipid

wifi.ap.config({ssid="Mynode-"..node.chipid()

, auth=wifi.OPEN})

enduser_setup.manual(true)

enduser_setup.start(

function()

print("Connected to wifi as:" .. wifi.sta.getip())

end,

function(err, str)

print("enduser_setup: Err #" .. err .. ": " .. str)

end

);

init.lua

-- init.lua
--Access Point management
pin = 5 --Input PIN
Resetta=0   --Variable used to manage AP reset
gpio.mode(pin,gpio.INPUT)   --Pin 5 in input mode

--If pin input is High let's start the nodemcu portal
if (gpio.read(pin)==gpio.HIGH ) then 

    Resetta=1
end

-- Check if reset the AP credential
if Resetta==1 then 

    -- Start the nodemcu portal
    tmr.alarm(0, 5000, 0, function() dofile("riazzerawifi.lua") end)

else
    -- Start the webserver wiht ip defined by Wi-Fi router
    tmr.alarm(0, 5000, 0, function() dofile("webserver.lua") end)

end

-- init.lua

--Access Point management

pin = 5 --Input PIN

Resetta=0 --Variable used to manage AP reset

gpio.mode(pin,gpio.INPUT) --Pin 5 in input mode

--If pin input is High let's start the nodemcu portal

if (gpio.read(pin)==gpio.HIGH ) then

Resetta=1

end

-- Check if reset the AP credential

if Resetta==1 then

-- Start the nodemcu portal

tmr.alarm(0, 5000, 0, function() dofile("riazzerawifi.lua") end)

else

-- Start the webserver wiht ip defined by Wi-Fi router

tmr.alarm(0, 5000, 0, function() dofile("webserver.lua") end)

end

It is possible to download the above samples at the following link

Sample code

Here is the documentation about the enduser_setup module

enduser_setup module documentation

The example consists of three files:

init.lua: It is executed at the startup of the esp8266.
riazzerawifi.lua: It starts the portal to connect and save the configuration to your Access Point.
webserver.lua: It starts the webserver sample on the nodemcu.

As you can see from the code in init.lua, when the pin D5 is in the state HIGH, we start the portal using enduser_setup module. In the case in which the pin D5 is in the state LOW the esp8266 acquires the IP from an Access Point defined previously after which the test webserver starts.

To save the access point confguration to which we want to connect we place the switch in order to have the HIGH input on pin D5 and reboot the card.

From a PC we can observe the presence of another access point, defined in the file riazzerawifi.lua

wifi.ap.config({ssid="Mynode-"..node.chipid()
, auth=wifi.OPEN})

1 2	wifi.ap.config({ssid="Mynode-"..node.chipid() , auth=wifi.OPEN})

composed by Mynode string + ChipID module

We can connect to this access point and via browser we access to the portal at the ip address 192.168.4.1

Select or enter the SSID of an access point providing the correct password. After the connection reposition the switch to have the LOW state for pin D5 and reboot the nodemcu dev kit.

Now the system will automatically connect to the SSID defined previously and starts the example of the web server.

Please refer to the Lua documentation nodemcu for further study and usable modules

LUA Nodemcu Documentation

Development, Software

Nodemcu Enduser_setup module lua sample(part1)

2016-11-21 admin

In the previous article we showed a sample LUA code for ESP8266

Lua sample code for esp8266

Let us now see an example in which we’ll use the enduser_setup Lua module.

As a first step we compile the nodemcu firmware by including the enduser_setup module. We have to apply the same steps discussed in the build process article

Nodemcu firmware build

editing the app/include/user_modules.h file and uncommenting the line

#define LUA_USE_MODULES_ENDUSER_SETUP

1	#define LUA_USE_MODULES_ENDUSER_SETUP

After the building and firmware upload to the device, we use a switch connected to nodemcu dev kit as shown in the picture

The pin D5 can be connected to a low or high input voltage. Based on the input voltage we can change the behavior of the system.

Note: The Pin D5 in this specific example has been used as Input Pin; in the case of use as Output Pin, you must insert a resistor to limit the output current, as specified in the link

GPIO Pin Allocations

In the next article we’lll upload a LUA sample code with enduser_setup module enabled and we’ll utilize it to manage the wifi connections

Nodemcu Enduser_setup module lua sample(part2)

Development, Software

Lua sample code for esp8266

2016-11-16 admin

As mentioned in the previous article

how to upload nodemcu firmware with esptool

we are now ready to upload some example code on ESP8266 system.

We follow the LUA Nodemcu documentation

Nodemcu LUA Documentation

and upload a simple http server on the system.

Using ESPlorer we upload the following code, a modified version of the code available on the github. Modify the fields “SSID” and “password” with the the values of your Wi-fi Router.

webserver pin

wifi.setmode(wifi.STATION)
wifi.sta.config("SSID", "password")
gpio.mode(1, gpio.OUTPUT)
srv=net.createServer(net.TCP)
srv:listen(80,function(conn)
    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> Hello, NodeMcu.</h1><form src=\"/\">Turn PIN1 <select name=\"pin\" onchange=\"form.submit()\">"
        local _on,_off = "",""
        if(_GET.pin == "ON")then
              _on = " selected=true"
              gpio.write(1, gpio.HIGH)
        elseif(_GET.pin == "OFF")then
              _off = " selected=\"true\""
              gpio.write(1, gpio.LOW)
        end
        buf = buf.."<option".._on..">ON</opton><option".._off..">OFF</option></select></form>"
        client:send(buf)
    end)
    conn:on("sent", function (c) c:close() end)
end)

wifi.setmode(wifi.STATION)

wifi.sta.config("SSID", "password")

gpio.mode(1, gpio.OUTPUT)

srv=net.createServer(net.TCP)

srv:listen(80,function(conn)

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

buf = buf.."<h1> Hello, NodeMcu.</h1><form src=\"/\">Turn PIN1 <select name=\"pin\" onchange=\"form.submit()\">"

local _on,_off = "",""

if(_GET.pin == "ON")then

_on = " selected=true"

gpio.write(1, gpio.HIGH)

elseif(_GET.pin == "OFF")then

_off = " selected=\"true\""

gpio.write(1, gpio.LOW)

end

buf = buf.."<option".._on..">ON</opton><option".._off..">OFF</option></select></form>"

client:send(buf)

end)

conn:on("sent", function (c) c:close() end)

end)

Save the file as ipstatico.lua. With ESPlorer upload the file to nodemcu devkit with “Save to ESP” button .
Create a second file named init.lua

tmr.alarm(0, 5000, 0, function() dofile("ipstatico.lua") end)

1	tmr.alarm(0, 5000, 0, function() dofile("ipstatico.lua") end)

Save this file on the device.

Reboot the device with the reset command on ESPlorer tool and from the ESPlorer command bar execute

print(wifi.sta.getip())

1	print(wifi.sta.getip())

This command provides us the ip acquired by the device. We are able now to access with a browser to the assigned ip address, discovered above, and interact with a small interface that allows us to activate or not the PIN1 output

With this method, however, we need to know the Access Point to which you must connect. To overcome this limitation, we can use the enduser_sertup module

Enduser_setup module

With this module we start the ESP8266 device as an access point with a portal on which we can enter the credentials of the access point which we want to connect.

In the next article we’ll build the nodemcu firmware by adding the enduser setup module, not available in the standard firmware, and we will do the same example using this module

Enduser_setup module sample

Micro Devices

Tag Archives: wifi

ESP32 – IDF Sdk with Eclipse

ESP32 – IDF Sdk

ESP32 – Nodemcu firmware compiling

ESP32 – MicroPython compiling for ESP32

MicroPython – MicroPython compiling for ESP8266 with additional modules

MicroPython – MicroPython compiling for ESP8266

ESP32 Wifi-Bluetooth Module

Nodemcu Enduser_setup module lua sample(part2)

Nodemcu Enduser_setup module lua sample(part1)

Lua sample code for esp8266

Blog about embedded devices