STATIC DISPLAY

I have made a 9(rows) x 24(columns) LED display panel using instructions and a code that I obtained from the internet.

Attached kindly find the code that runs my project. As you will note the code is for a 6x24 but I have been able to customize mine to a 9x24 panel.

The code displays a scrolling message after one types character(s) on the serial monitor

However according to my project needs I want a static message to be displayed instead of a scrolling message but I have been unable to edit the code successfully.

Kindly can someone assist me in editing the code to display a static message

FVYC7RUH2WEWWWM.txt (13.8 KB)

By "static message" do you mean one that fits in 24 columns and doesn't scroll? Or do you mean one that is built into the code and scrolls repeatedly?

For the second case, maybe this will work:

int latchPin = 10;
int clockPin = 13;
int dataPin = 11;
int clock = 9;
int Reset = 8;
int latchPinPORTB = latchPin - 8;
int clockPinPORTB = clockPin - 8;
int dataPinPORTB = dataPin - 8;
int i = 0;
const char incomingByte[] = "This is my static message!";
long scrolling_word[6];
const int array_turn = strlen(incomingByte);;
byte patterns[100][6];
byte dummy_array[70][6] = {BA, BB, BC, BD, BE, BF, BG, BH, BI, BJ, BK, BL, BM, BN, BO, BP, BQ, BR, BS, BT, BU, BV, BW, BX, BY, BZ, SPACE, NUM0, NUM1, NUM2, NUM3, NUM4, NUM5, NUM6, NUM7, NUM8, NUM9, DEVIDE, TWODOTS, DOT, COMA, LINE, QUASTION, MARK, LA, LB, LC, LD, LE, LF, LG, LH, LI, LJ, LK, LL, LM, LN, LO, LP, LQ, LR, LS, LT, LU, LV, LW, LX, LY, LZ};
void setup() {
  Serial.begin(9600);
  pinMode(dataPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(latchPin, OUTPUT);
  pinMode(clock, OUTPUT);
  pinMode(Reset, OUTPUT);
  digitalWrite(Reset, HIGH);
  digitalWrite(Reset, LOW);
  setupSPI();
}


void display_word(int loops, byte word_print[][6], int num_patterns, int delay_langth) { // this function displays your symbols
  i = 0;// resets the counter fot the 4017
  for (int g = 0; g < 6; g++) //resets the the long int where your word goes
    scrolling_word[g] = 0;
  for (int x = 0; x < num_patterns; x++) { //main loop, goes over your symbols
    // you will need to find a better way to make the symbols scroll my way is limited for 24 columns


    for (int r = 0; r < 6; r++) //puts the buildes the first symbol
      scrolling_word[r] |= word_print[x][r];
    for (int z = 0; z < 6; z++) { //the sctolling action
      for (int p = 0; p < 6; p++)
        scrolling_word[p] = scrolling_word[p] << 1;
      // end of the scrolling funcion
      for (int t = 0; t < delay_langth; t++) { // delay function, it just loops over the same display
        for (int y = 0; y < 6; y++) { // scaning the display
          if (i == 6) { // counting up to 6 with the 4017
            digitalWrite(Reset, HIGH);
            digitalWrite(Reset, LOW);
            i = 0;
          }
          latchOff();
          spi_transfer(make_word(0x01000000, y)); // sending the data
          spi_transfer(make_word(0x00010000, y));
          spi_transfer(make_word(0x00000100, y));
          latchOn();
          delayMicroseconds(800);//waiting a bit
          latchOff();
          spi_transfer(0);// clearing the data
          spi_transfer(0);
          spi_transfer(0);
          latchOn();
          digitalWrite(clock, HIGH); //counting up with the 4017
          digitalWrite(clock, LOW);
          i++;
        }
      }
    }
  }
  finish_scroll(delay_langth);
}


void finish_scroll(int delay_scroll) { // this function is the same as the funcion above, it just finishing scrolling
  for (int n = 0; n < 24; n++) {
    for (int h = 0; h < 6; h++)
      scrolling_word[h] = scrolling_word[h] << 1;
    for (int w = 0; w < delay_scroll; w++) {
      for (int k = 0; k < 6; k++) {
        if (i == 6) {
          digitalWrite(Reset, HIGH);
          digitalWrite(Reset, LOW);
          i = 0;
        }
        latchOff();
        spi_transfer(make_word(0x01000000, k));
        spi_transfer(make_word(0x00010000, k));
        spi_transfer(make_word(0x00000100, k));
        latchOn();
        delayMicroseconds(800);
        latchOff();
        spi_transfer(0);
        spi_transfer(0);
        spi_transfer(0);
        latchOn();
        digitalWrite(clock, HIGH);
        digitalWrite(clock, LOW);
        i++;
      }
    }
  }
}


byte make_word (long posistion, byte turn) {
  byte dummy_word = 0;
  for (int q = 0; q < 8; q++) {
    if (scrolling_word[turn] & (posistion << q))
      dummy_word |= 0x01 << q;
  }
  return dummy_word;
}




void loop() {


  if (array_turn != 0) {
    for (int az = 0; az < array_turn; az++) {
      if ((incomingByte[az] > 64 && incomingByte[az] < 91) || (incomingByte[az] > 96 && incomingByte[az] < 123)) {
        if (incomingByte[az] > 64 && incomingByte[az] < 91) {
          for (int lal = 0; lal < 6; lal++)
            patterns[az][lal] = dummy_array[incomingByte[az] - 65][lal];
        }
        else {
          for (int lal = 0; lal < 6; lal++)
            patterns[az][lal] = dummy_array[incomingByte[az] - 53][lal];
        }
      }
      else {
        switch (incomingByte[az]) {
          case 32://space
            for (int lol = 0; lol < 6; lol++)
              patterns[az][lol] = dummy_array[26][lol];
            break;
          case 33://mark
            for (int lol = 0; lol < 6; lol++)
              patterns[az][lol] = dummy_array[43][lol];
            break;
          case 45://line
            for (int lol = 0; lol < 6; lol++)
              patterns[az][lol] = dummy_array[41][lol];
            break;
          case 44://coma
            for (int lol = 0; lol < 6; lol++)
              patterns[az][lol] = dummy_array[40][lol];
            break;
          case 46://dot
            for (int lol = 0; lol < 6; lol++)
              patterns[az][lol] = dummy_array[39][lol];
            break;
          case 47://dvide
            for (int lol = 0; lol < 6; lol++)
              patterns[az][lol] = dummy_array[37][lol];
            break;
          case 48://0
            for (int lol = 0; lol < 6; lol++)
              patterns[az][lol] = dummy_array[27][lol];
            break;
          case 49://1
            for (int lol = 0; lol < 6; lol++)
              patterns[az][lol] = dummy_array[28][lol];
            break;
          case 50://2
            for (int lol = 0; lol < 6; lol++)
              patterns[az][lol] = dummy_array[29][lol];
            break;
          case 51://3
            for (int lol = 0; lol < 6; lol++)
              patterns[az][lol] = dummy_array[30][lol];
            break;
          case 52://4
            for (int lol = 0; lol < 6; lol++)
              patterns[az][lol] = dummy_array[31][lol];
            break;
          case 53://5
            for (int lol = 0; lol < 6; lol++)
              patterns[az][lol] = dummy_array[32][lol];
            break;
          case 54://6
            for (int lol = 0; lol < 6; lol++)
              patterns[az][lol] = dummy_array[33][lol];
            break;
          case 55://7
            for (int lol = 0; lol < 6; lol++)
              patterns[az][lol] = dummy_array[34][lol];
            break;
          case 56://8
            for (int lol = 0; lol < 6; lol++)
              patterns[az][lol] = dummy_array[35][lol];
            break;
          case 57://9
            for (int lol = 0; lol < 6; lol++)
              patterns[az][lol] = dummy_array[36][lol];
            break;
          case 58://tow dots
            for (int lol = 0; lol < 6; lol++)
              patterns[az][lol] = dummy_array[38][lol];
            break;
          case 63://quastion
            for (int lol = 0; lol < 6; lol++)
              patterns[az][lol] = dummy_array[42][lol];
            break;
          default:
            for (int lol = 0; lol < 6; lol++)
              patterns[az][lol] = dummy_array[26][lol];
            break;
        }
      }
    }
  }
  display_word(1, patterns, array_turn, 15);
//  array_turn = 0;
}




//display_word(1,patterns,43,15);// calls for the display_pattern function and says that int loop = 15(if you do more loop the pattern whould scrrol slower).


void latchOn() {
  bitSet(PORTB, latchPinPORTB);
}


void latchOff() {
  bitClear(PORTB, latchPinPORTB);
}




void setupSPI() {
  byte clr;
  SPCR |= ( (1 << SPE) | (1 << MSTR) ); // enable SPI as master
  //SPCR |= ( (1<<SPR1) | (1<<SPR0) ); // set prescaler bits
  SPCR &= ~( (1 << SPR1) | (1 << SPR0) ); // clear prescaler bits
  clr = SPSR; // clear SPI status reg
  clr = SPDR; // clear SPI data reg
  SPSR |= (1 << SPI2X); // set prescaler bits
  //SPSR &= ~(1<<SPI2X); // clear prescaler bits


  delay(10);
}


byte spi_transfer(byte data)
{
  SPDR = data;        // Start the transmission
  while (!(SPSR & (1 << SPIF)))   // Wait the end of the transmission
  {
  };
  return SPDR;        // return the received byte, we don't need that
}

By "static message" I mean one that fits in 24 columns and doesn't scroll at all after one types a message on the arduino IDE serial monitor.

Hi,
Welcome to the forum.

Please read the first post in any forum entitled how to use this forum.
http://forum.arduino.cc/index.php/topic,148850.0.html then look down to item #7 about how to post your code.
It will be formatted in a scrolling window that makes it easier to read.

Thanks… Tom… :slight_smile:

By "static message" I mean one that fits in 24 columns and doesn't scroll after one types a message on the arduino IDE serial monitor.

MWIKI:
By "static message" I mean one that fits in 24 columns and doesn't scroll after one types a message on the arduino IDE serial monitor.

You might be better off abandoning this sketch and just composing a 9x24 image to put on the display. With the current 5x6 font you can fit exactly four characters into your display.