Passing a char array to a function

Hello!
I built 8LED POV stick that displays text. I’m using Attiny85 and 74HC595 and transistor for switches, to get more current to the leds.
At first, I used a simple code - each letter has it’s own array, I wrote a function that displays the text one letter at a time.

//example of a letter array
byte A[] = {0x00, 0x7E, 0x11, 0x11, 0x11, 0x7E};      // Code for char A
//The function itself
void kirjuta(byte t2ht[] ) {
  for(foo = 0; foo < 6; foo++) {
    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin, MSBFIRST, t2ht[foo]);  
    digitalWrite(latchPin, HIGH);
    delay(del2);
  }  
}

//to write text to be displayed, I used
kirjuta(T);
kirjuta(E);
kirjuta(X);
kirjuta(T);

It worked, but I wanted something more elegant.
So, now I tried to have the tekst in one variable, like this.
char tekst = “THIS IS TEST”;

I’m using a NANO to test the code.

This would be passed on to a function, that splits the string to seperate letters and for each letter it finds a proper value from a big array, that stores 6 columns for each letter.

The problem is, that when I try to get the sizeof(tekst); in the void loop() - I get a proper value. But if I pass it to a function, the value is only 2.

void kirjuta( char tekst2[] ) {
  Serial.println(sizeof(tekst));
  Serial.println(sizeof(tekst2));
  for(i=0; i < sizeof(tekst2)-1; i++ ) { //split it to seperate letters
    
    Serial.print("Letter: ");
    Serial.println(tekst2[i]);
}

sizeof(tekst) comes as 12 and sizeof(tekst2) comes as 2.

I can’t pass the char array to a function. Any tips?

Actually there's a very good tutorial on this subject by one of our other members (pYro_65) HERE

Loop knows the size of the array but when you pass it to kirjuta it just passes the address of the array - a pointer, which is two bytes in size. Add another parameter to kirjuta and pass it the actual size.

There is no way for the function to know the size of the array unless you made it global. See if this works:

void loop() {
   // in your loop() function:
   kirjuta(byte t2ht);
}

void kirjuta( char *tekst2) {
   int i;

  Serial.println(sizeof(tekst));
  Serial.println(sizeof(tekst2));

  i = 0;
  while (tekst[i]) {                // Keep printing until a null is read...
    Serial.print("Letter: ");
    Serial.println(tekst2[i++]);
  }

}

I would also make both arrays char arrays, not byte.

Thank you for the replies! I tried again, now with a pointer.
My code so far:

//ATTiny 85 and 74HC595 - 8Led POV stick.
//10K trimmer connected to A2, momentary switch connected to PIN3.
//Todo: switch changes between diffrent messages.

char text[] = "PASTA  "; //String to be displayed

//Pin connected to ST_CP of 74HC595
byte latchPin = 1;
//Pin connected to SH_CP of 74HC595
byte clockPin = 2;
////Pin connected to DS of 74HC595
byte dataPin = 0;

//character array created with GLCD Font Creator
char jada[] = {
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00,      // Code for char  
        0x00, 0x00, 0x06, 0x5F, 0x06, 0x00,      // Code for char !
        0x00, 0x07, 0x03, 0x00, 0x07, 0x03,      // Code for char "
        0x00, 0x24, 0x7E, 0x24, 0x7E, 0x24,      // Code for char #
        0x00, 0x24, 0x2B, 0x6A, 0x12, 0x00,      // Code for char $
        0x00, 0x63, 0x13, 0x08, 0x64, 0x63,      // Code for char %
        0x00, 0x36, 0x49, 0x56, 0x20, 0x50,      // Code for char &
        0x00, 0x00, 0x07, 0x03, 0x00, 0x00,      // Code for char '
        0x00, 0x00, 0x3E, 0x41, 0x00, 0x00,      // Code for char (
        0x00, 0x00, 0x41, 0x3E, 0x00, 0x00,      // Code for char )
        0x00, 0x08, 0x3E, 0x1C, 0x3E, 0x08,      // Code for char *
        0x00, 0x08, 0x08, 0x3E, 0x08, 0x08,      // Code for char +
        0x00, 0x00, 0xE0, 0x60, 0x00, 0x00,      // Code for char ,
        0x00, 0x08, 0x08, 0x08, 0x08, 0x08,      // Code for char -
        0x00, 0x00, 0x60, 0x60, 0x00, 0x00,      // Code for char .
        0x00, 0x20, 0x10, 0x08, 0x04, 0x02,      // Code for char /
        0x00, 0x3E, 0x51, 0x49, 0x45, 0x3E,      // Code for char 0
        0x00, 0x00, 0x42, 0x7F, 0x40, 0x00,      // Code for char 1
        0x00, 0x62, 0x51, 0x49, 0x49, 0x46,      // Code for char 2
        0x00, 0x22, 0x49, 0x49, 0x49, 0x36,      // Code for char 3
        0x00, 0x18, 0x14, 0x12, 0x7F, 0x10,      // Code for char 4
        0x00, 0x2F, 0x49, 0x49, 0x49, 0x31,      // Code for char 5
        0x00, 0x3C, 0x4A, 0x49, 0x49, 0x30,      // Code for char 6
        0x00, 0x01, 0x71, 0x09, 0x05, 0x03,      // Code for char 7
        0x00, 0x36, 0x49, 0x49, 0x49, 0x36,      // Code for char 8
        0x00, 0x06, 0x49, 0x49, 0x29, 0x1E,      // Code for char 9
        0x00, 0x00, 0x6C, 0x6C, 0x00, 0x00,      // Code for char :
        0x00, 0x00, 0xEC, 0x6C, 0x00, 0x00,      // Code for char ;
        0x00, 0x08, 0x14, 0x22, 0x41, 0x00,      // Code for char <
        0x00, 0x24, 0x24, 0x24, 0x24, 0x24,      // Code for char =
        0x00, 0x00, 0x41, 0x22, 0x14, 0x08,      // Code for char >
        0x00, 0x02, 0x01, 0x59, 0x09, 0x06,      // Code for char ?
        0x00, 0x3E, 0x41, 0x5D, 0x55, 0x1E,      // Code for char @
        0x00, 0x7E, 0x11, 0x11, 0x11, 0x7E,      // Code for char A
        0x00, 0x7F, 0x49, 0x49, 0x49, 0x36,      // Code for char B
        0x00, 0x3E, 0x41, 0x41, 0x41, 0x22,      // Code for char C
        0x00, 0x7F, 0x41, 0x41, 0x41, 0x3E,      // Code for char D
        0x00, 0x7F, 0x49, 0x49, 0x49, 0x41,      // Code for char E
        0x00, 0x7F, 0x09, 0x09, 0x09, 0x01,      // Code for char F
        0x00, 0x3E, 0x41, 0x49, 0x49, 0x7A,      // Code for char G
        0x00, 0x7F, 0x08, 0x08, 0x08, 0x7F,      // Code for char H
        0x00, 0x00, 0x41, 0x7F, 0x41, 0x00,      // Code for char I
        0x00, 0x30, 0x40, 0x40, 0x40, 0x3F,      // Code for char J
        0x00, 0x7F, 0x08, 0x14, 0x22, 0x41,      // Code for char K
        0x00, 0x7F, 0x40, 0x40, 0x40, 0x40,      // Code for char L
        0x00, 0x7F, 0x02, 0x04, 0x02, 0x7F,      // Code for char M
        0x00, 0x7F, 0x02, 0x04, 0x08, 0x7F,      // Code for char N
        0x00, 0x3E, 0x41, 0x41, 0x41, 0x3E,      // Code for char O
        0x00, 0x7F, 0x09, 0x09, 0x09, 0x06,      // Code for char P
        0x00, 0x3E, 0x41, 0x51, 0x21, 0x5E,      // Code for char Q
        0x00, 0x7F, 0x09, 0x09, 0x19, 0x66,      // Code for char R
        0x00, 0x26, 0x49, 0x49, 0x49, 0x32,      // Code for char S
        0x00, 0x01, 0x01, 0x7F, 0x01, 0x01,      // Code for char T
        0x00, 0x3F, 0x40, 0x40, 0x40, 0x3F,      // Code for char U
        0x00, 0x1F, 0x20, 0x40, 0x20, 0x1F,      // Code for char V
        0x00, 0x3F, 0x40, 0x3C, 0x40, 0x3F,      // Code for char W
        0x00, 0x63, 0x14, 0x08, 0x14, 0x63,      // Code for char X
        0x00, 0x07, 0x08, 0x70, 0x08, 0x07,      // Code for char Y
        0x00, 0x71, 0x49, 0x45, 0x43, 0x00,      // Code for char Z
        0x00, 0x00, 0x7F, 0x41, 0x41, 0x00,      // Code for char [
        0x00, 0x02, 0x04, 0x08, 0x10, 0x20,      // Code for char BackSlash
        0x00, 0x00, 0x41, 0x41, 0x7F, 0x00,      // Code for char ]
        0x00, 0x04, 0x02, 0x01, 0x02, 0x04,      // Code for char ^
        0x80, 0x80, 0x80, 0x80, 0x80, 0x80,      // Code for char _
        0x00, 0x00, 0x03, 0x07, 0x00, 0x00,      // Code for char `
        0x00, 0x20, 0x54, 0x54, 0x54, 0x78,      // Code for char a
        0x00, 0x7F, 0x44, 0x44, 0x44, 0x38,      // Code for char b
        0x00, 0x38, 0x44, 0x44, 0x44, 0x28,      // Code for char c
        0x00, 0x38, 0x44, 0x44, 0x44, 0x7F,      // Code for char d
        0x00, 0x38, 0x54, 0x54, 0x54, 0x08,      // Code for char e
        0x00, 0x08, 0x7E, 0x09, 0x09, 0x00,      // Code for char f
        0x00, 0x18, 0xA4, 0xA4, 0xA4, 0x7C,      // Code for char g
        0x00, 0x7F, 0x04, 0x04, 0x78, 0x00,      // Code for char h
        0x00, 0x00, 0x00, 0x7D, 0x40, 0x00,      // Code for char i
        0x00, 0x40, 0x80, 0x84, 0x7D, 0x00,      // Code for char j
        0x00, 0x7F, 0x10, 0x28, 0x44, 0x00,      // Code for char k
        0x00, 0x00, 0x00, 0x7F, 0x40, 0x00,      // Code for char l
        0x00, 0x7C, 0x04, 0x18, 0x04, 0x78,      // Code for char m
        0x00, 0x7C, 0x04, 0x04, 0x78, 0x00,      // Code for char n
        0x00, 0x38, 0x44, 0x44, 0x44, 0x38,      // Code for char o
        0x00, 0xFC, 0x44, 0x44, 0x44, 0x38,      // Code for char p
        0x00, 0x38, 0x44, 0x44, 0x44, 0xFC,      // Code for char q
        0x00, 0x44, 0x78, 0x44, 0x04, 0x08,      // Code for char r
        0x00, 0x08, 0x54, 0x54, 0x54, 0x20,      // Code for char s
        0x00, 0x04, 0x3E, 0x44, 0x24, 0x00,      // Code for char t
        0x00, 0x3C, 0x40, 0x20, 0x7C, 0x00,      // Code for char u
        0x00, 0x1C, 0x20, 0x40, 0x20, 0x1C,      // Code for char v
        0x00, 0x3C, 0x60, 0x30, 0x60, 0x3C,      // Code for char w
        0x00, 0x6C, 0x10, 0x10, 0x6C, 0x00,      // Code for char x
        0x00, 0x9C, 0xA0, 0x60, 0x3C, 0x00,      // Code for char y
        0x00, 0x64, 0x54, 0x54, 0x4C, 0x00,      // Code for char z
        0x00, 0x08, 0x3E, 0x41, 0x41, 0x00,      // Code for char {
        0x00, 0x00, 0x00, 0x77, 0x00, 0x00,      // Code for char |
        0x00, 0x00, 0x41, 0x41, 0x3E, 0x08,      // Code for char }
        0x00, 0x02, 0x01, 0x02, 0x01, 0x00,      // Code for char ~
        0x00, 0x3C, 0x26, 0x23, 0x26, 0x3C       // Code for char 
        };

void setup() {}

void loop() {
  kirjuta(text, sizeof(text));
}

void kirjuta(char* ptr, int length) { // the (pointer to the) string and length of it

  int place = 0; // variable for the table
  int time = (analogRead(2)/8); // trimmer sets the delay between column changes
  
  for(int i = 0; i<length-1; i++) { //Seperates letters, -1 removes NULL from the end.
    place = (ptr[i] - 32)*6; // My ASCII table starts from the 32nd letter and has 6 columns per letter.

      for (int j=0; j<6; j++) { //for 6 columns
        digitalWrite(latchPin, LOW);
        shiftOut(dataPin, clockPin, MSBFIRST, jada[place+j]);  
        digitalWrite(latchPin, HIGH);
        delay(time);
      }
  }
}
 kirjuta(text, sizeof(text));

No.
It's a string, so what's wrong with "strlen"?

"sizeof" may well not give you the result you want:

void loop() {
  char text [100];
  strcpy (text, "PASTA ");
  kirjuta(text, sizeof(text));
}

See the problem?

AWOL:
See the problem?

I see both of them :grin:

But anyway... C strings are null terminated for a reason. In the example posted you don't need to know the length.

Thank you yaafm! I really didn’t need the lenght. Right now I have this:

//ATTiny 85 and 74HC595 - 8Led POV stick.
//10K trimmer connected to A2, momentary switch connected to PIN3.
//Todo: switch changes between diffrent messages.

char text[] = "PASTA  "; //String to be displayed
char text2[] = "MAGIC ";
int time = 0;
int time2 = 500;

//Pin connected to ST_CP of 74HC595
byte latchPin = 1;
//Pin connected to SH_CP of 74HC595
byte clockPin = 2;
////Pin connected to DS of 74HC595
byte dataPin = 0;

//character array created with GLCD Font Creator
char jada[] = {
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00,      // Code for char  
        0x00, 0x00, 0x06, 0x5F, 0x06, 0x00,      // Code for char !
        0x00, 0x07, 0x03, 0x00, 0x07, 0x03,      // Code for char "
        0x00, 0x24, 0x7E, 0x24, 0x7E, 0x24,      // Code for char #
        0x00, 0x24, 0x2B, 0x6A, 0x12, 0x00,      // Code for char $
        0x00, 0x63, 0x13, 0x08, 0x64, 0x63,      // Code for char %
        0x00, 0x36, 0x49, 0x56, 0x20, 0x50,      // Code for char &
        0x00, 0x00, 0x07, 0x03, 0x00, 0x00,      // Code for char '
        0x00, 0x00, 0x3E, 0x41, 0x00, 0x00,      // Code for char (
        0x00, 0x00, 0x41, 0x3E, 0x00, 0x00,      // Code for char )
        0x00, 0x08, 0x3E, 0x1C, 0x3E, 0x08,      // Code for char *
        0x00, 0x08, 0x08, 0x3E, 0x08, 0x08,      // Code for char +
        0x00, 0x00, 0xE0, 0x60, 0x00, 0x00,      // Code for char ,
        0x00, 0x08, 0x08, 0x08, 0x08, 0x08,      // Code for char -
        0x00, 0x00, 0x60, 0x60, 0x00, 0x00,      // Code for char .
        0x00, 0x20, 0x10, 0x08, 0x04, 0x02,      // Code for char /
        0x00, 0x3E, 0x51, 0x49, 0x45, 0x3E,      // Code for char 0
        0x00, 0x00, 0x42, 0x7F, 0x40, 0x00,      // Code for char 1
        0x00, 0x62, 0x51, 0x49, 0x49, 0x46,      // Code for char 2
        0x00, 0x22, 0x49, 0x49, 0x49, 0x36,      // Code for char 3
        0x00, 0x18, 0x14, 0x12, 0x7F, 0x10,      // Code for char 4
        0x00, 0x2F, 0x49, 0x49, 0x49, 0x31,      // Code for char 5
        0x00, 0x3C, 0x4A, 0x49, 0x49, 0x30,      // Code for char 6
        0x00, 0x01, 0x71, 0x09, 0x05, 0x03,      // Code for char 7
        0x00, 0x36, 0x49, 0x49, 0x49, 0x36,      // Code for char 8
        0x00, 0x06, 0x49, 0x49, 0x29, 0x1E,      // Code for char 9
        0x00, 0x00, 0x6C, 0x6C, 0x00, 0x00,      // Code for char :
        0x00, 0x00, 0xEC, 0x6C, 0x00, 0x00,      // Code for char ;
        0x00, 0x08, 0x14, 0x22, 0x41, 0x00,      // Code for char <
        0x00, 0x24, 0x24, 0x24, 0x24, 0x24,      // Code for char =
        0x00, 0x00, 0x41, 0x22, 0x14, 0x08,      // Code for char >
        0x00, 0x02, 0x01, 0x59, 0x09, 0x06,      // Code for char ?
        0x00, 0x3E, 0x41, 0x5D, 0x55, 0x1E,      // Code for char @
        0x00, 0x7E, 0x11, 0x11, 0x11, 0x7E,      // Code for char A
        0x00, 0x7F, 0x49, 0x49, 0x49, 0x36,      // Code for char B
        0x00, 0x3E, 0x41, 0x41, 0x41, 0x22,      // Code for char C
        0x00, 0x7F, 0x41, 0x41, 0x41, 0x3E,      // Code for char D
        0x00, 0x7F, 0x49, 0x49, 0x49, 0x41,      // Code for char E
        0x00, 0x7F, 0x09, 0x09, 0x09, 0x01,      // Code for char F
        0x00, 0x3E, 0x41, 0x49, 0x49, 0x7A,      // Code for char G
        0x00, 0x7F, 0x08, 0x08, 0x08, 0x7F,      // Code for char H
        0x00, 0x00, 0x41, 0x7F, 0x41, 0x00,      // Code for char I
        0x00, 0x30, 0x40, 0x40, 0x40, 0x3F,      // Code for char J
        0x00, 0x7F, 0x08, 0x14, 0x22, 0x41,      // Code for char K
        0x00, 0x7F, 0x40, 0x40, 0x40, 0x40,      // Code for char L
        0x00, 0x7F, 0x02, 0x04, 0x02, 0x7F,      // Code for char M
        0x00, 0x7F, 0x02, 0x04, 0x08, 0x7F,      // Code for char N
        0x00, 0x3E, 0x41, 0x41, 0x41, 0x3E,      // Code for char O
        0x00, 0x7F, 0x09, 0x09, 0x09, 0x06,      // Code for char P
        0x00, 0x3E, 0x41, 0x51, 0x21, 0x5E,      // Code for char Q
        0x00, 0x7F, 0x09, 0x09, 0x19, 0x66,      // Code for char R
        0x00, 0x26, 0x49, 0x49, 0x49, 0x32,      // Code for char S
        0x00, 0x01, 0x01, 0x7F, 0x01, 0x01,      // Code for char T
        0x00, 0x3F, 0x40, 0x40, 0x40, 0x3F,      // Code for char U
        0x00, 0x1F, 0x20, 0x40, 0x20, 0x1F,      // Code for char V
        0x00, 0x3F, 0x40, 0x3C, 0x40, 0x3F,      // Code for char W
        0x00, 0x63, 0x14, 0x08, 0x14, 0x63,      // Code for char X
        0x00, 0x07, 0x08, 0x70, 0x08, 0x07,      // Code for char Y
        0x00, 0x71, 0x49, 0x45, 0x43, 0x00,      // Code for char Z
        0x00, 0x00, 0x7F, 0x41, 0x41, 0x00,      // Code for char [
        0x00, 0x02, 0x04, 0x08, 0x10, 0x20,      // Code for char BackSlash
        0x00, 0x00, 0x41, 0x41, 0x7F, 0x00,      // Code for char ]
        0x00, 0x04, 0x02, 0x01, 0x02, 0x04,      // Code for char ^
        0x80, 0x80, 0x80, 0x80, 0x80, 0x80,      // Code for char _
        0x00, 0x00, 0x03, 0x07, 0x00, 0x00,      // Code for char `
        0x00, 0x20, 0x54, 0x54, 0x54, 0x78,      // Code for char a
        0x00, 0x7F, 0x44, 0x44, 0x44, 0x38,      // Code for char b
        0x00, 0x38, 0x44, 0x44, 0x44, 0x28,      // Code for char c
        0x00, 0x38, 0x44, 0x44, 0x44, 0x7F,      // Code for char d
        0x00, 0x38, 0x54, 0x54, 0x54, 0x08,      // Code for char e
        0x00, 0x08, 0x7E, 0x09, 0x09, 0x00,      // Code for char f
        0x00, 0x18, 0xA4, 0xA4, 0xA4, 0x7C,      // Code for char g
        0x00, 0x7F, 0x04, 0x04, 0x78, 0x00,      // Code for char h
        0x00, 0x00, 0x00, 0x7D, 0x40, 0x00,      // Code for char i
        0x00, 0x40, 0x80, 0x84, 0x7D, 0x00,      // Code for char j
        0x00, 0x7F, 0x10, 0x28, 0x44, 0x00,      // Code for char k
        0x00, 0x00, 0x00, 0x7F, 0x40, 0x00,      // Code for char l
        0x00, 0x7C, 0x04, 0x18, 0x04, 0x78,      // Code for char m
        0x00, 0x7C, 0x04, 0x04, 0x78, 0x00,      // Code for char n
        0x00, 0x38, 0x44, 0x44, 0x44, 0x38,      // Code for char o
        0x00, 0xFC, 0x44, 0x44, 0x44, 0x38,      // Code for char p
        0x00, 0x38, 0x44, 0x44, 0x44, 0xFC,      // Code for char q
        0x00, 0x44, 0x78, 0x44, 0x04, 0x08,      // Code for char r
        0x00, 0x08, 0x54, 0x54, 0x54, 0x20,      // Code for char s
        0x00, 0x04, 0x3E, 0x44, 0x24, 0x00,      // Code for char t
        0x00, 0x3C, 0x40, 0x20, 0x7C, 0x00,      // Code for char u
        0x00, 0x1C, 0x20, 0x40, 0x20, 0x1C,      // Code for char v
        0x00, 0x3C, 0x60, 0x30, 0x60, 0x3C,      // Code for char w
        0x00, 0x6C, 0x10, 0x10, 0x6C, 0x00,      // Code for char x
        0x00, 0x9C, 0xA0, 0x60, 0x3C, 0x00,      // Code for char y
        0x00, 0x64, 0x54, 0x54, 0x4C, 0x00,      // Code for char z
        0x00, 0x08, 0x3E, 0x41, 0x41, 0x00,      // Code for char {
        0x00, 0x00, 0x00, 0x77, 0x00, 0x00,      // Code for char |
        0x00, 0x00, 0x41, 0x41, 0x3E, 0x08,      // Code for char }
        0x00, 0x02, 0x01, 0x02, 0x01, 0x00,      // Code for char ~
        0x00, 0x3C, 0x26, 0x23, 0x26, 0x3C       // Code for char 
        };

void setup() {
//  Serial.begin(9600);
}

void loop() {
  time = (analogRead(2)/8); // trimmer sets the delay between column changes
  kirjuta(text);
  kirjuta(text2);
}

void kirjuta(char* ptr) { // the (pointer to the) string to be written to shift register
  int place = 0; // variable for the table
  int k=0;
  
  while (ptr[k] != NULL) { //Seperates letters
  place = (ptr[k++] - 32)*6; // My ASCII table starts from the 32nd letter and has 6 columns per letter.
      for (int j=0; j<6; j++) { //for 6 columns
        digitalWrite(latchPin, LOW);
        shiftOut(dataPin, clockPin, MSBFIRST, jada[place+j]);  
        digitalWrite(latchPin, HIGH);
        delay(time2);
      }
  }
}

This doesn’t work… All the leds are on. That’s it.

But for debugging I used Nano and this code

void kirjuta(char* ptr) { // the (pointer to the) string and length of it
  int place = 0; // variable for the table
  int k=0;
  
  while (ptr[k] != NULL) { //Seperates letters, -1 removes NULL from the end.
  place = (ptr[k++] - 32)*6; // My ASCII table starts from the 32nd letter and has 6 columns per letter.
      for (int j=0; j<6; j++) { //for 6 columns
          Serial.println(jada[place+j], BIN);
//        digitalWrite(latchPin, LOW);
//        shiftOut(dataPin, clockPin, MSBFIRST, jada[place+j]);  
//        digitalWrite(latchPin, HIGH);
        delay(time2);
      }
      Serial.println("-------END OF LETTER----------");
  }
}

And it outputs

-------END OF LETTER----------
0
1111110
10001
10001
10001
1111110
-------END OF LETTER----------
0
100110
1001001
1001001
1001001
110010
-------END OF LETTER----------

So, the code is okay but somehow the shift register can’t get the information.

but somehow the shift register can't get the information.

Perhaps because you commented out the call to shiftOut(). Why would you do that?

Sorry, must have posted the wrong code.
I have this on my ATTiny.

All the leds stay on, no changing or flickering.

//ATTiny 85 and 74HC595 - 8Led POV stick.
//10K trimmer connected to A2, momentary switch connected to PIN3.
//Todo: switch changes between diffrent messages.

char text[] = "PASTA  "; //String to be displayed
char text2[] = "MAGIC ";
int time = 0;
int time2 = 500;

//Pin connected to ST_CP of 74HC595
byte latchPin = 1;
//Pin connected to SH_CP of 74HC595
byte clockPin = 2;
////Pin connected to DS of 74HC595
byte dataPin = 0;

//character array created with GLCD Font Creator
char jada[] = {// array truncated, I reached the 9000 letter limit. Same as before.  };

// ******

void setup() {
  //set pins to output so you can control the shift register
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
}

// ******

void loop() {
  time = (analogRead(2)/8); // trimmer sets the delay between column changes
  kirjuta(text);
  kirjuta(text2);
}

// ******

void kirjuta(char* ptr) { // the (pointer to the) string and length of it
  int place = 0; // variable for the table
  int k=0;

  while (ptr[k] != NULL) { //Seperates letters
  place = (ptr[k++] - 32)*6; // My ASCII table starts from the 32nd letter and has 6 columns per letter.
      for (int j=0; j<6; j++) { //for 6 columns     
        digitalWrite(latchPin, LOW);
        shiftOut(dataPin, clockPin, MSBFIRST, jada[place+j]);  
        digitalWrite(latchPin, HIGH);
        delay(time);
      }
  }
}

However, my first version works just fine, like this

//Pin connected to ST_CP of 74HC595
byte latchPin = 1;
//Pin connected to SH_CP of 74HC595
byte clockPin = 2;
////Pin connected to DS of 74HC595
byte dataPin = 0;
// ******************************

byte A[] = {0x00, 0x7E, 0x11, 0x11, 0x11, 0x7E};      // Code for char A
byte B[] = {0x00, 0x7F, 0x49, 0x49, 0x49, 0x36};      // Code for char B
byte C[] = {0x00, 0x3E, 0x41, 0x41, 0x41, 0x22};     // Code for char C
byte D[] = {0x00, 0x7F, 0x41, 0x41, 0x41, 0x3E};      // Code for char D
byte E[] = {0x00, 0x7F, 0x49, 0x49, 0x49, 0x41};      // Code for char E
byte F[] = {0x00, 0x7F, 0x09, 0x09, 0x09, 0x01};      // Code for char F
byte G[] = {0x00, 0x3E, 0x41, 0x49, 0x49, 0x7A};      // Code for char G
byte H[] = {0x00, 0x7F, 0x08, 0x08, 0x08, 0x7F};      // Code for char H
byte I[] = {0x00, 0x00, 0x41, 0x7F, 0x41, 0x00};      // Code for char I
byte J[] = {0x00, 0x30, 0x40, 0x40, 0x40, 0x3F};      // Code for char J
byte K[] = {0x00, 0x7F, 0x08, 0x14, 0x22, 0x41};      // Code for char K
byte L[] = {0x00, 0x7F, 0x40, 0x40, 0x40, 0x40};      // Code for char L
byte M[] = {0x00, 0x7F, 0x02, 0x04, 0x02, 0x7F};      // Code for char M
byte N[] = {0x00, 0x7F, 0x02, 0x04, 0x08, 0x7F};      // Code for char N
byte O[] = {0x00, 0x3E, 0x41, 0x41, 0x41, 0x3E};      // Code for char O
byte P[] = {0x00, 0x7F, 0x09, 0x09, 0x09, 0x06};      // Code for char P
byte Q[] = {0x00, 0x3E, 0x41, 0x51, 0x21, 0x5E};      // Code for char Q
byte R[] = {0x00, 0x7F, 0x09, 0x09, 0x19, 0x66};      // Code for char R
byte S[] = {0x00, 0x26, 0x49, 0x49, 0x49, 0x32};      // Code for char S
byte T[] = {0x00, 0x01, 0x01, 0x7F, 0x01, 0x01};      // Code for char T
byte U[] = {0x00, 0x3F, 0x40, 0x40, 0x40, 0x3F};     // Code for char U
byte V[] = {0x00, 0x1F, 0x20, 0x40, 0x20, 0x1F};       // Code for char V

int del = 0;
byte del2 = 0;
byte foo = 0;


//********************************

void setup() {
  //set pins to output so you can control the shift register
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
}
//***********************************

void loop() {

del = analogRead(2);
del2 = del/8;

kirjuta(P);
kirjuta(A);
kirjuta(S);
kirjuta(T);
kirjuta(A);
kirjuta(tyhik);


}

void kirjuta(byte t2ht[] ) {
  for(foo = 0; foo < 6; foo++) {
    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin, MSBFIRST, t2ht[foo]);  
    digitalWrite(latchPin, HIGH);
    delay(del2);
  }  

}
//character array created with GLCD Font Creator
char jada[] = {// array truncated, I reached the 9000 letter limit. Same as before.  };

And yet we are supposed to guess just how big this array is, AND assume that it is small enough to not exceed the amount of memory available on the ATTiny. I think not.

I was the same array (jada) in my previous post. Sorry, if I didn’t make it clear enough.

char jada[] = {
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00,      // Code for char  
        0x00, 0x00, 0x06, 0x5F, 0x06, 0x00,      // Code for char !
        0x00, 0x07, 0x03, 0x00, 0x07, 0x03,      // Code for char "
        0x00, 0x24, 0x7E, 0x24, 0x7E, 0x24,      // Code for char #
        0x00, 0x24, 0x2B, 0x6A, 0x12, 0x00,      // Code for char $
        0x00, 0x63, 0x13, 0x08, 0x64, 0x63,      // Code for char %
        0x00, 0x36, 0x49, 0x56, 0x20, 0x50,      // Code for char &
        0x00, 0x00, 0x07, 0x03, 0x00, 0x00,      // Code for char '
        0x00, 0x00, 0x3E, 0x41, 0x00, 0x00,      // Code for char (
        0x00, 0x00, 0x41, 0x3E, 0x00, 0x00,      // Code for char )
        0x00, 0x08, 0x3E, 0x1C, 0x3E, 0x08,      // Code for char *
        0x00, 0x08, 0x08, 0x3E, 0x08, 0x08,      // Code for char +
        0x00, 0x00, 0xE0, 0x60, 0x00, 0x00,      // Code for char ,
        0x00, 0x08, 0x08, 0x08, 0x08, 0x08,      // Code for char -
        0x00, 0x00, 0x60, 0x60, 0x00, 0x00,      // Code for char .
        0x00, 0x20, 0x10, 0x08, 0x04, 0x02,      // Code for char /
        0x00, 0x3E, 0x51, 0x49, 0x45, 0x3E,      // Code for char 0
        0x00, 0x00, 0x42, 0x7F, 0x40, 0x00,      // Code for char 1
        0x00, 0x62, 0x51, 0x49, 0x49, 0x46,      // Code for char 2
        0x00, 0x22, 0x49, 0x49, 0x49, 0x36,      // Code for char 3
        0x00, 0x18, 0x14, 0x12, 0x7F, 0x10,      // Code for char 4
        0x00, 0x2F, 0x49, 0x49, 0x49, 0x31,      // Code for char 5
        0x00, 0x3C, 0x4A, 0x49, 0x49, 0x30,      // Code for char 6
        0x00, 0x01, 0x71, 0x09, 0x05, 0x03,      // Code for char 7
        0x00, 0x36, 0x49, 0x49, 0x49, 0x36,      // Code for char 8
        0x00, 0x06, 0x49, 0x49, 0x29, 0x1E,      // Code for char 9
        0x00, 0x00, 0x6C, 0x6C, 0x00, 0x00,      // Code for char :
        0x00, 0x00, 0xEC, 0x6C, 0x00, 0x00,      // Code for char ;
        0x00, 0x08, 0x14, 0x22, 0x41, 0x00,      // Code for char <
        0x00, 0x24, 0x24, 0x24, 0x24, 0x24,      // Code for char =
        0x00, 0x00, 0x41, 0x22, 0x14, 0x08,      // Code for char >
        0x00, 0x02, 0x01, 0x59, 0x09, 0x06,      // Code for char ?
        0x00, 0x3E, 0x41, 0x5D, 0x55, 0x1E,      // Code for char @
        0x00, 0x7E, 0x11, 0x11, 0x11, 0x7E,      // Code for char A
        0x00, 0x7F, 0x49, 0x49, 0x49, 0x36,      // Code for char B
        0x00, 0x3E, 0x41, 0x41, 0x41, 0x22,      // Code for char C
        0x00, 0x7F, 0x41, 0x41, 0x41, 0x3E,      // Code for char D
        0x00, 0x7F, 0x49, 0x49, 0x49, 0x41,      // Code for char E
        0x00, 0x7F, 0x09, 0x09, 0x09, 0x01,      // Code for char F
        0x00, 0x3E, 0x41, 0x49, 0x49, 0x7A,      // Code for char G
        0x00, 0x7F, 0x08, 0x08, 0x08, 0x7F,      // Code for char H
        0x00, 0x00, 0x41, 0x7F, 0x41, 0x00,      // Code for char I
        0x00, 0x30, 0x40, 0x40, 0x40, 0x3F,      // Code for char J
        0x00, 0x7F, 0x08, 0x14, 0x22, 0x41,      // Code for char K
        0x00, 0x7F, 0x40, 0x40, 0x40, 0x40,      // Code for char L
        0x00, 0x7F, 0x02, 0x04, 0x02, 0x7F,      // Code for char M
        0x00, 0x7F, 0x02, 0x04, 0x08, 0x7F,      // Code for char N
        0x00, 0x3E, 0x41, 0x41, 0x41, 0x3E,      // Code for char O
        0x00, 0x7F, 0x09, 0x09, 0x09, 0x06,      // Code for char P
        0x00, 0x3E, 0x41, 0x51, 0x21, 0x5E,      // Code for char Q
        0x00, 0x7F, 0x09, 0x09, 0x19, 0x66,      // Code for char R
        0x00, 0x26, 0x49, 0x49, 0x49, 0x32,      // Code for char S
        0x00, 0x01, 0x01, 0x7F, 0x01, 0x01,      // Code for char T
        0x00, 0x3F, 0x40, 0x40, 0x40, 0x3F,      // Code for char U
        0x00, 0x1F, 0x20, 0x40, 0x20, 0x1F,      // Code for char V
        0x00, 0x3F, 0x40, 0x3C, 0x40, 0x3F,      // Code for char W
        0x00, 0x63, 0x14, 0x08, 0x14, 0x63,      // Code for char X
        0x00, 0x07, 0x08, 0x70, 0x08, 0x07,      // Code for char Y
        0x00, 0x71, 0x49, 0x45, 0x43, 0x00,      // Code for char Z
        0x00, 0x00, 0x7F, 0x41, 0x41, 0x00,      // Code for char [
        0x00, 0x02, 0x04, 0x08, 0x10, 0x20,      // Code for char BackSlash
        0x00, 0x00, 0x41, 0x41, 0x7F, 0x00,      // Code for char ]
        0x00, 0x04, 0x02, 0x01, 0x02, 0x04,      // Code for char ^
        0x80, 0x80, 0x80, 0x80, 0x80, 0x80,      // Code for char _
        0x00, 0x00, 0x03, 0x07, 0x00, 0x00,      // Code for char `
        0x00, 0x20, 0x54, 0x54, 0x54, 0x78,      // Code for char a
        0x00, 0x7F, 0x44, 0x44, 0x44, 0x38,      // Code for char b
        0x00, 0x38, 0x44, 0x44, 0x44, 0x28,      // Code for char c
        0x00, 0x38, 0x44, 0x44, 0x44, 0x7F,      // Code for char d
        0x00, 0x38, 0x54, 0x54, 0x54, 0x08,      // Code for char e
        0x00, 0x08, 0x7E, 0x09, 0x09, 0x00,      // Code for char f
        0x00, 0x18, 0xA4, 0xA4, 0xA4, 0x7C,      // Code for char g
        0x00, 0x7F, 0x04, 0x04, 0x78, 0x00,      // Code for char h
        0x00, 0x00, 0x00, 0x7D, 0x40, 0x00,      // Code for char i
        0x00, 0x40, 0x80, 0x84, 0x7D, 0x00,      // Code for char j
        0x00, 0x7F, 0x10, 0x28, 0x44, 0x00,      // Code for char k
        0x00, 0x00, 0x00, 0x7F, 0x40, 0x00,      // Code for char l
        0x00, 0x7C, 0x04, 0x18, 0x04, 0x78,      // Code for char m
        0x00, 0x7C, 0x04, 0x04, 0x78, 0x00,      // Code for char n
        0x00, 0x38, 0x44, 0x44, 0x44, 0x38,      // Code for char o
        0x00, 0xFC, 0x44, 0x44, 0x44, 0x38,      // Code for char p
        0x00, 0x38, 0x44, 0x44, 0x44, 0xFC,      // Code for char q
        0x00, 0x44, 0x78, 0x44, 0x04, 0x08,      // Code for char r
        0x00, 0x08, 0x54, 0x54, 0x54, 0x20,      // Code for char s
        0x00, 0x04, 0x3E, 0x44, 0x24, 0x00,      // Code for char t
        0x00, 0x3C, 0x40, 0x20, 0x7C, 0x00,      // Code for char u
        0x00, 0x1C, 0x20, 0x40, 0x20, 0x1C,      // Code for char v
        0x00, 0x3C, 0x60, 0x30, 0x60, 0x3C,      // Code for char w
        0x00, 0x6C, 0x10, 0x10, 0x6C, 0x00,      // Code for char x
        0x00, 0x9C, 0xA0, 0x60, 0x3C, 0x00,      // Code for char y
        0x00, 0x64, 0x54, 0x54, 0x4C, 0x00,      // Code for char z
        0x00, 0x08, 0x3E, 0x41, 0x41, 0x00,      // Code for char {
        0x00, 0x00, 0x00, 0x77, 0x00, 0x00,      // Code for char |
        0x00, 0x00, 0x41, 0x41, 0x3E, 0x08,      // Code for char }
        0x00, 0x02, 0x01, 0x02, 0x01, 0x00,      // Code for char ~
        0x00, 0x3C, 0x26, 0x23, 0x26, 0x3C       // Code for char 
        };

I cut out all lowercase letters and it works!
Thanks!

I cut out all lowercase letters and it works!

Go the distance, and cut out use of SRAM for your lookup.

I can save a few bytes in the function, I don’t need int’s for simple variables. Other than that, I don’t know, if I can make it more efficent.

void kirjuta(char* ptr) { // the (pointer to the) string and length of it
  int place = 0; // variable for the table
  byte k=0; 

  while (ptr[k] != NULL) { //Seperates letters
  place = (ptr[k++] - 32)*6; // My ASCII table starts from the 32nd letter and has 6 columns per letter.
      for (byte j=0; j<6; j++) { //for 6 columns     
        digitalWrite(latchPin, LOW);
        shiftOut(dataPin, clockPin, MSBFIRST, jada[place+j]);  
        digitalWrite(latchPin, HIGH);
        delay(time);
      }
  }
}

But… My array with symbols and uppercase letters has 59 letters. 59*6 columns = 354bytes. ATTiny85 has only 512bytes of ram. I guess I have to figure out a way to burn the character lookup array to flash or eeprom. never done that before, so I have to do abit of googling!

ATTiny85 has only 512bytes of ram.

See reply #12

desmond3:
But... My array with symbols and uppercase letters has 59 letters. 59*6 columns = 354bytes. ATTiny85 has only 512bytes of ram. I guess I have to figure out a way to burn the character lookup array to flash or eeprom. never done that before, so I have to do abit of googling!

You can Google Arduino PROGMEM and you can use these two links below and STILL need to write a sketch or two to test things out.

http://www.nongnu.org/avr-libc/user-manual/group__avr__pgmspace.html

You might also take the (Solved) off the thread title!

Three hours of headache… But got it working with PROGMEM !

//ATTiny 85 and 74HC595 - 8Led POV stick.
//10K trimmer connected to A2, momentary switch connected to PIN3.
//Todo: switch changes between diffrent messages.

#include <avr/pgmspace.h>

char text[] = "working "; //String to be displayed
// char text2[] = "SECOND ";
// char text3[] = "THIRD";
// char text4[] = "FOURTH";
// char text5[] = "FIFTH";
// char text6[] = "SIXTH";
// char text7[] = "SEVENTH";

byte time = 0;
const byte nupp = 3;

//Pin connected to ST_CP of 74HC595
byte latchPin = 1;
//Pin connected to SH_CP of 74HC595
byte clockPin = 2;
////Pin connected to DS of 74HC595
byte dataPin = 0;

//character array created with GLCD Font Creator
const char  jada[] PROGMEM = {
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00,      // Code for char  
        0x00, 0x00, 0x06, 0x5F, 0x06, 0x00,      // Code for char !
        0x00, 0x07, 0x03, 0x00, 0x07, 0x03,      // Code for char "
        0x00, 0x24, 0x7E, 0x24, 0x7E, 0x24,      // Code for char #
        0x00, 0x24, 0x2B, 0x6A, 0x12, 0x00,      // Code for char $
        0x00, 0x63, 0x13, 0x08, 0x64, 0x63,      // Code for char %
        0x00, 0x36, 0x49, 0x56, 0x20, 0x50,      // Code for char &
        0x00, 0x00, 0x07, 0x03, 0x00, 0x00,      // Code for char '
        0x00, 0x00, 0x3E, 0x41, 0x00, 0x00,      // Code for char (
        0x00, 0x00, 0x41, 0x3E, 0x00, 0x00,      // Code for char )
        0x00, 0x08, 0x3E, 0x1C, 0x3E, 0x08,      // Code for char *
        0x00, 0x08, 0x08, 0x3E, 0x08, 0x08,      // Code for char +
        0x00, 0x00, 0xE0, 0x60, 0x00, 0x00,      // Code for char ,
        0x00, 0x08, 0x08, 0x08, 0x08, 0x08,      // Code for char -
        0x00, 0x00, 0x60, 0x60, 0x00, 0x00,      // Code for char .
        0x00, 0x20, 0x10, 0x08, 0x04, 0x02,      // Code for char /
        0x00, 0x3E, 0x51, 0x49, 0x45, 0x3E,      // Code for char 0
        0x00, 0x00, 0x42, 0x7F, 0x40, 0x00,      // Code for char 1
        0x00, 0x62, 0x51, 0x49, 0x49, 0x46,      // Code for char 2
        0x00, 0x22, 0x49, 0x49, 0x49, 0x36,      // Code for char 3
        0x00, 0x18, 0x14, 0x12, 0x7F, 0x10,      // Code for char 4
        0x00, 0x2F, 0x49, 0x49, 0x49, 0x31,      // Code for char 5
        0x00, 0x3C, 0x4A, 0x49, 0x49, 0x30,      // Code for char 6
        0x00, 0x01, 0x71, 0x09, 0x05, 0x03,      // Code for char 7
        0x00, 0x36, 0x49, 0x49, 0x49, 0x36,      // Code for char 8
        0x00, 0x06, 0x49, 0x49, 0x29, 0x1E,      // Code for char 9
        0x00, 0x00, 0x6C, 0x6C, 0x00, 0x00,      // Code for char :
        0x00, 0x00, 0xEC, 0x6C, 0x00, 0x00,      // Code for char ;
        0x00, 0x08, 0x14, 0x22, 0x41, 0x00,      // Code for char <
        0x00, 0x24, 0x24, 0x24, 0x24, 0x24,      // Code for char =
        0x00, 0x00, 0x41, 0x22, 0x14, 0x08,      // Code for char >
        0x00, 0x02, 0x01, 0x59, 0x09, 0x06,      // Code for char ?
        0x00, 0x3E, 0x41, 0x5D, 0x55, 0x1E,      // Code for char @
        0x00, 0x7E, 0x11, 0x11, 0x11, 0x7E,      // Code for char A
        0x00, 0x7F, 0x49, 0x49, 0x49, 0x36,      // Code for char B
        0x00, 0x3E, 0x41, 0x41, 0x41, 0x22,      // Code for char C
        0x00, 0x7F, 0x41, 0x41, 0x41, 0x3E,      // Code for char D
        0x00, 0x7F, 0x49, 0x49, 0x49, 0x41,      // Code for char E
        0x00, 0x7F, 0x09, 0x09, 0x09, 0x01,      // Code for char F
        0x00, 0x3E, 0x41, 0x49, 0x49, 0x7A,      // Code for char G
        0x00, 0x7F, 0x08, 0x08, 0x08, 0x7F,      // Code for char H
        0x00, 0x00, 0x41, 0x7F, 0x41, 0x00,      // Code for char I
        0x00, 0x30, 0x40, 0x40, 0x40, 0x3F,      // Code for char J
        0x00, 0x7F, 0x08, 0x14, 0x22, 0x41,      // Code for char K
        0x00, 0x7F, 0x40, 0x40, 0x40, 0x40,      // Code for char L
        0x00, 0x7F, 0x02, 0x04, 0x02, 0x7F,      // Code for char M
        0x00, 0x7F, 0x02, 0x04, 0x08, 0x7F,      // Code for char N
        0x00, 0x3E, 0x41, 0x41, 0x41, 0x3E,      // Code for char O
        0x00, 0x7F, 0x09, 0x09, 0x09, 0x06,      // Code for char P
        0x00, 0x3E, 0x41, 0x51, 0x21, 0x5E,      // Code for char Q
        0x00, 0x7F, 0x09, 0x09, 0x19, 0x66,      // Code for char R
        0x00, 0x26, 0x49, 0x49, 0x49, 0x32,      // Code for char S
        0x00, 0x01, 0x01, 0x7F, 0x01, 0x01,      // Code for char T
        0x00, 0x3F, 0x40, 0x40, 0x40, 0x3F,      // Code for char U
        0x00, 0x1F, 0x20, 0x40, 0x20, 0x1F,      // Code for char V
        0x00, 0x3F, 0x40, 0x3C, 0x40, 0x3F,      // Code for char W
        0x00, 0x63, 0x14, 0x08, 0x14, 0x63,      // Code for char X
        0x00, 0x07, 0x08, 0x70, 0x08, 0x07,      // Code for char Y
        0x00, 0x71, 0x49, 0x45, 0x43, 0x00,      // Code for char Z
        0x00, 0x00, 0x7F, 0x41, 0x41, 0x00,      // Code for char [
        0x00, 0x02, 0x04, 0x08, 0x10, 0x20,      // Code for char BackSlash
        0x00, 0x00, 0x41, 0x41, 0x7F, 0x00,      // Code for char ]
        0x00, 0x04, 0x02, 0x01, 0x02, 0x04,      // Code for char ^
        0x80, 0x80, 0x80, 0x80, 0x80, 0x80,      // Code for char _
        0x00, 0x00, 0x03, 0x07, 0x00, 0x00,      // Code for char `
        0x00, 0x20, 0x54, 0x54, 0x54, 0x78,      // Code for char a
        0x00, 0x7F, 0x44, 0x44, 0x44, 0x38,      // Code for char b
        0x00, 0x38, 0x44, 0x44, 0x44, 0x28,      // Code for char c
        0x00, 0x38, 0x44, 0x44, 0x44, 0x7F,      // Code for char d
        0x00, 0x38, 0x54, 0x54, 0x54, 0x08,      // Code for char e
        0x00, 0x08, 0x7E, 0x09, 0x09, 0x00,      // Code for char f
        0x00, 0x18, 0xA4, 0xA4, 0xA4, 0x7C,      // Code for char g
        0x00, 0x7F, 0x04, 0x04, 0x78, 0x00,      // Code for char h
        0x00, 0x00, 0x00, 0x7D, 0x40, 0x00,      // Code for char i
        0x00, 0x40, 0x80, 0x84, 0x7D, 0x00,      // Code for char j
        0x00, 0x7F, 0x10, 0x28, 0x44, 0x00,      // Code for char k
        0x00, 0x00, 0x00, 0x7F, 0x40, 0x00,      // Code for char l
        0x00, 0x7C, 0x04, 0x18, 0x04, 0x78,      // Code for char m
        0x00, 0x7C, 0x04, 0x04, 0x78, 0x00,      // Code for char n
        0x00, 0x38, 0x44, 0x44, 0x44, 0x38,      // Code for char o
        0x00, 0xFC, 0x44, 0x44, 0x44, 0x38,      // Code for char p
        0x00, 0x38, 0x44, 0x44, 0x44, 0xFC,      // Code for char q
        0x00, 0x44, 0x78, 0x44, 0x04, 0x08,      // Code for char r
        0x00, 0x08, 0x54, 0x54, 0x54, 0x20,      // Code for char s
        0x00, 0x04, 0x3E, 0x44, 0x24, 0x00,      // Code for char t
        0x00, 0x3C, 0x40, 0x20, 0x7C, 0x00,      // Code for char u
        0x00, 0x1C, 0x20, 0x40, 0x20, 0x1C,      // Code for char v
        0x00, 0x3C, 0x60, 0x30, 0x60, 0x3C,      // Code for char w
        0x00, 0x6C, 0x10, 0x10, 0x6C, 0x00,      // Code for char x
        0x00, 0x9C, 0xA0, 0x60, 0x3C, 0x00,      // Code for char y
        0x00, 0x64, 0x54, 0x54, 0x4C, 0x00,      // Code for char z
        0x00, 0x08, 0x3E, 0x41, 0x41, 0x00,      // Code for char {
        0x00, 0x00, 0x00, 0x77, 0x00, 0x00,      // Code for char |
        0x00, 0x00, 0x41, 0x41, 0x3E, 0x08,      // Code for char }
        0x00, 0x02, 0x01, 0x02, 0x01, 0x00,      // Code for char ~
        0x00, 0x3C, 0x26, 0x23, 0x26, 0x3C       // Code for char 
        };

void setup() {
  //set pins to output so you can control the shift register
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
  pinMode(nupp, INPUT);

}

void loop() {
  time = (analogRead(2)/10); // trimmer sets the delay between column changes
  kirjuta(text);

}

void kirjuta(char* ptr_S) { // the (pointer to the) string
  int place = 0; // variable for the table
  byte k = 0;
  const char* ptr_P = jada; // pointer for the table
  byte place_P = 0; // holder for PROGMEM location

  while (ptr_S[k] != NULL) { //Seperates letters
      place = (ptr_S[k++] - 32)*6; // My ASCII table starts from the 32nd letter and has 6 columns per letter. This finds the place where the letter starts
      for (byte j=0; j<6; j++) { //for 6 columns
      
        place_P = pgm_read_byte(&ptr_P[place+j]); //read a byte from jada, using it's pointer      
        
        digitalWrite(latchPin, LOW);
        shiftOut(dataPin, clockPin, MSBFIRST, place_P);  
        digitalWrite(latchPin, HIGH);
        delay(time);

      }
  }
}

It’s not pretty, but it’s getting late. I will clean it up someday.
Thank you for the links!

You stuck with it!
And you posted your solution.
Good for you :slight_smile:

Have some karma