8x8 matrix led-display

Erik_Baas · November 19, 2023, 5:40am

In elke beginset zit er wel een, maar zonder MAX7219 is er eigenlijk weinig mee te beginnen. 16 draden naar de Arduino, en multiplexen moet je zelf doen. Heeft iemand wel eens iets nuttigs gedaan met zo'n los display?
8x8disp

Frits1956 · November 19, 2023, 9:59am

is het misschien zoiets? https://www.farnell.com/datasheets/29075.pdf

xfpd · November 19, 2023, 4:11pm

Erik_Baas · November 19, 2023, 6:12pm

Nee, die gebruikt ook een of ander IC voor de aandrijving. Ik bedoel echt het kale display, dus met 16 aansluitingen (voor 8 rows en 8 columns).

xfpd · November 19, 2023, 6:25pm

Erik_Baas · November 19, 2023, 10:22pm

Die link is wel interessant! 't Is geen antwoord op mijn vraag, maar wel weer leerzaam. Is het je opgevallen dat in slechts twee van de sketches multiplexing wordt toegepast? En dat is nou juist een van de dingen die het zo lastig maken...

jirre · January 4, 2024, 9:58pm

Ik heb er een keer een lichtkrantje mee gemaakt.

#include <DS3231.h>
#include <EEPROM.h>
byte lop = 40;
byte spd = 50;
DS3231 clock;
RTCDateTime dt;
byte vt;

unsigned long nextMillis = 0;
unsigned char letterPt = 0;
unsigned char rijPt = 0;
unsigned char notePt;
unsigned char preBuffer;
char tekst[200] = "twee1234567890 En nog wat onzin op het moment...!? ";
unsigned char buf[10];
char number[11];
char note[100];

unsigned char *Tal[] = { "nul", "een", "twee", "drie", "vier", "vijf", "zes", "zeven", "acht", "negen", "tien",
                         "elf", "twaalf", "dertien", "veertien", "kwart"
                       };

unsigned char *Tus[] = { " over ", " voor half ", " over half ", " voor ", " ", " minuut", " minuten", " half " };


const byte letter[] PROGMEM = {
  0, 0, 0, 0, 0, //space
  B11111101, B00000000, B00000000, B00000000, B00000000, //!
  B11100000, B00000000, B11100000, B00000000, B00000000, //"
  B01000100, B11111110, B01000100, B11111110, B01000100, //#
  B00100100, B01010100, B11111110, B01010100, B01001000, //$
  B11100100, B10101000, B11111110, B00101010, B01001110, //%
  B01101100, B10010010, B10101010, B01000100, B00001010, //&
  B11100000, B00000000, B00000000, B00000000, B00000000, //'
  B01111110, B10000001, B00000000, B00000000, B00000000, //(
  B10000001, B01111110, B00000000, B00000000, B00000000, //)
  B10101000, B01110000, B11111000, B01110000, B10101000, //*
  B00010000, B00010000, B01111100, B00010000, B00010000, //+
  B00001101, B00001110, B00000000, B00000000, B00000000, //,
  B00010000, B00010000, B00010000, B00010000, B00010000, //-
  B00000110, B00000110, B00000000, B00000000, B00000000, //.
  B00000011, B00001100, B00110000, B11000000, B00000000, ///
  B01111100, B10000010, B10010010, B10000010, B01111100, //0
  B01000010, B11111110, B00000010, B00000000, B00000000, //1
  B01000010, B10000110, B10001010, B10010010, B01100010, //2
  B01000100, B10010010, B10010010, B10010010, B01101100, //3
  B00001100, B00010100, B00100100, B01000100, B11111110, //4
  B11110100, B10010010, B10010010, B10010010, B10001100, //5
  B01111100, B10010010, B10010010, B10010010, B01001100, //6
  B10000010, B10000100, B10001000, B10010000, B11100000, //7
  B01101100, B10010010, B10010010, B10010010, B01101100, //8
  B01100100, B10010010, B10010010, B10010010, B01111100, //9
  B01101100, B01101100, B00000000, B00000000, B00000000, //:
  B01101101, B01101110, B00000000, B00000000, B00000000, //;
  B00010000, B00101000, B01000100, B10000010, B00000000, //<
  B00101000, B00101000, B00101000, B00101000, B00101000, //=
  B10000010, B01000100, B00101000, B00010000, B00000000, //>
  B01000000, B10000000, B10001101, B10010000, B01100000, //?
  B01001100, B10010010, B10011110, B10000010, B01111100, //@
  B00111110, B01010000, B10010000, B01010000, B00111110, //A
  B11111110, B10010010, B10010010, B10010010, B01101100, //B
  B01111100, B10000010, B10000010, B10000010, B01000100, //C
  B11111110, B10000010, B10000010, B10000010, B01111100, //D
  B11111110, B10010010, B10010010, B10010010, B10000010, //E
  B11111110, B10010000, B10010000, B10010000, B10000000, //F
  B01111100, B10000010, B10000010, B10010010, B01011100, //G
  B11111110, B00010000, B00010000, B00010000, B11111110, //H
  B10000010, B11111110, B10000010, B00000000, B00000000, //I
  B00000100, B10000010, B10000010, B10000010, B11111100, //J
  B11111110, B00010000, B00101000, B01000100, B10000010, //K
  B11111110, B00000010, B00000010, B00000010, B00000010, //L
  B11111110, B01000000, B00100000, B01000000, B11111110, //M
  B11111110, B01000000, B00100000, B00010000, B11111110, //N
  B01111100, B10000010, B10000010, B10000010, B01111100, //O
  B11111110, B10010000, B10010000, B10010000, B01100000, //P
  B01111100, B10000010, B10000010, B10000100, B01111010, //Q
  B11111110, B10010000, B10011000, B10010100, B01100010, //R
  B01100100, B10010010, B10010010, B10010010, B01001100, //S
  B11000000, B10000010, B11111110, B10000010, B11000000, //T
  B11111100, B00000010, B00000010, B00000010, B11111100, //U
  B11100000, B00011000, B00000110, B00011000, B11100000, //V
  B11111100, B00000110, B00111000, B00000110, B11111100, //W
  B11000110, B00101000, B00010000, B00101000, B11000110, //X
  B11000000, B00100000, B00011110, B00100000, B11000000, //Y
  B11000110, B10001010, B10010010, B10100010, B11000110, //Z
  B11111111, B10000001, B00000000, B00000000, B00000000, //[
  B11000000, B01100000, B00110000, B00011000, B00001100, //backslash
  B10000010, B11111110, B00000000, B00000000, B00000000, //]
  B01000000, B10000000, B01000000, B00000000, B00000000, //^
  B00000001, B00000001, B00000001, B00000001, B00000001, //_
  B10000000, B01000000, B00000000, B00000000, B00000000, //`
  B00011100, B00100010, B00100010, B00111100, B00000010, //a
  B11111110, B00100010, B00100010, B00100010, B00011100, //b
  B00011100, B00100010, B00100010, B00100010, B00000000, //c
  B00011100, B00100010, B00100010, B11111100, B00000010, //d
  B00011100, B00101010, B00101010, B00101010, B00011000, //e
  B00100010, B01111110, B10100010, B10000000, B00000000, //f
  B00011000, B00100101, B00100101, B00111110, B00000000, //g
  B11111110, B00100000, B00100000, B00011110, B00000000, //h
  B00100010, B10111110, B00000010, B00000000, B00000000, //i
  B00000010, B00000001, B00100001, B10111110, B00000000, //j
  B11111110, B00001000, B00010100, B00100010, B00000000, //k
  B11111100, B00000010, B00000000, B00000000, B00000000, //l
  B00111110, B00100000, B00011110, B00100000, B00011110, //m
  B00111110, B00100000, B00100000, B00011110, B00000000, //n
  B00011100, B00100010, B00100010, B00100010, B00011100, //o
  B00111111, B00100100, B00100100, B00011000, B00000000, //p
  B00011000, B00100100, B00100100, B00111111, B00000000, //q
  B00111110, B00010000, B00100000, B00010000, B00000000, //r
  B00010010, B00101010, B00101010, B00100100, B00000000, //s
  B00100000, B01111100, B00100010, B00000000, B00000000, //t
  B00111100, B00000010, B00000010, B00111110, B00000000, //u
  B00110000, B00001100, B00000010, B00001100, B00110000, //v
  B00111000, B00000110, B00111000, B00000110, B00111000, //w
  B00100010, B00010100, B00001000, B00010100, B00100010, //x
  B00110001, B00001010, B00000100, B00001000, B00110000, //y
  B00100010, B00100110, B00101010, B00110010, B00100010, //z
  B00010000, B01101100, B10000010, 0, 0, //{
  B11111110, 0, 0, 0, 0, //|
  B10000010, B01101100, B00010000, 0, 0, //}
  B01000000, B10000000, B01000000, B10000000, 0 //tilde
};
const byte cyfer[] PROGMEM = {
B00011111, B00010001, B00011111,
B00000000, B00000000, B00011111,
B00010111, B00010101, B00011101,
B00010101, B00010101, B00011111,
B00011100, B00000100, B00011111,
B00011101, B00010101, B00010111,
B00011111, B00010101, B00010111,
B00010000, B00010000, B00011111,
B00011111, B00010101, B00011111,
B00011101, B00010101, B00011111
};

// plaats een teken in de buffer ( teken )

void displayCyfer(byte num, byte base) {

  for (int lp = 0; lp <= 2; lp++ ){
    buf[lp] = pgm_read_byte_near(cyfer + (num/base) * 3 + lp) ;
    buf[lp+4] = pgm_read_byte_near(cyfer +(num % base) * 3 + lp);
   } buf[3]=0;buf[7]=0;
}

// Toon de buffer

void displayBuffer() {
  for ( byte lp = 10; lp <= 17; lp++ ) {
    digitalWrite(lp, LOW);
    for (byte pin = 2; pin < 10; pin++) digitalWrite(pin, bitRead( buf[lp - 10], 9 - pin) );
    for (byte pin = 2; pin < 10; pin++) digitalWrite(pin, LOW);
    digitalWrite(lp, HIGH);
  }
}
void shiftBuffer() {
  for (int lp = 0; lp <= 8; lp++) buf[lp] = buf[lp + 1];
}
void nextColumn() {
  do {
    if (tekst[letterPt]) {
      preBuffer = pgm_read_byte_near(letter+(tekst[letterPt] - 32) * 5 + rijPt );
      if (preBuffer || tekst[letterPt] == 32) {
        buf[8] = preBuffer; shiftBuffer();
      }
      rijPt++; if (rijPt > 4) {
        buf[8] = 0; shiftBuffer();
        rijPt = 0;
        letterPt++;
      }
    } else letterPt = 0;
  } while (!preBuffer && tekst[letterPt] != 32);
}

void testDots() {
  for (int lp = 10; lp <= 17; lp++) { // test dots
    for (int rw = 2; rw <= 9; rw++) {
      digitalWrite(lp, LOW); digitalWrite(rw, HIGH); delay(10);
      digitalWrite(lp, HIGH); digitalWrite(rw, LOW);
    }
  }
}
void drukknoppen() {
  if (analogRead(A6) < 100) {
    spd++;
    while (analogRead(A6) < 100) { displayCyfer( spd, DEC); displayBuffer();};
    }
  if (analogRead(A7) < 100) {
    spd--;
    while (analogRead(A7) < 100) { displayCyfer( spd, DEC); displayBuffer();};
  }
constrain(spd, 10, 200);
}


void displayInSpreektaal(char uur, char mnt) {
  byte iks, ei;
  strcpy(tekst, "Het is nu ");
  char zet[12];
  if ( uur < 5) strcpy(zet, " 's nachts");
  else if (uur < 12) strcpy(zet, " 's morgens");
  else if (uur < 18) strcpy(zet, " 's middags");
  else strcpy(zet, " 's avonds");
  if (mnt > 15) uur = (uur + 1);
  uur = uur % 12;
  if ( uur == 0) uur = 12; // Bepaal uur
  if (mnt < 16) iks = 0;
  else if (mnt < 30) {
    mnt = 30 - mnt;
    iks = 1;
  }
  else if (mnt == 30 );
  else if (mnt < 45) {
    mnt = mnt - 30;
    iks = 2;
  }
  else {
    mnt = 60 - mnt;
    iks = 3;
  }
  if (mnt == 1) ei = 5;
  else if ( mnt == 15 || mnt == 0 ) ei = 4;
  else ei = 6;


  if (mnt == 0 ) {
    strcat(tekst, Tal[uur] );
    strcat(tekst, " uur ");
  }
  else if (mnt == 30 ) {
    strcat(tekst, Tus[7]);
    strcat(tekst, Tal[uur]);
  }
  else {
    strcat(tekst, Tal[mnt]); strcat(tekst, Tus[ei]);
    strcat(tekst, Tus[iks]); strcat(tekst, Tal[uur]);

  }
  strcat(tekst, zet);
  maakNummer(clock.readTemperature() * 100, 2, DEC);
  strcat(tekst, " de temperatuur is");
  strcat(tekst, number);
  strcat(tekst, " graden celsius. ");
  strcat(tekst, note);
}

void maakNummer( long waarde, int dp,  byte base) { // if dp -1 = no point
  number[0] = 0; shift();
  number[0] = 32 + 14 * (waarde < 0); shift(); waarde=abs(waarde);
  do {
    number[0] = mChar(waarde % base); shift(); waarde = waarde / base; dp--;
    if (!dp) { number[0] = 46; shift(); } 
   } while(waarde);
  number[0]=32;
}

void shift() {
  memmove(number+1, number, 8);
 
}

byte mChar(byte dig) {
  byte result = dig + 48;
  return result;
}

void setup()
{
  for (uint8_t WPIN = 2; WPIN <= 17 ; WPIN++) pinMode(WPIN, OUTPUT);
  for (uint8_t WPIN = 2; WPIN <= 9 ; WPIN++) digitalWrite(WPIN, LOW);
  for (uint8_t WPIN = 10; WPIN <= 17 ; WPIN++) digitalWrite(WPIN, HIGH);

Serial.begin(57600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }
   EEPROM.get(0, note);
  
  clock.begin();
//clock.setDateTime(__DATE__, __TIME__); //run this once to set clock
 testDots();
}
void loop() {
  byte aval;
    dt = clock.getDateTime();
  if (dt.minute != vt && !letterPt){
    displayInSpreektaal(dt.hour,dt.minute);vt=dt.minute;
  }
 if (millis() > nextMillis) {
      nextColumn();
      nextMillis = millis() + spd;
    } 
  displayBuffer();
  drukknoppen();
    aval = Serial.read();
  if (aval != 255) { // Dit is een barebone tekstverwerker enter bewaar display regel backspace verwijder laatste karakter
    if (aval == 13) {
      EEPROM.put(0, note); notePt = 0; 
    }
    else if (aval == 127) {
      notePt--;
      note[notePt] = 0;Serial.print(char(8));
    }
    else if (aval > 31) {
      note[notePt] = aval; notePt++; note[notePt] = 0;
    }
    Serial.print(char(13)); Serial.print(note);
  }
}

Je hebt bijna alle io pins nodig, de matrix word aan de cathodekant met weerstanden aan de IO's aangesloten.
Er is ook een klokmodule op aangesloten die de tijd in spreektaal opzegt. en de mogelijkheid een zin in de eeprom op te zeggen.

shooter · January 8, 2024, 4:37pm

op de microbit zit een display die direct gestuurd wordt en war wil je bereiken dan?

system · July 6, 2024, 4:38pm

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.

Topic		Replies	Views
8x8 LED Matrix LEDs and Multiplexing	17	6175	May 6, 2021
Arduino uno 8x8 LED max7219 Deutsch	58	8113	May 6, 2021
8x 5x7 LED Matrix Deutsch	30	5266	May 6, 2021
LED matrix Frequently-Asked Questions	22	16828	May 6, 2021
matrice (5,24) how to display a message ? LEDs and Multiplexing	13	4176	May 6, 2021

8x8 matrix led-display

Related topics