Investigation of Wi-Fi (Esp8266) Module and Application To An Audio Signal Transmission by Tatap Perets

INVESTIGATION OF WI-FI (ESP8266) MODULE AND APPLICATION TO AN AUDIO
SIGNAL TRANSMISSION
CHAPTER I: GENERAL INTRODUCTION
1.1 BACKGROUND AND CONTEXT OF STUDY

Technology goes ahead exponentially with each year whether we do something or not. With the
same speed engineers work hard to reduce the size of every electronic device or component and
loose most of the wiring. If you look back 20 years ago a device was called portable if you could
rise it in your arms and carry up. Today nothing is portable if it can’t fit in your pocket.
Nowadays devices, either they are made for regular or industrial use, are based on wireless
communication technology and the main reason is not to get rid of wires, but to be able to
interconnect between them. Meanwhile buying a wireless device became natural for everyone
and price for Wi-Fi Ready equipment lowered with time passing.
While you read this, a WiFi microchip has no more than 5mm length and can be powered with as
low as 10 micro Amps during sleep period. In this article we are going to test one of the cheapest
and easy to use WiFi development platform, the ESP8266 Arduino compatible device.
1.2PROBLEM STATEMENT
Nowadays, everything is moving toward the Internet of Things (IoT). Devices employ
microchips connected to the internet. A lot of work is put in place when dealing with the manual
configuration of devices. With this module, many IoT projects can be performed, one including
the transmission of audio signals over a great distance, even up to 1 km.
1.3OBJECTIVES
1.3.1 General Objectives
The ultimate objective of this project is to transmit an audio signal using the WiFi ESP8266
module. The receiver module will decode the signal and deliver the output for given purposes.
1.3.2 Specific Objectives

 To flash the firmware.
 To program the code to be used for the Wi-Fi.
 To connect a phone to the WiFi module using an App.
 To stream an audio signal through WiFi.
 To construct a 3.3 V regulator for the power supply of the ESP8266.
DISSERTATION/ BATCHANOU TATAP PERETS ARNAUD/ FE15A031/LEVEL 500/ UB/FET/2018-2019

Page | 1
SIGNAL TRANSMISSION
 To establish communication between the two ESP8266 modules, one acting like an AP
and the other like an SP
 To simulate the system on Proteus
1.4 PROPOSED METHODOLOGY
The proposed methodology I took to implement this project is to first of all understand the
functioning principle behind the project and to implement the various hardware and software
needed to realize this project with brilliance.
1.5 RESEARCH QUESTIONS

 How is sound transmitted via the WiFi module?
 What is the characterization of the sound signal?
 Which modulation process best suits the sound to be transmitted?
 How does one receive the sound code?
 Which IDE runs the code?
 How are the connections made for the sound to be transmitted?
1.6 RESEARCH HYPOTHESIS
The research hypothesis I used was to know whether or not the sound to be transmitted was
analog or digital. The format of the sound is very important for the smooth functioning of the
system.
1.7 SIGNIFICANCE OF STUDY

This project means a lot to the Telecommunications Engineer because it would mean a new era
in technology and the IoT because this will enable not only audio transmission to be done via
WiFi, but also a whole series of IoT projects can be performed.
1.8 SCOPE OF STUDY

The project encompasses a scope of study on wireless transmission, knowledge on audio sensors,
modulation techniques and norms and protocols, through simulation on Fritzing and finally
implementation using the ESP8266 module and the audio sensor.
1.9 DELIMITATION OF THE STUDY

 The ESP8266 module works only with 3.3 V hence this project is not easily adaptable. Any
other higher voltage will fry the module.
 The ESP-01 has just 2 GPIO pins hence not many signals can be transmitted at a time.
Page | 2
SIGNAL TRANSMISSION
1.10 DEFINITION OF KEYWORDS AND TERMS

 ESP8266: ESP8266 is a WiFi module that offers a complete and self-contained Wi-Fi
networking solution, allowing it to either host the application or to offload all Wi-Fi
networking functions from another application processor.
 IoT: IoT means ‘Internet of Things’. It is a worldwide family that deals with the wireless
connectivity of appliances via electronic and programmed devices in order to do specific
functions e.g. home automation. [3]
 WiFi: WiFi stands for Wireless Fidelity. It is a wireless communication system that
enables voice, data, and other signals to be carried from one point to another through radio
waves operating at UHF.
1.11 ORGANIZATION OF DISSERTATION

This dissertation can be organized as follows: Chapter one is a general introduction of the
project, dealing with a background of the study, the statement of problem, the significance of
study and other important points to be taken into consideration before the implementation of the
project.
Chapter two is the literature review, giving fundamentals of wireless communications,

investigation of the Wi-Fi module, characterization of the module, some related works, and the
applications of the module.
Chapter three is the analysis and design of the project. It gives the proposed methodology used to
implement the project, and the various steps to be undertaken for the project to work.
Chapter four gives the implementation of the project and the results obtained. It is in this chapter
that the output is shown and the work proper is demonstrated.
Chapter five gives a general conclusion to the whole work, with a summary of findings,
contribution to Engineering and Technology, open points and future scope.
Finally we have a reference and an appendix section.

Page | 3
SIGNAL TRANSMISSION
CHAPTER II: LITERATURE REVIEW
2.1INTRODUCTION
This chapter is devoted to having a knowledge on the ESP8266 module. This is important to
know how it functions. Proper understanding of the module would serve a means to better use it
for Telecommunication purposes.
2.2GENERAL CONCEPTS ON WIRELESS COMMUNICATIONS

2.2.1 Fundamental Knowledge
Wireless communications, as the name indicates, is communication between two or more devices
without the use of wires. Various wireless systems have been into place, like the GMS,
WCDMA/UMTS and the 4G LTE technologies.
In wireless communications, there must be a sender, a receiver, and a wireless channel for the
transfer of the signals. Many such channels exist. They include radio waves, microwaves, and X-
rays, all part of the EM spectrum.
When looking at the history of communications, we find that wireless communications is

actually the oldest form – shouts and jungle drums did not require any wires or cables to
function. Even the oldest “electromagnetic” (optical) communications are wireless: smoke
signals are based on propagation of optical signals along a line-of-sight connection. However,
wireless communications as we know it started only with the work of Maxwell and Hertz, who
laid the basis for our understanding of the transmission of electromagnetic waves. It was not long
after their groundbreaking work that Tesla demonstrated the transmission of information via
these waves – in essence, the first wireless communications system. In 1898, Marconi made his
well-publicized demonstration of wireless communications from a boat to the Isle of Wight in
the English Channel. It is noteworthy that while Tesla was the first to succeed in this important
endeavor, Marconi had the better public relations, and is widely cited as the inventor of wireless
communications, receiving a Nobel Prize in 1909.
In the subsequent years, the use of radio (and later television) became widespread throughout
the world. While in the “normal” language, we usually do not think of radio or TV as “wireless
communications,” they certainly are, in a scientific sense, information transmission from one

Page | 4
SIGNAL TRANSMISSION
place to another by means of electromagnetic waves. They can even constitute “mobile
communications,” as evidenced by car radios. A lot of basic research – especially concerning
wireless propagation channels – was done for entertainment broadcasting. By the late 1930s, a
wide network of wireless information transmission – though unidirectional – was in place.
When considering wireless communications, the following parameters need to be taken into
consideration: frequency, waveform, antennas, and spread spectrum, modulation,
multiplexing and signal propagation. The table below gives the different frequency bands and
the classification between them.
Table 1: Classification of different frequency bands
In wireless communications we have analog and digital signals. Analog signals are signals in a
continuous waveform while digital signals are discrete signals. I.e. they are analog signals that
have been sampled, quantized and encoded. The figure below shows examples of analog and
digital signals.
An Electromagnetic signal can be expressed in function of time or frequency, with an amplitude

and phase. The equation below best describes EM signals travelling in air:
S (t) = At sin (2 π ft t + φt) where ft is the frequency of the signal and φt is the phase.

Page | 5
SIGNAL TRANSMISSION
Fig 5: Analog and Digital signals
The table below shows the various frequency bands in MHz and their applications in wireless
communications.

Page | 6
SIGNAL TRANSMISSION
Table 2: Frequency bands (in MHz) and their standards worldwide
2.2.2 WIFI
At its most basic, Wi-Fi is the transmission of radio signals. WiFi is an IEEE 802.11 standard
dealing with a packet protocol that defines data transmission and manages location-independent
network access using radio signals.
Wi-Fi is a physical/link layer interface, as is Ethernet. The layers above the physical and data
link layers include TCP/IP. On a practical level, this means that all Rabbit sample programs and
customer applications for TCP/IP that are run on an Ethernet interface will also run on a Wi-Fi
interface.
WiFi networks work with two signals:
2.4 GHz – It comprises 14 channels, each with a bandwidth of approximately 20 to 22 MHz

operating in the ISM band. 802.11b/g networks operate in the 2.4 GHz band. It is a crowded
frequency because many devices other than 802.11 devices operate in it. For example, Bluetooth
as well as many consumer products such as microwaves, telephones, and garage door openers,
baby monitors, etc.

Page | 7
SIGNAL TRANSMISSION
5 GHz – It comprises 13 channels, each with a bandwidth of approximately 20 MHz operating in

the U-NII band. 802.11a networks operate in the 5 GHz band. Currently, this band is less
crowded than 2.4 GHz, but this is likely to change as the wireless market continues to grow.
Fig 1: Wireless Local Area Network connected to the internet
 Benefits of Wi-Fi
1. Wireless Ethernet: Wi-Fi is an Ethernet replacement. Wi-Fi and Ethernet, both IEEE
802 networks, share some core elements.
2. Extended Access: The absence of wires and cables extends access to places where
wires and cables cannot go or where it is too expensive for them to go.
3. Cost Reduction: As mentioned above, the absence of wires and cables brings down
cost. This is accomplished by a combination of factors, the relatively low cost of
wireless routers, and no need for trenching, drilling and other methods that may be
necessary to make physical connections.
4. Mobility: Wires tie you down to one location. Going wireless means you have the
freedom to change your location without losing your connection.
Page | 8
SIGNAL TRANSMISSION
5. Flexibility: Extended access, cost reductions, and mobility create opportunities for new
applications as well as the possibility of creative new solutions for legacy applications.
[12]
2.2.3 Investigation of the ESP8266 WiFi module (ESP-01)

 Overview
Figure 1: ESP -01 module, variant of ESP8266 [1]
The ESP8266 is a low-cost Wi-Fi microchip with full TCP/IP stack and microcontroller
capability produced by manufacturer Espressif Systems in Shanghai, China. [1]
ESP8266 offers a complete and self-contained Wi-Fi networking solution, allowing it to either
host the application or to offload all Wi-Fi networking functions from another application
processor. [7]
When ESP8266 hosts the application, and when it is the only application processor in the device,
it is able to boot up directly from an external flash. It has integrated cache to improve the
performance of the system in such applications, and to minimize the memory requirements.
Alternately, serving as a Wi-Fi adapter, wireless internet access can be added to any
microcontroller-based design with simple connectivity through UART interface or the CPU
AHB bridge interface.
ESP8266 on-board processing and storage capabilities allow it to be integrated with the sensors
and other application specific devices through its GPIOs with minimal development up-front and

Page | 9
SIGNAL TRANSMISSION
minimal loading during runtime. With its high degree of on-chip integration, which includes the
antenna switch balun, power management converters, it requires minimal external circuitry, and
the entire solution, including front-end module, is designed to occupy minimal PCB area.
Sophisticated system-level features include fast sleep/wake context switching for energy-
efficient VoIP, adaptive radio biasing for low-power operation, advance signal processing, and
spur cancellation and radio co-existence features for common cellular, Bluetooth, DDR, LVDS,
LCD interference mitigation.
Table 3: Characterization of ESP-01 module

Manufacturer Espressif Systems
Type 32-bit microcontroller
CPU @ 80 MHz default or 160 MHz
Memory 32KiB instruction, 80 KiB user data
Input 2 GPIO pins
Wi-Fi Protocols 802.11/b/g/n
Operating voltage 3.3 V
Operating current 800 mA
Network Protocols IPv4, TCP/UDP/HTTP/FTP
Successor ESP 32
Price 3$
 Pin Specifications
 Features
 32-pin QFN package
 Integrated RF switch, balun, 24dBm PA, DCXO, and PMU
 Integrated RISC processor, on-chip memory and external memory interfaces
 Integrated MAC/baseband processors

Page | 10
SIGNAL TRANSMISSION
 Quality of Service management
 I2S interface for high fidelity audio applications
 On-chip low-dropout linear regulators for all internal supplies
 Proprietary spurious-free clock generation architecture
 Integrated WEP, TKIP, AES, and WAPI engines
 11 b/g/n
 Wi-Fi Direct (P2P), soft-AP
 Integrated TCP/IP protocol stack
 Integrated TR switch, balun, LNA, power amplifier and matching network
 Integrated PLLs, regulators, DCXO and power management units
 +19.5dBm output power in 802.11b mode
 Power down leakage current of <10uA
 Integrated low power 32-bit CPU could be used as application processor
 SDIO 1.1/2.0, SPI, UART
 STBC, 1×1 MIMO, 2×1 MIMO
 A-MPDU & A-MSDU aggregation & 0.4ms guard interval
 Wake up and transmit packets in < 2ms
 Standby power consumption of < 1.0mW (DTIM3)
Figure 2: Pin specifications of ESP-01

Page | 11
SIGNAL TRANSMISSION
 Electronic Characteristics of ESP8266

1.Current Consumption
The following current consumption is based on 3.3V supply, and 25℃ ambient, using internal
regulators. Measurements are done at antenna port without SAW filter. All the transmitter’s
measurements are based on 90% duty cycle, continuous transmit mode.
Tab 4: ESP8266 Current Consumption Modes
Mode Min Typ Max Unit
Transmit 802.11b, CCK 1Mbps, POUT=+19.5dBm 215 mA
Transmit 802.11b, CCK 11Mbps, POUT=+18.5dBm 197 mA
Transmit 802.11g, OFDM 54Mbps, POUT =+16dBm 145 mA
Transmit 802.11n, MCS7, POUT=+14dBm 135 mA
Receive 802.11b, packet length=1024 byte, -80dBm 60 mA
Receive 802.11g, packet length=1024 byte, -70dBm 60 mA
Receive 802.11n, packet length=1024 byte, -65dBm 62 mA
Standby 0.9 mA
Deep Sleep 10 mA
Power Save Mode DTIM 1 1.2 mA
Power Save Mode DTIM 3 0.86 mA
Total Shutdown 0.5 mA

Page | 12
SIGNAL TRANSMISSION
2. RF Performance
The following are measured under room temperature conditions with 3.3V and 1.1V power
supplies.
Tab 5: ESP8266 RF Performance

Description Min Typical Max Unit
Input frequency 2412 2484 MHz
Input impedance 50 Ω
Input reflection -10 dB
Output power of PA for 72.2Mbps 14 15 16 dBm
Output power of PA for 11b mode 17.5 18.5 19.5 dBm
Sensitivity
CCK, 1Mbps -98 dBm
CCK, 11Mbps -91 dBm
6Mbps (1/2 BPSK) -93 dBm
54Mbps (3/4 64-QAM) -75 dBm
HT20, MCS7 (65Mbps, 72.2Mbps) -71 dBm
Adjacent Channel Rejection
OFDM, 6Mbps 37 dB
OFDM, 54 Mbps 21 dB
HT20, MCS0 37 dB
HT20, MCS7
 Pros of ESP8266
 The main advantage is that it is very cheap starting from $3. [1]
 It can act like AP (Access Point) or connect to AP or both.

Page | 13
SIGNAL TRANSMISSION
 It can be used in Home Automation devices.
 It can very well receive commands via the internet or local host.
 It can act like an Arduino.
 The ESP8266 is also faster and stores more than the Arduino
 CONS OF ESP8266
The main disadvantage of the ESP-01 is that it has only 2 GPIO pins. Hence in this respect, the
ESP-12 would be preferable.
 APPLICATIONS OF ESP8266 WIFI MODULE

The ESP8266 WiFi module (ESP-01) can be used in the following ways:
 Audio Signal Transmission
 Smart Power Plug
 Home Automation
 Mesh Network
 Industrial Wireless Control
 Baby Monitor
 Network Camera
 Sensor Networks
 Wearable Electronics
 Wireless Location-aware devices
 Security ID tag
 Wireless positioning system signals [7]

Page | 14
SIGNAL TRANSMISSION
2.3RELATED WORKS
A lot of related works were carried out by previous Engineers in the same technology. Sven 337
used the ESP8266 module to send the sound data of a baby over WiFi to a receiver (mum) at the
other room. This project helps in determining the state of the baby (baby monitor).
In [8] Dola Chakraborty developed a system capable of performing Voice Controlled Home
Automation using the ESP8266 NodeMCU. This system is designed to control electrical devices
throughout the house with ease of installing it, ease of use and cost effective design and
implement.
Rahul Singh and Saheli Dutta in [9] undertook the project of controlling home appliances via
Bluetooth, which is similar to WiFi home automation.
2.4PARTIAL CONCLUSION
In this chapter we have seen the fundamentals in the Engineering of the project. In the next
chapter we shall see the analysis and design of the project.

Page | 15
SIGNAL TRANSMISSION
CHAPTER III: ANALYSIS AND DESIGN
3.1INTRODUCTION
This chapter is devoted to understanding the methodology used to implement the project. It deals
with the various steps taken for the project to work.
3.2PROPOSED METHODOLOGY
This is a clear understanding of the path needed to undertake in order to achieve the goal of the
project. The ultimate objective of this project is to investigate the ESP8266 WiFi module and
apply it to an audio signal transmission. The investigation part has been done in the previous
chapters, where the RF characteristics, power consumption, specs and features of the ESP-01
module were given, together with the pin specifications and operating voltage. The next phase is
to use the ESP8266 to transmit an audio signal.
The methodology employed will be based on the investigation of the module and will be such as
to get an input sound signal, transmit the sound data over the WiFi frequency to the receiver, and
output through a loud speaker. Two ESP8266 modules will be used for this; one a server and the
other a client. Firstly, a serial communication will be established between the two modules to
ensure that any data can be transmitted. Then the sound data will be sent. A flow diagram shows
the different steps needed to be taken for this project.

Page | 16
SIGNAL TRANSMISSION
3.3 DESIGN
Start
Collect hardware/software and

Setup IDE for the ESP8266
Establish connection between two

ESP8266; transmitter and receiver
Upload transmitter and receiver

codes for audio signal transmission
Implement project with sound

sensor and speaker
No
Is there sound
transmission?
Check code and
circuit connection
Yes
Is there sound No
reception?
Check code and
Yes circuit connection
End
Fig 5: Project Flowchart

Page | 17
SIGNAL TRANSMISSION
The following circuit was simulated on Proteus to serve as a guide to the actual work that is to be
done in the project. No libraries of ESP-01 were found online, just that of ESP-12 were found,
and that is what was used during simulation.
Fig 5: Proteus Simulation
3.4 GLOBAL ARCHITECTURE OF THE SOLUTION

The figure above depicts the global architecture of the solution. For the purpose of audio signal
detection, the sound sensor SOUND1 was used. The signal, being analogous,, is converted to
digital format which will enter the GPIO2 pin of the ESP8266 as the sound data to be transmitted
via the WiFi 2.4 GHz band to the receiver, which will decode the data and reconvert it to analog
format though the PLL frequency demodulator, to be given on the loud speaker.

Page | 18
SIGNAL TRANSMISSION
ESP8266 ESP8266
sender receiver
PLL module module PLL
frequency frequency Loud
modulator AP SP
Sound demodulator speaker
Fig 7: Project Block Diagram
3.5 DESCRIPTION OF THE RESOLUTION PROCESS

The project will be solved as shown: The various steps taken for the construction of the project
will be elaborated carefully, from collecting the hardware/software as shown in the flow chart to
the implementation and testing of the system. Everything shall be explained in detail for clarity
purposes.
Working of ESP8266:
1. First we connect and set-up the environment required for ESP8266,that is through the
Arduino-IDE. Nowadays there are many different platforms to run ESP8266, but since
Arduino is universal, we will use that.
2. The ESP8266 needs to be flashed with a firmware which will host the program. In this too
there are many different firmware(s). And it needs to be put into Flash mode before
flashing.
3. After Flashing we upload our program in the same way like an Arduino but with a small
catch that the ESP8266 needs to be put into Boot loader mode before uploading.
4. Saving the program on the ESP8266 so that it does not reset after restarting.
5. Last but not the least ONLY 3.3V and NOT 5V. Any other higher voltage may end up
frying the module.
3.6 PARTIAL CONCLUSION

This chapter has presented the analysis and design of the project, giving highlights on the
methodology, the flowchart, the block diagram, the simulation, and the various steps needed to
be undertaken for the project to succeed with brilliance. The next chapter will give the
implementation of the project and the results obtained, together with the interpretation of results.
Page | 19
SIGNAL TRANSMISSION
CHAPTER IV: IMPLEMENTATION/ REALIZATION AND

PRESENTATION OF RESULTS
4.1INTRODUCTION
In this chapter we shall see the implementation of the system, the results and the discussion with
relation with the results.
4.2TOOLS AND MATERIALS USED

4.2.1 System Requirements
A good computer is requires to simulate and implement this project, preferably a Windows 8 or
10 OS or Linux and Ubuntu, with a RAM of at least 2GB, 1GHz processor speed., running on
Arduino IDE.
4.2.2 Hardware
 ESP8266 (ESP-01) WiFi module
 Arduino UNO
 Breadboard
 Jumper wires
 Sound sensor
 Green LED
 Resistors
 Capacitors
4.2.3 Software
 Arduino IDE
 ESP826 Flasher
 Fritzing
 Proteus
4.3DESCRIPTION OF THE IMPLEMENTATION PROCESS
The steps described below are those taken for the implementation of the project.
4.3.1: Collect Material and setup environment for ESP8266

Page | 20
SIGNAL TRANSMISSION
 Collect Material
As stated before, the very first step needed is to collect the material needed to implement the
project. They are all the materials described above.
 Setting Up Environment for ESP8266
Next the environment for programing the ESP8266 needs to be setup. The software used is
Arduino Environment v 1.6.4 or greater. Installing with Boards Manager Starting with 1.6.4,
Arduino allows installation of third-party platform packages using Boards Manager. It has
packages available for Windows, Mac OS, and Linux (32 and 64 bit).
 Install Arduino 1.6.4 (or greater) from the Arduino website (I have 1.6.11). Start Arduino and
open Preferences window.
 Enter http://arduino.esp8266.com/package_esp8266com_ind... into Additional Board

Manager URLs field. You can add multiple URLs, separating them with commas. Open
Boards Manager from Tools > Board menu and install ESP8266 platform (and don't forget to
select your ESP8266 board from Tools > Board menu after installation).
 Start Arduino 1.6.4 or Higher
 Select ‘Tools’- ‘Port’ whatever # your USB-serial is on
 Select ‘Tools’ -‘Board’ ‘Generic ESP8266 Module’
 Select ‘Tools’- ‘CPU Frequency’ ‘80MHz’ or Overclock afterwards at '160Mhz'
 Select ‘Tools’ -‘Flash Size’ ‘512K (64K SPIFFS) and ‘Upload Speed’ ‘115200’ for ESP 12E,
also Some ESPs may be 9600

Page | 21
SIGNAL TRANSMISSION
Photo 2: Setting up the Arduino IDE environment

Page | 22
SIGNAL TRANSMISSION
 Connecting the ESP8266 with Arduino
Photo 3: Arduino to ESP8266 connection on Fritzing
Firstly the Atmega Chip from the Arduino is removed.
1. Vcc and CH_PD ( ENable) to 3.3V on Arduino

2. GND to Ground. ( For ESP -12 , GPIO15 to GND as well )
3. Tx to Tx of Arduino
4. Rx to Rx of Arduino
5. RST , GPIO0, GPIO2 are floating ( Neither High nor Low )
Important part here is the ESP uses more current than the Arduino, thus at risk .Therefore I use
and external DC 9 V, 1 A beside the PC connection.
 Checking the connections

It is very important to check AT commands because they will enable the ESP to connect to a
WiFi in case it acts as a station point. In the appendix section we can see all the AT commands

Page | 23
SIGNAL TRANSMISSION
we can use to check the connections between the ESP8266 and the Arduino (without Atmega).
The ESP modules usually come with a built in AT Firmware by the Ai-Thinker.
 The Arduino IDE is open
 Go to the Serial Monitor (Do select your COM port) and Write: AT. This should return OK
, else it's not working
Possible Errors might be loose connections, the proper baud rate was not selected, the Arduino
COM port is not correct, or the red LED on the ESP 01 is not high, meaning the module is not
supplied.
Some commands we can also check are:
AT+GMR = to check firmware version
AT+RST = Soft reset
AT+CWLAP = Find Nearby Wi-Fi
AT+CWJAP = Connect to a specified AP
 Flashing the Firmware
Photo 5: Flashing the firmware

Page | 24
SIGNAL TRANSMISSION
We need to flash our ESP8266 modules in a firmware that will host the program. So we will
flash a firmware which will make the ESP to take the Arduino Script (Cpp script) and run it.
Now the main step,
The ESP can be programmed by various methods. There are many firmwares for it like the
NodeMCU, ESPBasic, Arduino, etc. The NodeMCU runs on the LUA script but Arduino still
runs on C++ (In my expertise)
So we will flash a firmware which will make the ESP to take the Arduino Script (Cpp script) and
run it. The softwares available are: ESP8266 Flasher, NodeMCU own Flasher, and ESP Flash
Download Tool. The software used is ESP8266 Flasher.
 Open ESP8266 Flasher
 Select the COM port ( Very Important )
 Select the BIN file , i.e. your Firmware file
 Take GPIO0 to GND ( RST and GPIO2 are floating )
 Select 0x00000
 Hit Download
 The Blue Led starts to Blink fast
It will start to Erase and Write firmware (0 to 99%). It will end at saying Unable to leave
Flash mode, don’t worry it's perfectly fine. THE BIN FILE is in THE ZIP (v0.9.2.2 AT
Firmware. bin). Use this.
Possible Errors:
 GPIO0 is not grounded
 Loose connections
 COM port is not correct

Page | 25
SIGNAL TRANSMISSION
If nothing works, restart your ESP and Take the RST (Reset) to Gnd and remove. It will let the
blue Led flash once and try again from the start.
4.3.2: Establishing connection between the transmitter and receiver ESP8266 modules
After all the above steps have been taken, we can now program the ESP8266 module. Many
programmers are available for this, but the programmer I used was the ESP8266 USB-to-Serial
UART programmer shown on the picture.
Photo 5: ES 01 UART Programmer:

The most important part here is to put the ESP module in Boot loader mode before
uploading. i.e. to connect GPIO0 and the ground.
There are two ESP8266 modules. One will act as a server or an Access Point (AP), and the other
as a client or a Station Point (SP). These two modules need to be programmed in this way in
order to initiate communication between the two.
The results of the serial monitor below show the various connections done for both the AP and
SP ESP modules.

Page | 26
SIGNAL TRANSMISSION
Photo 7: Uploading the ESP8266 AP code
4.3.3: Upload transmitter and receiver codes for audio signal transmission
After we have successfully established communication between the two ESP8266 Wi-Fi
modules, one as an AP and the other as an SP, we now need to upload the code for audio signal
transmission and reception on both sides respectively. The various codes are found in the
appendix section below.
4.3.4: Implement project with sound sensor and loud speaker
Once the codes have been uploaded to the WiFi modules, we now need to implement the project
circuit that will get the sound from a sound sensor and at the end receive the signal from a loud
speaker connected at the receiver side.

Page | 27
SIGNAL TRANSMISSION
4.4PRESENTATION AND INTERPRETATION OF RESULTS

The following results were obtained:
Photo 5: Designed system

Page | 28
SIGNAL TRANSMISSION
4.5 EVALUATION OF THE SOLUTION

The evaluation of the solution is measured by the amount of sound that has actually been
transmitted via the ESP8266 WiFi module. From what was implemented on board, we got some
noise data, showing that a lot of interference took place, leading to a weak amount of sound
received.
4.6 PARTIAL CONCLUSION

In this chapter we have seen the implementation of the project, as well as the results obtained.
We can realize from here that the ESP8266 module has been used to transmit an audio signal.

Page | 29
SIGNAL TRANSMISSION
CHAPTER V: CONCLUSION AND FUTURE WORKS
5.1 SUMMARY OF FINDINGS

This study entitled Investigation of WiFi (ESP8266) module and application to an audio signal
transmission aims at understanding the functioning of the WiFi module, which has
revolutionized the IoT, and applying it to transmit an audio signal. This is very important
because devices will henceforth be able to communicate together like this without having to go
through long distances.
The study resolves on general problems:
 Why the necessity of using this project for sound transmission in our today world?
(problem statement)
 What are the different material in making the project and how can they be coupled
together?
 What are the different tests to be done in order to determine the effectiveness and
efficiency of the project?
The first thing considered was investigating the WiFi module and understanding all its
characteristics for the implementation of the project. Then the various materials, both hardware
and software were gathered for the mounting of the circuit. Afterwards, testing and debugging
were done to make sure the project works. Finally the project was tested to see if it meets up to
the task of the objective. i.e. if it can actually transmit audio signal.
5.2 CONTRIBUTION TO ENGINEERING AND TECHNOLOGY

As a contribution to Engineering and Technology, this project can be used in homes or other
domestic or professional places to monitor the cries of babies or of any other vital element that
needs constant attention so as to prevent the occurrence of incidents at home.
It can also be used in large conferences for the distant transmission of sound data to various users
of the WLAN network.

Page | 30
SIGNAL TRANSMISSION
5.3 RECOMMENDATIONS
This project can be recommended to teaching conferences and large centers and auditoriums for
the distant communication between all panelists in the field.
It can also be used as a baby monitor to monitor the cries of babies and respond to them in case
of incidents- in homes, or other domestic purposes.
This project is also recommended in social spheres for the long-distant transfer of sound data
from one user to another.
5.4 DIFFICULTIES ENCOUNTERED

The difficulties I encountered throughout this project work was:
 The establishment of serial communication between the two ESP8266 modules.

 The connection between the sound input sensor and the output loud speaker.
 Programming the ESP8266 with the Arduino IDE due to a lot of bugs found on the line.
 The digitalization of the sound data was not done due t the lack of the PLL component
that could serve this purpose.
5.5 FUTURE WORKS

As a future scope we can try using a webserver to store the sound data before transmission over
WiFi to the receiver module. This leads to a more advance way of communicating with the
ESP8266 modules for the transfer of sensor data.

Page | 31
SIGNAL TRANSMISSION
REFERENCES
[1] http://en.wikipedia.org “ESP8266”, Article, last consultation on the 14/06/2019.
[2] https://www.instructables.com/member/kmanchanda/" “ESP8266 a Complete Beginners

Guide (IOT)”, INSTRUCTABLES, ARTICLE, last consultation on the 14/06/2019.
[3] Geekstips.com, “ESP8266 Arduino tutorial – WiFi module complete review”, 14/06/2019.
[4] ESP266.net, “The Internet of Things with ESP266”, 14/06/2019
[5] EVOTHINGS NAVIGATION, “ How to connect your phone to your ESP8266 module”,
Research Engine, 14/06/2019
[6] Luka RUGGERI “Top 5 wireless ways to communicate with your controller”, OPEN
ELECTRONICS, on March 3 2015.
[7] Sven337, “ESP8266-based DIY WiFi baby monitor”, ARTICLE, sven337@aquilenet.fr, 14

July 2016.
[8] Cnlohr HYPERLINK "https://hackaday.com/author/cnlohr/", “HOW TO DIRECTLY

PROGRAM AN INEXPENSIVE ESP8266 WIFI MODULE”, HACKADAY, April 16, 2019
[9] Andreas F. Molisch, “WIRELESS COMMUNICATIONS”, Second Edition, IEEE, Wiley

and sons, 2011.
[10] Neil Kolban, “Kolban’s book on ESP32”, May 2017.
[11] Rabbit, “An Introduction to WiFi”, PRODUCT MANUAL, Part Number 019-0170
•090409–B Printed in U.S.A. Digi International Inc. © 2007-2008 All rights reserved.

Page | 32
SIGNAL TRANSMISSION
APPENDIX
[Appendix A]: Schematic of the ESP8266 (ESP-01) WiFi module
[Appendix B]: Arduino code for serial communication between the two ESP8266 WiFi modules
(AP code)
/* Create a WiFi access point and provide a web server on it. */
#include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <ESP8266WebServer.h>
#ifndef APSSID
#define APSSID "ESPap"
#define APPSK "thereisnospoon"
#endif
/* Set these to your desired credentials. */
Page | 33
SIGNAL TRANSMISSION
const char *ssid = APSSID;

const char *password = APPSK;
ESP8266WebServer server(80);
/* Just a little test message. Go to http://192.168.4.1 in a web browser
connected to this access point to see it.
*/
void handleRoot() {
server.send(200, "text/html", "<h1>You are connected</h1>");
}
void setup() {
delay(1000);
Serial.begin(115200);
Serial.println();
Serial.print("Configuring access point...");
/* You can remove the password parameter if you want the AP to be open. */
WiFi.softAP(ssid, password);
IPAddress myIP = WiFi.softAPIP();
Serial.print("AP IP address: ");
Serial.println(myIP);
server.on("/", handleRoot);
server.begin();
Serial.println("HTTP server started");
}
void loop() {
server.handleClient();
}
[Appendix C]: Arduino code for serial communication between the two ESP8266 WiFi modules
(SP code)
/*

Page | 34
SIGNAL TRANSMISSION
This sketch establishes a TCP connection to a "quote of the day" service.

It sends a "hello" message, and then prints received data.
*/
#ifndef STASSID
#define STASSID "your-ssid"
#define STAPSK "your-password"
#endif
const char* ssid = STASSID;

const char* password = STAPSK;
const char* host = "djxmmx.net";
const uint16_t port = 17;
void setup() {
// We start by connecting to a WiFi network

Serial.println();
Serial.println();
Serial.print("Connecting to ");
Serial.println(ssid);
/* Explicitly set the ESP8266 to be a WiFi-client, otherwise, it by default,
would try to act as both a client and an access-point and could cause
network-issues with your other WiFi-devices on your WiFi-network. */
WiFi.mode(WIFI_STA);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
Page | 35
SIGNAL TRANSMISSION
}
Serial.println("");
Serial.println("WiFi connected");
Serial.println("IP address: ");
Serial.println(WiFi.localIP());
}
void loop() {
Serial.print("connecting to ");
Serial.print(host);
Serial.print(':');
Serial.println(port);
// Use WiFiClient class to create TCP connections
WiFiClient client;
if (!client.connect(host, port)) {
Serial.println("connection failed");
delay(5000);
return;
}
// This will send a string to the server
Serial.println("sending data to server");
if (client.connected()) {
client.println("hello from ESP8266");
}
// wait for data to be available
unsigned long timeout = millis();
while (client.available() == 0) {
if (millis() - timeout > 5000) {
Serial.println(">>> Client Timeout !");
client.stop();
Page | 36
SIGNAL TRANSMISSION
delay(60000);
return;
}
}
// Read all the lines of the reply from server and print them to Serial
Serial.println("receiving from remote server");
// not testing 'client.connected()' since we do not need to send data here
while (client.available()) {
char ch = static_cast<char>(client.read());
Serial.print(ch);
}
// Close the connection
Serial.println();
Serial.println("closing connection");
client.stop();
delay(300000); // execute once every 5 minutes, don't flood remote service
}
[Appendix D]: Arduino code for audio signal transmission through ESP8266 WiFi module
// Based on ESP_MCP3201_SPI
#include <SPI.h>
#include <WiFiUdp.h>
#include "wifi_params.h"
#include <ESP8266mDNS.h>
#include <ArduinoOTA.h>
WiFiUDP udp;
const int udp_recv_port = 45990; // for command&control

Page | 37
SIGNAL TRANSMISSION
const int udp_target_port = 45990; // sound transfer

const IPAddress IP_target_device(192, 168, 0, 13);
const IPAddress IP_target_PC(192, 168, 0, 2);
IPAddress IP_target = IP_target_device;
// Pin definitions:
const int scePin = D8; //15; // SCE - Chip select
/* HW definition of alternate function:
static const uint8_t MOSI = 13; D7 on nodemcu
static const uint8_t MISO = 12; D6 on nodemcu
static const uint8_t SCK = 14; D5 on nodemcu
*/
/* Hardware:
MCP3201 Pin ---------------- ESP8266 Pin
- 1-VREF ---------------- 3,3V
- 2-IN+ ---------------- ANALOG SIGNAL +
- 3-IN- ---------------- ANALOG SIGNAL -
- 4-GND ---------------- GND
- 5-CS ----CS---------- GPIO15/CS (PIN 19)
- 6-Dout(MISO)----MISO-------- GPIO12/MISO (PIN 16)
- 7-CLK ----SCLK-------- GPIO14 (PIN 17)
- 8-VDD ---------------- 3.3V
*/
uint16_t adc_buf[2][700]; // ADC data buffer, double buffered
int current_adc_buf; // which data buffer is being used for the ADC (the other is being sent)
unsigned int adc_buf_pos; // position in the ADC data buffer
int send_samples_now; // flag to signal that a buffer is ready to be sent
#define SILENCE_EMA_WEIGHT 1024
#define ENVELOPE_EMA_WEIGHT 2
int32_t silence_value = 2048; // computed as an exponential moving average of the signal
uint16_t envelope_threshold = 150; // envelope threshold to trigger data sending

Page | 38
SIGNAL TRANSMISSION
uint32_t send_sound_util = 0; // date until sound transmission ends after an envelope threshold has
triggered sound transmission
int enable_highpass_filter = 0;
static inline void setDataBits(uint16_t bits) {
const uint32_t mask = ~((SPIMMOSI << SPILMOSI) | (SPIMMISO << SPILMISO));
bits--;
SPI1U1 = ((SPI1U1 & mask) | ((bits << SPILMOSI) | (bits << SPILMISO)));
}
void spiBegin(void)
{
SPI.begin();
SPI.setDataMode(SPI_MODE0);
SPI.setBitOrder(MSBFIRST);
SPI.setClockDivider(SPI_CLOCK_DIV8);
SPI.setHwCs(1);
setDataBits(16);
}
#define ICACHE_RAM_ATTR __attribute__((section(".iram.text")))
/* SPI code based on the SPI library */
static inline ICACHE_RAM_ATTR uint16_t transfer16(void) {
union {
uint16_t val;
struct {
uint8_t lsb;
uint8_t msb;
};
} out;
// Transfer 16 bits at once, leaving HW CS low for the whole 16 bits
while(SPI1CMD & SPIBUSY) {}
SPI1W0 = 0;
SPI1CMD |= SPIBUSY;

Page | 39
SIGNAL TRANSMISSION
while(SPI1CMD & SPIBUSY) {}

/* Follow MCP3201's datasheet: return value looks like this:
xxxBA987 65432101
We want
76543210 0000BA98
So swap the bytes, select 12 bits starting at bit 1, and shift right by one.
*/
out.val = SPI1W0 & 0xFFFF;
uint8_t tmp = out.msb;
out.msb = out.lsb;
out.lsb = tmp;
out.val &= (0x0FFF << 1);
out.val >>= 1;
return out.val;
}
void ICACHE_RAM_ATTR sample_isr(void)
{
uint16_t val;
// Read a sample from ADC
val = transfer16();
adc_buf[current_adc_buf][adc_buf_pos] = val & 0xFFF;
adc_buf_pos++;
// If the buffer is full, signal it's ready to be sent and switch to the other one
if (adc_buf_pos > sizeof(adc_buf[0])/sizeof(adc_buf[0][0])) {
adc_buf_pos = 0;
current_adc_buf = !current_adc_buf;
send_samples_now = 1;
}
}
void ota_onstart(void)

Page | 40
SIGNAL TRANSMISSION
{
// Disable timer when an OTA happens
timer1_detachInterrupt();
timer1_disable();
}
void ota_onprogress(unsigned int sz, unsigned int total)
{
Serial.print("OTA: "); Serial.print(sz); Serial.print("/"); Serial.print(total);
Serial.print("="); Serial.print(100*sz/total); Serial.println("%%");
}
void ota_onerror(ota_error_t err)
{
Serial.print("OTA ERROR:"); Serial.println((int)err);
}
void setup(void)
{
Serial.println("I was built on " __DATE__ " at " __TIME__ "");
WiFi.setOutputPower(10); // reduce power to 10dBm = 10mW
Serial.print("Connecting to wifi SSID ");
Serial.print(ssid);
// Wait for connection
int now = millis();
while (WiFi.status() != WL_CONNECTED && (millis() - now) < 10000) {
delay(500);
Serial.print(".");
}
if (WiFi.status() != WL_CONNECTED) {

Page | 41
SIGNAL TRANSMISSION
Serial.println("failed to connect to home wifi, trying softAP");

// Could not connect to wifi network in 5 sec? We must not be at home. Connect to softAP
WiFi.begin(softap_ssid, softap_password);
delay(500);
Serial.print(".");
}
}
Serial.println ( "" );
Serial.print ( "Cnnectd to " );
Serial.println ( ssid );
Serial.print ( "IP " );
Serial.println ( WiFi.localIP() );
ArduinoOTA.onStart(ota_onstart);
ArduinoOTA.onError(ota_onerror);
ArduinoOTA.onProgress(ota_onprogress);
ArduinoOTA.setHostname("bb-xmit");
ArduinoOTA.begin();
spiBegin();
timer1_isr_init();
timer1_attachInterrupt(sample_isr);
timer1_enable(TIM_DIV16, TIM_EDGE, TIM_LOOP);
timer1_write(clockCyclesPerMicrosecond() / 16 * 50); //50us = 20kHz sampling freq
Serial.println("setup done");
udp.begin(udp_recv_port);
}
#pragma GCC push_options
#pragma GCC optimize("O3")
/* Digital filter designed by mkfilter/mkshape/gencode A.J. Fisher
Command line: ./mkfilter -Bu -Hp -o 5 -a 0.012 -l */

Page | 42
SIGNAL TRANSMISSION
// Highpass, Fc=150Hz, 5th order butterworth filter

#define NZEROS 5
#define NPOLES 5
#define GAIN 1.129790960e+00f
static float xv[NZEROS+1], yv[NPOLES+1];
static float filterloop(float input)
{ for (;;)
{ xv[0] = xv[1]; xv[1] = xv[2]; xv[2] = xv[3]; xv[3] = xv[4]; xv[4] = xv[5];
xv[5] = input / GAIN;
yv[0] = yv[1]; yv[1] = yv[2]; yv[2] = yv[3]; yv[3] = yv[4]; yv[4] = yv[5];
yv[5] = (xv[5] - xv[0]) + 5 * (xv[1] - xv[4]) + 10 * (xv[3] - xv[2])
+ ( 0.7834365141f * yv[0]) + ( -4.1083230157f * yv[1])
+ ( 8.6224512099f * yv[2]) + ( -9.0535899276f * yv[3])
+ ( 4.7560230574f * yv[4]);
return yv[5];
}
}
uint8_t *delta7_sample(uint16_t last, uint16_t *readptr, uint8_t *writeptr)
{
const uint8_t lowbyte1 = *((uint8_t *)readptr);
const uint8_t highbyte1 = *((uint8_t *)readptr+1);
const uint16_t val = *readptr;
const int32_t diff = val - last;
if (diff > -64 && diff < 64) {
// 7bit delta possible
// Encode the delta as "sign and magnitude" format.
// CSMMMMMM (compressed signed magnitude^6)
int8_t out = 0x80 | ((diff < 0) ? 0x40 : 0x0) | abs(diff);
*writeptr++ = out;
} else {

Page | 43
SIGNAL TRANSMISSION
// 7bit delta impossible, output as-is

*writeptr++ = highbyte1;
*writeptr++ = lowbyte1;
}
return writeptr;
}
void loop()
{
ArduinoOTA.handle();
if (send_samples_now) {
/* We're ready to send a buffer of samples over wifi. Decide if it has to happen or not,
that is, if the sound level is above a certain threshold. */
// Update silence and envelope computations
uint16_t number_of_samples = sizeof(adc_buf[0])/sizeof(adc_buf[0][0]);
int32_t accum_silence = 0;
int32_t envelope_value = 0;
int32_t now = millis();
uint8_t *writeptr = (uint8_t *)(&adc_buf[!current_adc_buf][0]);
uint16_t *readptr;
uint16_t last = 0;
for (unsigned int i = 0; i < number_of_samples; i++) {
readptr = &adc_buf[!current_adc_buf][i];
int32_t val = *readptr;
int32_t rectified;
if (enable_highpass_filter) {
*readptr = filterloop(val) + 2048;
val = *readptr;
}
rectified = abs(val - silence_value);
accum_silence += val;

Page | 44
SIGNAL TRANSMISSION
envelope_value += rectified;
// delta7-compress the data
writeptr = delta7_sample(last, readptr, writeptr);
last = val;
}
accum_silence /= number_of_samples;
envelope_value /= number_of_samples;
silence_value = (SILENCE_EMA_WEIGHT * silence_value + accum_silence) /
(SILENCE_EMA_WEIGHT + 1);
envelope_value = envelope_value;
if (envelope_value > envelope_threshold) {
send_sound_util = millis() + 15000;
}
if (millis() < send_sound_util) {
udp.beginPacket(IP_target, udp_target_port);
udp.write((const uint8_t *)(&adc_buf[!current_adc_buf][0]), writeptr - (uint8_t
*)&adc_buf[!current_adc_buf][0]);
udp.endPacket();
}
send_samples_now = 0;
Serial.print("Silence val "); Serial.print(silence_value); Serial.print(" envelope val ");
Serial.print(envelope_value);
Serial.print("delay "); Serial.print(millis() - now);
Serial.println("");
}
if (udp.parsePacket()) {
// Command and control packets
char buf[32];
char *ptr = &buf[0];
udp.read(&buf[0], 31);
buf[31] = 0;
#define MATCHSTR(X,Y) !strncmp(X, Y, strlen(Y))
Page | 45
SIGNAL TRANSMISSION
udp.beginPacket(udp.remoteIP(), udp.remotePort());
if (MATCHSTR(buf, "target PC")) {
// Direct sound to PC
IP_target = IP_target_PC;
udp.print("target PC");
} else if (MATCHSTR(buf, "target dev")) {
// Direct sound to device
IP_target = IP_target_device;
udp.print("target dev");
} else if (MATCHSTR(buf, "threshold ")) {
// Modify envelope threshold
ptr += strlen("threshold ");
envelope_threshold = atoi(ptr);
udp.print("threshold "); udp.println(envelope_threshold);
} else if (MATCHSTR(buf, "sendnow")) {
send_sound_util = millis() + 15000;
udp.print("sending for 15 sec");
} else if (MATCHSTR(buf, "filter")) {
enable_highpass_filter = !enable_highpass_filter;
if (enable_highpass_filter) {
udp.print("enabled");
} else {
udp.print("disabled");
}
udp.println(" highpass filter");
} else {
udp.print("unknown command "); udp.println(buf);
}
udp.endPacket();
}

Page | 46
SIGNAL TRANSMISSION
// If not sending anything, add a delay to enable modem sleep

if (millis() > send_sound_util) {
delay(10);
}
}
[Appendix E]: Arduino code for audio signal reception through ESP8266 WiFi module
#include <Wire.h>
#include <WiFiUdp.h>
#include "ESP8266mDNS.h"
#include <ArduinoOTA.h>
#include "wifi_params.h"
const IPAddress softAP_myaddress(192, 168, 0, 13);
const int mySDA = D7;
const int mySCL = D6;
const int AMPLI_MUTE_PIN = D2;
const int AMPLI_SHUTDOWN_PIN = D1;
const int RIGHT_BTN = D3;
const int LEFT_BTN = D4;
const int LED1 = D8;
const int udp_recv_port = 45990;
WiFiUDP udp;
TwoWire i2c;
#define NB_DATA_BUFS 5
uint16_t data_buf[NB_DATA_BUFS][700]; // data buffer, N buffered
unsigned int current_play_data_buf; // current data buf being played
unsigned int play_data_buf_pos; // position in the ADC data buffer

Page | 47
SIGNAL TRANSMISSION
unsigned int current_recv_data_buf; // current data buf being received

bool play_waiting = true;
bool amplifier_stopped = false;
long play_waiting_at;
volatile bool left_btn_pressed;
volatile bool right_btn_pressed;
#define ICACHE_RAM_ATTR __attribute__((section(".iram.text")))
#define twi_sda mySDA
#define twi_scl mySCL
#define twi_dcount 0
#define twi_clockStretchLimit 10
#define SDA_LOW() (GPES = (1 << twi_sda)) //Enable SDA (becomes output and since GPO
is 0 for the pin, it will pull the line low)
#define SDA_HIGH() (GPEC = (1 << twi_sda)) //Disable SDA (becomes input and since it has
pullup it will go high)
#define SDA_READ() ((GPI & (1 << twi_sda)) != 0)
#define SCL_LOW() (GPES = (1 << twi_scl))
#define SCL_HIGH() (GPEC = (1 << twi_scl))
#define SCL_READ() ((GPI & (1 << twi_scl)) != 0)
static void twi_delay(unsigned char v){
unsigned int i;
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
unsigned int reg;
for(i=0;i<v;i++) reg = GPI;
#pragma GCC diagnostic pop
}
static inline ICACHE_RAM_ATTR bool twi_write_start(void) {
SCL_HIGH();

Page | 48
SIGNAL TRANSMISSION
SDA_HIGH();
if (SDA_READ() == 0) return false;
SDA_LOW();
return true;
}
static inline ICACHE_RAM_ATTR bool twi_write_stop(void){
uint32_t i = 0;
SCL_LOW();
SDA_LOW();
SCL_HIGH();
while (SCL_READ() == 0 && (i++) < twi_clockStretchLimit); // Clock stretching
SDA_HIGH();
return true;
}
static inline ICACHE_RAM_ATTR bool twi_write_bit(bool bit) {
uint32_t i = 0;
SCL_LOW();
if (bit) SDA_HIGH();
else SDA_LOW();
twi_delay(twi_dcount+1);
SCL_HIGH();
while (SCL_READ() == 0 && (i++) < twi_clockStretchLimit);// Clock stretching
return true;
}
static inline ICACHE_RAM_ATTR bool twi_read_bit(void) {
uint32_t i = 0;
SCL_LOW();
SDA_HIGH();
twi_delay(twi_dcount+2);
Page | 49
SIGNAL TRANSMISSION
SCL_HIGH();
while (SCL_READ() == 0 && (i++) < twi_clockStretchLimit);// Clock stretching
bool bit = SDA_READ();
return bit;
}
static inline ICACHE_RAM_ATTR bool twi_write_byte(unsigned char byte) {
unsigned char bit;
for (bit = 0; bit < 8; bit++) {
twi_write_bit(byte & 0x80);
byte <<= 1;
}
return !twi_read_bit();//NACK/ACK
}
static inline ICACHE_RAM_ATTR unsigned char twi_read_byte(bool nack) {
unsigned char byte = 0;
unsigned char bit;
for (bit = 0; bit < 8; bit++) byte = (byte << 1) | twi_read_bit();
twi_write_bit(nack);
return byte;
}
unsigned char inline ICACHE_RAM_ATTR mytwi_writeTo(unsigned char address, unsigned
char * buf, unsigned int len, unsigned char sendStop){
unsigned int i;
if(!twi_write_start()) return 4;//line busy
if(!twi_write_byte(((address << 1) | 0) & 0xFF)) {
if (sendStop) twi_write_stop();
return 2; //received NACK on transmit of address
}
for(i=0; i<len; i++) {

Page | 50
SIGNAL TRANSMISSION
if(!twi_write_byte(buf[i])) {
if (sendStop) twi_write_stop();
return 3;//received NACK on transmit of data
}
}
if(sendStop) twi_write_stop();
i = 0;
while(SDA_READ() == 0 && (i++) < 10){
SCL_LOW();
SCL_HIGH();
}
return 0;
}
static inline ICACHE_RAM_ATTR uint8_t DAC(uint16_t value)
{
/* value is 76543210 XXXXBA98
per the datasheet for fast write:
1 1 0 0 A2 A1 A0 0 <ACK> 0 0 PD1 PD0 D11 D10 D9 D8 <ACK> D7 D6 D5 D4 D3 D2 D1
D0 <ACK>
*/
uint8_t buf[2] = { (value >> 8) & 0x0F, (value & 0xFF) };
int ret = mytwi_writeTo(0x60, buf, 2, true);
return ret;
}
void ICACHE_RAM_ATTR playsample_isr(void)
{
if (play_waiting) {
return;
}

Page | 51
SIGNAL TRANSMISSION
DAC(data_buf[current_play_data_buf][play_data_buf_pos]);
play_data_buf_pos++;
if (play_data_buf_pos >= sizeof(data_buf[0])/sizeof(data_buf[0][0])) {
play_data_buf_pos = 0;
current_play_data_buf++;
if (current_play_data_buf == NB_DATA_BUFS) {
current_play_data_buf = 0;
}
if (current_play_data_buf == current_recv_data_buf) {
play_waiting = true;
play_waiting_at = micros();
}
}
}
void ota_onstart(void)
{
// Disable timer when an OTA happens
timer1_detachInterrupt();
timer1_disable();
}
void ota_onprogress(unsigned int sz, unsigned int total)
{
Serial.print("OTA: "); Serial.print(sz); Serial.print("/"); Serial.print(total);
Serial.print("="); Serial.print(100*sz/total); Serial.println("%");
}
void ota_onerror(ota_error_t err)
{
Serial.print("OTA ERROR:"); Serial.println((int)err);
}
Page | 52
SIGNAL TRANSMISSION
void left_btn_intr()
{
left_btn_pressed = 1;
}
void right_btn_intr()
{
right_btn_pressed = 1;
}
void setup ( void )
{
Serial.begin ( 115200 );
Serial.println("I was built on " __DATE__ " at " __TIME__ "");
i2c.begin(mySDA, mySCL);
i2c.setClock(400000);
bool found = false;
int n = WiFi.scanNetworks();
for (int i = 0; i < n; i++) {
if (WiFi.SSID(i).equals(ssid)) {
found = true;
break;
}
}
if (!found) {
Serial.println("No wifi network found, starting softAP\n");
WiFi.disconnect();
WiFi.mode(WIFI_AP);
WiFi.softAPConfig(softAP_myaddress, softAP_myaddress, IPAddress(255,255,255,0));
WiFi.softAP(softap_ssid, softap_password);
Page | 53
SIGNAL TRANSMISSION
} else {
WiFi.setSleepMode(WIFI_MODEM_SLEEP);
Serial.print("Connecting to wifi");
int now = millis();
delay(500);
Serial.print(".");
}
}
Serial.println ( "" );
Serial.print ( "Cnnectd to " );
Serial.println ( ssid );
Serial.print ( "IP " );
Serial.println ( WiFi.localIP() );
ArduinoOTA.onStart(ota_onstart);
ArduinoOTA.onError(ota_onerror);
ArduinoOTA.onProgress(ota_onprogress);
ArduinoOTA.setHostname("bb-recv");
ArduinoOTA.begin();
timer1_isr_init();
timer1_attachInterrupt(playsample_isr);
timer1_enable(TIM_DIV16, TIM_EDGE, TIM_LOOP);
timer1_write(clockCyclesPerMicrosecond() / 16 * 50); //50us = 20 kHz sampling freq
udp.begin(udp_recv_port);
pinMode(AMPLI_MUTE_PIN, OUTPUT);
pinMode(AMPLI_SHUTDOWN_PIN, OUTPUT);
digitalWrite(AMPLI_SHUTDOWN_PIN, 0);
Page | 54
SIGNAL TRANSMISSION
digitalWrite(AMPLI_MUTE_PIN, 0);
pinMode(LEFT_BTN, INPUT_PULLUP);
attachInterrupt(digitalPinToInterrupt(LEFT_BTN), left_btn_intr, FALLING);
pinMode(RIGHT_BTN, INPUT_PULLUP);
attachInterrupt(digitalPinToInterrupt(RIGHT_BTN), right_btn_intr, FALLING);
pinMode(LED1, OUTPUT);
digitalWrite(LED1, 0);
}
int do_undelta7(const uint8_t *val, int sz, uint16_t *out)
{
// Implement delta 7 decompression.
// First bit = 0 <=> uncompressed 15 bits following
// First bit = 1 <=> 7 bits follow representing delta
// must switch to big endian...
uint16_t last = 0;
uint8_t *ptr = (uint8_t *)&out[0];
const uint8_t *start = ptr;
for (int i = 0; i < sz; i++) {
uint16_t *ptr16 = (uint16_t *)ptr;
const int8_t firstbyte = val[i];
if (firstbyte & 0x80) {
// Delta7 compressed
// byte is CSMMMMMM
int8_t delta = firstbyte & 0x3F;
if (firstbyte & 0x40) {
delta = -delta;
}
const uint16_t value = last + delta;
*ptr16 = value;
Page | 55
SIGNAL TRANSMISSION
ptr += 2;
last = value;
} else {
// uncompressed -- switch bytes back to LE
*ptr++ = val[i+1];
*ptr++ = val[i];
last = val[i+1] | val[i] << 8;
i++;
}
}
return ptr - start;
}
void loop ( void )
{
ArduinoOTA.handle();
int sz = udp.parsePacket();
if (sz) {
uint8_t buf[sz];
udp.read(&buf[0], sz);
current_recv_data_buf++;
if (current_recv_data_buf == NB_DATA_BUFS) {
current_recv_data_buf = 0;
if (current_recv_data_buf == current_play_data_buf && !play_waiting) {
Serial.println("buffer overflow when receiving");
}
}
do_undelta7(buf, sz, &data_buf[current_recv_data_buf][0]);
if (play_waiting) {
Serial.print("Restarting play, was waiting (us)"); Serial.println(micros() - play_waiting_at);
Page | 56
SIGNAL TRANSMISSION
// Re-enable *then* unmute in that order to avoid pops

play_waiting = false;
amplifier_stopped = false;
}
Serial.println("");
}
// If not playing anything, but amplifier is still up
if (!amplifier_stopped && play_waiting) {
if ((micros() - play_waiting_at) > 2000 * 1000) {
// If nothing has been played for two seconds, shut down the amplifier
Serial.println("Shutting down amplifier!");
amplifier_stopped = true;
}
}
if (left_btn_pressed) {
left_btn_pressed = 0;
}
if (right_btn_pressed) {
const IPAddress bcast(255, 255, 255, 255);
Page | 57
SIGNAL TRANSMISSION
udp.beginPacket(bcast, 45990);
udp.write("sendnow");
udp.endPacket();
right_btn_pressed = 0;
}
// If the amplifier is stopped, add a delay for power saving
if (amplifier_stopped) {
delay(10);
}
}
[Appendix F]: AT commands for the ESP8266

Page | 58
SIGNAL TRANSMISSION

Page | 59

Investigation of Wi-Fi (Esp8266) Module and Application To An Audio Signal Transmission by Tatap Perets

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Investigation of Wi-Fi (Esp8266) Module and Application To An Audio Signal Transmission by Tatap Perets

Uploaded by

Copyright:

Available Formats

INVESTIGATION OF WI-FI (ESP8266) MODULE AND APPLICATION TO AN AUDIO

CHAPTER I: GENERAL INTRODUCTION

1.1 BACKGROUND AND CONTEXT OF STUDY

1.3.2 Specific Objectives

DISSERTATION/ BATCHANOU TATAP PERETS ARNAUD/ FE15A031/LEVEL 500/ UB/FET/2018-2019

1.5 RESEARCH QUESTIONS

1.7 SIGNIFICANCE OF STUDY

1.8 SCOPE OF STUDY

1.9 DELIMITATION OF THE STUDY

1.10 DEFINITION OF KEYWORDS AND TERMS

1.11 ORGANIZATION OF DISSERTATION

Chapter two is the literature review, giving fundamentals of wireless communications,

Finally we have a reference and an appendix section.

DISSERTATION/ BATCHANOU TATAP PERETS ARNAUD/ FE15A031/LEVEL 500/ UB/FET/2018-2019

CHAPTER II: LITERATURE REVIEW

2.2GENERAL CONCEPTS ON WIRELESS COMMUNICATIONS

When looking at the history of communications, we ﬁnd that wireless communications is

DISSERTATION/ BATCHANOU TATAP PERETS ARNAUD/ FE15A031/LEVEL 500/ UB/FET/2018-2019

Table 1: Classification of different frequency bands

An Electromagnetic signal can be expressed in function of time or frequency, with an amplitude

DISSERTATION/ BATCHANOU TATAP PERETS ARNAUD/ FE15A031/LEVEL 500/ UB/FET/2018-2019

Fig 5: Analog and Digital signals

DISSERTATION/ BATCHANOU TATAP PERETS ARNAUD/ FE15A031/LEVEL 500/ UB/FET/2018-2019

Table 2: Frequency bands (in MHz) and their standards worldwide

WiFi networks work with two signals:

2.4 GHz – It comprises 14 channels, each with a bandwidth of approximately 20 to 22 MHz

DISSERTATION/ BATCHANOU TATAP PERETS ARNAUD/ FE15A031/LEVEL 500/ UB/FET/2018-2019

5 GHz – It comprises 13 channels, each with a bandwidth of approximately 20 MHz operating in

Fig 1: Wireless Local Area Network connected to the internet

2.2.3 Investigation of the ESP8266 WiFi module (ESP-01)

Figure 1: ESP -01 module, variant of ESP8266 [1]

DISSERTATION/ BATCHANOU TATAP PERETS ARNAUD/ FE15A031/LEVEL 500/ UB/FET/2018-2019

Table 3: Characterization of ESP-01 module

Type 32-bit microcontroller

CPU @ 80 MHz default or 160 MHz

Memory 32KiB instruction, 80 KiB user data

Input 2 GPIO pins

Wi-Fi Protocols 802.11/b/g/n

Operating voltage 3.3 V

Operating current 800 mA

Network Protocols IPv4, TCP/UDP/HTTP/FTP

 Integrated RF switch, balun, 24dBm PA, DCXO, and PMU

 Integrated RISC processor, on-chip memory and external memory interfaces

 Integrated MAC/baseband processors

 Quality of Service management

 I2S interface for high fidelity audio applications

 On-chip low-dropout linear regulators for all internal supplies

 Proprietary spurious-free clock generation architecture

 Integrated WEP, TKIP, AES, and WAPI engines

 Wi-Fi Direct (P2P), soft-AP

 Integrated TCP/IP protocol stack

 Integrated TR switch, balun, LNA, power amplifier and matching network

 Integrated PLLs, regulators, DCXO and power management units

 +19.5dBm output power in 802.11b mode

 Power down leakage current of <10uA

 Integrated low power 32-bit CPU could be used as application processor

 SDIO 1.1/2.0, SPI, UART

 STBC, 1×1 MIMO, 2×1 MIMO

 A-MPDU & A-MSDU aggregation & 0.4ms guard interval

 Wake up and transmit packets in < 2ms

 Standby power consumption of < 1.0mW (DTIM3)

Figure 2: Pin specifications of ESP-01

DISSERTATION/ BATCHANOU TATAP PERETS ARNAUD/ FE15A031/LEVEL 500/ UB/FET/2018-2019