#include "MD_MAXPanel.h"

const MD_MAX72XX::moduleType_t HARDWARE_TYPE = MD_MAX72XX::PAROLA_HW;
const uint8_t X_DEVICES = 4;
const uint8_t Y_DEVICES = 5;

const uint8_t CLK_PIN = 12;  // or SCK
const uint8_t DATA_PIN = 11; // or MOSI
const uint8_t CS_PIN = 10;   // or SS

// SPI hardware interface
   MD_MAXPanel mp = MD_MAXPanel(HARDWARE_TYPE,                    CS_PIN, X_DEVICES, Y_DEVICES);
// MD_MAXPanel mx = MD_MAXPanel(HARDWARE_TYPE, DATA_PIN, CLK_PIN, CS_PIN, X_DEVICES, Y_DEVICES);

void setup() {
    mp.begin();
}

void loop() {
    mp.clear();
    mp.setPoint(20, 30, true); //No matrix index is needed for the 20-th position on the 3-d module
}


Meteor.ino

diagram.json

/*************************************************
 * Public Constants
 *************************************************/

#define NOTE_B0 31
#define NOTE_C1 33
#define NOTE_CS1 35
#define NOTE_D1 37
#define NOTE_DS1 39
#define NOTE_E1 41
#define NOTE_F1 44
#define NOTE_FS1 46
#define NOTE_G1 49
#define NOTE_GS1 52
#define NOTE_A1 55
#define NOTE_AS1 58
#define NOTE_B1 62
#define NOTE_C2 65
#define NOTE_CS2 69
#define NOTE_D2 73
#define NOTE_DS2 78
#define NOTE_E2 82
#define NOTE_F2 87
#define NOTE_FS2 93
#define NOTE_G2 98
#define NOTE_GS2 104
#define NOTE_A2 110
#define NOTE_AS2 117
#define NOTE_B2 123
#define NOTE_C3 131
#define NOTE_CS3 139
#define NOTE_D3 147
#define NOTE_DS3 156
#define NOTE_E3 165
#define NOTE_F3 175
#define NOTE_FS3 185
#define NOTE_G3 196
#define NOTE_GS3 208
#define NOTE_A3 220
#define NOTE_AS3 233
#define NOTE_B3 247
#define NOTE_C4 262
#define NOTE_CS4 277
#define NOTE_D4 294
#define NOTE_DS4 311
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_FS4 370
#define NOTE_G4 392
#define NOTE_GS4 415
#define NOTE_A4 440
#define NOTE_AS4 466
#define NOTE_B4 494
#define NOTE_C5 523
#define NOTE_CS5 554
#define NOTE_D5 587
#define NOTE_DS5 622
#define NOTE_E5 659
#define NOTE_F5 698
#define NOTE_FS5 740
#define NOTE_G5 784
#define NOTE_GS5 831
#define NOTE_A5 880
#define NOTE_AS5 932
#define NOTE_B5 988
#define NOTE_C6 1047
#define NOTE_CS6 1109
#define NOTE_D6 1175
#define NOTE_DS6 1245
#define NOTE_E6 1319
#define NOTE_F6 1397
#define NOTE_FS6 1480
#define NOTE_G6 1568
#define NOTE_GS6 1661
#define NOTE_A6 1760
#define NOTE_AS6 1865
#define NOTE_B6 1976
#define NOTE_C7 2093
#define NOTE_CS7 2217
#define NOTE_D7 2349
#define NOTE_DS7 2489
#define NOTE_E7 2637
#define NOTE_F7 2794
#define NOTE_FS7 2960
#define NOTE_G7 3136
#define NOTE_GS7 3322
#define NOTE_A7 3520
#define NOTE_AS7 3729
#define NOTE_B7 3951
#define NOTE_C8 4186
#define NOTE_CS8 4435
#define NOTE_D8 4699
#define NOTE_DS8 4978

pitches.h

# Wokwi Library List
# See https://docs.wokwi.com/guides/libraries
MD_MAX72XX


libraries.txt

MD_MAXPanel.h

/*
MD_MAXPanel - Library for MAX7219/7221 LED Panel

See header file for comments

This file contains class and hardware related methods.

Copyright (C) 2018-23 Marco Colli. All rights reserved.

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 */
#include <Arduino.h>
#include "MD_MAXPanel.h"
#include "MD_MAXPanel_lib.h"

/**
 * \file
 * \brief Implements class graphics methods
 */

MD_MAXPanel::MD_MAXPanel(MD_MAX72XX::moduleType_t mod, uint8_t dataPin, uint8_t clkPin, uint8_t csPin, uint8_t xDevices, uint8_t yDevices) :
_xDevices(xDevices), _yDevices(yDevices), _rotatedDisplay(false)
{
  _D = new MD_MAX72XX(mod, dataPin, clkPin, csPin, xDevices*yDevices);
  _killOnDestruct = true;
}

MD_MAXPanel::MD_MAXPanel(MD_MAX72XX::moduleType_t mod, uint8_t csPin, uint8_t xDevices, uint8_t yDevices) :
_xDevices(xDevices), _yDevices(yDevices), _rotatedDisplay(false)
{
  _D = new MD_MAX72XX(mod, csPin, xDevices*yDevices);
  _killOnDestruct = true;
}

MD_MAXPanel::MD_MAXPanel(MD_MAX72XX *D, uint8_t xDevices, uint8_t yDevices) :
_xDevices(xDevices), _yDevices(yDevices), _rotatedDisplay(false)
{
  _D = D;
  _killOnDestruct = false;
}

MD_MAXPanel::MD_MAXPanel(MD_MAX72XX::moduleType_t mod, SPIClass &spi, uint8_t csPin, uint8_t xDevices, uint8_t yDevices) :
_xDevices(xDevices), _yDevices(yDevices), _rotatedDisplay(false)
{
  _D = new MD_MAX72XX(mod, spi, csPin, xDevices*yDevices);
  _killOnDestruct = true;
}

bool MD_MAXPanel::begin(void)
{
  bool b = _D->begin();

  _charSpacing = CHAR_SPACING_DEFAULT;
  _updateEnabled = true;

  return(b);
}

MD_MAXPanel::~MD_MAXPanel(void)
{
  if (_killOnDestruct) delete _D;
}

uint16_t MD_MAXPanel::getXMax(void)
{ 
  uint16_t m;

  if (_rotatedDisplay)
    m = (_yDevices * ROW_SIZE) - 1;
  else
    m = (_xDevices * COL_SIZE) - 1;

  return(m);
}

uint16_t MD_MAXPanel::getYMax(void) 
{ 
  uint16_t m;

  if (_rotatedDisplay)
    m = (_xDevices * COL_SIZE) - 1;
  else
    m = (_yDevices * ROW_SIZE) - 1;

  return(m);
}

bool MD_MAXPanel::drawHLine(uint16_t y, uint16_t x1, uint16_t x2, bool state)
// draw a horizontal line at row y between columns x1 and x2 inclusive
{
  bool b = true;

  _D->control(MD_MAX72XX::UPDATE, MD_MAX72XX::OFF);

  if (x1 > x2)      // swap x1/x2
  {
    uint16_t  t = x1;
    x1 = x2;
    x2 = t;
  }

  for (uint16_t i = x1; i <= x2; i++)
    b &= setPoint(i, y, state);

  update(_updateEnabled);

  return(b);
}

bool MD_MAXPanel::drawVLine(uint16_t x, uint16_t y1, uint16_t y2, bool state)
// draw a vertical line at column x between rows y1 and y2 inclusive
{
  bool b = true;

  _D->control(MD_MAX72XX::UPDATE, MD_MAX72XX::OFF);

  if (y1 > y2)      // swap y1/y2
  {
    uint8_t  t = y1;
    y1 = y2;
    y2 = t;
  }

  for (uint8_t i = y1; i <= y2; i++)
    b &= setPoint(x, i, state);

  update(_updateEnabled);

  return(b);
}

bool MD_MAXPanel::drawLine(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, bool state)
// draw an arbitrary line between two points using Bresentham's line algorithm
// Bresentham's line algorithm at https://rosettacode.org/wiki/Bitmap/Bresenham%27s_line_algorithm#C
{
  bool b = true;

  _D->control(MD_MAX72XX::UPDATE, MD_MAX72XX::OFF);

  PRINT("\n\nLine from ", x1); PRINT(",", y1);
  PRINT(" to ", x2); PRINT(",", y2);

  if (x1 > x2)    // swap direction for line
  {
    uint16_t t;

    t = x1; x1 = x2; x2 = t;
    t = y1; y1 = y2; y2 = t;
    //    PRINTS(" SWAP X");
  }

  //  PRINT("\nPlotting from ", x1); PRINT(",", y1);
  //  PRINT(" to ", x2); PRINT(",", y2);

  int16_t dx = x2 - x1;
  int16_t sx = 1;
  int16_t dy = y2 - y1;
  if (dy < 0) dy = -dy;
  int16_t sy = y1 < y2 ? 1 : -1;
  int16_t err = (dx > dy ? dx : -dy) / 2;
  int16_t e2;

  //  PRINT("\ndx=", dx);
  //  PRINT(" dy=", dy);
  //  PRINT(" ystep=", sy);
  //  PRINT(" xstep=", sx);

  for (;;)
  {
    //    PRINT("\nerror=", err);
    //    PRINT(" [", x1); PRINT(",", y1); PRINTS("]");

    b &= setPoint(x1, y1, state);
    if (x1 == x2 && y1 == y2) break;
    e2 = err;
    if (e2 >-dx) { err -= dy; x1 += sx; }
    if (e2 < dy) { err += dx; y1 += sy; }
  }

  update(_updateEnabled);

  return(b);
}

bool MD_MAXPanel::drawRectangle(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, bool state)
// draw a rectangle given the 2 diagonal vertices
{
  bool b = true;
  bool u = _updateEnabled;

  _D->control(MD_MAX72XX::UPDATE, MD_MAX72XX::OFF);
  update(false);

  b &= drawHLine(y1, x1, x2, state);
  b &= drawHLine(y2, x1, x2, state);
  b &= drawVLine(x1, y1, y2, state);
  b &= drawVLine(x2, y1, y2, state);
  
  update(u);

  return(b);
}

bool MD_MAXPanel::drawFillRectangle(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, bool state)
{
  bool b = true;
  bool u = _updateEnabled;

  _D->control(MD_MAX72XX::UPDATE, MD_MAX72XX::OFF);
  update(false);

  for (uint8_t i = x1; i <= x2; i++)
    drawVLine(i, y1, y2, state);

  update(u);

  return(b);
};

bool MD_MAXPanel::drawQuadrilateral(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, uint16_t x3, uint16_t y3, uint16_t x4, uint16_t y4, bool state)
// draw a arbitrary quadrilateral given the 4 corner vertices
{
  bool b = true;
  bool u = _updateEnabled;

  _D->control(MD_MAX72XX::UPDATE, MD_MAX72XX::OFF);
  update(false);

  b &= drawLine(x1, y1, x2, y2, state);
  b &= drawLine(x2, y2, x3, y3, state);
  b &= drawLine(x3, y3, x4, y4, state);
  b &= drawLine(x4, y4, x1, y1, state);

  update(u);

  return(b);
}

bool MD_MAXPanel::drawTriangle(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, uint16_t x3, uint16_t y3, bool state)
// draw an arbitrary triangle given the 3 corner vertices
{
  bool b = true;
  bool u = _updateEnabled;

  _D->control(MD_MAX72XX::UPDATE, MD_MAX72XX::OFF);
  update(false);

  b &= drawLine(x1, y1, x2, y2, state);
  b &= drawLine(x2, y2, x3, y3, state);
  b &= drawLine(x3, y3, x1, y1, state);

  update(u);

  return(b);
}

/*
bool MD_MAXPanel::drawFillTriangle(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, uint16_t x3, uint16_t y3, bool state)
// draw an arbitrary filled triangle given the 3 corner vertices
// Uses slope method, originally from Adafruit Industries
{
#define SWAP(a, b) { uint16_t t = a; a = b; b = t; }

  uint8_t a, b, y, last;
  bool r = true;
  bool u = _updateEnabled;

  _D->control(MD_MAX72XX::UPDATE, MD_MAX72XX::OFF);
  update(false);

  // Sort coordinates by Y order (y3 >= y2 >= y1)
  if (y1 > y2) { SWAP(y1, y2); SWAP(x1, x2); }
  if (y2 > y3) { SWAP(y3, y2); SWAP(x3, x2); }
  if (y1 > y2) { SWAP(y1, y2); SWAP(x1, x2); }

  if (y1 == y3) // All in same line
  {
    a = b = x1;
    if (x2 < a)      a = x2;
    else if (x2 > b) b = x2;

    if (x3 < a)      a = x3;
    else if (x3 > b) b = x3;

    r &= drawHLine(y1, a, b, state);
  }
  else
  {
    int8_t dx12 = x2 - x1;
    int8_t dy12 = y2 - y1;
    int8_t dx13 = x3 - x1;
    int8_t dy13 = y3 - y1;
    int8_t dx23 = x3 - x2;
    int8_t dy23 = y3 - y2;
    int16_t sa = 0, sb = 0;

    // For upper part of triangle, find scanline crossings for segment
    // 1-2 and 1-3.  If y2=y3 (flat-bottomed triangle), the scanline y
    // is included here (and second loop will be skipped, avoiding a /0
    // error there), otherwise scanline y2 is skipped here and handle
    // in the second loop...which also avoids a /0 error here if y1=y
    // (flat-topped triangle)
    if (y2 == y3) last = y2;   // Include y2 scanline
    else          last = y2 - 1; // Skip it

    for (y = y1; y <= last; y++)
    {
      a = x1 + sa / dy12;
      b = x1 + sb / dy13;
      sa += dx12;
      sb += dx13;
      // longhand a = x1 + (x2 - x1) * (y - y1) / (y2 - y1)
      //          b = x0 + (x3 - x1) * (y - y1) / (y3 - y1)
      r &= drawHLine(y, a, b, state);
    }

    // For lower part of triangle, find scanline crossings for segment
    // 1-3 and 2-3.  This loop is skipped if y2=y3
    sa = dx23 * (y - y2);
    sb = dx13 * (y - y1);
    for (; y <= y3; y++)
    {
      a = x2 + sa / dy23;
      b = x1 + sb / dy13;
      sa += dx23;
      sb += dx13;
      // longhand a = x2 + (x3 - x2) * (y - y2) / (y3 - y2)
      //          b = x1 + (x2 - x1) * (y - y1) / (y3 - y1)
      r &= drawHLine(y, a, b, state);
    }
  }

  update(u);

  return(r);
}
*/

bool MD_MAXPanel::drawFillTriangle(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, uint16_t x3, uint16_t y3, bool state)
// Fill a triangle - Bresenham method
// Original from http://www.sunshine2k.de/coding/java/TriangleRasterization/TriangleRasterization.html
{
#define SWAP(a, b) { uint16_t t = a; a = b; b = t; }

  uint8_t t1x, t2x, y, minx, maxx, t1xp, t2xp;
  bool changed1 = false;
  bool changed2 = false;
  int8_t signx1, signx2, dx1, dy1, dx2, dy2;
  uint8_t e1, e2;
  bool b = true;
  bool u = _updateEnabled;

  _D->control(MD_MAX72XX::UPDATE, MD_MAX72XX::OFF);
  update(false);

  // Sort vertices
  if (y1>y2) { SWAP(y1, y2); SWAP(x1, x2); }
  if (y1>y3) { SWAP(y1, y3); SWAP(x1, x3); }
  if (y2>y3) { SWAP(y2, y3); SWAP(x2, x3); }

  t1x = t2x = x1; y = y1;   // Starting points

  dx1 = (int8_t)(x2 - x1); 
  if (dx1<0) { dx1 = -dx1; signx1 = -1; }
  else signx1 = 1;
  dy1 = (int8_t)(y2 - y1);

  dx2 = (int8_t)(x3 - x1); 
  if (dx2<0) { dx2 = -dx2; signx2 = -1; }
  else signx2 = 1;
  dy2 = (int8_t)(y3 - y1);

  if (dy1 > dx1) // swap values
  {
    SWAP(dx1, dy1);
    changed1 = true;
  }
  if (dy2 > dx2) // swap values
  {
    SWAP(dy2, dx2);
    changed2 = true;
  }

  e2 = (uint8_t)(dx2 >> 1);
  // Flat top, just process the second half
  if (y1 == y2) goto next;
  e1 = (uint8_t)(dx1 >> 1);

  for (uint8_t i = 0; i < dx1;) 
  {
    t1xp = 0; t2xp = 0;
    if (t1x<t2x) { minx = t1x; maxx = t2x; }
    else		     { minx = t2x; maxx = t1x; }
    // process first line until y value is about to change
    while (i<dx1) 
    {
      i++;
      e1 += dy1;
      while (e1 >= dx1) 
      {
        e1 -= dx1;
        if (changed1) t1xp = signx1;//t1x += signx1;
        else          goto next1;
      }
      if (changed1) break;
      else t1x += signx1;
    }
    // Move line
  next1:
    // process second line until y value is about to change
    while (1) 
    {
      e2 += dy2;
      while (e2 >= dx2) 
      {
        e2 -= dx2;
        if (changed2) t2xp = signx2;//t2x += signx2;
        else          goto next2;
      }
      if (changed2)     break;
      else              t2x += signx2;
    }
  next2:
    if (minx>t1x) minx = t1x; 
    if (minx>t2x) minx = t2x;
    if (maxx<t1x) maxx = t1x; 
    if (maxx<t2x) maxx = t2x;
    b &= drawHLine(y, minx, maxx, state); // Draw line from min to max points found on the y
    // Now increase y
    if (!changed1) t1x += signx1;
    t1x += t1xp;
    if (!changed2) t2x += signx2;
    t2x += t2xp;
    y += 1;
    if (y == y2) break;

  }
  next:
  // Second half
  dx1 = (int8_t)(x3 - x2); 
  if (dx1<0) { dx1 = -dx1; signx1 = -1; }
  else       signx1 = 1;
  dy1 = (int8_t)(y3 - y2);
  t1x = x2;

  if (dy1 > dx1) 
  {   // swap values
    SWAP(dy1, dx1);
    changed1 = true;
  }
  else changed1 = false;

  e1 = (uint8_t)(dx1 >> 1);

  for (uint8_t i = 0; i <= dx1; i++) 
  {
    t1xp = 0; t2xp = 0;
    if (t1x<t2x) { minx = t1x; maxx = t2x; }
    else		     { minx = t2x; maxx = t1x; }
    // process first line until y value is about to change
    while (i<dx1) 
    {
      e1 += dy1;
      while (e1 >= dx1) 
      {
        e1 -= dx1;
        if (changed1) { t1xp = signx1; break; }//t1x += signx1;
        else          goto next3;
      }
      if (changed1) break;
      else   	   	  t1x += signx1;
      if (i<dx1) i++;
    }
  next3:
    // process second line until y value is about to change
    while (t2x != x3) 
    {
      e2 += dy2;
      while (e2 >= dx2) 
      {
        e2 -= dx2;
        if (changed2) t2xp = signx2;
        else          goto next4;
      }
      if (changed2) break;
      else          t2x += signx2;
    }
  next4:

    if (minx>t1x) minx = t1x; 
    if (minx>t2x) minx = t2x;
    if (maxx<t1x) maxx = t1x; 
    if (maxx<t2x) maxx = t2x;
    b &= drawHLine(y, minx, maxx, state);    // Draw line from min to max points found on the y
    // Now increase y
    if (!changed1) t1x += signx1;
    t1x += t1xp;
    if (!changed2) t2x += signx2;
    t2x += t2xp;
    y += 1;
    if (y>y3) goto outtahere;
  }

outtahere:
  update(u);

  return(b);
}


bool MD_MAXPanel::drawCirclePoints(uint16_t xc, uint16_t yc, uint16_t x, uint16_t y, bool state)
// draw symmetrical circle points
{
  bool b = true;

  b &= setPoint(xc + x, yc + y, state);
  b &= setPoint(xc - x, yc + y, state);
  b &= setPoint(xc + x, yc - y, state);
  b &= setPoint(xc - x, yc - y, state);
  b &= setPoint(xc + y, yc + x, state);
  b &= setPoint(xc - y, yc + x, state);
  b &= setPoint(xc + y, yc - x, state);
  b &= setPoint(xc - y, yc - x, state);

  return(b);
}

bool MD_MAXPanel::drawCircle(uint16_t xc, uint16_t yc, uint16_t r, bool state)
// draw a circle given center and radius
// Bresenhams Algorith from http://www.pracspedia.com/CG/bresenhamcircle.html
{
  int x = 0, y = r;
  int pk = 3 - (2 * r);
  bool b = false;

  _D->control(MD_MAX72XX::UPDATE, MD_MAX72XX::OFF);

  PRINT("\n\nCircle center ", xc); PRINT(",", yc); PRINT(" radius ", r);

  b &= drawCirclePoints(xc, yc, x, y, state);

  while (x < y)
  {
    // check for decision parameter and correspondingly update pk, x, y
    if (pk <= 0)
    {
      pk = pk + (4 * x) + 6;
      b &= drawCirclePoints(xc, yc, ++x, y, state);
    }
    else
    {
      pk = pk + (4 * (x - y)) + 10;
      b &= drawCirclePoints(xc, yc, ++x, --y, state);
    }
  }

  update(_updateEnabled);

  return(b);
}

bool MD_MAXPanel::drawCircleLines(uint16_t xc, uint16_t yc, uint16_t x, uint16_t y, bool state)
// draw symmetrical circle lines for the filled circle
{
  bool b = true;

  b &= drawHLine(yc - y, xc - x, xc + x, state);
  b &= drawHLine(yc + y, xc - x, xc + x, state);
  b &= drawHLine(yc - x, xc - y, xc + y, state);
  b &= drawHLine(yc + x, xc - y, xc + y, state);

  return(b);
}

bool MD_MAXPanel::drawFillCircle(uint16_t xc, uint16_t yc, uint16_t r, bool state)
// Draw a filled circle given center and radius
// Bresenhams Algorith from http://www.pracspedia.com/CG/bresenhamcircle.html
{
  int x = 0, y = r;
  int pk = 3 - (2 * r);
  bool b = false;
  bool u = _updateEnabled;

  _D->control(MD_MAX72XX::UPDATE, MD_MAX72XX::OFF);
  update(false);

  PRINT("\n\nFilled Circle center ", xc); PRINT(",", yc); PRINT(" radius ", r);
  b &= drawCircleLines(xc, yc, x, y, state);
  while (x < y)
  {
    // check for decision parameter and correspondingly update pk, x, y
    if (pk <= 0)
    {
      pk = pk + (4 * x) + 6;
      b &= drawCircleLines(xc, yc, ++x, y, state);
    }
    else
    {
      pk = pk + (4 * (x - y)) + 10;
      b &= drawCircleLines(xc, yc, ++x, --y, state);
    }
  }

  update(u);

  return(b);
}

uint16_t MD_MAXPanel::Y2Row(uint16_t x, uint16_t y)
// Convert y coord to linear coord
{
  uint16_t Y;

  if (_rotatedDisplay)
  {
    x = getXMax() - x;
    Y = (ROW_SIZE - (x % ROW_SIZE) - 1);
  }
  else
    Y = (ROW_SIZE - (y % ROW_SIZE) - 1);

  return(Y);
}

uint16_t MD_MAXPanel::X2Col(uint16_t x, uint16_t y)
// Convert x coord to linear coord
{
  uint16_t X;

  if (_rotatedDisplay)
  {
    x = getXMax() - x;
    X = ((x / ROW_SIZE) * (_xDevices * COL_SIZE) + (_xDevices * COL_SIZE) - 1 - (y % (_xDevices * COL_SIZE)));
  }
  else
    X = ((y / ROW_SIZE) * (_xDevices * COL_SIZE) + (_xDevices * COL_SIZE) - 1 - (x % (_xDevices * COL_SIZE)));

  return(X);
}

bool MD_MAXPanel::getPoint(uint16_t x, uint16_t y)
{
  if (x > getXMax() || y > getYMax())
    return(false);

  return(_D->getPoint(Y2Row(x,y), X2Col(x,y)));
}

bool MD_MAXPanel::setPoint(uint16_t x, uint16_t y, bool state)
{
  if (x > getXMax() || y > getYMax())
    return(false);

  //PRINT("[", x); PRINT(",", y); PRINTS("]");

  return(_D->setPoint(Y2Row(x,y), X2Col(x,y), state));
}

MD_MAXPanel.cpp

/*
MD_MAXPanel - Library for panels of MAX72xx LED matrix controllers

See header file for comments

This file contains library related definitions and is not visible
to user code.

Copyright (C) 2018 Marco Colli. All rights reserved.

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 */
#pragma once

/**
 * \file
 * \brief Includes library only definitions
 */

#define MP_DEBUG 0   ///< Enable or disable (default) debugging output from the MD_MAX72xx library

#if MP_DEBUG
#define PRINT(s, v)   { Serial.print(F(s)); Serial.print(v); }      ///< Print a string followed by a value (decimal)
#define PRINTX(s, v)  { Serial.print(F(s)); Serial.print(v, HEX); } ///< Print a string followed by a value (hex)
#define PRINTB(s, v)  { Serial.print(F(s)); Serial.print(v, BIN); } ///< Print a string followed by a value (binary)
#define PRINTS(s)     { Serial.print(F(s)); }                       ///< Print a string
#else
#define PRINT(s, v)   ///< Print a string followed by a value (decimal)
#define PRINTX(s, v)  ///< Print a string followed by a value (hex)
#define PRINTB(s, v)  ///< Print a string followed by a value (binary)
#define PRINTS(s)     ///< Print a string
#endif

#define X2COL(x, y) (((y / ROW_SIZE) * (getXMax() + 1)) + (getXMax() - (x % (getXMax() + 1)))) ///< Convert x coord to linear coord
#define Y2ROW(x, y) (ROW_SIZE - (y % ROW_SIZE) - 1)    ///< Convert y coord to linear coord

#define CHAR_SPACING_DEFAULT 1  ///< Default number of pixels between characters

MD_MAXPanel_lib.h

/*
MD_MAXPanel - Library for MAX7219/7221 LED Panel

See header file for comments

This file contains font and text related methods.
 */
#include <Arduino.h>
#include "MD_MAXPanel.h"
#include "MD_MAXPanel_lib.h"

/**
 * \file
 * \brief Implements font and text methods
 */

uint16_t MD_MAXPanel::getTextWidth(const char *psz)
{
  uint16_t  sum = 0;
  uint8_t bufSize = _D->getMaxFontWidth();
  uint8_t buf[bufSize];

  while (*psz != '\0')
  {
    sum += _D->getChar(*psz++, bufSize, buf);
    if (*psz) sum += _charSpacing;  // next character is not nul, so add inter-character spacing
  }

  return(sum);
}

uint16_t MD_MAXPanel::drawText(uint16_t x, uint16_t y, const char *psz, rotation_t rot, bool state)
{
  uint8_t height = _D->getFontHeight();
  uint8_t bufSize = _D->getMaxFontWidth() + _charSpacing;
  uint8_t buf[bufSize];
  uint8_t size;
  uint16_t sum = 0;

  PRINT("\ndrawText: ", psz);
  PRINT(" height ", height);
  while (*psz != '\0')
  {
    PRINT("\nChar ", *psz);
    memset(buf, '\0', bufSize*sizeof(uint8_t));
    size = _D->getChar(*psz, bufSize, buf);
    psz++;
    if (*psz != '\0') size += _charSpacing;   // add in the blank columns
    sum += size;

    // now display the char depending on what the orientation is
    switch (rot)
    {
    case ROT_0:
      for (uint16_t i = 0; i < size; i++)
        for (uint16_t j = 0; j < height; j++)
            setPoint(x + i, y - j, (buf[i] & (1 << j) ? state : !state));
      x += size;
      break;

    case ROT_90:
      for (uint16_t j = 0; j < size; j++)
        for (uint16_t i = 0; i < height; i++)
          setPoint(x + i, y + j, (buf[j] & (1 << i) ? state : !state));
      y += size;
      break;

    case ROT_180:
      for (uint16_t i = 0; i < size; i++)
        for (uint16_t j = 0; j < height; j++)
          setPoint(x - i, y + j, (buf[i] & (1 << j) ? state : !state));
      x -= size;
      break;

    case ROT_270:
      for (uint16_t j = 0; j < size; j++)
        for (uint16_t i = 0; i < height; i++)
          setPoint(x - i, y - j, (buf[j] & (1 << i) ? state : !state));
      y -= size;
      break;
    }
  }

  return(sum);
}

MD_MAXPanel_Font.cpp

#pragma once

MD_MAX72XX::fontType_t _Fixed_5x3[] PROGMEM = 
{
  'F', 1, 32, 127, 5,
	2, 0, 0,		// 32 - 'Space'
	1, 23,		// 33 - '!'
	3, 3, 0, 3,		// 34 - '"'
	3, 31, 10, 31,		// 35 - '#'
	3, 22, 31, 13,		// 36 - '$'
	3, 9, 4, 18,		// 37 - '%'
	3, 10, 21, 26,		// 38 - '&'
	1, 3,		// 39
	2, 14, 17,		// 40 - '('
	2, 17, 14,		// 41 - ')'
	3, 10, 4, 10,		// 42 - '*'
	3, 4, 14, 4,		// 43 - '+'
	2, 16, 8,		// 44 - ','
	3, 4, 4, 4,		// 45 - '-'
	1, 16,		// 46 - '.'
	3, 8, 4, 2,		// 47 - '/'
	3, 31, 17, 31,		// 48 - '0'
	3, 0, 31, 0,		// 49 - '1'
	3, 29, 21, 23,		// 50 - '2'
	3, 17, 21, 31,		// 51 - '3'
	3, 7, 4, 31,		// 52 - '4'
	3, 23, 21, 29,		// 53 - '5'
	3, 31, 21, 29,		// 54 - '6'
	3, 1, 1, 31,		// 55 - '7'
	3, 31, 21, 31,		// 56 - '8'
	3, 23, 21, 31,		// 57 - '9'
	1, 10,		// 58 - ':'
	2, 16, 10,		// 59 - ';'
	3, 4, 10, 17,		// 60 - '<'
	3, 10, 10, 10,		// 61 - '='
	3, 17, 10, 4,		// 62 - '>'
	3, 1, 21, 3,		// 63 - '?'
	3, 14, 21, 22,		// 64 - '@'
	3, 30, 5, 30,		// 65 - 'A'
	3, 31, 21, 10,		// 66 - 'B'
	3, 14, 17, 17,		// 67 - 'C'
	3, 31, 17, 14,		// 68 - 'D'
	3, 31, 21, 17,		// 69 - 'E'
	3, 31, 5, 1,		// 70 - 'F'
	3, 14, 17, 29,		// 71 - 'G'
	3, 31, 4, 31,		// 72 - 'H'
	3, 17, 31, 17,		// 73 - 'I'
	3, 8, 16, 15,		// 74 - 'J'
	3, 31, 4, 27,		// 75 - 'K'
	3, 31, 16, 16,		// 76 - 'L'
	3, 31, 2, 31,		// 77 - 'M'
	3, 31, 14, 31,		// 78 - 'N'
	3, 14, 17, 14,		// 79 - 'O'
	3, 31, 5, 2,		// 80 - 'P'
	3, 14, 25, 30,		// 81 - 'Q'
	3, 31, 5, 26,		// 82 - 'R'
	3, 18, 21, 9,		// 83 - 'S'
	3, 1, 31, 1,		// 84 - 'T'
	3, 15, 16, 15,		// 85 - 'U'
	3, 7, 24, 7,		// 86 - 'V'
	3, 15, 28, 15,		// 87 - 'W'
	3, 27, 4, 27,		// 88 - 'X'
	3, 3, 28, 3,		// 89 - 'Y'
	3, 25, 21, 19,		// 90 - 'Z'
	2, 31, 17,		// 91 - '['
	3, 2, 4, 8,		// 92 - '\'
	2, 17, 31,		// 93 - ']'
	3, 2, 1, 2,		// 94 - '^'
	3, 16, 16, 16,		// 95 - '_'
	2, 1, 2,		// 96 - '`'
	3, 12, 18, 28,		// 97 - 'a'
	3, 31, 18, 12,		// 98 - 'b'
	3, 12, 18, 18,		// 99 - 'c'
	3, 12, 18, 31,		// 100 - 'd'
	3, 12, 26, 20,		// 101 - 'e'
	3, 4, 31, 5,		// 102 - 'f'
	3, 20, 26, 12,		// 103 - 'g'
	3, 31, 2, 28,		// 104 - 'h'
	1, 29,		// 105 - 'i'
	2, 16, 13,		// 106 - 'j'
	3, 31, 8, 20,		// 107 - 'k'
	1, 31,		// 108 - 'l'
	3, 30, 6, 30,		// 109 - 'm'
	3, 30, 2, 28,		// 110 - 'n'
	3, 12, 18, 12,		// 111 - 'o'
	3, 30, 10, 4,		// 112 - 'p'
	3, 4, 10, 30,		// 113 - 'q'
	2, 30, 4,		// 114 - 'r'
	3, 20, 30, 10,		// 115 - 's'
	3, 4, 30, 4,		// 116 - 't'
	3, 14, 16, 30,		// 117 - 'u'
	3, 14, 16, 14,		// 118 - 'v'
	3, 14, 24, 14,		// 119 - 'w'
	3, 18, 12, 18,		// 120 - 'x'
	3, 22, 24, 14,		// 121 - 'y'
	3, 26, 30, 22,		// 122 - 'z'
	3, 4, 27, 17,		// 123 - '{'
	1, 27,		// 124 - '|'
	3, 17, 27, 4,		// 125 - '}'
	3, 6, 2, 3,		// 126 - '~'
	3, 31, 31, 31,		// 127 - 'Full Block'
};

Font5x3.h

#pragma once

#include "MD_MAXPanel.h"

// A class to encapsulate the score display
class cScore
{
private:
  MD_MAXPanel *_mp;   // the MAXPanel object for drawing the score
  uint16_t _score;    // the score
  uint16_t _x, _y;    // coordinate of top left for display
  uint8_t _width;     // number of digits wide
  uint16_t _limit;    // maximum value allowed

public:
  void begin(MD_MAXPanel *mp, uint16_t x, uint16_t y, uint16_t maxScore) { _mp = mp;  _x = x, _y = y; limit(maxScore); reset(); }
  void reset(void)       { erase(); _score = 0; draw(); }
  void set(uint16_t s)   { if (s <= _limit) { erase(); _score = s; draw(); } }
  void increment(uint16_t inc = 1) { if (_score + inc <= _limit) { erase(); _score += inc; draw(); } }
  void decrement(uint16_t dec = 1) { if (_score >= dec) { erase(); _score -= dec; draw(); } }
  uint16_t score(void)   { return(_score); }
  void erase(void)       { draw(false); }
  uint16_t width(void)   { return(_width); }

  void limit(uint16_t m)
  {
    erase();    // width may change, so delete with the curret parameters

    _limit = m;
    // work out how many digits this is
    _width = 0;
    do
    {
      _width++;
      m /= 10;
    } while (m != 0);
  }

  void draw(bool state = true)
  {
    char sz[_width + 1];
    uint16_t s = _score;

    // PRINT("\n-- SCORE: ", _score);
    sz[_width] = '\0';
    for (int i = _width - 1; i >= 0; --i)
    {
      sz[i] = (s % 10) + '0';
      s /= 10;
    }

    _mp->drawText(_x, _y, sz, MD_MAXPanel::ROT_0, state);
  }
};

score.h

#pragma once
// Random seed creation --------------------------
// Adapted from http://www.utopiamechanicus.com/article/arduino-better-random-numbers/

const uint8_t RANDOM_SEED_PORT = A3;    // port read for random seed

uint16_t bitOut(uint8_t port)
{
  static bool firstTime = true;
  uint32_t prev = 0;
  uint32_t bit1 = 0, bit0 = 0;
  uint32_t x = 0, limit = 99;

  if (firstTime)
  {
    firstTime = false;
    prev = analogRead(port);
  }

  while (limit--)
  {
    x = analogRead(port);
    bit1 = (prev != x ? 1 : 0);
    prev = x;
    x = analogRead(port);
    bit0 = (prev != x ? 1 : 0);
    prev = x;
    if (bit1 != bit0)
      break;
  }

  return(bit1);
}

uint32_t seedOut(uint16_t noOfBits, uint8_t port)
{
  // return value with 'noOfBits' random bits set
  uint32_t seed = 0;

  for (int i = 0; i<noOfBits; ++i)
    seed = (seed << 1) | bitOut(port);
  
  return(seed);
}
//------------------------------------------------------------------------------

randomseed.h

#pragma once

// A class to encapsulate primitive sound effects
class cSound
{
private:
  const uint16_t EOD = 0; // End Of Data marker 
  uint8_t _pinBeep;       // the pin to use for beeping

  // Sound data - frequency followed by duration in pairs. 
  // Data ends in End Of Data marker EOD.
  const uint16_t soundSplash[1] PROGMEM = { EOD };
  const uint16_t soundHit[3]    PROGMEM = { 1000, 50, EOD };
  const uint16_t soundBounce[3] PROGMEM = { 500, 50, EOD };
  const uint16_t soundPoint[3]  PROGMEM = { 150, 150, EOD };
  const uint16_t soundStart[7]  PROGMEM = { 250, 100, 500, 100, 1000, 100, EOD };
  const uint16_t soundOver[7]   PROGMEM = { 1000, 100, 500, 100, 250, 100, EOD };

  void playSound(const uint16_t *table)
    // Play sound table data. Data table must end in EOD marker.
  {
    uint8_t idx = 0;

    //PRINTS("\nTone Data ");
    while (table[idx] != EOD)
    {
      uint16_t t = table[idx++];
      uint16_t d = table[idx++];

      //PRINTXY("-", t, d);
      tone(_pinBeep, t);
      delay(d);
    }
    //PRINTS("-EOD");
    noTone(_pinBeep); // be quiet now!
  }

public:
  void begin(uint8_t pinBeep) { _pinBeep = pinBeep; }  
  void splash(void) { playSound(soundSplash); }
  void start(void)  { playSound(soundStart); }
  void hit(void)    { playSound(soundHit); }
  void bounce(void) { playSound(soundBounce); }
  void point(void)  { playSound(soundPoint); }
  void over(void)   { playSound(soundOver); }
};