e Paper with Arduino and Raspberry Pi

Rek XIX
40 followers
2 Video Views·Oct 31, 2022
e Paper with Arduino and Raspberry Pi
Today in the workshop we're working with e-paper displays.
We'll see how these displays work and how we can use them with both an Arduino and a
Raspberry Pi.
We'll also look at a no-code method of building an information display panel.
The writing's on the wall today, so welcome to the workshop.
Well hello and welcome to the workshop and today we are going to be working with electronic
paper or e-paper displays.
Now e-paper displays are a bit of a different beast than the other types of displays that
we've looked at here in the workshop.
And one of the primary differences is that e-paper displays reflect light, they do not
emit light themselves.
E-paper as the name would imply is very similar to regular paper and so it can be used in
environments that are brightly lit or even outdoors.
Now these displays do have a few disadvantages.
They can't be refreshed that quickly and they display only a limited number of colors.
So they aren't very good as video displays.
But in applications where you don't need to refresh very quickly, they have a number of
advantages.
One of the primary advantages of an e-paper display is that they consume very little current.
In fact, they only consume current when they are being written to or refreshed.
Because of that, you can write to an e-paper display, remove all electricity from it and
what you've written will still stay on the display.
Now there's a little bit of terminology I want to go over here before we get going today.
I used to refer to these as e-ink displays, but that's actually incorrect and the analogy
is the same as that of paper and regular ink.
The paper or e-paper is the medium and the ink, or in this case the e-ink, is what you
write on the medium with.
Now I'm going to be using a very common and very inexpensive e-paper display for my experiments
today, but you can use another one if you wish.
The display I'm using is from Wavecare and it is both a Raspberry Pi hat and a device
that can be used with any microcontroller or microcomputer because it also has an external
SPI connector on it.
So before we get going, let's learn a little bit about how electronic paper displays work.
Electronic paper or e-paper displays mimic the appearance of ink on paper.
These displays reflect ambient light as opposed to emitting light.
E-paper displays can hold images indefinitely without requiring electricity.
They were developed in the 1970s by Nick Sheridan at the Xerox Palo Alto Research Center.
The Sony e-reader, which included an e-paper display, was released in 2004.
The Amazon Kindle, which is the most popular e-reader with an e-paper display, was released
in 2007.
Multicolor e-paper displays have been available since 2012.
The most familiar use of e-paper displays is with e-reader devices, but they can be
used for many other applications as well.
Large e-paper displays can be used for public signage such as the ones used in transit systems.
Because of their excellent readability in standard lighting conditions, e-paper displays
are also ideal for instrumentation devices.
E-paper displays consist of a number of e-ink capsules.
E-ink capsules are clear capsules that have a number of colored nodules in them, generally
black ones and white ones.
For multicolor e-ink displays, the black ones can be replaced with red ones.
The nodules within the e-ink capsules are polarity sensitive, with the black ones being
attracted to negative charges and the white ones being attracted to a positive one.
If the polarities are reversed, the nodules will change position within the capsule.
Now here's the cross section of a standard e-ink display.
The top layer consists of transparent electrodes, each one the size of one pixel.
The middle layer is a liquid polymer that contains the e-ink capsules.
The lower layer, which is not transparent, also consists of electrodes at the opposite
polarity to the top layer.
By changing polarities between the two layers, you can change the arrangement of the nodules
within the e-ink capsules.
This results in the following pixel pattern, given the polarities given in this diagram.
E-paper displays have advantages and disadvantages when compared to liquid crystal displays and
organic light emitting diodes.
The chart here highlights just a few of the advantages and disadvantages of e-paper displays.
Most e-paper displays use the SPI bus for communications.
Only the master out serial in data is required.
There's no master in serial out, as the display does not give information back to its controlling host.
Today we're going to be using a very popular e-ink display, the Waveshare 2.7 inch e-paper
hat, which can be used with both the Raspberry Pi and with microcontrollers.
It has a Raspberry Pi GPIO connector for easy use with a Raspberry Pi, and it has an SPI
bus connector for use with other microcontrollers and microcomputers.
Let's go and take a look at that display now.
Now here's the display that we're going to be using today, the Waveshare 2.7 inch e-paper
hat for the Raspberry Pi.
But as I said, it can also be used with an Arduino or another microcontroller as well.
Now if you look on the back of it, you will see the 40 pin connector that is used for
the Raspberry Pi GPIO.
And this will work with pretty well any modern Raspberry Pi.
You'll also see a connector on this end.
I'll turn it around so you can see some of the writing on it.
And this is the SPI connector.
In addition to SPI, it also has the power and the ground.
And there's also a busy signal that comes back out or reset, etc.
And I'll show you how we can use that when we hook it up to an Arduino.
Now if we flip it over again and look at the front, you can see there are four push buttons
down on the side over here.
And they're disconnected to a few of the GPIO pins, and we're not going to be using the
push buttons in today's experiments.
But if you're building something with the display, you could make use of the push buttons
if you wish.
Now you'll also notice my display already is displaying something, and it's displaying
this cute little robot over here.
And I don't have it connected to anything at the moment, and no, there is no battery
on the back here.
There's no large capacitor to hold the charge.
This is actually just displaying the last thing that I wrote to the display, and that
of course is the nature of ePaper.
It holds the last thing on the display, and until I write something else, it's going to
continue to display this.
And incidentally, if you're curious as to how I wrote this, well just keep watching
the video, because I'll be showing you that later.
But there you go, the Waveshare 2.7 inch ePaper hat that we'll be using in today's experiments.
So now we've learned a little bit about how ePaper works, and we've also taken a look
at our Waveshare ePaper display.
It's time to start using it, and we're going to start with an Arduino.
Now I'm going to be using an Arduino Nano 33 IoT for these experiments, but you certainly
don't need to be using that particular processor.
In fact, just about any Arduino will work, because this particular Waveshare display,
although it's a 3.3 volt device, is 5 volt tolerant, so it'll even work with an Arduino Uno.
Now if you are using a different display, I would check to make certain that your display
is 5 volt tolerant if you want to use a 5 volt microcontroller with it.
So let's go and see how we hook this up, and then we'll run a bit of code to demonstrate
the operation of our Waveshare ePaper display.
For our project, we're going to require an Arduino microcontroller.
Now I'm using an Arduino Nano 33 IoT, but you could use pretty well any Arduino for
this project.
For the ePaper display, I'm using a Waveshare 2.7 inch display, but Waveshare manufactures
a number of different size displays that would also work.
Just make certain the display you're using has an external SPI connector.
We'll begin by connecting the 3.3 volt input to the display to the Arduino's 3.3 volt output.
The ground on the ePaper display will be connected to the Arduino's ground.
DIN, which is the master out serial in connector, will be connected to the Arduino data pin D11.
The CLK pin, which is the SPI bus clock pin, will be connected to data pin D13.
The SPI bus chip select pin will be connected to data pin D10 on the Arduino.
DC is the data command control.
It's high for data and low for commands, and it's connected to pin D9 on the Arduino.
The RST pin is the external reset, and it's connected to pin D8.
And the BUSY pin is a state output pin that is connected to data pin D7.
And this completes our wiring.
Now, in order to use the ePaper display, we're going to need to grab a library,
and there are two of them up on GitHub that we could use, and they both originate from Waveshare.
One of them, however, I find has been structured a bit better,
and it's the one I'm going to be using. It's this one under sewn use.
There's another one here under Waveshare itself called ePaper,
and this says code for both the Arduino and the Raspberry Pi,
and we'll actually be making use of this library when we go to the Raspberry Pi.
Now, both of these libraries have a number of files over here,
a number of folders, excuse me, for different displays,
and the Waveshare one has a lot more of them.
If you go into Arduino here, you'll see a much longer list of displays.
So, if your display hasn't been found in this one under sewn use,
then you'll need to grab the Waveshare one.
Now, the only difference between the two is the way the library folders have been structured,
and this one has been structured properly for the Arduino.
This one actually isn't, and what I mean by that is when you go
and you look at examples from custom libraries,
you'll find the code is directly in there rather than as a menu item,
and it's the only real difference between the two of them.
They install in the same fashion.
Now, this one also has an advantage in that at the bottom they have an image
that shows you all the various Waveshare displays,
so you can go and pick out yours and know which one that you are using,
know which library you need to use,
and this is my display down over here at the bottom corner,
and so the library I actually need to use then is the 2.7 inch ePaper underscore B library.
No matter which one you want, the easiest way to do this is to grab the code
by going over here and downloading the zip file,
and then we go into the file manager, and I've got my file manager.
I've already expanded the zip file, so I've got all of these different folders,
and here's the one I want, the 2.7 inch ePaper B,
and if I go into this, I'll find the folder under here,
and this is the actual library,
and you want to copy that into your Arduino libraries folder,
and this is my Arduino's library folder or directory if you wish,
and I've already got this copied into here, so you can see it down over here,
and so now we'll go into the Arduino IDE,
and we'll go under file, we'll go to examples,
and we'll go to examples from custom libraries,
and we find it over here, and we find a demo,
and that's the actual code that we want to run,
and it is actually by Waveshare.
It's the same code, as I said, it's just structured a bit better,
so if your display is on that soon used one, I'd recommend using that,
but otherwise the Waveshare one is fine, and you install it in the same fashion,
and it's actually a fairly easy example to understand.
It comes with a couple of extra files as well.
One, and they have to do with the image data,
because there are a couple of icon images that are going to be displayed,
and it basically goes through everything that you need to do
with the display, the library it installs,
this library over here does all the heavy lifting, so to speak,
and of course we need the SPI library as well,
because the SPI connection is being used for the display,
and then if we go through here, we can see how it works.
It's actually quite easy to understand if you read it.
We do a clear to it, we clear the display.
It tells you to draw a straight line at a specific location,
and then write the words e-paper demo, etc,
and you set the width and the height and everything.
You can go through all of this and use this as a great example for writing your own code,
and it's all the code, by the way, is in the setup function.
There is nothing in the loop at all, so this is going to run through this,
and then at the very end, it puts the display into a deep sleep,
and it'll hold the last image that was up on it.
So the easiest way to see how this works is just to upload it to my Arduino Nano 33 IoT,
which I've got connected, and run the demonstration.
So I'm about to run the Waveshare e-paper demo.
Now, what I've done is I've blanked my display
so that you can see everything right from start,
and the code is loaded onto my Arduino Nano 33 IoT,
but I don't have it plugged into the USB right now,
so there's no power on the Arduino.
As soon as I power it up, it's going to start the demonstration on the display,
and so I'm going to go and do that right now,
and there we go.
You can start to see the e-paper demo running on the display,
and it displays some text and a number of shapes,
a bunch of icons over here,
and eventually it settles in over here where it's displaying things such as shading and dimming,
and this completes the demonstration,
but one thing I want to show you,
I'm going to disconnect the USB cable,
so there's no actual current going to the display,
and of course, it still holds it,
and to prove that, I'll disconnect it,
and as you can see, the display is still displaying the last thing that was printed out to it,
and that, of course, is the nature of e-paper,
and so that concludes that first display with the Waveshare test code.
Now, the particular e-paper display that I'm working with today
is a Raspberry Pi hat hardware attached on top,
and it ends up with an amusing name of the e-paper hat,
which makes you think about something you'd wear on your head,
but it's not,
and so we're going to put it on top of a Raspberry Pi instead of her heads,
and we are going to see what it takes to make this display work with a Raspberry Pi.
Now, there's no wiring diagram for the Raspberry Pi, of course,
because this is a hat, a hardware attached on top board,
and you just simply plug it onto the Raspberry Pi GPO.
So I've already done that,
but before I can do anything, I need to do one other thing in the Raspberry Pi operating system,
and that's enable the SPI bus,
and you can do that over here,
and go down into preferences,
and go to Raspberry Pi configuration,
and go to interfaces,
and look for SPI,
and enable SPI,
and say okay,
and now we've enabled our SPI bus.
Now we're going to open our terminal,
and in the terminal, we're going to go and grab the example files that Waveshare has up on GitHub.
This is the same GitHub directory I showed you earlier when we worked with the Arduino,
and this will create a folder called e-paper,
and copy all the files into it,
and we're done,
and if we do an LS right now,
we should actually be able to see that folder,
and it's over there,
and so we can go into that folder.
Let's go into it,
and if we do an LS over here,
we will see we have a couple of directories,
one called Arduino,
and one called Raspberry Pi slash Jetson,
and that's the one we want to go into,
so let's go into that,
and if we look inside here,
we'll see that we have a folder called Python,
and there's another one called C.
We want to run a Python example,
so let's go into that,
and again, we can list what's inside there,
and we see a few examples, etc.,
and we see one that is called examples,
and finally, let's list the examples,
and we see all of the different Python files for the different displays.
Now, remember, I have the 2.7 inch display,
so let's just run that.
We'll do Python 3,
and this is the example that we are going to run,
and so let's hit enter,
and our demonstration starts to run,
and this is a similar demonstration to the one that we saw with the Arduino.
It has a few more screens on it,
and it ends with a blank display,
and so as you can see,
we're all set up and ready to use the WaveShare ePaper hat on our Raspberry Pi.
So now we've seen how we can run demonstration code
on both an Arduino and a Raspberry Pi,
but what I'm sure you really want to do
is run your own code on your ePaper display.
Now, at the beginning of the video, I showed you this.
I showed you my little welcome to the workshop with my robot on my ePaper display,
and so right now, I'd like to show you how I coded for this in Python.
So let me show you how you can add text and images onto your ePaper display.
Now, to start developing our own code to drive the ePaper display,
we first need to set up our environment.
So what we are going to do is we are going to go into the ePaper directory
that was created during the WaveShare demo,
then go into the Raspberry Pi Jetson Nano directory,
and then into the Python directory,
and into the lib directory, which is the library directory,
and we'll see this folder called WaveShare underscore EPD.
And these are all the libraries for all the different WaveShare displays.
If you go into here, you'll see there's a number of Python files inside here,
and they're all the libraries.
So what I have done is I've created my own directory called myPython,
now you can call it anything you like,
and I've copied that WaveShare underscore EPD directory into that directory
so that I can easily make use of it.
And then I've also created another directory called pic,
and if you look inside this directory, you'll see two different files.
The first is the bitmap file of my little robot,
and if we open up that, you'll see it's a very tiny little robot
because I've scaled it to the correct size,
and it's important that you do that.
Now, a bitmap is the most ideal file to work with,
but you can also work with a PNG file.
However, be aware that if you're using a transparent PNG,
the background will not be transparent.
So if you want something with a transparent background,
a bitmap is what you're going to need to use.
The other file is a TrueType font file,
and this one's called Avenir Next.
And you could use any TrueType font file,
you certainly don't have to use this one.
I got this one up on GitHub,
but if you have a preference, by all means, use a different font file.
Now we'll go back into my MyPython directory,
and you'll see that I've created a Python sketch
called dbws underscore robot dot py,
and I've got it open here in the Thonny IDE,
so we can take a look at it.
The sketch starts by importing all the required Python libraries,
and we do that in this line over here.
And then we also import the library from the WaveShare libraries
that we just put into our folder,
and we have to import the correct one.
And in my case, I'm using the 2.7 inch ePaper display,
so this is the one that I chose.
But of course, if you're using a different display,
you'll need to use a different file.
Then we get a number of functions from Pillow.
Pillow is a utility that is already built into the Raspberry Pi.
It works with images.
If you have an earlier version of the Raspberry Pi,
it may not be there, and you'll have to manually install it.
And in the article accompanying this video
on the dronebotworkshop.com website,
I do have the commands you would need to use
if you're using an older version of the Raspberry Pi operating system.
But if you're using the latest one, it's already there.
And then we define that image directory,
which I called pic,
and I called the variable defining it as pic underscore dir.
Then we go into a try,
because that's where we're going to do everything.
And at first, we define our display over here.
So here's our display.
And then we initialize the display over here.
Then we need to clear the display,
and we use a display.clear command.
Now, we pass to it a number,
and the number is the shade that the display is going to turn
when it is cleared.
Zero being black, 255 being white.
I've chosen 255.
Now, this is kind of interesting,
and maybe a bit confusing to some,
in that I've reversed the height and the width.
And the reason I've done that
is that I want a horizontal display
as opposed to a vertical display.
But the display by its nature is vertical.
If you want to keep it vertical,
then don't do this backwards.
I've called W the display height,
and H the display width.
But you could reverse the two, like I said,
if you want a vertical display.
Then I'm just going to print the display width and height.
And as you can see, I've already run it once,
and it's down over here.
And so that gives me some reference points
for when I'm placing my text, etc.
It's just optional.
It's just something you do for diagnostics.
Then we're going to go and define the fonts.
And I've got two different fonts I'm using,
one on the top text and one on the bottom,
which I'm calling top font and bottom font.
And I'm defining which font I'm using, the font file.
And it's in the picture directory.
So we've got that over here.
The 18 is the size of the font.
So the top one is 18 points, and the bottom one is 16.
And the index is the style of the font.
And every font will have a number of different styles,
and that's unique to the font.
For this particular one, index one is a bold,
and index five is kind of a light font.
So you can look at the font that you've chosen
if you're choosing a different one,
and give it the correct index number for your needs.
Then we're going to define and draw the background
where everything is going to be placed on.
And we're basically making a new image
whose size is the complete width and height,
and whose color is 255, which is white.
Now, if you wanted to put it onto a gray background
or a black background, you could change this number
with zero being black and 255 being white,
and all sorts of shades of gray in between.
And then we're going to draw the image,
although this doesn't draw it to the screen.
It's actually drawing everything into a buffer,
and that's one thing to remember.
We're writing into a buffer right now.
We're not actually writing directly
to our e-paper display at the moment.
And then we're also going to draw some text,
and we're going to give the coordinates for the text.
So I've got the text at the top over here,
which says, welcome to the workshop.
And the one on the bottom,
which has the URL of the DroneBot workshop.
And the top one is using the top font,
and the bottom one is using the bottom font.
There's no fill on it,
which means there's no background
underneath the character.
And the alignment in both cases is left.
Now, you could have also taken the width of this,
divided it by two,
and use that as your alignment instead
of the 15 and the 10 that I've used over here,
and then done the line equals center,
and that probably would even look nicer.
Then we're going to go and get the image.
So I defined the image as to where it is.
We're going to open it, and there's my image.
We're going to paste the image onto the background.
And so I'm pasting that image at these coordinates.
And then we've got everything now in the buffer.
We are going to write the buffer to our display.
So we're going to write the whole thing
with this command here,
and that should print everything
onto our ePaper display.
The only thing underneath over here
is an exception, an error handler,
and we would print the error down to the shell.
So now that we've seen the code,
let's run it and see what happens to our display.
So to run the code,
all that we need to do is hit the run button,
and we can observe the display,
and we can see it initializing.
And there you go.
It writes out our display,
and we can see our welcome to the workshop on here.
So as you can see that it's not that difficult
to use Python with the Raspberry Pi
in order to write to an ePaper display.
Now, at the very beginning of the video,
I promised that I would show you a method
of using an ePaper display
that didn't actually require any coding,
and that method is something called PaperPi.
Now, PaperPi is a piece of software
that you run on a Raspberry Pi,
and it is capable of driving
just about any common WaveShare display,
including the 2.7-inch display
that we're using today.
Now, it really excels with larger displays,
but even with a small display,
I can show you the capabilities of PaperPi.
With PaperPi, instead of coding,
all you do is you add plugins,
and there are plugins available
for a number of different things.
You can get things like the phases of the moon,
you can get weather reports,
you can get comics,
you can even get music off of Spotify.
So let me show you how we can configure PaperPi,
and I'll show you how we can use a couple of plugins
to make some really interesting ePaper displays
without having to write even one line of code.
Now, the entire PaperPi project is available
and is documented on GitHub,
and it's documented quite well.
It describes, first of all, what the project is
and how it makes use of plugins,
and plugins allow you to tailor the display
for your own needs,
and there's quite a list of plugins.
I've just got a few samples over here.
So here's a Spotify plugin, for example,
and here's one from Logitech Media Server,
and both of those are going to require you
to add an audio board onto your Pi as well
so that you can get sound.
Here's a really neat one, the Word Clock.
It doesn't give you the exact time,
but it tells you the time
in a more human-readable format.
You can get moon phases.
The Weather plugin is very nice,
and here's one for cryptocurrency
that'll give you the current value of the Bitcoin.
Here's a comic one, a basic clock.
There are a number of other plugins,
including comics from The New Yorker.
So you can style it to your own needs,
and they go through the entire installation process
and the setup process,
and you can set this up just to run at the command line,
which is what we're going to do today,
but you can also set it up with a daemon
so that it runs when the Raspberry Pi
is first booted up,
and they also give you information
for building your own plugins for PaperPi.
Now, they also provide info
for a really neat project,
which is something you'd use
with a larger e-ink display,
excuse me, e-paper display.
I said it again,
and it shows you how you can build a frame for it.
Here's the weather program,
which looks quite nice in its frame,
and it goes through the construction details.
So this is a well-documented project
that I don't think you'll have any problem getting to run.
So now we're going to go over to our Raspberry Pi
and install and run PaperPi.
So on the Raspberry Pi at the command line,
the first thing we're going to need to do
is to download the latest version of PaperPi
as a compressed file.
So I've already entered the command in.
I'm going to hit enter right now,
and we've downloaded.
That was pretty quick.
Now we need to decompress it,
and this is where the only typo is in the instructions,
but it's actually a pretty obvious typo, actually.
And the typo, by the way,
is it said paperpi.tgz,
and it should say paperpi underscore latest.
So let's extract that,
and we've done that.
And so the first step is to launch PaperPi,
and when you first launch it,
it's going to build a configuration file.
And so as it says,
it's the first time it's been run,
and it's built a config file,
so it hasn't done anything on my display yet.
So what I need to do is edit that config file,
and we'll bring up the nano editor.
And there's a couple of things
that we have to do in the editor to get it to work.
And the first thing to do
is to tell it what display type we need.
And I'm using the WaveShare 2.7 inch display, of course.
And if you're using a different display,
naturally, you would do that.
And for now, that's all we're going to edit.
So we'll do an exit with a Control X.
We'll tell it we want to save it,
and we'll save it to overwrite the original file.
And then we'll go back and we'll run PaperPi again.
As you can see, we're getting a splash screen,
and it's telling us that no plugins are active,
and it gives us a clock.
And this is because no plugins are indeed active.
So the next step is we need to go and activate some plugins.
So in order to configure the plugins,
we need to go back into the config file.
And if we scroll down, we'll see a number of plugins.
And they're already here.
We have a decimal binary clock.
We have a weather plugin over here,
a crypto plugin, moon phase, et cetera.
Let's scroll down until we get to the basic clock
because it's a pretty easy plugin to work with.
And in order to activate a plugin,
you need to just take out the letter X where it says xplugin
because it's looking for the text plugin, not xplugin.
So just delete that.
And we'll go and we'll save our file.
And we'll go back and we'll run PaperPi again.
We get our splash screen.
And then we get our basic clock.
And this is going to refresh itself,
I think about every 30 seconds or so.
It's in the config file how often that it refreshes.
And it's simply displaying the time.
Now, if we want to get out of PaperPi,
at the command line, we need to do a Control C.
Do Control C and hit Enter.
And it blanks the display and goes back to the command line.
Let's go and edit it again.
I'm going to throw in the weather plugin.
I've already put in some data for the weather plugin.
Now, it comes up defaulting to Ethiopia.
But as I'm not in Ethiopia, I modified it.
And the lines I modified are as follows.
I put my location name.
Now, you can write anything you want.
I wrote Montreal because that's where I am.
But I could have written anything.
This is just what's going to print on the display.
And actually, the text is so small, you won't really see it.
And then I put my latitude and my longitude in right now
because it came up by default for the Addis Ababa,
which is in Ethiopia.
And I believe it's a misspelling.
I think there's two Ds in the first word,
but I'm not sure about that.
But at any rate, I configured my latitude and longitude,
which you can easily find on Google.
So I took the X out of XPlugin.
And I haven't done anything to the base of clock.
So I'm now running two plugins.
So let's just exit again.
Save the buffer.
And we'll run PaperPi.
We'll get our splash screen.
And it comes up with our weather.
And this would look much nicer on a larger display
where you'd be able to see it.
But nonetheless, you can get the idea.
It's giving me the current temperature.
And unfortunately, this is accurate.
It is indeed negative 14 Celsius outside there.
And we're going up to a balmy negative 12 Celsius
a little later on today.
And then tonight, we're dipping down to negative 16 Celsius,
which is why I'm planning to spend the day indoors.
And it also gives you the wind direction over here.
It tells you a bit about whether it's going to be sunny.
At least it is going to be a sunny day today.
And we can't see it, but up in the corner there,
it says Montreal.
Now it's flipped over to the second plugin.
And that, of course, is our basic clock.
And you can add as many plugins as you want.
And it'll just cycle through all of the different plugins,
which is really neat.
And I think with a large display,
especially with that picture frame project that they had,
it would look fantastic.
So if you could afford a large e-paper display,
this would be really a great way to drive it.
But as you can see, PaperPi is an excellent way
of making an e-paper display
without writing a single line of code.
And so that concludes our look at e-paper displays.
I hope that you enjoyed the video
and that it's opened your eyes
to a couple of applications of your own
where you could use e-paper displays.
Now, if you want some more information
about these displays,
or if you want to grab the code
and the files that I used
in order to code my own e-paper display,
you'll find all of that in the article
that accompanies this video
on the DroneBotWorkshop.com website.
And there's a link to that article right below the video.
While you're on the website,
please consider signing up for my newsletter
if you haven't already.
The newsletter isn't a sales letter by any means.
It's just my way of keeping in touch with you
to let you know what's going on here in the workshop.
Now, if you want to discuss e-paper displays further,
the best place to do that
is on the DroneBotWorkshop forum.
You'll find a dedicated thread
that goes along with this video.
And you'll also find thousands of other posts
from like-minded individuals
who like to work with microcontrollers and electronics.
And of course, the forum is also free to join.
And if you haven't yet,
please subscribe to the YouTube channel.
I would really appreciate that.
All you need to do is hit the subscribe button
and then also hit that little bell notification.
And providing you allow notifications
on your YouTube account,
then you will be notified every time
that I make a new video.
So until we get together the next time,
please take good care of yourself.
Please stay safe out there.
And I will see you soon here in the DroneBotWorkshop.
Goodbye for now.
