@felmue I've updated the code, it should now compile with no warnings in PlatformIO.

@felmue I'll try to get PlatformIO set up and take a look, thanks,

@bwubs Just one, which you have to specify when compiling the app.

Source available here: https://github.com/murraypaul/M5Sudoku

M5Sudoku

Sudoku application for M5Paper

Can generate uniquely solveable Sudoku puzzles, targetting a given number of clues, to act as a difficulty setting.

At any point, can validate that the puzzle is still solvable.

Can mark squares as either a known value, or a set of possible values.

Can save and reload current state to EEPROM.

Will automatically shutdown and save state after 5 minutes of inactivity.

Notes:

• Selecting a square in the large grid will display it in the small grid on the right
• The selected square is highlighted in the large grid
• You can use the small grid to either set a single known value for the square, or select multiple possible values
• It may not be possible to generate a uniquely solveable puzzle of the given numbers of clues in the time requested
• In this situation, the puzzle with the lowest number of clues that still gives a unqiue solution will be returned
• The fewer target clues you ask for, the longer it will take to generate the puzzle
• The 'Validate' button will confirm that the puzzle is still uniquely solveable
• The 'Clue' button will fill in one randon unsolved square
• Over time the screen may get a bit muddy, due to the fast refresh option used on the EPD screen
• The 'Validate' button will also do a full screen slow refresh, which will clean up the display

The most likely issue is that the filename you pass doesn't start with '/', which is required by the SD library.

To view the logging output, assuming you are using the Arduino UI, first do Tools->Core Debug Level->Set to Debug or Verbose. Then do Tools->Serial Monitor.
You will see debug output from the M5Paper appear in the serial monitor window.

I have a M5Paper, not a Core2, but the APIs look very similar.
You can use something like bin2header (https://github.com/AntumDeluge/bin2header) to convert your jpg file to a C header file and include that in your project. It will start with something like:

static const unsigned char my_file_name_jpg[] = {...

You can then use the memory buffer form of drawJpg:

      void drawJpg(const uint8_t *jpg_data, size_t jpg_len, uint16_t x = 0,
                  uint16_t y = 0, uint16_t maxWidth = 0, uint16_t maxHeight = 0,
                  uint16_t offX = 0, uint16_t offY = 0,
                  jpeg_div_t scale = JPEG_DIV_NONE);

Like this:

drawJpg(my_file_name_jpg,sizeof(my_file_name_jpg),x,y,...)

(As the other poster said, this might not be the best way of doing it, but it is available.)

Application to monitor and control a Spotify client using the M5Paper.
Note: This is not itself a Spotify client, it cannot stream Spotify through the M5Paper.

Three screen layouts available, show below.
Initial Spotify authentication through a built-on webserver, then refresh token saved to EEPROM and should function independently.

Polls Spotify to update data at one of two compile-time configurable rates, depending on whether there is currently an active Spotify device found or not. Shuts down after configurable interval with no active client found if running on battery.

You need to create a (free) developer account and client app with Spotify, and approve access of this application to your Spotify account.

Requested scopes are:

• user-read-private
• user-read-currently-playing
• user-read-recently-played
• user-read-playback-state
• user-modify-playback-state

Code available at https://github.com/murraypaul/M5Spot.
Based on original M5Spot project by Cosmic Mac available at https://github.com/CosmicMac/M5Spot.

Icons by icons8.

My question is, if the behavior is required or an artifact of the integration with the driver?

I think this is required.
When actually transferring data to the screen, this is done 4 pixels at a time.

Shouldn't the library simply forbid creating a canvas that is not a multiple of 4?

Probably, yes.

Someone had asked in another thread whether there was an easy way to take a screenshot of the M5Paper.
I've put together a function to do that.
It can take a screenshot in two formats. 16 colour (4bpp) BMP makes the most sense, as that is what the device can actually display, and only takes about 250KB, but full colour (24bpp) BMP is the format that the device can easily read back in again, and takes about 1.5MB.
This is recording what is stored in the canvas framebuffer, not what is actually displayed on the screen. They will be different if you have called drawing functions and not yet called pushCanvas, or if you are using multiple canvases.
Taking a full screen 24bpp screenshot is quite slow, taking about 10 seconds on my SD card.

bool takeScreenshot( M5EPD_Canvas& canvas, String filename, bool bFull24bpp = true, int xPos = 0, int yPos = 0, int xSize = -1, int ySize = -1 )
{
  File bmpFile = SD.open(filename,FILE_WRITE);
  if( !bmpFile )
  {
    log_e("Failed to open '%s' for write",filename);
    return false;
  }
  
  xSize = max( 1, min( xSize == -1 ? canvas.width() : xSize, canvas.width() - xPos ) ); 
  ySize = max( 1, min( ySize == -1 ? canvas.height() : ySize, canvas.height() - yPos ) ); 
  if( !bFull24bpp && xSize % 2 == 1 ) xSize++;
  
  log_d("Taking %d x %d screenshot to '%s'", xSize, ySize, filename);

  size_t bytes_written = 0;
  auto write8 = [&file=bmpFile,&bytes_written]( uint8_t data )
  {
    bytes_written += file.write(data); 
  };
  auto write16 = [&file=bmpFile,&bytes_written]( uint16_t data )
  {
    bytes_written += file.write(((uint8_t *)&data)[0]); 
    bytes_written += file.write(((uint8_t *)&data)[1]);  
  };
  auto write32 = [&file=bmpFile,&bytes_written]( uint32_t data )
  {
    bytes_written += file.write(((uint8_t *)&data)[0]); 
    bytes_written += file.write(((uint8_t *)&data)[1]);  
    bytes_written += file.write(((uint8_t *)&data)[2]);  
    bytes_written += file.write(((uint8_t *)&data)[3]);  
  };
  auto writeN = [&file=bmpFile,&bytes_written]( uint8_t* data, size_t N )
  {
    bytes_written += file.write(data,N); 
  };  

  uint8_t bpp = bFull24bpp ? 24 : 4;
  size_t bmpHeaderSize = 14;
  size_t dibHeaderSize = 40;
  size_t colourTableSize = bpp == 24 ? 0 : pow(2,bpp)*4;
  size_t gap1Size = 2;
  size_t rowSize = ceil(bpp * xSize / 32.0) * 4;
  size_t rowGap = rowSize - (bpp * xSize / 32.0) * 4;
  size_t pixelArraySize = rowSize * ySize;
  size_t pixelArrayOffset = bmpHeaderSize + dibHeaderSize + colourTableSize + gap1Size;
  size_t expectedSize = pixelArrayOffset + pixelArraySize;
//  log_d("Expected size %d, row size %d, row gap %d, pixel array offset %d, pixel array size = %d",expectedSize, rowSize, rowGap, pixelArrayOffset, pixelArraySize);
  
  write16( 0x4D42 );
  write32( expectedSize );
  write32( 0 );
  write32( pixelArrayOffset );
  
  write32( dibHeaderSize );
  write32( xSize );
  write32( ySize );
  write16( 1 );
  write16( bpp );
  write32( 0 );
  write32( 0 );
  write32( 9252 );
  write32( 9252 );
  write32( 0 );
  write32( 0 );

  // From M5EPD_Canvas.cpp
  const uint8_t alphamap[16] = {0, 17, 34, 51, 68, 85, 102, 119, 136, 153, 170, 187, 204, 221, 238, 255};
  if( bpp == 4 )
  {
    uint8_t buffer[16*4];
    int iCount = 0;
    for( int i = 0 ; i < 16 ; i++ )
    {
      uint8_t value = 255-alphamap[i];
      buffer[iCount++] = value;
      buffer[iCount++] = value;
      buffer[iCount++] = value;
      buffer[iCount++] = 0;
    }
    writeN(buffer,iCount);
  }
  for( int i = 0 ; i < gap1Size ; i++ )
    write8( 0 );

  uint8_t buffer[960*3];
//  log_d("After headers, bytes_written = %d",bytes_written);
  for( int y = ySize + yPos - 1; y >= yPos ; y-- )
  {
    int iCount = 0; 
    for( int x = xPos ; x < xSize + xPos ; x++ )
    {
      uint16_t pixel = canvas.readPixel(x,y);
      uint8_t value = min(pixel,(uint16_t)15); 
      switch( bpp )
      {
        case 24:
        default:
          value = alphamap[15-min(value,(uint8_t)15)];
          buffer[iCount++] = value;
          buffer[iCount++] = value;
          buffer[iCount++] = value;
          break;
        case 4:
          if( (x-xPos) % 2 == 0 )
            buffer[iCount] = (value << 4) & 0xf0;
          else
          {
            buffer[iCount] |= value & 0x0f;          
            iCount++;
          }
          break;
      }
    }
    for( int gap = 0 ; gap < rowGap ; gap++ )
      buffer[iCount++] = 0;
    writeN(buffer,iCount);
  }

  bmpFile.close();

  if( bytes_written != expectedSize )
    log_e("Total bytes written %d vs expected %d",bytes_written,expectedSize);
  
  log_d("Screenshot done");
  
  return true;
}

Currently the M5EPD library only supports a single loaded TTF font.
For most applications this is fine, but for something like an eReader or web browser it is limiting, as it means you can't have bold/italic/monospaced text.
For my own use, I've modified the library to allow multiple loaded TTF fonts, and I thought I'd share in case it is of use to anyone else.
This is still very experimental, so there may be issues I haven't encountered yet.
The way I've added this support to to use the textfont variable, which isn't currently used when TTF fonts are active. Calling setTextFont switches the currently active TTF font slot, and any subsequent loadFont/createRender/drawString calls will use that slot, until you change it again.
Each loaded font has its own set of render caches, and you can render each font at multiple, different, sizes.
You must call setTextSize each time you call setTextFont, as that is what selects the correct render for the font you have chosen.
This works with either file fonts or header fonts.
Example sketch:

#include "M5EPD.h"

#define USE_HEADER_FONTS 0

#if USE_HEADER_FONTS
#include "OpenSans_Regular.ttf.h"
#include "OpenSans_ExtraBold.ttf.h"
#include "OpenSans_Italic.ttf.h"
#include "OpenSans_ExtraBoldItalic.ttf.h"

std::vector<std::pair<const unsigned char*,uint32_t>> fonts = 
  {{OpenSans_Regular_ttf,sizeof(OpenSans_Regular_ttf)}
  ,{OpenSans_ExtraBold_ttf,sizeof(OpenSans_ExtraBold_ttf)}
  ,{OpenSans_Italic_ttf,sizeof(OpenSans_Italic_ttf)}
  ,{OpenSans_ExtraBoldItalic_ttf,sizeof(OpenSans_ExtraBoldItalic_ttf)}};
#else
std::vector<String> fonts = {"/Fonts/OpenSans-Regular.ttf","/Fonts/OpenSans-ExtraBold.ttf","/Fonts/OpenSans-Italic.ttf","/Fonts/OpenSans-ExtraBoldItalic.ttf"};
#endif

M5EPD_Canvas Canvas(&M5.EPD);

void setup() { 
  M5.begin();
  M5.EPD.SetRotation(90);
  M5.EPD.Clear(true);
  M5.TP.SetRotation(90);
  M5.RTC.begin();

  Canvas.createCanvas(540,960);

  Canvas.useFreetypeFont(true);
  Canvas.setFreeFont(nullptr);

  for( int font = 1 ; font <= 4 ; font++ )
  {
    Canvas.setTextFont(font); 
#if USE_HEADER_FONTS
    Canvas.loadFont(fonts[font-1].first,fonts[font-1].second); 
#else
    Canvas.loadFont(fonts[font-1],SD); 
#endif
    Canvas.createRender(48,32);
  }

  Canvas.setTextColor(15);
  Canvas.setTextDatum(TL_DATUM);

  int xPos = 64;
  for( int font = 1 ; font <= 4 ; font++ )
  {
    Canvas.setTextFont(font);
    Canvas.setTextSize(48);
    xPos += Canvas.drawString("Test ",xPos,64);
  }
  
  Canvas.pushCanvas(0,0,UPDATE_MODE_GC16);
}

void loop() {}

In this example I have loaded each font and created its render together, and created all fonts before using any of them. Neither of those is required, you can load fonts and create renders at any time, as long as you select the correct textfont before each operation. You can also delete renders, unload fonts and load a new font into the slot, as long as no canvases are using that slot.

Edit: The updated M5EPD library is available at https://github.com/murraypaul/M5EPD