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.

To enable the Arduino IDE Serial Monitor on a Digispark ATtiny85 board, connect a USB-to-Serial converter. Then use the SoftwareSerial library in the Arduino IDE to create a UART port on the ATtiny85 chip.

For Digispark ATtiny85 pinout guide, kindly see Digispark ATtiny85 Pinout and Configuration.

Step by Step Guide For Serial Monitor

STEP 1 – Connect a USB-to-Serial Converter

First, connect a USB-to-serial converter to the Digispark ATtiny85 board as shown in Figure 1 and Figure 2.

There are many inexpensive USB-to-serial converters on the Internet. Examples of USB-to-serial converters are shown below in Figure 3. These converters are sometimes referred to as USB-to-serial TTL converters or USB-to-UART converters. Also, the converters use a variety of chips, hence, they may be referred to by their chip names. Some of the popular USB-to-serial chip names that you may encounter are FTDI, CP2104, CH304, and PL2303.

STEP 2 – Install the USB-to-Serial Converter Device Driver

Download and install the device driver for your USB-to-serial converter. Because USB-to-serial converters use different chips, you need to search the internet for the device driver for your particular USB-to-serial converter.

You can do a quick test if you have the right device driver installed. Open the Arduino IDE and go to the Tools/Port menu. You should see an additional port instead on only COM1 on the Serial Ports list when you plug in your USB-to-serial converter. Please see Figure 4.

STEP 3 – Install the Board Core ATTinycore by Spence Konde

Although we may use the original Digistump AVR board core, I prefer to use the ATTinyCore as it supports almost all of the ATtiny line of AVR chips. Additionally, the ATTinyCore gives us the option to program the ATtiny85 in several ways: no bootloader, Optiboot, and Micronucleus (Digispark) modes. If you need help in installing the ATTinyCore, please see How to Install ATTinyCore on Arduino IDE.

STEP 4 – Use Software Serial to Create UART Ports on ATtiny85

Open the Arduino IDE and upload the sketch shown below. If you need help in uploading the sketch using the board core ATtinyCore, you may visit How to Program Digispark ATtiny85 Board with Arduino IDE.

IMPORTANT NOTE
Before hitting the Upload button to install the sketch, unplug both USB cables for the Digispark board and the USB-to-serial converter. Plug in the USB cable for the Digispark board when prompted by the Arduino IDE. When the sketch upload is done, unplug the USB cable from the Digispark board. Connect the USB cable for the USB-to-serial converter and proceed to STEP 5 for testing the Serial Monitor.

/* cyberblogspot.com 15Jan2023 */

#include "SoftwareSerial.h"

SoftwareSerial mySerial(1, 0);  //RX, TX  PB1, PB0

void setup() { 
  mySerial.begin(19200);
  
  mySerial.println("Change baud rate to 19200");
  mySerial.println("Type something and press ENTER");
}

void loop() {
  if (mySerial.available()){
    mySerial.println(mySerial.readString());
  }
}

The sketch above needs no explanation. Simply include the library header file for the SoftwareSerial library. You do not have to download the SofwareSerial library as it should come with the ATtinyCore board core installation.

Regarding the code creating the SoftwareSerial object in line 5,

SoftwareSerial mySerial(1, 0); //RX, TX PB1, PB0

you may use any two (2) available ATtiny85 ports available. In this case, I used PB1 for RX (receiver) and PB0 for TX (transmitter).

STEP 5 – Test the Serial Monitor

After uploading the sketch to the Digispark ATtiny85 board, unplug the USB cable from the Digispark board. Plug in the USB cable for the USB-to-serial converter.

Then, select the correct COM port for your USB-to-serial converter in the Arduino IDE “Tools/Port” menu. Test the program and you should now be able to use the Serial Monitor on the Digispark ATtiny85 board.

References on How to Enable Serial Monitor on Digispark ATtiny85

USB-to-serial adapter – Wikipedia article on USB to Serial Converter
How to Install Arduino IDE on Windows 10
How to Install ATTinyCore on Arduino IDE
How to Use Arduino as ISP Programmer
How to Program ATtiny85 with Arduino IDE
Digispark ATtiny85 Pinout and Configuration
How to Program Digispark ATtiny85 Board with Arduino IDE
Digispark USB Device Not Recognized
How to Use AT-09 BLE with Arduino and Smartphone

The post How to Enable Serial Monitor on Digispark ATtiny85 appeared first on CyberBlogSpot.

To use an Arduino board as an ISP programmer, simply upload the Arduino IDE example sketch named “ArduinoISP”. Next, connect the SPI pins of the Arduino board to the MCU chip or MCU board to be programmed. Then, you can start using the Arduino board as an ISP programmer.

To illustrate the steps for the procedure, first, I will make an Arduino Nano board into an ISP programmer. Then, I will show how to upload sketches and burn bootloaders to a Digispark ATtiny85 development board.

Step by Step Guide on How to Use Arduino as ISP Programmer

STEP 1 – Connect your Arduino board to your computer’s USB port.

Connect the Arduino board of your choice to your programming computer hosting the Arduino IDE. In the next several steps, we will upload the ArduinoISP sketch to the board to make it an ISP programmer.

STEP 2 – Open your Arduino IDE and open the ArduinoISP sketch.

Open your Arduino IDE. If you are a beginner and you have not yet installed the Arduino IDE, please see How to Install Arduino IDE on Windows 10. On the Main menu, select File/Examples/11.ArduinoISP/ArduinoISP.

You should see the screen shown below after clicking on the ArduinoISP on the Built-in Examples menu.

STEP 3 – Choose the name of your Arduino board from the Board Manager’s list.

Go to Tools/Board/Arduino AVR Boards and select the type of Arduino board you are using. As shown in the screenshot below, I chose Arduino Nano for my Arduino board.

STEP 4 – Set the proper COM serial port for your board.

On the Tools menu, select Port. Then select from the serial ports list the appropriate port for your Arduino board.

STEP 5 – Click the Upload button.

As a final step for uploading the ArduinoISP sketch to the Arduino board, click on the Upload button.

When you see the message “Done uploading”, congratulations!!! You now have a full-pledged ISP programmer.

In the following steps, we are going to show how to use the Arduino board acting as an ISP programmer to:

• Program or upload a sketch to a Digispark ATtiny85 board
• Burn an Optiboot bootloader
• Burn a Micronucleus bootloader

STEP 6 – Connect the ISP programmer (the Arduino board) to the Digispark ATtiny85 development board.

Like in any other ISP programmers, including the popular USBtinyISP and USBasp programmers, we use six (6) terminals of the ISP programmer to connect to the device to be programmed. These terminals are:

• MOSI
• MISO
• SCLK
• RESET
• VCC
• GND

On the Arduino board acting as an ISP programmer, the corresponding terminals are as follow:

• D11 (MOSI) —> MOSI
• D12 (MISO) —> MISO
• D13 (SCLK) —> SCLK
• D10 (SS) —> RESET
• 5V —> VCC
• GND —> GND

Now, based on the foregoing discussion, we can connect the Arduino board to the Digispark ATtiny85 board using the following terminals:

Arduino Board —> Digispark ATtiny85 Board
D11 (MOSI) —> PB0(MOSI)
D12 (MISO) —> PB1(MISO)
D13 (SCLK) —> PB2(SCLK)
D10 (SS) —> PB5(RESET)
5V —> 5V
GND —> GND

For reference purposes, the Digispark ATtiny85 development board pinout is shown below. For more information on Digispark ATtiny85, you may consult the Digispark ATtiny85 Pinout and Configuration.

Shown below is the Fritzing breadboard diagram for connecting the Arduino Nano board to the Digispark ATtiny85 board.

How to connect the Arduino Nano board to the Digispark ATtiny85 board illustrated by an old-school schematic diagram.

After connecting the Arduino board to the Digispark ATtiny85 board, we are now ready to test drive the Arduino board as an ISP programmer.

Since we are going to work with the Digispark ATtiny85 board, you must have the board core ATTinyCore by Spence Konde installed on your Arduino IDE. If you do not have the ATTinyCore installed yet, see the article How to Install ATTinyCore on Arduino IDE.

STEP 7 – Copy and Paste the Blink Program.

Going back to the Arduino IDE, create a new sketch and then copy and paste the Blink program sketch shown below.

/*
www.cyberblogspot.com
07Jan2022  
*/

#define LED_BUILTIN 1  //PB1 for Model A
                       //PB0 for Model B

void setup() {
  // initialize digital pin LED_BUILTIN as an output.
  pinMode(LED_BUILTIN, OUTPUT);
}

// the loop function runs over and over again forever
void loop() {
  digitalWrite(LED_BUILTIN, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(1000);                       // wait for a second
  digitalWrite(LED_BUILTIN, LOW);    // turn the LED off by making the voltage LOW
  delay(1000);                       // wait for a second
}

STEP 8 – Change the board from Arduino board to Digispark ATtiny85 board.

Go to Tools/Board/ATTinyCore and select ATtiny25/45/85 (No bootloader). Take note that we are using the “No bootloader” option and NOT the “Micronucleus/Digispark” option. This is because we are going to upload the Blink sketch via an ISP programmer (the Arduino board) and not thru the Digispark’s USB port.

STEP 9 – Select the proper COM port.

Go to Tools/Port and choose the correct COM port from the ports list.

STEP 10 – Select the programmer type.

On the Tools/Programmer menu, select Arduino as ISP as the programmer type.

STEP 11 – Upload the Blink program.

Upload the Blink program by clicking on the Upload button.

When you see the message saying that the upload is done, your Digispark ATtiny85 board should start blinking the built-in LED.

How to Burn Bootloader on Digispark ATtiny85 Using Arduino as ISP Programmer

Burn Optiboot Bootloader

STEP 1 – Select ATtiny45/85 (Optiboot) from the ATtinyCore list.

STEP 2 – Verify that the proper COM port is selected.

STEP 3 – Make sure that the programmer selected is “Arduino as ISP”.

STEP 4 – Click “Burn bootloader” to start the burning process.

Burn Micronucleus Bootloader

To burn the Micronucleus bootloader onto the Digispark ATtiny85 board using the Arduino as ISP programmer, follow the steps above for burning the Optiboot bootloader. However, instead of selecting ATtiny45/85 (Optiboot), select ATtiny85 (Micronucleus / Digispark) from the ATtinyCore list of supported devices.

References on How to Use Arduino as ISP Programmer

In-System Programming (ISP)
How to Install ATTinyCore on Arduino IDE
How to Program ATtiny85 with Arduino IDE
Digispark ATtiny85 Pinout and Configuration
How to Program Digispark ATtiny85 Board with Arduino IDE
Digispark USB Device Not Recognized
How to Use AT-09 BLE with Arduino and Smartphone

The post How to Use Arduino as ISP Programmer appeared first on CyberBlogSpot.

Types of Digispark Boards

Figure 1 shows the two (2) popular versions of the Digispark ATtiny85 development boards. The one on the left uses a type-A USB connector to connect directly to the USB port of a PC or a laptop. On the other hand, the board on the right has a micro-USB connector. As a result, we need a micro-USB cable to connect this to a computer for programming purposes.

It should be observed that both boards have the same pin layout. We can breadboard them as long as we do not connect a header pin to the VIN terminal.

Figure 2 is a picture of another type of Digispark ATtiny85 board. As shown in the picture, the board does not have an ATtiny85 chip but instead only an 8-pin DIP socket. We must provide a DIP-type ATtiny85 chip in order to use this board. Also, the pin layout of this board is different. This board is not breadboard friendly. However, the pin layout is ICSP-programmer ready. That is, the pins are arranged so as to accept the female connector of an AVR ICSP-programmer.

It must be mentioned here that technically, this board is not (yet) a Digispark ATtiny85 board. A Digispark ATtiny85 board has an ATtiny85 chip that was burned with a Micronucleus bootloader. In order to make this board a Digispark board, it needs an ATtiny85 chip that was pre-programmed with a Micronucleus bootloader. Otherwise, an ATtiny85 without a bootloader can be inserted into the DIP socket and an ICSP programmer is used to burn a new Micronucleus bootloader into it.

Digispark ATtiny85 Specifications

• Support for the Arduino IDE 1.0+ (OSX/Win/Linux)
• Power via USB or External Source – 5v or 7-35v (12v or less recommended, automatic selection)
• On-board 500ma 5V Regulator
• Built-in USB
• 6 I/O Pins (2 are used for USB only if your program actively communicates over USB, otherwise you can use all 6 even if you are programming via USB)
• 8k Flash Memory (about 6k after bootloader)
• I2C and SPI (vis USI)
• PWM on 3 pins (more possible with Software PWM)
• ADC on 4 pins
• Power LED and Test/Status LED

Digispark ATtiny85 Pinout

Digispark ATtiny85 Pinout Description

ATtiny85 Breakout

First of all, by referring to Figure 3, you will notice that the Digispark board serves as a breakout board for the ATtiny85 chip. All of the eight pins of the ATtiny85 chip are accessible. The physical pins of the ATtiny5 chip are designated by the gray-colored pinouts numbered 1 to 8.

Six (6) Digital I/O Pins

As per specification, the Digispark ATtiny85 board can be configured to use six (6) digital I/O ports. These ports are shown in Figure 3 as yellow pins, labeled PB0 to PB5. NOTE: Port B pin PB5 is by default configured as a RESET pin. In order to use PB5 as an I/O port, an ATtiny85 fuse (RSTDISBL) has to be reset (changed from 1 to 0). Please see How to Reset ATtiny85 Fuses.

Arduino IDE Programming Notes

In the Arduino IDE, pins PB0 to PB5, when used as digital I/O are referred to as 0 to 5. That is,

/*
cyberblogspot.com 09Jan2023
*/

bool a, b, c;

void setup() {
  // put your setup code here, to run once:
  pinMode(0, INPUT);   //set PB0 as input
  pinMode(1, INPUT);   //set PB1 as input
  pinMode(2, INPUT);   //set PB2 as input
  pinMode(3, OUTPUT);  //set PB3 as output
  pinMode(4, OUTPUT);  //set PB4 as output
  pinMode(5, OUTPUT);  //set PB5 as output
}

void loop() {
  // put your main code here, to run repeatedly:
  a = digitalRead(0);     //read PB0
  b = digitalRead(1);     //read PB1
  c = digitalRead(2);     //read PB2
  digitalWrite(3, LOW);   //set PB3 LOW
  digitalWrite(4, LOW);   //set PB4 LOW
  digitalWrite(5, HIGH);  //set PB5 HIGH
}

Four (4) Analog to Digital Converter (ADC) Ports

Port B ports PB2 to PB5 can be configured as analog inputs. These pins are shown in Figure 3 as orange pins. The pins are labeled ADC0 to ADC3. Be aware that the Port B numbers do not exactly match the ADC port numbers. In other words, PB2 does not correspond ADC2, PB3 does not correspond to ADC3, and so on. Instead,

• ADC0 is PB5
• ADC1 is PB2
• ADC2 is PB4
• ADC3 is PB3

Arduino IDE Programming Notes

When using the command analogRead(), Arduino IDE assumes you are using the ADC port numbers (0 for ADC0, 1 for ADC1, 2 for ADC2, and 3 for ADC3) and NOT the Port B numbers (0 for PB0, 1 for PB1, 2 for PB2, 3 for PB3, 4 for PB4, and 5 for PB5). However, the pinMode() command expects you to use the Port B numbers. This is one of ATtiny85’s peculiarities that is very confusing. The example code below should clear this up.

/*
cyberblogspot.com 09Jan2023
*/

int a, b, c, d;

void setup() {
// put your setup code here, to run once:
// the following four lines of code are actually not needed
// because by default the I/O pins are in Hi-Z INPUT mode
pinMode(2, INPUT); //set PB2 as input
pinMode(3, INPUT); //set PB3 as input
pinMode(4, INPUT); //set PB4 as input
pinMode(5, INPUT); //set PB5 as input
}

void loop() {
// put your main code here, to run repeatedly:
a = analogRead(0); //read ADC0 which is in PB5
b = analogRead(1); //read ADC1 which is in PB2
c = analogRead(2); //read ADC2 which is in PB4
d = analogRead(3); //read ADC3 which is in PB3
}

Three (3) Pulse Width Modulation (PWM) Outputs

Referring again to Figure 3, there are three (3) PWM outputs available on Digispark ATtiny85 boards. These are colored green in the pinout shown above and are labeled as PWM0, PWM1, and PWM4. There is no typo error here. The third PWM output is labeled as PWM4 because the PWM port numbers use the same Port B numbers. To clarify,

• PWM0 is PB0
• PWM1 is PB1
• PWM4 is PB4

Arduino IDE Programming Notes

The PWM output signal is generated by the command analogWrite(). Although we are going to use the ports as analog outputs, we DO NOT use the ADC port numbers. Rather, we use the PWM port numbers which are the same as the Port B numbers. In other words, we are also using the Port B numbers in programming PWM in the Arduino IDE. Please take a look at the following sketch.

/*
cyberblogspot.com 09Jan2023
*/

void setup() {
  // put your setup code here, to run once:
  pinMode(0, OUTPUT);  //set PB0 (PWM0) as output  
  pinMode(1, OUTPUT;  //set PB1 (PWM1) as output
  pinMode(4, OUTPUT);  //set PB4 (PWM4) as output
}

void loop() {
  // put your main code here, to run repeatedly:
  analogWrite(0, 255);  //100% duty cycle PWM on PB0
  analogWrite(1, 128);  //50% duty cycle PWM on PB1
  analogWrite(4, 0);    //0% duty cycle PWM on PB4
}

SPI (Serial Peripheral Interface) Communication

Ports PB0, PB1, and PB2 can be used for SPI communication:

• MOSI – PB0
• MISO – PB1
• SCLK – PB2

I²C (Inter-Integrated Circuit) Communication

Ports PB0 and PB2 can be used for I2C communication:

• SDA – PB0
• SCK – PB2

USB (Universal Serial Bus) Communication

Ports PB3 and PB4 can be used for USB communication:

• USB- is PB4
• USB+ is PB3

Pin Change Interrupt and External Interrupt

Finally, ports PB0 to PB5 can all be used for pin change interrupt and PB2 as external interrupt pin.

Final Notes on Port B Pins

PB5 has limited current sourcing capacity. Also, when it is at output HIGH, it generates 3V instead of 5V on its output.

PB3 and PB4 are both used during programming (sketch upload). Therefore, it may be necessary to temporarily disconnect the circuits connected to them to avoid interfering with the uploading of sketches. Additionally, PB3 has a 1.5K pull-up resistor that is used for USB communication.

PB0 or PB1 has the built-in LED attached to it. Version A boards use PB1 while version B boards use PB0.

Digispark ATtiny85 Schematic Diagram

References on Digispark ATtiny85 Pinout and Configuration

http://digistump.com/wiki/digispark
ATtiny85 External and Pin Change Interrupt
How to Install Arduino IDE on Windows 10
How to Install ATTinyCore on Arduino IDE
How to Program ATtiny85 with Arduino IDE
How to Program Digispark ATtiny85 Board with Arduino IDE
Digispark USB Device Not Recognized
How to Use AT-09 BLE with Arduino and Smartphone

The post Digispark ATtiny85 Pinout and Configuration appeared first on CyberBlogSpot.

A bare chip ATtiny85 needs to be connected to an ICSP (aka ISP) programmer in order to upload Arduino sketches. To facilitate programming, Digistump created the Digispark ATtiny85 USB Development Board. The Digispark ATtiny85 board does not need an ICSP programmer. Instead, it is directly connected to the USB port of the computer hosting the Arduino IDE. This is the normal way of how to program a Digispark ATtiny85 board.

Difference in Uploading the Sketch

Although a Digispark ATtiny85 board plugs directly into a USB port like any other Arduino development board, there is a slight difference in uploading a program or a sketch. While an Arduino board is connected first to the USB port prior to uploading a sketch, the Digispark board is connected to the USB port after initiating the upload sketch procedure. That is, to upload a sketch to the Digispark board, you have to first press the “Upload” button on the Arduino IDE. Afterwards, a message saying “Please plug in the device (will time out in 60 secs)” will appear on the Arduino IDE. Then, you plug in the Digispark board and the sketch starts uploading. Finally, when the sketch is successfully uploaded, Digispark will run the sketch automatically after five (5) seconds (not instantly as in other Arduino boards).

Configuring Arduino IDE for Digispark ATtiny85 Programming

To program the Digispark ATtiny85 board, first, install the latest version of Arduino IDE if you do not have the Arduino IDE yet on your computer. If you need help on installing the Arduino IDE, please see How to Install Arduino IDE on Windows 10 if you are using Microsoft Windows.

Next, you need to install the ATtinyCore on the Arduino IDE in order for Arduino IDE to recognize the Digispark ATtiny85 boards. You may want to read the article How to Install ATtinyCore on Arduino IDE.

Uploading the Blink Program on Arduino IDE

STEP 1 – Open the Arduino IDE and select the proper board.

STEP 2 – Create a new sketch. Then copy and paste the sketch below.

/*
www.cyberblogspot.com
07Jan2022  
*/

#define LED_BUILTIN 1  //PB1 for Model A
                       //PB0 for Model B

void setup() {
  // initialize digital pin LED_BUILTIN as an output.
  pinMode(LED_BUILTIN, OUTPUT);
}

// the loop function runs over and over again forever
void loop() {
  digitalWrite(LED_BUILTIN, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(1000);                       // wait for a second
  digitalWrite(LED_BUILTIN, LOW);    // turn the LED off by making the voltage LOW
  delay(1000);                       // wait for a second
}

STEP 3 – Click on the Upload button.

STEP 4 – Insert the Digispark ATtiny85 board into the USB port when the message to do so appears.

If the message “USB device not recognized” appears when you insert the Digispark ATtiny85 board, the board may not have the Micronucleus bootloader installed. See the article Digispark USB Device Not Recognized to resolve the issue.

After the last step, you should see the messages as shown below and the LED on the Digispark ATtiny85 board should start blinking.

Important Notes on Digispark ATtiny85 I/O Ports

According to specifications, Digispark ATtiny85 boards support a total of six (6) digital I/O ports. However, there are several points to consider. Please refer to the Digispark ATtiny85 pinout in Figure 6.

• PB5 is by default being used as a Reset pin, hence, unavailable as a digital IO. ATtiny85 fuses have to be set to enable PB5 as an IO port. Moreover, PB5, when used as an output port, have some peculiarities. When it is at output HIGH, its output is 3V instead of 5V. Aside from that, it has limited current sourcing capability unlike the other ports that can source up to 20 milliamperes (20mA).
• Either PB0 or PB1 is used by the built-in LED depending on the Digispark model. Model A uses PB1 while Model B uses PB0. The explanation can be found here: Digispark Model A vs Model B.
• PB3 is used as USB+ for USB communication and has a 1.5K pull-up resistor.
• PB4 is used as USB- also for USB communication.

How to Address or Reference Digispark ATtiny85 Ports in Program

When programming the Digispark ATtiny85 in Arduino IDE, references to the IO ports differ between digital IO and analog input. When using the ports as digital input or digital output, PB0 to PB5 are referred to by their port numbers. That is, PB0 is 0, PB1 is 1, PB2 is 2, PB3 is 3, PB4 is 4, and PB5 is 5. For example:

pinMode(0, INPUT);  //PB0 is input
pinMode(1, INPUT);  //PB1 is input
pinMode(2, INPUT);  //PB2 is input
pinMode(3, OUTPUT);  //PB3 is output
pinMode(4, OUTPUT);  //PB4 is output
pinMode(5, OUTPUT);  //PB5 is output
bool x,y,z;
x = digitalRead(0);  //read PB0
y = digitalRead(1);  //read PB1
z = digitalRead(2);  //read PB2 
digitalWrite(3, HIGH);  //make PB3 HIGH  
digitalWrite(4, HIGH);  //make PB4 HIGH 
digitalWrite(5, LOW);  //make PB5 LOW

However, when the ports are used as analog input, the port references are different. Please refer to Digispark ATtiny85 pinout in Figure 6. There are only four (4) ports usable as ADC input. These are PB2, PB3, PB4, and PB5. Their corresponding ADC port numbers are ADC1, ADC3, ADC2, and ADC0. In other words,

• PB2 is ADC1
• PB3 is ADC3
• PB4 is ADC2
• PB5 is ADC0

As an example,

//pinMode() always refer to the Port B numbers
//applicable to both digital and analog I/O
pinMode(5, INPUT);  //Make PB5 as input (ADC0)
pinMode(2, INPUT);  //Make PB2 as input  (ADC1)
pinMode(4, INPUT);  //Make PB4 as input (ADC2)
pinMode(3, INPUT);  //Make PB3 as input (ADC3)
int a, b, c, d; 
//Uses analog port numbers instead of Port B numbers
a = analogRead(0);  //Read PB5
b = analogRead(1);  //Read PB2
c = analogRead(2);  //Read PB4
d = analogRead(3);  //Read PB3

Now, how about analogWrite()? Does it use the analog port numbers too? The answer is NO.

Again, referring to the Digispark ATtiny85 pinout above, there are three (3) ports capable of PWM outputs. These are PB0, PB1, and PB4. Let us look at an example of how to use them.

//all port references are Port B numbers like digitalRead() and digitalWrite()
pinMode(0, OUTPUT);
pinMode(1, OUTPUT);
pinMode(4, OUTPUT); 
analogWrite(0, 255);  //100% duty cycle (fully on) PWM on PB0
analogWrite(1, 128);  //50% duty cycle PWM on PB1
analogWrite(4, 0);  //0% duty cycle (off) PWM on PB4

Summary on How to Address or Reference Digispark ATtiny85 Ports in Program

To summarize, the commands pinMode(), digitalRead(), digitalWrite(), and analogWrite() all use the Port B number references. Specifically, 0 for PB0, 1 for PB1, 2 for PB2, 3 for PB3, 4 for PB4, and 5 for PB5. However, as an exception, analogRead() uses its own ADC port numbers. Namely, 0 for PB5, 1 for PB2, 2 for PB4, and 3 for PB3.

References on How to Program Digispark ATtiny85 Board with Arduino IDE

How to Program ATtiny85 with Arduino IDE
Digispark USB Device Not Recognized
How to Enable Serial Monitor on Digispark ATtiny85
Digispark ATtiny85 Pinout and Configuration
How to Use AT-09 BLE with Arduino and Smartphone
Arduino IDE Download Page
ATtinyCore by SpenceKonde on Github
Digispark Model A Versus Model B

The post How to Program Digispark ATtiny85 Board with Arduino IDE appeared first on CyberBlogSpot.