Hi Norfeldt, I think you misunderstood my post.
An example is there for users to learn from and adapt to their needs.
I thought you could easily find out if there exists something similar to WiFiClient for Particle, or get help for this in this forum. I do not decline to help you, but you could start with searching on Particle.
GxEPD2_WiFi_Example
Jean-Marc
I have started a topic in this forum to get help for me to help:
There are numerous httpclients in the library and now httpsclients so strike requirement 1.
I have done a HTTP download to an SD card of a .bmp file but never got around to getting it to work for HTTPS.
It should be possible to combine the GxEPD2_WiFi_Example (where all the hard work in processing the .bmp format to write to the EPD has been done by Jean-Marc) with the httpsclient to get something that can would on the Particle platform.
Your example code has been a big help for me and I have used it to print the quotations with different colors.
It's just that this example is over 1300 lines of code and I'm not so good at Arduino code at this level - I'm much stronger with JavaScript.
I thought that it would be too big of a question to ask for help with this example on the community - since it would essentially be "can you help me to code this for me?".
I donāt know your exact requirements, but maybe you just need the function showBitmapFrom_HTTP() from the GxEPD2_PP_WiFi_Example to start with.
You are right, that seems like a good start.
I was thinking of using Firebase storage to host the .bmp files (and Firebase functions to do the conversion from .jpg to .bmp via JIMP) - that would use HTTPS.
But just to get some experience your example would be an excellent start.
Has anybody here used this version of the Waveshare display?
Iām wondering if the library will drive this display or if itās incompatible?
Yes, it is supported. I think I even tested it with GxEPD2_PP.
Note that this e-paper display has an unpleasant long refresh time of about 15 seconds.
Thanks for mentioning the long refresh time.
Have you tested the highlighted version of the 4.2 inch version that has 1 Second Partial Refresh times?
Iām looking for something bigger than 4 inches that has quick partial refresh times for a AD display.
The B & W 7.5 inch display looks good with 4.3 second refresh times, just trying to keep the flashing down so itās causing anybody to have Epilepsy.
Any advice?
Ok, this is the actual table from GxEPD2. Note that GxEPD2_PP lags behind GxEPD2, as well as the GxEPD2 version published for Particle.
GDEW042T2 is the largest SPI e-paper with differential partial update (without flashing).
Note that the wavetable for partial update of this e-paper is currently under question, see
https://forum.arduino.cc/index.php?topic=487007.msg4244907#msg4244907
GDEW075T8 has no differential update, means it flashes during the 4.3s refresh.
There is a new 7.5" e-paper announced, GDEW075T7 b/w 800x480, with a controller that can do differential update, but no available waveform table for differential update afaik.
@ZinggJM I see @manu84 has got the Partial update working on the 4.2 inch display which you have.
Is there any way you could share a video showing what the 4 inch display looks like when doing partial updates vs full updates using your enhanced library? Iām trying to get a good idea of what is possible before heading down the eInk road.
Iām currently using Sharp Memory LCDās and they make a 4.4 inch version but the resolution of 320x240 is lower then Iām wanting ideally so the eInk and itās larger sizes and more pixels are attractive in that respect.
Pictured is a 2.7 inch Sharp Memory LCD with 400x240 pixels.
Sorry, I spend a lot of time answering posts. I am willing to add some pictures sometimes. But taking videos is asking too much. BTW there are many e-paper videos on YouTube, and certainly some with the 4.2". Or you could search for G6EJD, he uses my library GxEPD and produces videos.
Yea no problem, figured it wouldnāt hurt to ask. Thanks for pointing me in the right direction.
So officially until the new 7.5inch screen is released there is no way to get a refresh quicker than 14 seconds right?
Thanks for your work on the library for these displays!
So Iāve been playing around with this library for a couple of days now, and am sufficiently stumped as to how to get it to do what I want.
Goals:
This is what I have now, using the 2.9" Waveshare display. Any help would be greatly appreciated.
#include <Adafruit_GFX_RK.h>
#include <GxEPD2_PP.h>
// base class GxEPD2_GFX can be used to pass references or pointers to the display instance as parameter, uses ~1.2k more code
// enable or disable GxEPD2_GFX base class
#define ENABLE_GxEPD2_GFX 0
#include <Arduino.h>
#include <Adafruit_GFX.h>
#include <FreeMonoBold9pt7b.h>
#include <FreeMono12pt7b.h>
// #include "imagedata.h"
#include <GxEPD2_BW.h>
#include <GxEPD2_3C.h>
GxEPD2_BW<GxEPD2_290, GxEPD2_290::HEIGHT> display(GxEPD2_290(/*CS=A2*/ SS, /*DC=*/ A1, /*RST=*/ A0, /*BUSY=*/ A4));
// GxEPD2_BW<GxEPD2_290_T5, GxEPD2_290_T5::HEIGHT> display(GxEPD2_290_T5(/*CS=A2*/ SS, /*DC=*/ A1, /*RST=*/ A0, /*BUSY=*/ A4)); // GDEW029T5
#include "bitmaps/Bitmaps128x296.h" // 2.9" b/w
const char HelloWorld[] = "Hello World!";
const char HelloArduino[] = "Hello Arduino!";
const char HelloEpaper[] = "Hello E-Paper!";
void setup()
{
Serial.begin(115200);
Serial.println();
Serial.println("setup");
delay(100);
display.init(115200);
display.clearScreen();
display.writeScreenBuffer();
delay(1000);
drawBitmaps128x296();
drawBitmaps128x296();
display.clearScreen();
display.writeScreenBuffer();
delay(1000);
}
void loop()
{
//Serial.println("helloArduino");
display.setRotation(1);
display.setFont(&FreeMonoBold9pt7b);
display.setTextColor(GxEPD_BLACK);
int16_t tbx, tby; uint16_t tbw, tbh;
// align with centered HelloWorld
display.getTextBounds(HelloWorld, 0, 0, &tbx, &tby, &tbw, &tbh);
uint16_t x = ((display.width() - tbw) / 2) - tbx;
// height might be different
display.getTextBounds(HelloArduino, 0, 0, &tbx, &tby, &tbw, &tbh);
uint16_t y = ((display.height() / 4) - tbh / 2) - tby; // y is base line!
// make the window big enough to cover (overwrite) descenders of previous text
uint16_t wh = FreeMonoBold9pt7b.yAdvance;
uint16_t wy = (display.height() / 4) - wh / 2;
display.setFullWindow();
// display.setPartialWindow(8, wy, display.width(), wh);
display.firstPage();
do
{
display.fillScreen(GxEPD_WHITE);
//display.drawRect(x, y - tbh, tbw, tbh, GxEPD_BLACK);
display.setCursor(x, y);
display.print(HelloArduino);
display.setCursor(x - 40 , y + 80);
display.print(HelloEpaper);
display.setFont(&FreeMono12pt7b);
display.setCursor(x + 40 , y + 60);
display.print(HelloWorld);
}
while (display.nextPage());
delay(5000);
display.setFullWindow();
display.fillScreen(GxEPD_WHITE);
display.firstPage();
do
{
display.fillScreen(GxEPD_WHITE);
//display.drawRect(x, y - tbh, tbw, tbh, GxEPD_BLACK);
display.setCursor(x, y + 20);
display.print(HelloWorld);
}
while (display.nextPage());
delay(5000);
}
void drawBitmaps128x296()
{
const unsigned char* bitmaps[] =
{
Bitmap128x296_1, logo128x296, first128x296, second128x296, third128x296
};
bool m = display.mirror(true);
for (uint16_t i = 0; i < sizeof(bitmaps) / sizeof(char*); i++)
{
display.firstPage();
do
{
display.fillScreen(GxEPD_WHITE);
display.drawInvertedBitmap(0, 0, bitmaps[i], display.epd2.WIDTH, display.epd2.HEIGHT, GxEPD_BLACK);
}
while (display.nextPage());
delay(2000);
}
display.mirror(m);
}
Display different sized text in the same update
You need to #include all fonts you want to use, and use display.setFont() to select the active font.
Show some text inverted in a configurable sized section with ānormalā text
Draw a black rectangle, and write the text over it with GxEPD_WHITE.
Full buffer drawing
Read the README.MD
GxEPD2 has an example: https://github.com/ZinggJM/GxEPD2/tree/master/examples/GxEPD2_NotPagedExample
It looks like using the full buffer has solved my issue with images, and the alternating displays in my loop(). The formatting of the README makes it harder to understand what I needed to do, since bullet points are breaking up sentences and interrupting the flow.
The only thing I still canāt figure out is how to completely clear the display.
This sequence displays the second last image shown at startup, then goes through the bitmap list and my custom logo, then completely clears the display before going into the main loop().
void setup()
{
Serial.begin(115200);
delay(100);
display.init(115200);
// display.setFullWindow();
// display.clearScreen();
display.fillScreen(GxEPD_WHITE);
display.display(false);
// display.fillScreen(GxEPD_WHITE);
// display.display(false);
delay(5000);
drawBitmaps128x296();
drawlogo();
display.fillScreen(GxEPD_WHITE);
display.display(false);
delay(5000);
}
Why isnāt the display blank for 5 seconds before going into drawBitmaps(), but it is after draw logo?
I wouldnāt expect this with display.display(false); maybe with display.display(true);
Unfortunately it takes time for me to make a system ready for testing with Particle. I only have a system ready for tests with Arduino. So I may test and answer in 2 to 3 days maybe.
I confirm that this doesnāt work with neither the published version of this library, nor the version on GitHub.
The library lags behind the GxEPD2 library for Arduino.
from README.MD of GxEPD2_PP:
from README.MD of GxEPD2:
The version of GxEPD2 published for Particle also does not have these fixes.
I will update the versions for Particle, but donāt know yet when I have time for this.
Updating the versions is not the problem, but testing takes time.
Donāt use display.display() with this version, for e-papers with āfast partial updateā.
Use at least one full update before using partial update (like in the example).
Use a partial update to full screen equal to the initial full update, before using partial updates.
Sorry for the inconvenience, my Arduino libraries are more important for me and for most users.
Note that the GxEPD2 version on GitHub can be used with Particle as private library (untested for Particle). The examples for Particle are in directory āextrasā.
Perhaps Iām misunderstanding the example; but when I copied the Hello World code over into my project, and condensed it down to what I believe I needed, Iām still getting a similar problem. This time I still get the second last image shown instead of a blank screen, and I also get another 5 seconds of the last image shown before going into drawbitmaps().
void setup()
{
Serial.begin(115200);
delay(100);
display.init(115200);
display.setFullWindow();
display.firstPage();
do
{
display.fillScreen(GxEPD_WHITE);
}
while (display.nextPage());
delay(2000);
drawBitmaps128x296();
drawlogo();
display.fillScreen(GxEPD_WHITE);
display.display();
delay(2000);
fontDemo();
}
I confirm this also, but I have no idea why. I have checked that the example works, so this should work also. I have currently no time to investigate further.