Question about dot matrix

Hi,

it is my first post in which im requesting your help.

i work on this:

const int clockPin = 13;
const int dataPin = 11;
const int latchPin = 10;

byte arrow[8]={0x18,0x3C,0x66,0xDB,0x18,0x18,0x18,0x18};
byte displayBuffer[8]= {0};
  
int fontDefinitions[475] = {
0x00,0x00,0x00,0x00,0x00,/*space*/ // is 32 in ASCII
0x00,0xF6,0xF6,0x00,0x00,/*!*/
0x00,0xE0,0x00,0xE0,0x00,/*"*/
0x28,0xFE,0x28,0xFE,0x28,/*#*/
0x00,0x64,0xD6,0x54,0x08,/*$*/
0xC2,0xCC,0x10,0x26,0xC6,/*%*/
0x4C,0xB2,0x92,0x6C,0x0A,/*&*/
0x00,0x00,0xE0,0x00,0x00,/*'*/
0x00,0x38,0x44,0x82,0x00,/*(*/
0x00,0x82,0x44,0x38,0x00,/*)*/
0x88,0x50,0xF8,0x50,0x88,/***/
0x08,0x08,0x3E,0x08,0x08,/*+*/
0x00,0x00,0x05,0x06,0x00,/*,*/
0x08,0x08,0x08,0x08,0x08,/*-*/
0x00,0x00,0x06,0x06,0x00,/*.*/
0x02,0x0C,0x10,0x60,0x80,/*/*/
0x7C,0x8A,0x92,0xA2,0x7C,/*0*/
0x00,0x42,0xFE,0x02,0x00,/*1*/
0x42,0x86,0x8A,0x92,0x62,/*2*/
0x44,0x82,0x92,0x92,0x6C,/*3*/
0x10,0x30,0x50,0xFE,0x10,/*4*/
0xE4,0xA2,0xA2,0xA2,0x9C,/*5*/
0x3C,0x52,0x92,0x92,0x0C,/*6*/
0x80,0x86,0x98,0xE0,0x80,/*7*/
0x6C,0x92,0x92,0x92,0x6C,/*8*/
0x60,0x92,0x92,0x94,0x78,/*9*/
0x00,0x00,0x36,0x36,0x00,/*:*/
0x00,0x00,0x35,0x36,0x00,/*;*/
0x10,0x28,0x44,0x82,0x00,/*<*/
0x28,0x28,0x28,0x28,0x28,/*=*/
0x00,0x82,0x44,0x28,0x10,/*>*/
0x40,0x80,0x8A,0x90,0x60,/*?*/
0x7C,0x82,0xBA,0xBA,0x62,/*@*/
0x3E,0x48,0x88,0x48,0x3E,/*A*/
0xFE,0x92,0x92,0x92,0x6C,/*B*/
0x7C,0x82,0x82,0x82,0x44,/*C*/
0xFE,0x82,0x82,0x82,0x7C,/*D*/
0xFE,0x92,0x92,0x92,0x82,/*E*/
0xFE,0x90,0x90,0x90,0x80,/*F*/
0x7C,0x82,0x82,0x8A,0x4E,/*G*/
0xFE,0x10,0x10,0x10,0xFE,/*H*/
0x82,0x82,0xFE,0x82,0x82,/*I*/
0x84,0x82,0xFC,0x80,0x80,/*J*/
0xFE,0x10,0x28,0x44,0x82,/*K*/
0xFE,0x02,0x02,0x02,0x02,/*L*/
0xFE,0x40,0x20,0x40,0xFE,/*M*/
0xFE,0x60,0x10,0x0C,0xFE,/*N*/
0x7C,0x82,0x82,0x82,0x7C,/*O*/
0xFE,0x90,0x90,0x90,0x60,/*P*/
0x7C,0x82,0x82,0x86,0x7E,/*Q*/
0xFE,0x90,0x98,0x94,0x62,/*R*/
0x64,0x92,0x92,0x92,0x4C,/*S*/
0x80,0x80,0xFE,0x80,0x80,/*T*/
0xFC,0x02,0x02,0x02,0xFC,/*U*/
0xF8,0x04,0x02,0x04,0xF8,/*V*/
0xFC,0x02,0x0C,0x02,0xFC,/*W*/
0xC6,0x28,0x10,0x28,0xC6,/*X*/
0xC0,0x20,0x1E,0x20,0xC0,/*Y*/
0x86,0x8A,0x92,0xA2,0xC2,/*Z*/
0x00,0x00,0xFE,0x82,0x00,/*[*/
0x00,0x00,0x00,0x00,0x00,/*this should be / */
0x80,0x60,0x10,0x0C,0x02,/*]*/
0x20,0x40,0x80,0x40,0x20,/*^*/
0x01,0x01,0x01,0x01,0x01,/*_*/
0x80,0x40,0x20,0x00,0x00,/*`*/
0x04,0x2A,0x2A,0x2A,0x1E,/*a*/
0xFE,0x12,0x22,0x22,0x1C,/*b*/
0x1C,0x22,0x22,0x22,0x14,/*c*/
0x1C,0x22,0x22,0x12,0xFE,/*d*/
0x1C,0x2A,0x2A,0x2A,0x18,/*e*/
0x10,0x7E,0x90,0x80,0x40,/*f*/
0x18,0x25,0x25,0x25,0x1E,/*g*/
0xFE,0x10,0x10,0x10,0x0E,/*h*/
0x00,0x12,0x5E,0x02,0x00,/*i*/
0x02,0x01,0x01,0x11,0x5E,/*j*/
0xFE,0x08,0x08,0x14,0x22,/*k*/
0x00,0x82,0xFE,0x02,0x00,/*l*/
0x3E,0x20,0x1C,0x20,0x1E,/*m*/
0x3E,0x20,0x20,0x20,0x1E,/*n*/
0x1C,0x22,0x22,0x22,0x1C,/*o*/
0x3F,0x24,0x24,0x24,0x18,/*p*/
0x18,0x24,0x24,0x3F,0x01,/*q*/
0x3E,0x10,0x20,0x20,0x10,/*r*/
0x12,0x2A,0x2A,0x2A,0x04,/*s*/
0x00,0x10,0x3C,0x12,0x04,/*t*/
0x3C,0x02,0x02,0x02,0x3E,/*u*/
0x30,0x0C,0x02,0x0C,0x30,/*v*/
0x38,0x06,0x18,0x06,0x38,/*w*/
0x22,0x14,0x08,0x14,0x22,/*x*/
0x38,0x05,0x05,0x05,0x3E,/*y*/
0x22,0x26,0x2A,0x32,0x22,/*z*/
0x00,0x10,0x6C,0x82,0x82,/*{*/
//0x00,0x00,0xFF,0x00,0x00,/*|*/
0x04,0x02,0xFF,0x02,0x04,/*|, arrow*/
0x82,0x82,0x6C,0x10,0x00,/*}*/
0x08,0x10,0x18,0x08,0x10/*~*/
};

void setup() {
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
  pinMode(latchPin, OUTPUT);
}

void loop() {
      displayString("This is a scrolling LED matrix display. You can easily make your own! ", 70);
}

void scrollBufferLeft() {
  for(int i=7; i>=0; i--) {
    displayBuffer[i+1] = displayBuffer[i];
  }
}

void addCharSliceToBuffer(char c, byte pos) {
  displayBuffer[0] = fontDefinitions[((c - 32) * 5) + pos];  
}

void displayString(char * stringToDisplay, byte stringLength) {
  for(int k = 0; k < stringLength; k++) {
    for(int j = 0; j < 5; j++) {
      addCharSliceToBuffer(stringToDisplay[k], j);
      for(int i=0; i<20; i++) drawImage(displayBuffer);
      scrollBufferLeft();
    }
      addCharSliceToBuffer(' ', 0);
      for(int i=0; i<20; i++) drawImage(displayBuffer);
      scrollBufferLeft();
  }
}

void drawImage(byte * matrix) {
  for(int i=0; i<8; i++) {
    for(int j=0; j<8; j++) { 
      digitalWrite(clockPin, LOW);
      digitalWrite(dataPin, (matrix[i]) & (1<<j) );
      digitalWrite(clockPin, HIGH);
    }
    
    for(int j=7; j>=0; j--) { 
      digitalWrite(clockPin, LOW);
      digitalWrite(dataPin, (~(1<<i)) & (1<<j) );
      digitalWrite(clockPin, HIGH);
    }

    digitalWrite(latchPin,LOW);
    digitalWrite(latchPin,HIGH);
  } 
}

https://github.com/paramaggarwal/scrollingmatrix/blob/master/main.ino

and i want to do this part…

void drawImage(byte * matrix) {
  for(int i=0; i<8; i++) {
    for(int j=0; j<8; j++) { 
      digitalWrite(clockPin, LOW);
      digitalWrite(dataPin, (matrix[i]) & (1<<j) );
      digitalWrite(clockPin, HIGH);
    }
    
    for(int j=7; j>=0; j--) { 
      digitalWrite(clockPin, LOW);
      digitalWrite(dataPin, (~(1<<i)) & (1<<j) );
      digitalWrite(clockPin, HIGH);
    }

    digitalWrite(latchPin,LOW);
    digitalWrite(latchPin,HIGH);
  } 
}

… with shiftOut(). how can i do it?

Hi, you have put your sketch inside quotation markers instead of code markers. Please edit your post and fix that. Use the “#” button not the speech bubble button.

I think your code would become:

void drawImage(byte * matrix) {
  for(int i=0; i<8; i++) {

    shiftOut(clockPin, dataPin, LSBFIRST, matrix);
    shiftOut(clockPin, dataPin, MSBFIRST, ~(1<<i));

    digitalWrite(latchPin,LOW);
    digitalWrite(latchPin,HIGH);

  }
}

Another option would be to use the SPI library, since you already seem to be using the appropriate pins for that.

Paul

hi paul

thanks for helps.

i try it but it doesn't work. have you got an other idea?

Did it work 100% before the change?

EDIT: you changed the sketch since my original reply! You made a correction from "(matrix)" to "(matrix [ i ])". I wondered if that was an error. Did you make the corresponding change in my suggested version?

now it works :slight_smile:

    shiftOut(clockPin, dataPin, LSBFIRST, matrix);
    shiftOut(clockPin, dataPin, MSBFIRST, ~(1<<i));

I did not pay attention to it

must be

    shiftOut(dataPin, clockPin, LSBFIRST, matrix[i]);
    shiftOut(dataPin, clockPin, MSBFIRST, ~(1<<i));

thanks a lot for your helps paul