Matrix MAX7219 LED 8x8x4 Panel SPI Display Module – Grøn

kr.85.00 inkl. moms

Matrix MAX7219 LED 8x8x4 Panel SPI Display Module – Grøn.

På lager

Varenummer (SKU): 8817 Kategori: Tags: , , , , , , , , ,

Matrix MAX7219 LED 8x8x4 Panel SPI Display Module – Grøn er en klynge af 4 enkelte moduler, internt forbundet. Disse moduler kan også adskilles, fordi hvert modul bærer den samme Maxim MAX7219-chip og kommer med den samme strøm- og dataforbindelse. Den inkluderer en B-type BCD-encoder på chip, multikanals scanningsløkke, segmentorddriver og en 8×8 statisk RAM til at gemme hver data. Der bruges kun et eksternt register til at indstille segmentstrømmen for hver LED. Et praktisk fire-leder serielt interface kan tilsluttes alle gængse mikroprocessorer. Hver data kan adresseres uden behov for at overskrive alle displays ved opdatering. MAX7219 giver også brugeren mulighed for at vælge, om hver data skal kodes eller ej. Hele enheden inkluderer en 150μA lav-strøm nedlukningstilstand, analog og digital lysstyrkekontrol, et scanningsgrænseregister, der tillader brugeren at vise 1-8 bits af data, og en detekteringstilstand, der tillader alle LED’er at lyse.

Tekniske detaljer:

Resolution: 8 x 32
Display size: 130 x 32mm
Driver IC: MAX7219
Requires only 3 communication wires of MCU
Working Current: 320mA
Working Voltage: 4.5 to 5V
Interface type: SPI
Color: Green

Installere MD_MAX72XX Library

  • Download library (Download)
  • Åben Arduino IDE software og klik på “Sketch/Include library”
  • Klik nu på “Add Zip. library” og find Zip filen du lige har downloaded.
  • Luk, og åben Arduino IDE programmet. (Genstart programmet)
  • Nu er library installeret.
  • Library kan også downloades direkte i Arduino IDE find den her: “Sketch/Include library/Manage library/MD_MAX72XX – by majicDesigns”

Eksempel

Her vises et eksempel på hvordan du kan få vist forskellige symboler og tekst.

Du skal bruge:

Forbind det sådan:

1. Venstre side af modulet er inputporten, og højre side er outputporten.
2. Når du styrer et enkelt modul, behøver du kun at tilslutte inputporten til CPU’en.
3. Når flere moduler er kaskadekoblet, er indgangen på det første modul forbundet til CPU’en,
udgangen er forbundet til indgangen på det andet modul, udgangen af ​​det andet modul er
forbundet til indgangen på det tredje modul, og så videre.

VCC (Modul) – 5V (Arduino)
GND (Modul) – GND (Arduino)
DIN (Modul) – D11 (Arduino)
CS (Modul) – D10 (Arduino)
CLK (Modul) – D13 (Arduino)

Kode:

// Program to exercise the MD_MAX72XX library
//
// Uses most of the functions in the library
#include <MD_MAX72xx.h>

// Turn on debug statements to the serial output
#define DEBUG 1

#if DEBUG
#define PRINT(s, x) { Serial.print(F(s)); Serial.print(x); }
#define PRINTS(x) Serial.print(F(x))
#define PRINTD(x) Serial.println(x, DEC)

#else
#define PRINT(s, x)
#define PRINTS(x)
#define PRINTD(x)

#endif

// Define the number of devices we have in the chain and the hardware interface
// NOTE: These pin numbers will probably not work with your hardware and may
// need to be adapted
#define HARDWARE_TYPE MD_MAX72XX::FC16_HW
#define MAX_DEVICES 11

#define CLK_PIN 13 // or SCK
#define DATA_PIN 11 // or MOSI
#define CS_PIN 10 // or SS

// SPI hardware interface
MD_MAX72XX mx = MD_MAX72XX(HARDWARE_TYPE, CS_PIN, MAX_DEVICES);
// Specific SPI hardware interface
//MD_MAX72XX mx = MD_MAX72XX(HARDWARE_TYPE, SPI1, CS_PIN, MAX_DEVICES);
// Arbitrary pins
//MD_MAX72XX mx = MD_MAX72XX(HARDWARE_TYPE, DATA_PIN, CLK_PIN, CS_PIN, MAX_DEVICES);

// We always wait a bit between updates of the display
#define DELAYTIME 100 // in milliseconds

void scrollText(const char *p)
{
uint8_t charWidth;
uint8_t cBuf[8]; // this should be ok for all built-in fonts

PRINTS("\nScrolling text");
mx.clear();

while (*p != '\0')
{
charWidth = mx.getChar(*p++, sizeof(cBuf) / sizeof(cBuf[0]), cBuf);

for (uint8_t i=0; i<=charWidth; i++) // allow space between characters
{
mx.transform(MD_MAX72XX::TSL);
mx.setColumn(0, (i < charWidth) ? cBuf[i] : 0); 
delay(DELAYTIME);
}
}
}

void zeroPointSet()
// Demonstrates the use of setPoint and
// show where the zero point is in the display
{
PRINTS("\nZero point highlight");
mx.clear();

if (MAX_DEVICES > 1)
mx.setChar((2*COL_SIZE)-1, '0');

for (uint8_t i=0; i<ROW_SIZE; i++)
{
mx.setPoint(i, i, true);
mx.setPoint(0, i, true);
mx.setPoint(i, 0, true);
delay(DELAYTIME);
}

delay(DELAYTIME*3);
}

void rows()
// Demonstrates the use of setRow()
{
PRINTS("\nRows 0->7");
mx.clear();

for (uint8_t row=0; row<ROW_SIZE; row++)
{
mx.setRow(row, 0xff);
delay(2*DELAYTIME);
mx.setRow(row, 0x00);
}
}

void checkboard()
// nested rectangles spanning the entire display
{
uint8_t chkCols[][2] = { { 0x55, 0xaa }, { 0x33, 0xcc }, { 0x0f, 0xf0 }, { 0xff, 0x00 } };

PRINTS("\nCheckboard");
mx.clear();

for (uint8_t pattern = 0; pattern < sizeof(chkCols)/sizeof(chkCols[0]); pattern++)
{
uint8_t col = 0;
uint8_t idx = 0;
uint8_t rep = 1 << pattern;

while (col < mx.getColumnCount())
{
for (uint8_t r = 0; r < rep; r++)
mx.setColumn(col++, chkCols[pattern][idx]); // use odd/even column masks
idx++;
if (idx > 1) idx = 0;
}

delay(10 * DELAYTIME);
}
}

void columns()
// Demonstrates the use of setColumn()
{
PRINTS("\nCols 0->max");
mx.clear();

for (uint8_t col=0; col<mx.getColumnCount(); col++)
{
mx.setColumn(col, 0xff);
delay(DELAYTIME/MAX_DEVICES);
mx.setColumn(col, 0x00);
}
}

void cross()
// Combination of setRow() and setColumn() with user controlled
// display updates to ensure concurrent changes.
{
PRINTS("\nMoving cross");
mx.clear();
mx.control(MD_MAX72XX::UPDATE, MD_MAX72XX::OFF);

// diagonally down the display R to L
for (uint8_t i=0; i<ROW_SIZE; i++)
{
for (uint8_t j=0; j<MAX_DEVICES; j++)
{
mx.setColumn(j, i, 0xff);
mx.setRow(j, i, 0xff);
}
mx.update();
delay(DELAYTIME);
for (uint8_t j=0; j<MAX_DEVICES; j++)
{
mx.setColumn(j, i, 0x00);
mx.setRow(j, i, 0x00);
}
}

// moving up the display on the R
for (int8_t i=ROW_SIZE-1; i>=0; i--)
{
for (uint8_t j=0; j<MAX_DEVICES; j++)
{
mx.setColumn(j, i, 0xff);
mx.setRow(j, ROW_SIZE-1, 0xff);
}
mx.update();
delay(DELAYTIME);
for (uint8_t j=0; j<MAX_DEVICES; j++)
{
mx.setColumn(j, i, 0x00);
mx.setRow(j, ROW_SIZE-1, 0x00);
}
}

// diagonally up the display L to R
for (uint8_t i=0; i<ROW_SIZE; i++)
{
for (uint8_t j=0; j<MAX_DEVICES; j++)
{
mx.setColumn(j, i, 0xff);
mx.setRow(j, ROW_SIZE-1-i, 0xff);
}
mx.update();
delay(DELAYTIME);
for (uint8_t j=0; j<MAX_DEVICES; j++)
{
mx.setColumn(j, i, 0x00);
mx.setRow(j, ROW_SIZE-1-i, 0x00);
}
}
mx.control(MD_MAX72XX::UPDATE, MD_MAX72XX::ON);
}

void bullseye()
// Demonstrate the use of buffer based repeated patterns
// across all devices.
{
PRINTS("\nBullseye");
mx.clear();
mx.control(MD_MAX72XX::UPDATE, MD_MAX72XX::OFF);

for (uint8_t n=0; n<3; n++)
{
byte b = 0xff;
int i = 0;

while (b != 0x00)
{
for (uint8_t j=0; j<MAX_DEVICES+1; j++)
{
mx.setRow(j, i, b);
mx.setColumn(j, i, b);
mx.setRow(j, ROW_SIZE-1-i, b);
mx.setColumn(j, COL_SIZE-1-i, b);
}
mx.update();
delay(3*DELAYTIME);
for (uint8_t j=0; j<MAX_DEVICES+1; j++)
{
mx.setRow(j, i, 0);
mx.setColumn(j, i, 0);
mx.setRow(j, ROW_SIZE-1-i, 0);
mx.setColumn(j, COL_SIZE-1-i, 0);
}

bitClear(b, i);
bitClear(b, 7-i);
i++;
}

while (b != 0xff)
{
for (uint8_t j=0; j<MAX_DEVICES+1; j++)
{
mx.setRow(j, i, b);
mx.setColumn(j, i, b);
mx.setRow(j, ROW_SIZE-1-i, b);
mx.setColumn(j, COL_SIZE-1-i, b);
}
mx.update();
delay(3*DELAYTIME);
for (uint8_t j=0; j<MAX_DEVICES+1; j++)
{
mx.setRow(j, i, 0);
mx.setColumn(j, i, 0);
mx.setRow(j, ROW_SIZE-1-i, 0);
mx.setColumn(j, COL_SIZE-1-i, 0);
}

i--;
bitSet(b, i);
bitSet(b, 7-i);
}
}

mx.control(MD_MAX72XX::UPDATE, MD_MAX72XX::ON);
}

void stripe()
// Demonstrates animation of a diagonal stripe moving across the display
// with points plotted outside the display region ignored.
{
const uint16_t maxCol = MAX_DEVICES*ROW_SIZE;
const uint8_t stripeWidth = 10;

PRINTS("\nEach individually by row then col");
mx.clear();

for (uint16_t col=0; col<maxCol + ROW_SIZE + stripeWidth; col++)
{
for (uint8_t row=0; row < ROW_SIZE; row++)
{
mx.setPoint(row, col-row, true);
mx.setPoint(row, col-row - stripeWidth, false);
}
delay(DELAYTIME);
}
}

void spiral()
// setPoint() used to draw a spiral across the whole display
{
PRINTS("\nSpiral in");
int rmin = 0, rmax = ROW_SIZE-1;
int cmin = 0, cmax = (COL_SIZE*MAX_DEVICES)-1;

mx.clear();
while ((rmax > rmin) && (cmax > cmin))
{
// do row
for (int i=cmin; i<=cmax; i++)
{
mx.setPoint(rmin, i, true);
delay(DELAYTIME/MAX_DEVICES);
}
rmin++;

// do column
for (uint8_t i=rmin; i<=rmax; i++)
{
mx.setPoint(i, cmax, true);
delay(DELAYTIME/MAX_DEVICES);
}
cmax--;

// do row
for (int i=cmax; i>=cmin; i--)
{
mx.setPoint(rmax, i, true);
delay(DELAYTIME/MAX_DEVICES);
}
rmax--;

// do column
for (uint8_t i=rmax; i>=rmin; i--)
{
mx.setPoint(i, cmin, true);
delay(DELAYTIME/MAX_DEVICES);
}
cmin++;
}
}

void bounce()
// Animation of a bouncing ball
{
const int minC = 0;
const int maxC = mx.getColumnCount()-1;
const int minR = 0;
const int maxR = ROW_SIZE-1;

int nCounter = 0;

int r = 0, c = 2;
int8_t dR = 1, dC = 1; // delta row and column

PRINTS("\nBouncing ball");
mx.clear();

while (nCounter++ < 200)
{
mx.setPoint(r, c, false);
r += dR;
c += dC;
mx.setPoint(r, c, true);
delay(DELAYTIME/2);

if ((r == minR) || (r == maxR))
dR = -dR;
if ((c == minC) || (c == maxC))
dC = -dC;
}
}

void intensity()
// Demonstrates the control of display intensity (brightness) across
// the full range.
{
uint8_t row;

PRINTS("\nVary intensity ");

mx.clear();

// Grow and get brighter
row = 0;
for (int8_t i=0; i<=MAX_INTENSITY; i++)
{
mx.control(MD_MAX72XX::INTENSITY, i);
if (i%2 == 0)
mx.setRow(row++, 0xff);
delay(DELAYTIME*3);
}

mx.control(MD_MAX72XX::INTENSITY, 8);
}

void blinking()
// Uses the test function of the MAX72xx to blink the display on and off.
{
int nDelay = 1000;

PRINTS("\nBlinking");
mx.clear();

while (nDelay > 0)
{
mx.control(MD_MAX72XX::TEST, MD_MAX72XX::ON);
delay(nDelay);
mx.control(MD_MAX72XX::TEST, MD_MAX72XX::OFF);
delay(nDelay);

nDelay -= DELAYTIME;
}
}

void scanLimit(void)
// Uses scan limit function to restrict the number of rows displayed.
{
PRINTS("\nScan Limit");
mx.clear();

mx.control(MD_MAX72XX::UPDATE, MD_MAX72XX::OFF);
for (uint8_t row=0; row<ROW_SIZE; row++)
mx.setRow(row, 0xff);
mx.control(MD_MAX72XX::UPDATE, MD_MAX72XX::ON);

for (int8_t s=MAX_SCANLIMIT; s>=0; s--)
{
mx.control(MD_MAX72XX::SCANLIMIT, s);
delay(DELAYTIME*5);
}
mx.control(MD_MAX72XX::SCANLIMIT, MAX_SCANLIMIT);
}

void transformation1()
// Demonstrates the use of transform() to move bitmaps on the display
// In this case a user defined bitmap is created and animated.
{
uint8_t arrow[COL_SIZE] =
{
0b00001000,
0b00011100,
0b00111110,
0b01111111,
0b00011100,
0b00011100,
0b00111110,
0b00000000
};

MD_MAX72XX::transformType_t t[] =
{
MD_MAX72XX::TSL, MD_MAX72XX::TSL, MD_MAX72XX::TSL, MD_MAX72XX::TSL,
MD_MAX72XX::TSL, MD_MAX72XX::TSL, MD_MAX72XX::TSL, MD_MAX72XX::TSL,
MD_MAX72XX::TSL, MD_MAX72XX::TSL, MD_MAX72XX::TSL, MD_MAX72XX::TSL,
MD_MAX72XX::TSL, MD_MAX72XX::TSL, MD_MAX72XX::TSL, MD_MAX72XX::TSL,
MD_MAX72XX::TFLR,
MD_MAX72XX::TSR, MD_MAX72XX::TSR, MD_MAX72XX::TSR, MD_MAX72XX::TSR,
MD_MAX72XX::TSR, MD_MAX72XX::TSR, MD_MAX72XX::TSR, MD_MAX72XX::TSR,
MD_MAX72XX::TSR, MD_MAX72XX::TSR, MD_MAX72XX::TSR, MD_MAX72XX::TSR,
MD_MAX72XX::TSR, MD_MAX72XX::TSR, MD_MAX72XX::TSR, MD_MAX72XX::TSR,
MD_MAX72XX::TRC,
MD_MAX72XX::TSD, MD_MAX72XX::TSD, MD_MAX72XX::TSD, MD_MAX72XX::TSD,
MD_MAX72XX::TSD, MD_MAX72XX::TSD, MD_MAX72XX::TSD, MD_MAX72XX::TSD,
MD_MAX72XX::TFUD,
MD_MAX72XX::TSU, MD_MAX72XX::TSU, MD_MAX72XX::TSU, MD_MAX72XX::TSU,
MD_MAX72XX::TSU, MD_MAX72XX::TSU, MD_MAX72XX::TSU, MD_MAX72XX::TSU,
MD_MAX72XX::TINV,
MD_MAX72XX::TRC, MD_MAX72XX::TRC, MD_MAX72XX::TRC, MD_MAX72XX::TRC,
MD_MAX72XX::TINV
};

PRINTS("\nTransformation1");
mx.clear();

// use the arrow bitmap
mx.control(MD_MAX72XX::UPDATE, MD_MAX72XX::OFF);
for (uint8_t j=0; j<mx.getDeviceCount(); j++)
mx.setBuffer(((j+1)*COL_SIZE)-1, COL_SIZE, arrow);
mx.control(MD_MAX72XX::UPDATE, MD_MAX72XX::ON);
delay(DELAYTIME);

// run through the transformations
mx.control(MD_MAX72XX::WRAPAROUND, MD_MAX72XX::ON);
for (uint8_t i=0; i<(sizeof(t)/sizeof(t[0])); i++)
{
mx.transform(t[i]);
delay(DELAYTIME*4);
}
mx.control(MD_MAX72XX::WRAPAROUND, MD_MAX72XX::OFF);
}

void transformation2()
// Demonstrates the use of transform() to move bitmaps on the display
// In this case font characters are loaded into the display for animation.
{
MD_MAX72XX::transformType_t t[] =
{
MD_MAX72XX::TINV,
MD_MAX72XX::TRC, MD_MAX72XX::TRC, MD_MAX72XX::TRC, MD_MAX72XX::TRC,
MD_MAX72XX::TINV,
MD_MAX72XX::TSL, MD_MAX72XX::TSL, MD_MAX72XX::TSL, MD_MAX72XX::TSL, MD_MAX72XX::TSL,
MD_MAX72XX::TSR, MD_MAX72XX::TSR, MD_MAX72XX::TSR, MD_MAX72XX::TSR, MD_MAX72XX::TSR,
MD_MAX72XX::TSR, MD_MAX72XX::TSR, MD_MAX72XX::TSR, MD_MAX72XX::TSR, MD_MAX72XX::TSR, MD_MAX72XX::TSR, MD_MAX72XX::TSR, MD_MAX72XX::TSR,
MD_MAX72XX::TSL, MD_MAX72XX::TSL, MD_MAX72XX::TSL, MD_MAX72XX::TSL, MD_MAX72XX::TSL, MD_MAX72XX::TSL, MD_MAX72XX::TSL, MD_MAX72XX::TSL,
MD_MAX72XX::TSR, MD_MAX72XX::TSR, MD_MAX72XX::TSR,
MD_MAX72XX::TSD, MD_MAX72XX::TSU, MD_MAX72XX::TSD, MD_MAX72XX::TSU,
MD_MAX72XX::TFLR, MD_MAX72XX::TFLR, MD_MAX72XX::TFUD, MD_MAX72XX::TFUD
};

PRINTS("\nTransformation2");
mx.clear();
mx.control(MD_MAX72XX::WRAPAROUND, MD_MAX72XX::OFF);

// draw something that will show changes
for (uint8_t j=0; j<mx.getDeviceCount(); j++)
{
mx.setChar(((j+1)*COL_SIZE)-1, '0'+j);
}
delay(DELAYTIME*5);

// run thru transformations
for (uint8_t i=0; i<(sizeof(t)/sizeof(t[0])); i++)
{
mx.transform(t[i]);
delay(DELAYTIME*3);
}
}

void wrapText()
// Display text and animate scrolling using auto wraparound of the buffer
{
PRINTS("\nwrapText");
mx.clear();
mx.wraparound(MD_MAX72XX::ON);

// draw something that will show changes
for (uint16_t j=0; j<mx.getDeviceCount(); j++)
{
mx.setChar(((j+1)*COL_SIZE)-1, (j&1 ? 'M' : 'W'));
}
delay(DELAYTIME*5);

// run thru transformations
for (uint16_t i=0; i<3*COL_SIZE*MAX_DEVICES; i++)
{
mx.transform(MD_MAX72XX::TSL);
delay(DELAYTIME/2);
}
for (uint16_t i=0; i<3*COL_SIZE*MAX_DEVICES; i++)
{
mx.transform(MD_MAX72XX::TSR);
delay(DELAYTIME/2);
}
for (uint8_t i=0; i<ROW_SIZE; i++)
{
mx.transform(MD_MAX72XX::TSU);
delay(DELAYTIME*2);
}
for (uint8_t i=0; i<ROW_SIZE; i++)
{
mx.transform(MD_MAX72XX::TSD);
delay(DELAYTIME*2);
}

mx.wraparound(MD_MAX72XX::OFF);
}

void showCharset(void)
// Run through display of the the entire font characters set
{
mx.clear();
mx.update(MD_MAX72XX::OFF);

for (uint16_t i=0; i<256; i++)
{
mx.clear(0);
mx.setChar(COL_SIZE-1, i);

if (MAX_DEVICES >= 3)
{
char hex[3];

sprintf(hex, "%02X", i);

mx.clear(1);
mx.setChar((2*COL_SIZE)-1,hex[1]);
mx.clear(2);
mx.setChar((3*COL_SIZE)-1,hex[0]);
}

mx.update();
delay(DELAYTIME*2);
}
mx.update(MD_MAX72XX::ON);
}

void setup()
{
#if DEBUG
Serial.begin(57600);
#endif
PRINTS("\n[MD_MAX72XX Test & Demo]");

if (!mx.begin())
PRINTS("\nMD_MAX72XX initialization failed");
}

void loop()
{
#if 1
scrollText("Graphics");
zeroPointSet();
rows();
columns();
cross();
stripe();
checkboard();
bullseye();
bounce();
spiral();
#endif

#if 1
scrollText("Control");
intensity();
scanLimit();
blinking();
#endif

#if 1
scrollText("Transform");
transformation1();
transformation2();
#endif

#if 1
scrollText("Charset");
wrapText();
showCharset();
#endif
}

Kontakt os

Du er altid velkommen til at kontakte os på info@ardustore.dk, eller sende os en besked via messenger (Klik her) og vi vil hjælpe dig.

Anmeldelser

Der er endnu ikke nogle anmeldelser.

Vær den første til at anmelde “Matrix MAX7219 LED 8x8x4 Panel SPI Display Module – Grøn”

Din e-mailadresse vil ikke blive publiceret. Krævede felter er markeret med *