PIC n’Mix
Mike Hibbett’s column for PIC project enlightenment and related topics
Part 8: PIC18F Development Board
I
n our previous article, we
completed the software required for
our PIC18F Development Board to
monitor the voltage rails on the battery
and the solar panel of an industrial solarpowered air quality sensor. The details of
the sensor itself are unimportant, but it
was the development and testing of that
device which triggered this series of articles. Not the design of the air quality
sensor itself, rather the desire to monitor
how well a solar panel could recharge the
battery supplying the sensor, while the
sensor operated continuously. The customer wanted the sensor to operate for
over two years without servicing, which
is reasonable, since replacing batteries
on a remotely located industrial sensor
can be inconvenient and time-consuming. The sensor drew on average 15mA
at 5.0V, so the battery to achieve this requirement would need to have a capacity
of close to a kWh – completely unrealistic for a low-cost product. Fortunately,
this is an outdoor sensor, so we could
consider adding a solar panel to charge
a much lower capacity lithium ion (Liion) rechargeable battery. The question
now became how to balance the size of
the solar panel (big solar panels are expensive, and require large enclosures,
which are expensive) versus the size of
the Li-ion battery (bigger capacities are
expensive, large and difficult to ship.)
Doing some basic calculations, an offthe-shelf 5.6Ah (20Wh) 3.7V Li-ion battery
pack with a small 4×6-inch solar panel
appeared to provide the balance required
PIC n’ Mix PIC18F
Development Board
The PCB for the PIC18F
Development Board is available
from the PE PCB Service – see the
July 2021 section.
www.electronpublishing.com/
product-category/pe-pcb-service/
62
to provide continuous
+
Solar charge
operation through night
4 V to 6 V
P C B
–
Solar
panel
and day cycles. There is
‘ D evi ce under test’
C harge when
a ‘gotcha’ however – this
possible
Ω
calculation was based on
+
+ 5V D C
3. 7 V L iP ol
Boost
datasheet analysis, and
–
–
battery
regulator
while that is normally
appropriate for circuit
designs, when it comes to
solar panel performance
T P 2 T P 1 G N D
I nterf ace to monitoring syst em
datasheets cannot account for the weather. Fig.1. Block diagram of the ‘Device Under Test’.
As these devices will be
deployed in the UK, where clear skies
It’s very simple, as shown in Fig.1. The
are unpredictable and typically infrefully integrated PCB is small, measuring
quent, we needed some real-life testing
just 63×33 mm. (For this customer apover an extended period and ideally covplication, we chose an off-the-shelf PCB
ering the worst weather seasons to see
because the quantities to be built are low,
if the solar panel would receive enough
but the circuit is straight forward with an
daylight to keep the system running. In
easily available IC, so an integrated design
such a system, monitoring the setup over
could be possible should a future cost
months of operation cannot be done manreduction or size reduction be desired.)
ually. An automated monitoring system
Finally, we added the monitoring points
is required, which is where this project
for measuring the instantaneous solar
came into being.
panel output voltage and the battery
The author lives in an area with even
output voltage, the latter tells us if the
cloudier weather than the UK – Ireland!
sensor circuit is being supplied with sufTherefore, testing the setup there offered
ficient power: day and night.
a degree of safety margin for the results
With our ‘Device Under Test’ system
and their applicability to the customer’s
configured, it’s time to look at how to conUK market.
figure the PIC18F Development Board to
monitor the system. For this, we build on
the software and hardware setup develCreating the test system
oped in the previous two articles, where
We know the average current consumpwe buffer the incoming voltages from TP1
tion of the sensor system – 15mA – so it
and TP2 to the processor’s analogue-towas simple to devise a test system. We
digital converter pins using the op amps
needed only a resistor that would draw
configured as unity-gain buffers. This way,
15mA at 5.0V. Ohm’s law tells us a 330Ω
the potential divider circuit (necessary to
resistor would suffice. Although the real
device will have peaks of power consumption when transmitting data, and
long periods in very-low-power sleep
mode, the impact on the battery can be
safely simulated by providing this fixed,
average current consumption. The resistor will be dissipating just 50mW, so just
about any resistor power rating would do.
Now let’s turn to the circuit. We need
our solar panel, the charger circuit with
combined 5V regulator (an off-the-shelf
Fig.2. The solar charger PCB, available
PCB purchased online) and the battery.
from DFRobot.
Practical Electronics | November | 2021
shown later in the article. The block diagram for this test system is shown in Fig.4.
could we? We’ll have to think about that!)
For IoT applications, however, where we
are typically sending a few hundred bytes
per minute, it’s ideal.
Adding Wi-Fi
Following the success of the ESP8266,
Having wired the system up as shown in
Espressif launched the far more capable
Fig.1 and Fig.4, placed it in a nice waterESP32 processor in 2016, and their latest
proof transparent enclosure and installed
processor the ESP32-S3 was released in
the application developed in the previous
2020. This latest IC offers a dual CPU chip
article, the system meets our basic requirerunning at 240MHz, 512KB of SRAM and
ments, storing the readings into a text file
both Wi-Fi and Bluetooth LE communion a MicroSD Media card. However, there
cations on chip. While it is great to see
are limitations with this solution. It’s inmore complex Wi-Fi-enabled ICs becomconvenient having to remove the card to
ing available, the ‘old’ ESP8266 is still a
extract the data and even then, with the
perfectly usable processor for IoT projects.
data
copied
to
your
computer,
how
do
you
Fig.3. Wiring up the op amps / resistors.
Thankfully, the Far-East manufacturers
visualise it? Not everyone has Microsoft
agree, and simple modules that provide
Office installed on their computers and
reduce the voltages to below the microbasic Wi-Fi connectivity are widely availthe knowledge to draw graphs in Excel.
controller’s 3.3V supply level) can be high
able, and incredibly cheap.
The solution to this is to make use of the
values (here, 470kΩ) so as not to present
The ESP-01 is a generic module manuWi-Fi interface integrated into the Develan additional ‘load’ to the test device’s
factured by many different vendors, some
opment Board, a capability provided by a
battery. At 5V, this potential divider will
with slightly different features than others.
plug-in ESP-01 module. We’ve not made
draw just 5µA additional current. The
Our intended use of the device is simple
use of this yet, so this will be an ideal opaverage load of the ‘Device Under Test’
(just basic Wi-Fi communication to a Wi-Fi
portunity to test its capabilities. With the
is 15mA, so it’s clear the impact will be
Access Point) so any generic version will
Development Board connected to the Innegligible. We attached the resistors to
do, as long as it has the same pin-out to
ternet via a Wi-Fi network, we not only
the op amps by cutting a pair of femalematch our Development Board’s header
gain easier access to our data, but we can
female jump wires, and soldering them to
pins. The firmware on these devices can
also send the data automatically to the Inthe resistors, as shown in Fig.3. This is a
be updated over the header pins, and our
ternet, and specifically to one of the freely
bit of a waste of two jump wires, but we
Development Board provides the physiavailable IoT Dashboard services, where
wanted to avoid soldering to the pins. The
cal connections from the header to GPIO
we can visualise our data as an interactive
choice is yours, but header pins are hard
on the PIC processor to do so if required.
graph – updating in real time!
to re-use with jump wires once you’ve
The module comes pre-programmed
The ESP-01 module is a small PCB
soldered to them.
with special Wi-Fi communications firmwith very little to it – an ESP8266 IC, a
While the resistor potential divider
ware, using a simple command set that
Flash memory IC to hold the code, and
circuit has no impact on the current conis accessed over a 3.3V UART serial ina tiny integrated PCB trace antenna. The
sumption of the ‘Device Under Test’, the
terface. The commands loosely follow
ESP8266 was released in 2014, and it
current consumption of our test system
the Hayes AT command set, so anyone
made a significant impact – once docuis another matter. With Wi-Fi active it
familiar with old modems will feel at
mentation in English became available.
will draw approximately 60mA on avhome. For the rest of us, the commands
It is a very capable processor with inteerage, so it does need to be powered by
are simple enough to use, and if you
grated Wi-Fi communication costing just
an independent mains power source to
connect an ESP-01 to a PC with a serial
a couple of pounds, or less. It does have
ensure that we do not interfere with the
interface (such as a 3.3V USB-to-UART
very limited peripherals, but for IoT uses
target sensor we are testing. This setup
cable) you can type the commands using
(reading a sensor connected by SPI or I2C
was going to be left running continuously
a serial interface terminal program such
for months, so we used a mains 9V DC
and sending that data to the cloud) it met
as Microsoft’s Hyperterm (although we
power brick and a long cable to keep the
many requirements and was quickly adfavour the free alternative, called ‘Putty’
system operational. For initial testing of
opted world-wide for the blossoming IoT
– see: www.putty.org)
the system setup however, we used a large
market. Data throughput is not fast, at
A reference to the command set can
7.4V LiPol battery, which ran for several
less than 1MB/s, so you won’t be watchbe found on the Internet. A quick search
days and gave us the interesting results
ing YouTube videos with this module (or
for ‘ESP-01 AT Commands’ yielded the following web page, which
we used for our experimentation:
Ω
IN 1 +
+
T P 1
https://bit.ly/pe-nov21-at
H D R
+
1 A
7 .4 V
There are various versions of
–
–
L iP ol
H D R
firmware supplied with the difΩ
1 B
ferent clones, and the ESP-01 we
received had old firmware on them
G N D
G N D
(determined by running the comP I C 1 8F
D eve lopment
mand AT+GMR) Running older
Ω
Board
software does not seem to limit
Ω
IN 2 +
us, and we could if we wanted to
+
T P 2
perform a firmware update, but
–
to avoid a complicated upgrade
process we stuck with the old firmP IC
GND GPIO2 GPIO0 RX
ware. There are several interesting
TX
CH_PD RESET VCC
firmware updates that can be deFig.4. Test system block diagram.
Fig.5. ESP-01 module. ployed, including full Arduino code
Practical Electronics | November | 2021
63
Integrating the
module
The module is shown
in Fig.5. Note that it
runs at 3.3V only, so
the Development Board
must be set to run at
3.3V too, by fitting JP1.
Before writing any
software to talk to
the module we need
to bring the second
UART peripheral into
action to be able to talk
to it. The module communicates at 115200
baud, eight data bits,
Fig.6. Setting up
no parity, and does not
UART2 in MPLAB-X.
make use of RTS or CTS
signalling. Nor does it
use XON/XOFF flow control thankfully.
development compatibility, and we can
This is a slow Wi-Fi interface, and with
cover doing this in a future article if there
the kind of data exchanges we are going
is sufficient interest. When we designed
to be performing, flow control of transmitthe PIC18F Development Board we anticited and received messages is unnecessary.
pated needing to update the firmware on
We will continue using UART1 for our inthe ESP-01 and added the control signals
terface over the USB-to-UART link because
to the header to be able to do it. We’d just
this will be very useful for seeing debug
need to write the software.
messages from our software and response
The ESP-01 is more than a simple Wi-Fi
messages from the ESP-01 module. Also,
communications module; it’s a fully funcwe have two UARTs, so why not use them!
tional, programmable microcontroller with
First, we open the project code, named
a well-supported free development envipassthrough (unzipped from passthrough.
ronment of its own. This begs the question,
zip, available for download from the No‘Why add another processor to our Develvember 2021 page of the PE website) and
opment Board, why not just use the ESP-01
load it into MPLAB-X.
processor?’ There are several good reasons,
Open up the MCC dialogue panel in
but the main one is a lack of simultaneousMPLAB-X again, and add the UART2
ly accessible peripherals. There are only a
peripheral to our project. The module
few pins available on the ESP-01 module,
communicates at 115200 baud; and since
so it is not suitable for creating a generic
our data exchange rate will be slow (we
development system with many periphwill send voltage messages every minute
erals available for use at the same time. In
or so) we do not need to use more comspecific applications, however, it can be an
plicated-to-understand interrupt-based
ideal solution, hence its popularity over the
communication. On this basis, we configyears in both module and IC formats. The
ure the UART as shown in Fig.6.
ESP-01 module runs at up to 80MHz, has
Having configured the UART periphUART, SPI, I2C and Wi-Fi peripherals, 96KB
eral, we can now move on and select
of on-chip RAM and an external 1MB of
which pins connect to it by clicking on
Flash memory for code – so a much higher
the Pin Module entry in the Project Respecification than the PIC processor, albeit
sources list. After clicking on it, the lower
with fewer pins available.
window should change to the Pin Manager
view. Scroll down until the UART2 row
is visible and use the left mouse button to
select PORT B pins 4 and 5 to connect to
TX2 and RX2, as shown in Fig.7. Confirm
that the RB4 and RB5 rows shown above
it are correctly set too, as shown in Fig.8.
Next, click the Generate button to action
these requests. MCC will now create new
UART2 driver files in our project and update
our existing code to make reference to them.
We are now ready to write some code.
Let’s go take a look in the header file for
the new UART2 driver we’ve created, to
see which functions will be useful, and
how to use them.
Open the file uart2.h, by clicking on the
filename in the left hand ‘Files’ tab. You will
find it in the mcc_generated_files sub-directory. Unsurprisingly, it looks identical to
that of uart1.h. The peripherals are identical,
the only difference is that we have mapped
them to different pins, and perhaps set the
baud rate differently. This means that the
code generated for the UART2_Initialize() function will be very different. Not
that we are interested; that code has been
generated for us and will be automatically
called on processor reset without us needing to write that line of code – MCC added
it for us. In fact, there are only three functions that are of interest to us:
void UART2_Write(uint8_t txData);
This function will send a single character
out over the UART, when it is free to do so.
uint8_t UART2_Read(void);
Returns the value of the last character received over the UART.
bool UART2_is_rx_ready(void);
This will return true if there is data to
read from the receive buffer.
That’s it; that is all we need from the
driver. It would be useful to have a ‘write a
string of characters’ function, but this is trivial to implement. The code looks like this:
Fig.7. Completing the setup of UART2.
64
Practical Electronics | November | 2021
Fig.8. Connecting the GPIO pins to UART2.
void uart2_putstr(uint8_t *str)
{
uint8_t val;
while (*str) {
UART2_WriteUART2_Write(*str++);
__delay_ms(5);
if (UART2_is_rx_ready()) {
val = UART2_Read();
UART1_Write(val);
}
}
}
The short delay is introduced to allow the ESP-01 module time
to process the data we sent to it. We implemented this function
in our own main.c file. (Do not edit code automatically generated by MCC – it may become overwritten should you use MCC
to make other configuration changes.)
Now we are ready to start talking to the ESP-01 module. Let’s
begin by writing a very simple program that allows you to use
a terminal program such as Putty to communicate directly
with the ESP-01 module. We refer to this kind of program as a
‘passthrough’ application. The code can be seen in Listing 1. Its
operation is simple, and it’s a piece of code we have used many
times in the past. If a character is received from the module,
Practical Electronics | November | 2021
then retransmit it over the USB UART interface. If a character
is received from the USB UART interface, then retransmit it
to the module. There is one additional step, implemented by
these four lines of code:
if (val == ‘\r’) {
do {} while (!UART2_is_tx_ready());
UART2_Write(‘\n’);
}
\r is a special character, known as ‘Carriage Return’. This is
the character the Putty program will send when you press the
Enter key on the keyboard, to send a command. The module
expects two characters: Carriage Return and then ‘Line Feed’,
represented in the C programming language by \n. So, if we
detect a Carriage Return character, we send it and then immediately send a Line Feed character. We run this sequence of code
in a loop to provide a simple yet effective communication link
between our PC and the module.
With a terminal programming running on the PC (Putty in
our case) we can type AT followed by the Enter key, and get the
response OK back from the module.
If you see this, all is good. If not, check that the terminal program is connected to the virtual serial port created when you
plugged in the USB cable between the Development Board and
the PC, and check the code you typed.
65
Having explored the module’s functionality, we found that integrating the module
into our project consists of two tasks:
1.
Configure the module to connect to
your Wi-Fi access point
2.
Use commands to connect to a website, post data and receive responses.
Fig.9. A complicated Thingsboard dashboard displaying a bus fleet monitoring system.
Listing 1: Talking to the ESP-01.
void main(void)
{
uint8_t val;
// Initialize the device
SYSTEM_Initialize();
do {
// UART1 is USB serial cable, 115200 baud
if (UART1_is_rx_ready()) {
val = UART1_Read();
do {} while (!UART2_is_tx_ready());
UART2_Write(val);
if (val == ‘\r’) {
do {} while (!UART2_is_tx_ready());
UART2_Write(‘\n’);
}
}
The configuration setup in step 1 gets written into Flash memory, and so needs to be
done only once. This is ideal because one
of the commands requires you to enter the
password for your Wi-Fi access, and that
is not something we would want visible in
source code. Just a few commands, entered
while the Development Board is running the
‘passthrough’ program, completes step 1).
ATE0
AT+CWMODE=3
AT+CIPMUX=0
AT+CIPMODE=0
AT+CWJAP="HomeWifi","WiFiPassword"
If these were entered correctly, the module should return the
message:
WIFI CONNECTED
WIFI GOT IP
We can now move on to sending actual data – but, to where?
Internet dashboards
Internet-based dashboard services are websites that provide
an online database to store telemetry data from you Internetconnected devices, and which display that data on graphs,
updated in real time, with the ability to manipulate and filter
the data being displayed on those graphs. The graphs are displayed on a webpage called a dashboard, which you configure
// UART2 is ESP-01 module
yourself, selecting from a range of predefined graph types, and
if (UART2_is_rx_ready()) {
you can also select what data from which devices to display
val = UART2_Read();
on those graphs. You can sign up with a monthly subscripUART1_Write(val);
tion to have your own private system hosted by a third party,
}
but some companies offer free hosting for hobbyists. Things} while (1);
board is one such company, and we will use their free service,
}
available at: https://demo.thingsboard.io
The Thingsboard service can enable you to create very complex
You can now refer to the list of AT commands available and dashboards, an example of a bus fleet monitoring system can be
experiment; it’s not possible to damage the module by send- seen in Fig.9. To build dashboards like this requires some skill
and experience, but a very simple dashboard displaying two
ing incorrect commands.
voltage levels from our single device
will be simple to configure. Creating an
account, configuring a virtual device
and creating a dashboard is better deSolar volts
scribed by a video, see here: https://
youtu.be/gX1DMkdYgfg
The key point is that when you create
Battery volts
a ‘device’ on Thingsboard you are provided with a unique ‘Access Token’
for that device. This is effectively a
password for writing data into the
Cloud-based database.
To write data, your device must connect to the Thingsboard website at demo.
thingsboard.io, and then send a ‘post’
command, which is a text string provid12:00
14:00
16:00
18:00
20:00
22:00
00:00
02:00
04:00
06:00
08:00
10:00
ing the Access Token password and a
JSON-formatted string containing your
Fig.10. Example data over 24-hours, on a cloudy day for the Solar Voltage Charger Monitor.
66
Practical Electronics | November | 2021
Listing. 2 Reading voltages and sending them to Thingsboard.
ADCC_StartConversion(channel_ANA0);
while(!ADCC_IsConversionDone());
solarPanel_volts_adc = ADCC_GetConversionResult();
solarPanel_volts = (double)solarPanel_volts_adc;
// Convert ADC value to volts, compensate for divide by 2
solarPanel_volts = (solarPanel_volts * 3.3 * 2.0) / 4095.0;
ADCC_StartConversion(channel_ANA5);
while(!ADCC_IsConversionDone());
battery_volts_adc = ADCC_GetConversionResult();
battery_volts = (double)battery_volts_adc;
// Convert ADC value to volts, compensate for divide by 2
battery_volts = (battery_volts * 3.3 * 2.0) / 4095.0;
parse_response(2000);
Fig.11. The test system, in a real-world
location – my Dublin garden!
variable name and a value. This is performed with just three ESP-01 commands,
AT+CIPSTART to connect to the website,
AT+CIPSEND to tell the ESP-01 how many
bytes you are going to send to the website,
and then the string of bytes to send, starting with the text POST. That’s it, and you
can repeat this in an infinite loop to complete the monitoring application, as seen
in Listing 2. solarsensor, the full code for
this application, can also be download
from the PE website. Unzip solarsensor.
zip, open the project in MPLAB-X and
then open the main.c file. You can add
your unique access token on the two lines
near the end of the file, replace ACCESSTOKEN with your unique string.
Having run the system outdoors for a
weekend, the results were fascinating.
You can see a 24-hour period covering an
overcast Irish September day in Fig.10,
and the test setup in Fig.11. In this graph
we can see that the solar panel appears to
have four different stable output states,
and with some thought it become clear
what is going on. At first, under daylight
conditions, the system is running, the solar
panel under load is charging the battery
and supplying power to the device under
test. After sunset the solar panel is attempting to do the same, but with no sunlight,
the output is clamped to zero volts. At
around midnight the battery expires and
the device under test turns off. Now, with
no current drain, the solar panel can float
up to a few volts. At sunrise, the device is
still turned off, so the solar panel can rise
even higher, to its open-circuit voltage of
around 5.2V. Finally, at 10AM the battery
has charged sufficiently to turn the device
on, presenting a larger load to the solar
panel, causing its output voltage to drop
again. These are valuable insights that
would be impossible to gain by looking
at a list of numbers. And the conclusion –
don’t start your system with a flat battery!
Practical Electronics | November | 2021
uart2_putstr(“AT+CIPSTART=\”TCP\”,\”demo.thingsboard.io\”,80\r\n”);
parse_response(1000);
uart2_putstr(“AT+CIPSEND=180\r\n”); parse_response(500);
sprintf(esp01_buff, “POST /api/v1/access-token-string/telemetry
HTTP/1.1\r\nHost: demo.thingsboard.io\r\nAccept:
application/json\r\nContent-Length: 23\r\n
Content-Type: application/json\r\n\r\n{\”
SolarVolts\”: %1.3f}\r\n”, solarPanel_volts);
uart2_putstr(esp01_buff); parse_response(1000);
uart2_putstr(“AT+CIPSEND=182\r\n”); parse_response(500);
sprintf(esp01_buff, “POST /api/v1/access-token-string/telemetry
HTTP/1.1
\r\nHost: demo.thingsboard.io\r\nAccept:
application/json\r\nContent-Length: 25\r\n
Content-Type: application/json\r\n\r\n{\”
BatteryVolts\”: %1.3f}\r\n”, battery_volts);
uart2_putstr(esp01_buff);
parse_response(1000);
__delay_ms(10000);
This has been a challenging stage in
the article series as there were many
tricky issues to solve when working out
how to post data in the correct format to
the Internet. It involved a lot of trial and
error, which thankfully you will not have
to endure. With the addition of a Wi-Fi
interface and the use of freely available online IoT platforms, we no longer need to
use the SD Media card for storage of data
locally. The capability is there however,
and can work in parallel with Internet
communications if desired. This is one
of the benefits of using a PIC microcontroller with a large number of GPIO pins.
Both Listings are available for
download from the November
2021 page of the PE website.
In our next article we will add an LCD to
the project, giving local status information
and showing (again) how easy it is to add
complex peripherals to the Development
Board. We will also talk further on formatting and sending data to the Thingsboard
platform and review other freely available
Internet dashboard services.
PIC n’ Mix files
The programming files discussed
in this article are available for
download from the PE website.
67
