1. ListBox

• Purpose: Used for displaying a simple list of items, primarily for single or multi-selection.
• Appearance: Displays items in a single column by default (like a plain list).
• Selection: Supports single and multi-selection modes.
• Item Display: Each item is typically displayed as plain text (without any columns or sub-items).
• Features:
  • Supports basic item selection (single or multiple).
  • Can bind to data sources for simple lists.
  • Can respond to events like SelectedIndexChanged and DoubleClick.
  • Limited customization in terms of item display (e.g., text only).

Use Case: Use ListBox when you need a simple list for users to pick from, like a list of names, categories, or simple text items.

Example Usage:

' Adding items to a ListBox
ListBox1.Items.Add("Item 1")
ListBox1.Items.Add("Item 2")
ListBox1.Items.Add("Item 3")

' Retrieving the selected item
Dim selectedItem As String = ListBox1.SelectedItem.ToString()

2. ListView

• Purpose: Used for displaying a list of items with more complex structures, often with additional details like columns and sub-items.
• Appearance: Can display items in various views:
  • Details: Shows columns (like a table).
  • List: Similar to ListBox but with optional icons.
  • LargeIcon and SmallIcon: Displays items with large or small icons.
  • Tile: Displays items with both icons and details.
• Selection: Supports single and multi-selection modes.
• Item Display: Allows for displaying multiple columns and sub-items (great for tabular data).
• Features:
  • Supports columns, sub-items, and rich item views.
  • Allows for customization with icons, checkboxes, and images.
  • Can be used to create a grid-like view, making it more flexible than ListBox.
  • Events like SelectedIndexChanged, ItemActivate, and ColumnClick allow for more complex interactions.

Use Case: Use ListView when you need to display detailed or structured data, like a file explorer, a product list with prices, or any tabular data.

Example Usage:

' Setting up a ListView in Details mode
ListView1.View = View.Details
ListView1.Columns.Add("Name", 100)
ListView1.Columns.Add("Price", 70)

' Adding items to a ListView
Dim item As New ListViewItem("Item 1")
item.SubItems.Add("$10")
ListView1.Items.Add(item)

' Adding another item with sub-items
Dim item2 As New ListViewItem("Item 2")
item2.SubItems.Add("$20")
ListView1.Items.Add(item2)

Comparison Table

When to Use Which?

• Use ListBox if you only need a simple, text-based list of items and do not require additional details like columns or icons.
• Use ListView if you need to display more complex data with columns, icons, or multiple views. It’s ideal for displaying tabular data or lists with multiple attributes per item.

Conclusion

• ListBox is straightforward and lightweight, ideal for simple lists.
• ListView is more versatile and feature-rich, suitable for more detailed data presentation.

Related Topics

Specifying Data Type When Adding Columns to a DataTable
How to Create a Custom File in VB.Net

The post Difference Between ListView and ListBox in VB.Net appeared first on CyberBlogSpot.

Reasons for Specifying the Column Type

table.Columns.Add("WatchListName", GetType(String))  ' Stores text data
table.Columns.Add("Price", GetType(Decimal))         ' Stores decimal numbers
table.Columns.Add("Volume", GetType(Integer))        ' Stores integer numbers

1. Data Storage and Memory Management:
   • The DataTable is a highly efficient data structure that stores data in memory. By specifying the data type of each column, the DataTable can allocate memory more efficiently.
   • If you specify GetType(String), the DataTable knows to allocate memory suitable for storing text.
   • If you specify GetType(Integer), it will store numeric values in a more compact format, using less memory than storing them as strings.
2. Data Integrity:
   • Specifying the type ensures that only data of that type can be stored in that column. This helps prevent data entry errors.
   • For example, if a column is defined as GetType(Integer), trying to insert a string value like "ABC" will cause an error, which helps maintain the integrity of your data.
3. Performance Optimization:
   • The DataTable can perform operations like sorting, filtering, and searching more efficiently when it knows the data type of each column.
   • For example, sorting a column with GetType(DateTime) is faster and more accurate than sorting text representations of dates.
4. Type Safety:
   • By specifying a data type, you get the benefit of type safety at compile time. This means that the code will produce errors if you try to add data of the wrong type, which helps catch bugs early in the development process.
5. Compatibility with Databases:
   • When working with databases, columns in tables have specific data types (VARCHAR, INT, DECIMAL, etc.). By specifying types in your DataTable, you ensure compatibility when filling data from or sending data to a database.

Example of Creating a DataTable with Specified Types

Here’s an example of creating a DataTable with multiple columns of different types:

' Create a new DataTable
Dim table As New DataTable("WatchLists")

' Add columns with specific types
table.Columns.Add("WatchListName", GetType(String))   ' Text data
table.Columns.Add("Symbol", GetType(String))          ' Text data
table.Columns.Add("Price", GetType(Decimal))          ' Numeric data
table.Columns.Add("Volume", GetType(Integer))         ' Integer data
table.Columns.Add("LastUpdated", GetType(DateTime))   ' Date/Time data

' Add a row of data to the table
Dim row As DataRow = table.NewRow()
row("WatchListName") = "My WatchList"
row("Symbol") = "MER"
row("Price") = 400.5D
row("Volume") = 1000
row("LastUpdated") = DateTime.Now
table.Rows.Add(row)

What Happens if You Don’t Specify a Type?

• If you don’t specify a type (e.g., table.Columns.Add("WatchListName")), the column will default to GetType(Object).
• This means it can store any type of data (e.g., strings, integers, dates), but it comes at the cost of reduced type safety, performance, and increased memory usage.

Example of Column Without Specified Type:

table.Columns.Add("UnspecifiedType") ' Defaults to Object type
table.Rows.Add("SomeText")           ' Works fine
table.Rows.Add(123)                  ' Also works, but not type-safe

• Using GetType(Object) is more flexible but less efficient. It’s generally better to specify the correct type unless you truly need to store mixed types in a single column.

Conclusion

• Specifying the type when adding columns to a DataTable is essential for data integrity, performance optimization, type safety, and memory efficiency.
• It’s a good practice to define the data type that best matches the data you intend to store in each column, similar to how you would define data types in a database table.

The post Specifying Data Type When Adding Columns to a DataTable appeared first on CyberBlogSpot.

To create a custom File Explorer in VB.NET, we will make use of the “vbUtilities” class library. This third-party library provides a set of useful tools and functionalities that can simplify the development process and enhance the capabilities of our application. The library also includes pre-built user interface components that we can utilize to create a visually appealing and intuitive user interface. Using vbUtilities, we can save time and effort by avoiding the need to write custom code for these common functionalities and instead focus on the core business logic of our application.

You can download vbUtilities from github.com.

STEP 1 – Create a VB Project

Create a Windows Forms App (.NET Framework). Make sure that “.NET Framework 4.8” is selected under “Framework”. The vbUtilities is targetted for this specific .NET Framework version. Name the project as “Custom File Explorer”.

STEP 2 – Drop Controls on the Form

Drop a TreeView control, a ListView control, a ComboBox control, and three (3) ImageList controls. We may leave the names of the TreeView, ListView, and ComboBox controls with their default names (TreeView1, ListView1, and ComboBox1 respectively). However, because we have three (3) ImageList controls, it is best to rename them to avoid confusion.

The first ImageList will store the icons for the TreeView control. Therefore, we should rename it as ilTreeView. I renamed the second ImageList control as ilSmallIcons and the third ImageList as ilLargeIcons. These two last ImageList will hold the icons for the ListView control.

STEP 3 – Add a Reference to vbUtilities

Download and unzip the vbUtilities class library from github.com. Next, on the Visual Studio IDE, go to Project -> Add Reference. On the Reference Manager window, click the Browse button on the lower right of the window. Search for the vbUtilities.dll from the downloaded files and click the Add button. When you are back on the Reference Manager, click the OK button to close the Reference Manager window.

STEP 4 – Add Source Code

Double click on the form, delete the existing code, and copy and paste the following source code.

Imports vbUtilities
Public Class Form1
    Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
        vbUtilities.CustomFileExplorer.InitializeCFE("C:\", TreeView1, ilTreeView, ListView1, ilSmallIcons, ilLargeIcons, ComboBox1)
    End Sub

    Private Sub TreeView1_BeforeCollapse(sender As Object, e As TreeViewCancelEventArgs) Handles TreeView1.BeforeCollapse
        vbUtilities.CustomFileExplorer.TreeView_BeforeCollapse(e)
    End Sub

    Private Sub TreeView1_BeforeExpand(sender As Object, e As TreeViewCancelEventArgs) Handles TreeView1.BeforeExpand
        vbUtilities.CustomFileExplorer.TreeView_BeforeExpand(e, ilTreeView)
    End Sub

    Private Sub TreeView1_AfterSelect(sender As Object, e As TreeViewEventArgs) Handles TreeView1.AfterSelect
        vbUtilities.CustomFileExplorer.TreeView_AfterSelect(e, ListView1, ilSmallIcons, ilLargeIcons)
    End Sub

    Private Sub ComboBox1_SelectedIndexChanged(sender As Object, e As EventArgs) Handles ComboBox1.SelectedIndexChanged
        vbUtilities.CustomFileExplorer.ComboBox_SelectedIndexChanged(ComboBox1.SelectedItem, ListView1)
    End Sub
End Class

STEP 5 – Compile and Run

Click the Start button on the Visual Studio IDE.

The post How to Create a Custom File Explorer in VB.NET appeared first on CyberBlogSpot.

One of the straightforward way of adding, editing, and deleting records in a database table is thru the direct execution of SQL commands. That is, to add a record to an existing table, the SQL command INSERT is used. Likewise, to edit a record, the SQL command UPDATE is executed. For record deletion, the SQL command is DELETE. Finally for searching and reading of records, the SQL command SELECT is used.

SQL Commands for Reading, Adding, Editing, and Deleting Records

1. SQL SELECT Statement

Reading or retrieval of a table record or set of records

SELECT column1, column2, column3, ..., columnN
FROM table_name
WHERE condition;

VB.Net SqlCommand

cmd.CommandText = "SELECT * FROM table_name WHERE condition"
cmd.ExecuteReader()

2. SQL INSERT Statement

Addition, creation, or insertion of a new table record

INSERT INTO table_name (column1, column2, column3, ..., columnN)
VALUES (value1, value2, value3, ..., valueN);

VB.Net SqlCommand

cmd.CommandText = "INSERT INTO table_name (column1, column2, column3, ..., columnN)
                   VALUES (value1, value2, value3, ..., valueN) WHERE condition"
cmd.ExecuteNonQuery()

3. SQL UPDATE Statement

Editing or updating a table record

UPDATE table_name
SET column1 = value1, column2 = value2, column3 = value3, ..., columnN = valueN 
WHERE condition;

VB.Net SqlCommand

cmd.CommandText = "UPDATE table_name SET column1 = value1, column2 = value2,
                   column3 = value3, ..., columnN = valueN"
cmd.ExecuteNonQuery

4. SQL DELETE Statement

Delete a table record or set of records

DELETE FROM table_name WHERE condition;

VB.Net SqlCommand

cmd.CommandText = "DELETE FROM table_name WHERE condition"
cmd.ExecuteNonQuery

We can execute SQL commands in VB.Net by using an SqlCommand object. However, an SqlCommand object needs an SqlConnection object. Also, we need to provide the SqlConnection object with a connection string. The connection string specifies how to connect to the database.

Sample Add, Edit, Delete Program in VB.Net

To illustrate the use of the different SQL commands, let us first create a simple SQL database. For this tutorial, I am using a Visual Studio 2019 Community Edition. In order to work with SQL databases in VS2019, you must install the Data Storage and Processing toolset. If you did not install it when you installed your VS2019, re-run the installer. Put a checkmark on Data Storage and Processing under the Other Toolsets list.

You may install an SQL server if you want. There are two free editions of Microsoft SQL Server that you can use. These are the Developer and Express editions. They can be downloaded here.

Notes on Visual Studio Project Types

Windows Forms App versus Windows Forms App (.Net Framework)

If you are new to Visual Studio, choosing a project type can be confusing. Take a look at the screenshot below. Both Windows Forms App and Windows Forms App (.Net Framework) are used for creating WinForms. Both types also mention “.Net”. So, what’s the difference?

Windows Forms App (.Net Framework) is for creating apps targeting .Net Framework. Whereas the plain Windows Forms App is for creating apps that use the .Net Core. These will become clear after you select the project type.

.Net Framework is the old and mature .Net that runs on the Windows platform. In contrast, .Net Core is the new .Net that is cross-platform.

Read

Dim connStr As String = "Data Source=localhost\SQLEXPRESS;
                         Initial Catalog=myDatabase;
                         Integrated Security=True;
                         Pooling=False"
Dim conn As New SqlConnection(connStr)
Dim cmd As SqlCommand

cmd = conn.CreateCommand
cmd.CommandText = "Select * from Employees"

After prepping the SqlCommand object as shown above, the actual execution of the SqlCommand depends on the type of the command. In this case, because it is a SELECT command, we expect the command to return a set of values. Therefore, we need an object to receive the results.

conn.Open()
Dim reader As SqlDataReader
reader = cmd.ExecuteReader

Imports System.Data.SqlClient
Public Class Form1
    Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
        Dim connStr As String = "Data Source=localhost\SQLEXPRESS;
                                 Initial Catalog=myDatabase;
                                 Integrated Security=True;
                                 Pooling=False"
        Dim conn As New SqlConnection(connStr)
        Dim cmd As SqlCommand

        cmd = conn.CreateCommand
        cmd.CommandText = "Select * from Employees"

        conn.Open()
        Dim dt As New DataTable
        dt.Load(cmd.ExecuteReader())
        conn.Close()

        DataGridView1.DataSource = dt
    End Sub
End Class

ADD

CREATE – or INSERT a record into a table. The SQL command starts with the keywords INSERT INTO. It is followed with the name of the table. Then, the column names are specified inside a pair of parentheses. Finally, the corresponding values for the columns are enumerated, again, inside a pair of parentheses.

SQL INSERT COMMAND

Imports System.Data.SqlClient
Public Class frmAdd
    Private Sub btnAdd_Click(sender As Object, e As EventArgs) Handles btnAdd.Click
        Dim connStr As String = "Data Source=localhost\SQLEXPRESS;
                                Initial Catalog=myDatabase;
                                Integrated Security=True;
                                Pooling=False"
        Dim conn As New SqlConnection(connStr)
        Dim cmd As SqlCommand

        'DATA VALIDATION
        'Check if all required fields are filled
        If Trim(txtEmployeeID.Text) = "" Or Trim(txtEmployeeName.Text) = "" Or Trim(txtAge.Text) = "" Then
            MsgBox("Please fill all fields", vbExclamation, "Add Record Error")
            Exit Sub
        End If

        'Check if EmployeeID is numeric
        If Not IsNumeric(txtEmployeeID.Text) Then
            MsgBox("Please enter a numeric value for Employee ID", vbExclamation, "Add Record Error")
            Exit Sub
        End If

        'Check if Age is numeric
        If Not IsNumeric(txtAge.Text) Then
            MsgBox("Please enter a numeric value for Age", vbExclamation, "Add Record Error")
            Exit Sub
        End If

        'Check if EmployeeID is already in use
        cmd = conn.CreateCommand
        cmd.CommandText = "SELECT * FROM Employees WHERE EmployeeID = '" & txtEmployeeID.Text & "'"

        conn.Open()
        Dim reader As SqlDataReader
        reader = cmd.ExecuteReader()

        If reader.HasRows Then
            MsgBox("Employee ID already exist", vbExclamation, "Add Record Error")
            reader.Close()
            conn.Close()
            Exit Sub
        End If

        reader.Close()

        'SAVE RECORD
        cmd.CommandText = "INSERT INTO Employees (EmployeeID, EmployeeName, Age) 
                           VALUES (" & txtEmployeeID.Text & "," & txtEmployeeName.Text & "," & txtAge.Text & ")"

        Dim result As Integer
        result = cmd.ExecuteNonQuery()

        If result > 0 Then
            MsgBox("Record successfully saved", vbInformation, "Add Record Info")
        Else
            MsgBox("Record save failed", vbCritical, "Add Record Error")
        End If

        reader.Close()
        conn.Close()
    End Sub
End Class

READ – or retrieve a record or a set of records. The keyword for the SQL command is SELECT. The column names are then enumerated. Then, the keyword FROM followed by the table name. As an option, a condition clause can be added to the command.

VB.Net Code

Imports System.Data.SqlClient
Public Class frmRead
    Private Sub frmRead_Load(sender As Object, e As EventArgs) Handles MyBase.Load
        Dim connStr As String = "Data Source=localhost\SQLEXPRESS;
                                 Initial Catalog=myDatabase;
                                 Integrated Security=True;
                                 Pooling=False"
        Dim conn As New SqlConnection(connStr)
        Dim cmd As SqlCommand
        Dim dt As New DataTable

        cmd = conn.CreateCommand
        cmd.CommandText = "Select * from Employees"

        conn.Open()
        dt.Load(cmd.ExecuteReader)
        conn.Close()

        Dim drow As DataRow = dt.Rows(0)
        txtEmployeeID.Text = drow(0)
        txtEmployeeName.Text = drow(1)
        txtAge.Text = drow(2)

        DataGridView1.DataSource = dt
    End Sub
End Class

UPDATE

DELETE

'
Private Sub dgv_RowsAdded(sender As Object, e As DataGridViewRowsAddedEventArgs) Handles dgv.RowsAdded
        rowIndex = e.RowIndex
        rowCount = e.RowCount
End Sub

Creating a Database

Project–>Add New Item–>Service-based Database–>Click Add button
In the Solution Explorer, a file name Database1.mdf will appear. On the Server Explorer, the same file will appear under Data Connections

Rename the file into “StudentDatabase.mdf” on the Solution Explorer

Creating a Table

On the Server Explorer, expand the StudentDatabase.mdf, and right-click the Tables program to create a new Table

Opening a database.

PROBLEM WITH SQL QUERY WITH DATES, INPUTTED DATE FORMAT IS MODIFIED DURING SQL QUERY

FOR EXAMPLE INPUT 06/30/2021 BECOMES 30/06/2021, THEREBY GENERATING ERRORS

SOLUTION : CHANGE LANGUAGE SETTINGS TO US

EXECUTESCALAR CAUSING ERROR IF RESULT IS DBNULL

SOLUTION: MAKE THE RECEIVING VARIABLE AN OBJECT

dim result as long
result=cmd.executescalar ’causes error when result is dbnull or nothing

solution:

dim result as object

Related Articles on Add Edit Delete in VB.Net Programming

How to Install Esptool on Windows 10

References on Add Edit Delete in VB.Net Programming

CRUD on Wikipedia

The post Add Edit Delete in VB.Net Programming appeared first on CyberBlogSpot.

Did you know that there are two (2) versions of ESP-01 Wi-Fi modules? Check out the article:
Difference Between ESP-01 and ESP-01S

The ESP-01 Wi-Fi relay module is used as a smart switch for remotely turning on and off any device connected to it. A pre-programmed ESP-01 module is inserted into the relay module to serve as a microcontroller for the relay. The attached ESP-01 module also provides the Wi-Fi capability to the relay module to enable a computer or a smartphone to control the relay module remotely or wirelessly.

ESP-01 Module Programmer

In order to use the ESP-01 Wi-Fi relay module, a programmer is needed to program the ESP-01 module. An example of an ESP-01 programmer is shown in Figure 3. If you do not a have an ESP-01 programmer module, you can make one if you have a USB-to-serial converter. Or simply use an Arduino board as an ESP-01 programmer if you have an available Arduino board. For details on how to make a DIY ESP-01 programmer, see the article: ESP-01 and ESP-01S Pinout and Configuration

Schematic Diagram of ESP-01 Wi-Fi Relay Module

Before we start programming the ESP-01 module to be used on the ESP-01 Wi-Fi relay module, let us first study the schematic diagram of the ESP-01 Wi-Fi relay module. There are two (2) versions of ESP-01 Wi-Fi relay modules. Version 1 is shown in Figure 5 and Version 4 is shown in Figure 6.

An examination of the two (2) schematic diagrams above will show that the difference in the two versions has something to do with the relay driver. On version 1, the relay is driven by an NPN junction transistor. On the other hand, on version 4, the relay is driven by an N-channel MOSFET transistor. Also, in version 4, the MOSFET driving the relay is in turn being driven by an opto-coupler.

In terms of programming, we should note that on both versions, the relay is activated by the ESP-01 module thru port GPIO0. However, on Version 1, the relay uses ACTIVE HIGH logic levels. That is, a logic HIGH on GPIO0 will activate the relay and a logic LOW will deactivate it. On the other hand, on a Version 4 model, the relay is activated using ACTIVE LOW signals. This means that a logic HIGH will turn OFF the relay and a logic LOW will turn it ON. In short, the two versions use opposite signals for activating the relay. These differing signals should be taken into account when programming the ESP-01 module. Or else, turning ON the relay may result to it being turned OFF instead. And vice versa, turning the relay OFF may cause the relay to turn ON.

How to Program the ESP-01 Module for Use with the Wi-Fi Relay Module

In this article, we will pre-program the ESP-01 module with NodeMCU or Lua program. Afterwards, we will create a smartphone app to control the ESP-01 Wi-Fi relay module remotely. It is also possible to program the ESP-01 module with the Arduino IDE. If you would prefer an Arduino IDE program for the ESP-01 module, please see – How to Control ESP-01 Without a Router.

Flashing the NodeMCU Firmware on ESP-01 Module

First, we need to install the NodeMCU firmware into the ESP-01 module. There are several ways to do this but we will use the one that I think is the easiest. Download the NodeMCU Flasher from Github. Extract the zip file and run the file “ESP8266Flasher.exe”. There are two versions of ESP8266Flasher.exe, a Win32 and a Win64 version. Select the appropriate version for your computer.

Plug in your ESP-01 programmer with the ESP-01 module to your computer’s USB port. The NodeMCU Flasher should be able to detect the ESP-01 programmer and automatically change the COM Port setting. If this is your first time to use your ESP-01 programmer, you may have to install the device driver for it.

Click on Config tab of the NodeMCU Flasher and verify that you have the settings INTERNAL://NODEMCU and hex 0x00000. The INTERNAL://NODEMCU setting tells the NodeMCU Flasher to use the NodeMCU firmware that comes with the NodeMCU Flasher installation (the firmware file can be found under the Resources/Binaries directory). Meanwhile, the setting 0x00000 is the memory starting location where the NodeMCU firmware will be installed. See Figure 9 for the correct settings.

Next, click on the Advanced tab of the NodeMCU Flasher. Change the Flash size to 1Mbyte and the SPI mode to QIO. These two (2) settings are specific to ESP-01 modules, see Figure 10 below.

Click back on the Operation tab and click on the Flash(F) button to start flashing the NodeMCU firmware to the ESP-01 module. Please refer to Figure 11.

Wait for the progress bar to be filled up and you should see a green checkmark at the bottom left of the NodeMCU Flasher screen as depicted in Figure 12.

We have now successfully installed the NodeMCU firmware on the ESP-01 module, so we will go to the next procedure.

ESPlorer Integrated Development Environment

ESPlorer is an Integrated Development Environment (IDE) used for programming ESP8266 modules like ESP-01 with NodeMCU and Micropython. Download the ESPlorer from Github. Extract the zip file and run the file “ESPlorer.bat”.

Make sure that the proper COM port for your ESP-01 programmer is selected and the baud rate setting is 9600 baud (see Figure 14). Then click on the Open button.

If the ESPlorer can’t autodetect the NodeMCU firmware, reset the ESP-01 module by pressing the reset button on your ESP-01 programmer. Or click on the RTS button on the ESPlorer IDE twice. When you click the RTS button on the ESPlorer IDE, it sends a RESET signal to the connected ESP-01 programmer module.

After resetting the ESP-01 module, you should see a message with the NodeMCU firmware version. This verifies that you have successfully flashed the ESP-01 module with the NodeMCU firmware in the preceding procedure.

If the ESPlorer IDE cannot detect your NodeMCU firmware, see the article:
ESPlorer Can’t Autodetect Firmware

The Lua Program

Copy and paste the following Lua program on the left pane of the ESPlorer IDE.

print("Ready to start soft ap")

local str=wifi.ap.getmac();
local ssidTemp=string.format("%s%s%s",string.sub(str,10,11),string.sub(str,13,14),string.sub(str,16,17));

cfg={}
cfg.ssid="ESP8266_"..ssidTemp;
cfg.pwd="12345678"
wifi.ap.config(cfg)

cfg={}
cfg.ip="192.168.1.1";
cfg.netmask="255.255.255.0";
cfg.gateway="192.168.1.1";
wifi.ap.setip(cfg);
wifi.setmode(wifi.SOFTAP)

str=nil;
ssidTemp=nil;
collectgarbage();

print("Soft AP started")
print("Heep:(bytes)"..node.heap());
print("MAC:"..wifi.ap.getmac().."\r\nIP:"..wifi.ap.getip());

led1 = 3
led2 = 4
gpio.mode(led1, gpio.OUTPUT)
gpio.mode(led2, gpio.OUTPUT)
srv=net.createServer(net.TCP)
srv:listen(80,function(conn)
    conn:on("receive", function(client,request)
        local buf = "";
        buf = buf.."HTTP/1.1 200 OK\n\n"
        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
        
        if(_GET.pin == "ON1")then
              gpio.write(led1, gpio.HIGH);
			  print("led1 on")
        elseif(_GET.pin == "OFF1")then
              gpio.write(led1, gpio.LOW);
			print("led1 off")
        elseif(_GET.pin == "ON2")then
              gpio.write(led2, gpio.HIGH);
			print("led2 on")
        elseif(_GET.pin == "OFF2")then
              gpio.write(led2, gpio.LOW);
			print("led2 off")
        end
        client:send(buf);
        client:close();
        collectgarbage();
    end)
end)

Save the file to your computer. Click the Save button on the top left pane (1). Name the file as “init.lua” (2). Then click on the Save button on the Save screen (3).

After saving the program to your hard disk, the ESPlorer IDE uploaded the file init.lua to your ESP-01 module and ran the program (dofile(“init.lua”)).

Testing the ESP-01 Module Access Point

Before we proceed to building the smartphone app to control the ESP-01 Wi-Fi relay module, let us first check if we have successfully programmed the ESP-01 module.

Get your smartphone and scan for Wi-Fi devices. With my Android smartphone, I would go to the “Settings/Network and Internet/Wi-Fi” setting. See Figure 20. You should see the Wi-Fi SSID “ESP8266_XXXXXX” where XXXXXX is the last six digits of your ESP-01 module’s MAC address.

Connect your smartphone to the ESP-01 access point by entering the password “12345678” (Figure 21).

Figure 22 below shows the smartphone connected to the ESP-01 module’s access point.

Click on the gear icon to display the network details. Your smartphone will be assigned an IP address of 192.168.1.2. The gateway is the IP address of the ESP-01 access point.

Now we are ready to create the smartphone app to control the ESP-01 Wi-Fi relay module.

How to Create the Smartphone App to Control the ESP-01 Wi-Fi Relay Module

We are going to use the MIT App Inventor 2 to create a smartphone app to control the ESP-01 Wi-Fi relay module. First, we need to download the MIT App Inventor 2 Companion App to our smartphones. We will need it to facilitate installing the created controller app to our smartphones.

Next, download the source code from Github – ESP8266 Controller. Extract the file ESP8266_Controller.aia.

Go to MIT App Inventor website and click on the Create Apps! button.

Import the project ESP8266_Controller.aia (the file downloaded from Github).

The ESP8266 controller app designers view.

If you want to modify how the program works, go to the Blocks view.

Compile and build the app by clicking the Build/Android App(apk) item on the menu. Refer to Figure 30 below.

After a successful build, a bar code will appear on your computer’s screen (see Figure 31). Scan the bar code with your smartphone using the MIT App Inventor Companion app. Follow the instructions on your smartphone to install the ESP8266 Controller app.

How to Use the ESP8266 Controller App to Control the ESP-01 Wi-Fi Relay Module

Remove the ESP-01 module from the programmer module and insert it into the ESP-01 Wi-Fi relay module. Provide power to the relay module. Next, connect the smartphone to the ESP-01 access point as discussed above on testing the ESP-01 module access point. Then, open the ESP8266 Controller app and set the IP address to “192.168.1.1”.

You may now enjoy playing around with your new smart switch ESP-01 Wi-Fi relay module using the ESP8266 Controller smartphone app.

Related Articles on How to Use ESP-01 Wi-Fi Relay Module

How to Program ESP-01 with Arduino IDE
How to Set up Arduino IDE for ESP8266 Programming
How to Test an ESP-01 ESP8266 Module
How to Control ESP-01 thru a Router
How to Control ESP-01 Without a Router
ESP-01 with RTC and LCD Display
How to Save and Restore ESP8266 and ESP32 Firmware
NodeMCU V3 ESP8266 Pinout and Configuration
How to Test a NodeMCU V3 ESP8266 Dev Board
How to Use AT-09 BLE with Arduino and Smartphone

References on How to Use ESP-01 Wi-Fi Relay Module

ESP8266 on Wikipedia
ESP-01 Wi-Fi Relay Module on Shopee

The post How to Use ESP-01 Wi-Fi Relay Module appeared first on CyberBlogSpot.

By following the message on the screen to reset the module, the result is a gibberish message with the words “MEM CHECK FAIL” at the end. See Figure 2.

Cause of the Error Can’t Autodetect Firmware

This error can often be mistaken for a failed NodeMCU firmware flashing. But whether you used the NodeMCU Flasher or the Espressif Download Tool or manually used ESPTool.py to flash the NodeMCU firmware, you will get the same error.

The error is caused by a wrong BAUD rate setting on the ESPlorer IDE and NOT on a defective firmware flashing. See Figure 3. The baud rate setting is at 115200 baud when it should be only 9600 baud.

How to Fix the Error Can’t Autodetect Firmware

To fix the error “can’t autodetect firmware”, close the connection and change the baud rate to 9600 baud. Then reset the ESP8266 module by pressing the reset button or simply click the RTS button on the ESPtool IDE twice. Figure 4 shows the fixed error and with the NodeMCU firmware being detected correctly.

Important Note on ESPlorer Can’t Autodetect Firmware

If you flash your ESP8266 board with the newer NodeMCU firmware, the correct BAUD rate to use is 115200 baud. See Figure 5 that shows the ESPlorer IDE with NodeMCU firmware version 1.5 and Figure 6 with NodeMCU firmware version 3.0. Both are using 115200 baud rates.

What is ESPlorer?

ESPlorer is a multi-platform Integrated Development Environment (IDE) for programming ESP8266 modules. It is primarily used for programming ESP8266 modules with NodeMCU (Lua) and MicroPython. It can also be used to program ESP8266 modules with AT commands. Additionally, it can also program RN2483 LoRa modules.

Related Articles

How to Program ESP-01 with Arduino IDE
How to Set up Arduino IDE for ESP8266 Programming
How to Test an ESP-01 ESP8266 Module
How to Control ESP-01 thru a Router
How to Control ESP-01 Without a Router
ESP-01 with RTC and LCD Display
How to Save and Restore ESP8266 and ESP32 Firmware
NodeMCU V3 ESP8266 Pinout and Configuration
How to Test a NodeMCU V3 ESP8266 Dev Board
How to Use AT-09 BLE with Arduino and Smartphone

References

esp8266 – Developer Community
NodeMCU Documentation

The post ESPlorer Can’t Autodetect Firmware appeared first on CyberBlogSpot.

Wiring Diagram to Use AT-09 BLE with Arduino and Smartphone

To use an AT-09 BLE with Arduino and a smartphone, connect the AT-09 module to the Arduino board using the schematic diagram below. In this article, I am using an Arduino Nano board as an example. However, you may use any Arduino board that is available. As a matter of fact, you may use ANY microcontroller at your disposal. On my next project, I would connect an AT-09 BLE module to an ATtiny85 chip for a low-current car central door lock system.

As shown by the Fritzing breadboard and the KiCad schematic diagram below, there are only four terminals that we need to connect. These are the RX, TX, GND, and VCC.

Referring to Figure 4 above, the Arduino Nano’s D2 and D3 terminals are labelled as RX (Receiver) and TX (Transmitter) respectively. These terminals will simulate a UART port and will be assigned as RX and TX ports thru software (software serial). The choice of D2 and D3 is arbitrary and you may use any two (2) available digital IO pins except D0 and D1 (hardware serial ports).

The ports D0 and D1 (RX and TX) may not be used because we will use the Arduino IDE Serial Monitor. Remember that the ports D0 and D1 are connected to the USB port of the Arduino board and are connected to your computer for uploading sketches. Therefore, in order to use the Serial Monitor, the ports D0 and D1 must be free (unused, no external circuitry). We will use the Serial Monitor as input and output device for interacting with the AT-09 BLE module.

Take note that the Arduino Nano’s RX and TX (D2 and D3) terminals are cross-wired with the RX and TX terminals of the AT-09 BLE module. That is, the RX terminal of the Arduino Nano connects to the TX terminal of the AT-09 BLE module. Vice versa, the TX terminal of the Arduino Nano is wired to the RX terminal of the AT-09 BLE module.

Resistors R1 and R2 are used as logic level translators. The circuit reduces the 5V output from the Arduino Nano’s TX port to the 3V logic level needed by the AT-09 BLE board. However, the RX port does not need a logic level translation since it is receiving a lower 3V logic that it can sufficiently handle.

Smartphone App for Use with AT-09 BLE Module and Arduino Board

There are many smartphone apps available for controlling a Bluetooth module but as a starter, we will use the Arduino Bluetooth Controller (HM-10 Module). Since this app is specifically for HM-10 module and the AT-09 module being compatible with the HM-10 module, the app works perfectly well with the AT-09 BLE module. If you want to make your own Android smartphone app, you can create one even if you are not a programmer. Take a look at MIT App Inventor.

Before we start programming the Arduino board, download and install the Arduino Bluetooth Controller from the Google Play Store. There are many similarly named Bluetooth controllers on the Google Play Store, so look for the one made by Argon Dev. See Figure 5 below.

Quick Test on AT-09 BLE Module

After downloading the Bluetooth controller app, power up the Arduino board by plugging it into the computer’s USB port. When the AT-09 BLE module is powered up, you should see the onboard LED flashing. The flashing LED light indicates it is transmitting and advertising its presence. Open the Bluetooth controller app.

Click on the search icon. See Figure 6 above.

When the AT-09 BLE module connects to the Bluetooth controller, you should see the displayed message turning into green, similar to the one displayed on Figure 7. BT05 is the Bluetooth device name of the AT-09 BLE module and the 12-digit hex number is its Bluetooth MAC address. Also, look at the AT-09 BLE module. You should see the LED on the board stop flashing and stay steadily lit.

If you can connect to the AT-09 BLE module using a smartphone, you can now proceed to programming the Arduino board. We will first program the Arduino Nano to play around with the AT commands. After that, we will insert additional codes to the sketch to control the Arduino’s onboard LED using the smartphone.

The AT-09 BLE Module AT Commands

AT commands are instructions sent to the Bluetooth module to display and change its configuration. For example, if we want to display or change its device name, we send it the command AT+NAME. If we want to display its Bluetooth MAC address, we use the command AT+LADDR. We will learn more about these AT commands after uploading the following sketch to the Arduino board.

/* cyberblogspot.com 21Jan2023
 *  
 * Program to send AT commands to AT-09 BLE module
 * and display the responses on the Serial Monitor
 * 
 * RX and TX cross wired 
 * 2k and 3k voltage divider on AT-09 RX (reduce 5V to 3V)
 */

#include <SoftwareSerial.h>
SoftwareSerial bleSerial(2, 3); //D2 is RX, D3 is TX

char bleData;  //storage for AT-09 data   
String mData;  //storage for AT-09 and serial monitor data

void setup() {
  Serial.begin(115200);   //initialize serial monitor
  bleSerial.begin(9600);  //and BLE serial port, default AT-09 baud rate is 9600 baud
  
  Serial.println("AT-09 BLE module ready");
}

void loop() {
  if (Serial.available()) {      
    mData = Serial.readString(); //read serial monitor input
    Serial.println(mData);       //echo keyboard input to serial monitor
    bleSerial.println(mData);    //send keyboard input to AT-09 module
  }

  bleSerial.listen();                  //listen to the AT-09 port
  while (bleSerial.available() > 0) {  //if AT-09 data available
    bleData = bleSerial.read();        //read character and
    mData = String(bleData);           //convert to string format 
    Serial.print(mData);               //display to serial monitor
  }
}

The sketch above will let us type AT commands on the Arduino IDE’s Serial Monitor and send it to the AT-09 BLE module. Anything that we type on the Serial Monitor will be echoed back (displayed) on the Serial Monitor. At the same time, it will be sent to the AT-09 module. When the AT-09 module replies in response to the AT commands sent, it will also be displayed on the Serial Monitor.

The program starts by including the library SoftwareSerial. It is a built-in Arduino library so you do not need to download or install it.

#include <SoftwareSerial.h>

Next, we create the SoftwareSerial object bleSerial.

SoftwareSerial bleSerial(2, 3); //D2 is RX, D3 is TX

As per discussion above on the wiring diagram (see Figure 4 above), the digital IO port D2 will be used as an RX port and digital IO port D3 will become a TX port. Because the hardware UART ports D1 and D2 are being used by the Serial Monitor, we are creating an additional UART port via software. This additional port is where the AT-09 BLE module is connected.

void setup() {
  Serial.begin(115200);   //initialize serial monitor
  bleSerial.begin(9600);  //and BLE serial port, default AT-09 baud rate is 9600 baud
  
  Serial.println("AT-09 BLE module ready");
}

In the setup() routine, the hardware UART port “Serial” and the software UART port “bleSerial” are initialized. Note that the “bleSerial” speed is set to 9600 baud only because the module is configured to use that speed by default.

void loop() {
  if (Serial.available()) {      
    mData = Serial.readString(); //read serial monitor input
    Serial.println(mData);       //echo keyboard input to serial monitor
    bleSerial.println(mData);    //send keyboard input to AT-09 module
  }

  bleSerial.listen();                  //listen to the AT-09 port
  while (bleSerial.available() > 0) {  //if AT-09 data available
    bleData = bleSerial.read();        //read character and
    mData = String(bleData);           //convert to string format 
    Serial.print(mData);               //display to serial monitor
  }
}

Finally on the loop() procedure, the program is very simple. The program checks if there is input on the Serial Monitor. If there is, it sends the data to the AT-09 BLE module. In the same manner but vice versa, it checks for any available data from the AT-09 module and sends it to the Serial Monitor.

Upload the sketch to the Arduino board and then open the Arduino IDE Serial Monitor. Change the Serial Monitor settings to “No line ending” and “115200 baud” as in Figure 8.

Type “AT” and press the ENTER key, and you should get the message “OK”. That means that the AT-09 BLE module is accepting AT commands.

Type “AT+VERSION” and the firmware version of the AT-09 module will be displayed on the Serial Monitor.

Type “AT+NAME” and the response should be the default device name of “BT05”.

Type “AT+LADDR” and see the module’s local address or Bluetooth MAC address.

Type “AT+UUID” and the Universal Unique Identifier is displayed which is hex FFE0.

Type “AT+PIN” and the serial monitor will display the default PIN of 123456 used for pairing with other Bluetooth devices.

Finally, type “AT+HELP” and the Serial Monitor will display all the available AT commands that the AT-09 BLE module supports.

Now, open the Arduino Bluetooth Controller. Connect to the AT-09 BLE module, type the word “hi”, and press the SEND button.

You should see the word “hi” in the Arduino Serial Monitor as shown in Figure 12.

Type “hello” on the Arduino Serial Monitor. You will see the word “hello” on your smartphone.

It must be clear now that you can send messages from your smartphone to your Arduino board. And the other way around, you can send messages from the Arduino board to your smartphone.

Let us go back to the Serial Monitor and type the AT command “AT+HELP” again.

The word “AT+HELP” was echoed back on the Serial Monitor as expected (Figure 15). It was also sent to the smartphone app Arduino Bluetooth Controller (Figure 16). However, the AT-09 BLE module did not respond to the AT command “AT+HELP” to display the list of AT commands. This shows that the AT-09 BLE module will only respond to AT commands when it is not connected to any device. And to prove this to yourself, disconnect the Arduino Bluetooth Controller from the AT-09 module and type the “AT+HELP” again on the Serial Monitor and see what happens.

Controlling the Arduino Onboard LED with Smartphone

Now, we are ready to control the the AT-09 BLE module on the Arduino board using our smartphone. We are going to turn on and off the built-in LED on the Arduino Nano board. To do this, we will add a few lines of code to our sketch.

pinMode(13, OUTPUT);    //set D13 as output where built-in LED is connected
digitalWrite(13, LOW);  //initially turn off LED

In the setup() procedure, we will insert the two lines of code shown above. Since the Arduino Nano built-in LED is connected to the digital IO port D13, we will set it up as an OUTPUT port. Then send a digitalWrite() command to initially turn it off.

if (mData == "0") {
    digitalWrite(13, LOW);   //turn off LED
  }

  if (mData == "1") {
    digitalWrite(13, HIGH);  //turn on LED
  }

Then, we will also insert codes in the loop() procedure to check the messages that are being received by the AT-09 BLE module and the Arduino board. If a “0” message is received, the Arduino board turns off the LED, and if a “1” message comes in, the LED will be turned on.

Figure 17 shows how the additional codes are inserted into the previous sketch.

The complete Arduino IDE source code on how to use AT-09 BLE module with Arduino and smartphone.

/* cyberblogspot.com 21Jan2023
 *  
 * Program to send AT commands to AT-09 BLE module
 * and display the responses on the Serial Monitor
 * 
 * RX and TX cross wired 
 * 2k and 3k voltage divider on AT-09 RX (reduce 5V to 3V)
 */

#include <SoftwareSerial.h>
SoftwareSerial bleSerial(2, 3); //D2 is RX, D3 is TX

char bleData;  //storage for AT-09 data   
String mData;  //storage for AT-09 and serial monitor data

void setup() {
  Serial.begin(115200);   //initialize serial monitor
  bleSerial.begin(9600);  //and BLE serial port, default AT-09 baud rate is 9600 baud

  pinMode(13, OUTPUT);    //set D13 as output where built-in LED is connected
  digitalWrite(13, LOW);  //initially turn off LED
  
  Serial.println("AT-09 BLE module ready");
}

void loop() {
  if (Serial.available()) {      
    mData = Serial.readString(); //read serial monitor input
    Serial.println(mData);       //echo keyboard input to serial monitor
    bleSerial.println(mData);    //send keyboard input to AT-09 module
  }

  bleSerial.listen();                  //listen to the AT-09 port
  while (bleSerial.available() > 0) {  //if AT-09 data available
    bleData = bleSerial.read();        //read character and
    mData = String(bleData);           //convert to string format 
    Serial.print(mData);               //display to serial monitor
  }
  
  if (mData == "0") {
    digitalWrite(13, LOW);   //turn off LED
  }

  if (mData == "1") {
    digitalWrite(13, HIGH);  //turn on LED
  } 
}

How to Set Up the Arduino Bluetooth Controller

To set up the Arduino Bluetooth Controller, open the app and click on the plus icon (+) to open the template designer.

Enter the Name, Text, Description, and select a color. You may use a different name, description and color but the text must be “1”, in order to match with the code of the sketch. Then click on Save button. Refer to Figure 19 below.

Figure 20 shows the saved template with the completed first button. If you made a mistake, long press on the saved button, delete it, and start all over again.

Repeat the above procedure for the second button. Refer to Figure 21 below.

After saving the second button, you should have a display similar to Figure 22.

That completes the setup for the Arduino Bluetooth Controller and you may now test it for use with AT-09 BLE, Arduino and a smartphone.

Related Articles on How to Use AT-09 BLE with Arduino and Smartphone

How to Use Arduino as ISP Programmer
How to Control ESP-01 thru a Router
How to Control ESP-01 Without a Router
How to Install Esptool on Windows 10
How to Save and Restore ESP8266 and ESP32 Firmware
NodeMCU V3 ESP8266 Pinout and Configuration
NodeMCU ESP-32S Pin Configuration
Digispark ATtiny85 Pinout and Configuration
How to Program Digispark ATtiny85 Board with Arduino IDE
How to Enable Serial Monitor on Digispark ATtiny85

References on How to Use AT-09 BLE with Arduino and Smartphone

Bluetooth Low Energy on Wikipedia
HM-10 Datasheet
Arduino Bluetooth Controller (HM-10 Module)

The post How to Use AT-09 BLE with Arduino and Smartphone appeared first on CyberBlogSpot.

ESP-01 and its latest version ESP-01S are popular microcontrollers with Wi-Fi networking capabilities. They are part of the ESP8266 family of microcontrollers manufactured by Espressif Systems. In this article, we will learn the ESP-01 and ESP-01S pinout and configuration in actual applications.

ESP-01 Wi-Fi Module Specifications

Power Supply:
Voltage 3.0V ~ 3.6V
Current >300mA

Current Consumption:
Continuous Transmission: Average: ~ 71mA, Peak: 300mA
Modem Sleep: ~20mA
Light Sleep: ~2mA
Deep Sleep: ~0.02mA

SPI Flash Memory:
Default 8Mbit (1MB)

Interface:
UART/GPIO

IO Port:
2

UART Baud Rate:
Support 300 ~ 4608000 bps
Default 115200 bps

Frequency Range:
2412 ~ 2484MHz

Transmit Power:
802.11b: 16±2 dBm (@11Mbps)
802.11g: 14±2 dBm (@54Mbps)
802.11n: 13±2 dBm (@HT20, MCS7)

Receiving Sensitivity:
CCK, 1 Mbps : -90dBm
CCK, 11 Mbps: -85dBm
6 Mbps (1/2 BPSK): -88dBm
54 Mbps (3/4 64-QAM): -70dBm
HT20, MCS7 (65 Mbps, 72.2 Mbps): -67dBm

For a complete specifications, you may refer to the ESP-01 Product Specification PDF.

ESP-01 and ESP-01S Pinout

Have you just bought a new ESP-01 Wi-Fi module? Take a look at
How to Test an ESP-01 ESP8266 Module

Learn how to differentiate between ESP-01 and ESP-01S Wi-Fi modules, see:
Difference Between ESP-01 and ESP-01S

ESP-01 Pin Descriptions

TX – UART0 data send (transmit) pin, also known as GPIO1.
RX – UART0 data receive pin, also known as GPIO3.
CH_PD – Chip Power Down (also known as CH_EN or Chip Enable) – Chip enable pin, active high
RST – External reset pin, active low
GPIO2 – General Purpose Input / Output
GPIO0 – General Purpose Input / Output
VCC – +3.3 Volts Supply Positive
GND – Ground – Supply negative

ESP-01 Module Breadboarding and Adapters

When breadboarding, you can not insert the ESP-01 module as it is. A few years ago, you do all sort of tricks to breadboard an ESP-01 module, from bending the header pins to making your own DIY adapter. Luckily, now you can buy a cheap breadboard adapter for the ESP-01 module. See Figure 5.

If you will be connecting the ESP-01 board to an Arduino board, you must remember two (2) things:

• Do not supply the ESP-01 module with the 3.3V output from the Arduino board – the ESP-01 module, as per specification above, may require up to 300mA of current. The 3.3V regulator on the Arduino board may overheat and may become damaged.
• Provide logic level translation between the ESP-01 and the Arduino board – the Arduino board uses 5V logic while the ESP-01 module uses 3.3V logic.

A good ESP-01 adapter that can satisfy the requirements for interfacing with Arduino boards is shown in Figure 6. It has a built-in 3.3V regulator and two (2) bi-directional logic level converters for the RX and TX pins. The schematic diagram for the adapter is shown in Figure 7.

ESP-01 Programmers

ESP-01 USB-to-Serial Converter Programmer Module

Unlike the other ESP8266 boards, ESP-01 boards need a programmer to be uploaded with programs or sketches from the Arduino IDE. An inexpensive programmer is shown below in Figure 8. The programmer uses a Silabs 2104 serial to USB converter chip. With this programmer, you just plug it into your computer’s USB port, select the proper COM port and start uploading sketches.

DIY USB-to-Serial Converter Programmer

If you do not have a programmer module but you have an available USB-to-serial converter, you can wire it up as an ESP-01 programmer. The schematic diagram of a DIY programmer is shown in Figure 9. With this programmer, you need to put the ESP-01 module into programming mode before uploading a sketch. This is done by holding down the Flash switch, pressing and releasing the Reset switch, and then releasing the Flash switch.

Shown below in Figures 10, 11, and 12 is my DIY ESP-01 programmer. The USB-to-serial converter connects to the programmer board via the 4-pin male header on the board.

Arduino Board as ESP-01 Programmer
Another option for an ESP-01 programmer is to use an Arduino board. You may use any available Arduino board such as Arduino Uno, Arduino Nano, etc.

The idea here is to use the Arduino board’s built-in USB-to-serial converter. The schematic diagram in Figure 13 is the same as the DIY ESP-01 programmer in Figure 9, but the USB-to-serial converter was replaced with an Arduino Uno.

As previously discussed above, the 3.3V output from the Arduino board should not be used. Instead, a 3.3V voltage regulator was provided for the ESP-01 module. Also, a logic level converter was used consisting of a 2.2K resistor in series with a 3.3K resistor acting as a voltage divider. This protects the RX pin of the ESP-01 module from being exposed to a 5V signal from the Arduino board. Note that the TX pin of the ESP-01 module was connected directly to the TX pin of the Arduino board. We can do away with the logic level converter because the TX pin is acting as an output (outgoing signal).

You may have noticed that the TX and RX pins of the Arduino board are connected to the corresponding TX and RX pins of the ESP-01 module. But in the DIY programmer in Figure 9, the TX and RX terminals are cross-wired. That is, the TX pin of the USB-to-serial converter is connected to the RX pin of the ESP-01 module and ,vice versa, the RX pin of the USB-to-serial converter is connected to the TX pin of the ESP-01 module.

If you want to find out why the Arduino board’s RX and TX pins are wired straight thru and not crossed over with the ESP-01 board, consult an Arduino board schematic and look at how the MCU chip and the USB-to-serial converter chip are wired. I am leaving this one as an exercise for the reader.

Related Articles on ESP-01 and ESP-01S Pinout and Configuration

How to Program ESP-01 with Arduino IDE
How to Set up Arduino IDE for ESP8266 Programming
How to Test an ESP-01 ESP8266 Module
How to Control ESP-01 thru a Router
How to Control ESP-01 Without a Router
ESP-01 with RTC and LCD Display
How to Save and Restore ESP8266 and ESP32 Firmware
NodeMCU V3 ESP8266 Pinout and Configuration
How to Test a NodeMCU V3 ESP8266 Dev Board
How to Use AT-09 BLE with Arduino and Smartphone

References on ESP-01 and ESP-01S Pinout and Configuration

ESP-01 Specification
ESP-01 Datasheet

The post ESP-01 and ESP-01S Pinout and Configuration appeared first on CyberBlogSpot.

The ESP-01 Wi-Fi module is one of the most popular ESP8266-based microcontroller board. It is very inexpensive and widely available. If you are new with ESP-01 modules, or are contemplating on buying one, you are lucky for visiting this page. We have here all the necessary information on the difference between ESP-01 and ESP-01S Wi-Fi modules.

The ESP-01 module and the ESP-01S module are functionally the same. However, knowing the difference between the two is very important because it can affect how you wire them to external circuits. Also, the boards have different current consumption owing to their difference in the number of onboard LEDs.

ESP-01S is a Newer Version

First off, the ESP-01 module was the original version that was popularized almost a decade ago. The ESP-01S is the newer version. At the time of this writing, circa 2023, the original ESP-01 module is still widely available. Most online stores would allow you to choose between an ESP-01 or an ESP-01S. But some stores may sell you an ESP-01 for an ESP-01S, or vice versa.

Difference in Physical Appearance

At first glance, the two modules look the same. However, a close examination of the boards will show the difference in the number of LEDs (Light Emitting Diodes). Please see Figure 2 below. In the original ESP-01, there are two (2) small LEDs. On the other hand, the ESP-01S has a single, bigger LED.

The difference becomes more apparent when you supply power to the boards. The ESP-01 board will have a red LED light turned on indicating the presence of power. On the ESP-01S board, you will only see a blue LED flash for a while when the power is applied.

The Blue LED Wiring Difference Between ESP-01 and ESP-01S

Although both boards have a blue serial-activity LED, the blue LEDs are wired differently. See Figure 3. In the ESP-01 board, the blue LED is connected on the VCC and the TX pins, while on the ESP-01S, it is connected on the VCC and the GPIO2 pins. On both boards, a 2.2K ohms resistor is used in series with the blue LED as a current limiter.

Pull-up Resistors on ESP-01S

Another difference between ESP-01 and ESP-01S is the presence of three (3) pull-up resistors on the ESP-01S module. Pull-up resistors are used to provide a logic HIGH signal to a circuit. As shown on the right side of Figure 3 above, three (3) 12K-ohm resistors are connected from the VCC to the RESET, GPIO0, and CH_PD pins on the ESP-01S board.

Prior to the availability of the ESP-01S module, a popular ESP-01 wiring scheme for adding a reset switch and a programming switch is shown below in Figure 4. First of all, in order to power up the ESP-01 board, you need to pull up the CH_PD (Chip Enable/Power Down) pin. Next, you connect the RESET pin to the VCC because you do not want the RESET pin hanging and be vulnerable to noise causing unexpected resets. And third, pulling up the GPIO0 pin to VCC will automatically run the program or sketch loaded on the ESP-01 module after a power up or a reset.

On the newer ESP-01S module, the circuit shown above will be a lot more simple. There is no need to externally supply the three (3) pull-up resistors. See Figure 5.

Summary on Difference Between ESP-01 and ESP-01S

The ESP-01 and the ESP-01S Wi-Fi modules are functionally the same. The ESP-01S module is a newer version of the original ESP-01 module. The ESP-01 module has a red power indicator LED that is absent on the ESP-01S. Both modules have a blue LED that indicates serial activity. However, the blue LED is wired differently on each module’s version. And finally, the ESP-01S module has three (3) on board pull-up resistors that are missing on an ESP-01 module.

Related Articles

How to Program ESP-01 with Arduino IDE
How to Set up Arduino IDE for ESP8266 Programming
How to Test an ESP-01 ESP8266 Module
How to Control ESP-01 thru a Router
How to Control ESP-01 Without a Router
ESP-01 with RTC and LCD Display
How to Save and Restore ESP8266 and ESP32 Firmware
NodeMCU V3 ESP8266 Pinout and Configuration
How to Test a NodeMCU V3 ESP8266 Dev Board
How to Use AT-09 BLE with Arduino and Smartphone

References on Difference Between ESP-01 and ESP-01S

ESP8266 on Wikipedia
ESP8266 Boot Process

The post Difference Between ESP-01 and ESP-01S appeared first on CyberBlogSpot.

When you buy a new ESP-01 ESP8266 module, the very first thing to do is to test it. That is, you need to make sure that you have a good and working ESP-01 module. We will take a look at the different methods of testing the ESP-01 ESP8266 Wi-Fi module.

Differences Between ESP-01 and ESP-01S ESP8266 Module

Before we proceed, be aware that there are two (2) versions of ESP-01 modules. The older ESP-01 module and the newer ESP-01S module. Both modules are functionally the same. However, there are two points worth mentioning here.

First, the ESP-01 has two (2) LEDs, a red LED power indicator and a blue LED that indicates serial activity. On the other hand, the newer ESP-01S has only one (1) LED, the blue LED light (see Figure 2 above). Moreover, the blue LED serial activity indicator light is wired differently on each module. That is, on an ESP-01 module, it is connected on the TX pin (GPIO1) while on the ESP-01S module, it is connected on the GPIO2 pin. And as a side note, pins GPIO0 and GPIO1 are both serial TX capable pins (refer to the ESP-01S schematic diagram at the end of this article).

Second, the ESP-01S module has three (3) additional on-board resistors used as pull-up resistors. These pull-up resistors are 12K-ohm resistors each connected on the GPIO0, the RESET, and the CH_PD pins. You may also want to refer again to the ESP-01S schematic diagram included at the end of this article.

Quick and Dirty Test

The ESP-01 module is shipped with a program called AT firmware. The firmware will let you send AT commands to configure and program the module. More important, the module is configured as a Wi-Fi Access Point (AP) when shipped. Therefore, a quick and dirty test is to power the ESP-01 module and use a smartphone to connect to the Access Point.

Power up the ESP-01 module as shown in Figure 3. Notice that we need to connect the ESP-01 module to a 3.3V power supply. Do not connect the ESP-01 module to the 3.3V output of an Arduino board. Provide a separate 3.3V power supply with sufficient current capacity. Also, note that a 10K ohms resistor is connected from the CH_PD pin to the VCC or the 3.3V supply. The CH_PD (Chip Power Down / Enable Pin) pin has to be pulled up to the VCC for the module to function. If you have the ESP-01S module, you do not need to connect a 10K ohm resistor on the CH_PD pin. As per discussion above on the differences between the ESP-01 and the ESP-01S modules, the ESP-01S already has a 12K-ohm pull-up resistor on the CH_PD pin.

After powering up, you should see the ESP-01 access point when you scan for Wi-Fi devices. The default SSID of the ESP-01 module I am using is ESP_7B0F95. See Figure 4.

Connect to the ESP-01 Access Point.

Click on the Settings icon (gear icon) and see the network details of the ESP-01 module Access Point.

AT Command Test

For the next test, you need an ESP-01 programmer or flasher. An inexpensive programmer/flasher is shown below in Figures 7. In Figure 8, the ESP-01 module is shown inserted into the programmer/flasher. If you do not have a programmer/flasher, it is possible to use an Arduino board as a programmer/flasher. Also, if you have a USB-to-serial(TTL) converter, you could wire it up as an ESP-01 programmer/flasher.

Insert the ESP-01 module to the programmer as shown in Figure 8 and plug the programmer to the computer. If it is your first time to use your programmer/flasher, you may have to install its device driver. Open the Arduino IDE and set the appropriate COM port for your programmer (Figure 9). For the meantime, there is no need to set the Board type.

Open the Serial Monitor and change the settings as shown in Figure 10. The line ending setting must be set to both newline and carriage return, “Both NL & CR”. Additionally, the baud rate setting must be set to “115200 baud”.

Now type “AT”, press the return key and the ESP-01 module should reply “OK”.

To view the ESP-01 module firmware version, type “AT+GMR”.

Type “AT+CIFSR” to view the Access Point’s IP address and network MAC address. See Figure 11 for the output display.

For a complete guide on the ESP-01 module AT commands, see ESP8266 – AT Command Reference.

Programming with Arduino IDE

In the next test, we will upload a modified version of the sample sketch Blink from the Arduino IDE. The sketch should make the blue LED on the ESP-01 module turn on and off.

IMPORTANT
Uploading an Arduino sketch to the ESP-01 module will erase the AT firmware. The AT commands will not work anymore after the upload. If you want to be able to restore the original firmware, please see the article
How to Save and Restore ESP8266 and ESP32 Firmware.

With the ESP-01 module still in the programmer/flasher, open the Arduino IDE and change the Board setting to “Generic ESP8266 Module” as shown in Figure 12.

Create a new sketch, copy and paste the blink program shown below. Upload the sketch to the ESP-01 module. The blue LED should start blinking after successfully uploading the sketch.

/*
 * cyberblogspot.com 01Feb2023
 */

#define LED_BUILTIN 1                // GPIO1 for ESP-01, GPIO2 for ESP-01S
                                     // Change to 2 for ESP-01S module
void setup() {
  pinMode(LED_BUILTIN, OUTPUT);   
}

void loop() {
  digitalWrite(LED_BUILTIN, LOW);   // Turn the LED on (ESP-01 LED is active low)
  delay(1000);                      
  digitalWrite(LED_BUILTIN, HIGH);  // Turn the LED off 
  delay(1000);                     
}

Schematic Diagram of ESP-01S ESP8266 Wi-Fi Module

Related Articles on How to Test an ESP-01 ESP8266 Module

How to Set up Arduino IDE for ESP8266 Programming
How to Program ESP-01 with Arduino IDE
How to Control ESP-01 thru a Router
How to Control ESP-01 Without a Router
ESP-01 with RTC and LCD Display
ESP-01 ESP8266 NTP Clock with LCD Display
How to Test NodeMCU V3 Using Esptool
NodeMCU V3 ESP8266 Pinout and Configuration
How to Use AT-09 BLE with Arduino and Smartphone

References on How to Test an ESP-01 ESP8266 Module

ESP8266 on Wikipedia

The post How to Test an ESP-01 ESP8266 Module appeared first on CyberBlogSpot.