I've learned a bunch today now on the lighting some leds 8x8 the letters work fine
CrossRoads:
Why is this an int?
int indexTable[][8] =
Whole array is filled with bytes.Are all the entries printable characters? If not, you may not see anything in the serial monitor.
There are no lines controlling IO pins, how are LEDs to be turned on? You don't seem to have any IO multiplexing going on.
Why is this a int because that's what it used over here https://www.arduino.cc/en/Reference/Array
I/O come later I ask about indexing a table or look up table because I have not done that in C ++
be80be:
I was playing with this but I have something wrong
That looks like the correct approach (apart from using int when you should save memory by using byte).
But you have not told us what goes wrong so I can't help.
...R
It was dumb lol I never used arrays much and and C or C++ is not my normal. But if I can see it I can do it.
But anyway I want to write a libaray that lets me print to some 8x8 leds I done made the leds board with a bunch of blue leds. So i start with the table all I want is the ABC's and 0 to 9 I layout a 8x8 and it gives me the binary for the 8 rows. Now I fire up a arduino and test to see if I can send that out serially I get what I think is hex and I think it's not working wrong it's dec and It was working fine.
So now I'm back to figuring the next part how to index 62 letters and numbers so I can pass acii to a function
that then sends words that I can buffer and scan out on my display I'm sure lot of people have done something like this but I want to do it kind of like a LCD so I just pass the words like
ledarrayWrite("It's been a good Day")
So now I'm back to figuring the next part how to index 62 letters and numbers
I thought that this had already been covered. The ASCII value of the character will allow you to determine the index to an array holding the data for the display.
be80be:
Can arduino do multidimensional arrays?
Can C do multidimensional arrays? Yes.
be80be:
Now I fire up a arduino and test to see if I can send that out serially I get what I think is hex and I think it's not working wrong it's dec and It was working fine.
Without seeing your code and the output from it this is meaningless.
...R
For what it's worth, I have code that sends bitmapped characters to an LCD:
There is an array of bit settings for each character:
// font data - each character is 8 pixels deep and 5 pixels wide
const byte font [96] [5] PROGMEM = {
{ 0x00, 0x00, 0x00, 0x00, 0x00 }, // space (0x20)
{ 0x00, 0x00, 0x2F, 0x00, 0x00 }, // !
{ 0x00, 0x07, 0x00, 0x07, 0x00 }, // "
{ 0x14, 0x7F, 0x14, 0x7F, 0x14 }, // #
...
{ 0x7E, 0x11, 0x11, 0x11, 0x7E }, // A
{ 0x7F, 0x49, 0x49, 0x49, 0x36 }, // B
{ 0x3E, 0x41, 0x41, 0x41, 0x22 }, // C
{ 0x7F, 0x41, 0x41, 0x22, 0x1C }, // D
{ 0x7F, 0x49, 0x49, 0x49, 0x41 }, // E
{ 0x7F, 0x09, 0x09, 0x09, 0x01 }, // F
{ 0x3E, 0x41, 0x49, 0x49, 0x7A }, // G
...
{ 0x00, 0x00, 0x7F, 0x00, 0x00 }, // |
{ 0x00, 0x41, 0x36, 0x08, 0x00 }, // }
{ 0x30, 0x08, 0x10, 0x20, 0x18 }, // ~
{ 0x7F, 0x55, 0x49, 0x55, 0x7F } // unknown char (0x7F)
};
This writes one character (shortened a bit to omit irrelevant stuff):
// write one letter (space to 0x7F)
void I2C_graphical_LCD_display::letter (byte c)
{
if (c < 0x20 || c > 0x7F)
c = 0x7F; // unknown glyph
c -= 0x20; // force into range of our font table (which starts at 0x20)
// font data is in PROGMEM memory (firmware)
for (byte x = 0; x < 5; x++)
writeData (pgm_read_byte (&font [c] [x]));
} // end of I2C_graphical_LCD_display::letter
I've not had much time to work on this I was breaking it down in parts. Like I said the first part was making the table and I tested it send the 8 bytes to serial monitor. I didn't think it was sending right because I was sending Hex and converting it with a calculator to see the byte if it matched. I fixed that and see how it's done. And learned how it send it the same as my table.
byte letterA[] ={B00110000,B01001000,B10000100,B10000100,B11111100,B10000100,B10000100,B10000100};
byte letterB[] ={B11111000,B10000100,B10000100,B11111000,B11111000,B10000100,B10000100,B11111000};
byte letterC[] ={B00111000,B01000100,B10000000,B10000000,B10000000,B10000000,B01000100,B00111000};
byte letterD[] ={B11110000,B10001000,B10000100,B10000100,B10000100,B10000100,B10001000,B11110000};
byte letterE[] ={B11111100,B10000000,B10000000,B11100000,B11100000,B10000000,B10000000,B11111100};
byte letterF[] ={B11111100,B10000000,B10000000,B11110000,B11110000,B10000000,B10000000,B10000000};
byte letterG[] ={B00111000,B01000100,B10000100,B10000000,B10011000,B10000100,B01000100,B00111000};
byte letterH[] ={B10000100,B10000100,B10000100,B10000100,B11111100,B10000100,B10000100,B10000100};
byte letterI[] ={B11111110,B00010000,B00010000,B00010000,B00010000,B00010000,B00010000,B11111110};
byte letterJ[] ={B11111110,B00010000,B00010000,B00010000,B00010000,B10010000,B10010000,B01100000};
byte letterK[] ={B10000100,B10001000,B10010000,B11100000,B11100000,B10010000,B10001000,B10000100};
byte letterL[] ={B10000000,B10000000,B10000000,B10000000,B10000000,B10000000,B10000000,B11111100};
byte letterM[] ={B10000010,B11000110,B10101010,B10010010,B10000010,B10000010,B10000010,B10000010};
byte letterN[] ={B10000010,B11000010,B11100010,B10110010,B10011010,B10001110,B10000110,B10000010};
byte letterO[] ={B00110000,B01001000,B10000100,B10000100,B10000100,B10000100,B01001000,B00110000};
byte letterP[] ={B11110000,B10001000,B10000100,B10001000,B11110000,B10000000,B10000000,B10000000};
byte letterQ[] ={B00110000,B01001000,B10000100,B10000100,B10000100,B10000100,B01001000,B00110100};
byte letterR[] ={B11110000,B10001000,B10000100,B10001000,B11110000,B10001000,B10000100,B10000100};
byte letterS[] ={B01110000,B10001000,B00001000,B00110000,B01000000,B10000000,B10001000,B01110000};
byte letterT[] ={B11111110,B00010000,B00010000,B00010000,B00010000,B00010000,B00010000,B00010000};
byte letterU[] ={B10000100,B10000100,B10000100,B10000100,B10000100,B10000100,B01001000,B00110000};
byte letterV[] ={B10000100,B10000100,B10000100,B10000100,B10000100,B10000100,B01001000,B00110000};
byte letterW[] ={B10000010,B10000010,B10000010,B10000010,B10000010,B10010010,B01010100,B00101000};
byte letterX[] ={B10000010,B01000100,B00101000,B00010000,B00010000,B00101000,B01000100,B10000010};
byte letterY[] ={B10000010,B01000100,B00101000,B00010000,B00010000,B00010000,B00010000,B00010000};
byte letterZ[] ={B11111100,B00000100,B00001000,B00010000,B00010000,B00100000,B01000000,B11111100};
void setup() {
Serial.begin(9600); // opens serial port, sets data rate to 9600 bps
} //close setup()
void loop() {
int i;
for (i = 0; i < 8; i = i + 1) {
Serial.println(letterA[i],BIN);
delay(1000);
}
} //close loop()
Now I'm trying to figure how the best way to send out the 8 bytes making words. And yes the int was a big hog thanks all
Make a multidimensional array like I did in reply #28.
Thanks Nick I set it up like this figure it run threw the whole set guess i'm thinking wrong
const byte indexTable[208][8]PROGMEM ={
{B00110000,B01001000,B10000100,B10000100,B11111100,B10000100,B10000100,B10000100} //A
,{B11111000,B10000100,B10000100,B11111000,B11111000,B10000100,B10000100,B11111000} //B
,{B00111000,B01000100,B10000000,B10000000,B10000000,B10000000,B01000100,B00111000} //C
,{B11110000,B10001000,B10000100,B10000100,B10000100,B10000100,B10001000,B11110000} //D
,{B11111100,B10000000,B10000000,B11100000,B11100000,B10000000,B10000000,B11111100} //E
,{B11111100,B10000000,B10000000,B11110000,B11110000,B10000000,B10000000,B10000000} //F
,{B00111000,B01000100,B10000100,B10000000,B10011000,B10000100,B01000100,B00111000} //G
,{B10000100,B10000100,B10000100,B10000100,B11111100,B10000100,B10000100,B10000100} //H
,{B11111110,B00010000,B00010000,B00010000,B00010000,B00010000,B00010000,B11111110} //I
,{B11111110,B00010000,B00010000,B00010000,B00010000,B10010000,B10010000,B01100000} //J
,{B10000100,B10001000,B10010000,B11100000,B11100000,B10010000,B10001000,B10000100} //K
,{B10000000,B10000000,B10000000,B10000000,B10000000,B10000000,B10000000,B11111100} //L
,{B10000010,B11000110,B10101010,B10010010,B10000010,B10000010,B10000010,B10000010} //M
,{B10000010,B11000010,B11100010,B10110010,B10011010,B10001110,B10000110,B10000010} //N
,{B00110000,B01001000,B10000100,B10000100,B10000100,B10000100,B01001000,B00110000} //O
,{B11110000,B10001000,B10000100,B10001000,B11110000,B10000000,B10000000,B10000000} //P
,{B00110000,B01001000,B10000100,B10000100,B10000100,B10000100,B01001000,B00110100} //Q
,{B11110000,B10001000,B10000100,B10001000,B11110000,B10001000,B10000100,B10000100} //R
,{B01110000,B10001000,B00001000,B00110000,B01000000,B10000000,B10001000,B01110000} //S
,{B11111110,B00010000,B00010000,B00010000,B00010000,B00010000,B00010000,B00010000} //T
,{B10000100,B10000100,B10000100,B10000100,B10000100,B10000100,B01001000,B00110000} //U
,{B10000100,B10000100,B10000100,B10000100,B10000100,B10000100,B01001000,B00110000} //V
,{B10000010,B10000010,B10000010,B10000010,B10000010,B10010010,B01010100,B00101000} //w
,{B10000010,B01000100,B00101000,B00010000,B00010000,B00101000,B01000100,B10000010} //X
,{B10000010,B01000100,B00101000,B00010000,B00010000,B00010000,B00010000,B00010000} //Y
,{B11111100,B00000100,B00001000,B00010000,B00010000,B00100000,B01000000,B11111100} //Z
};
void setup() {
Serial.begin(9600); // opens serial port, sets data rate to 9600 bps
} //close setup()
void loop() {
for(byte i = 0; i < 26; i++){
for(byte j = 0; j < 8; j++){
delay(500);
Serial.println(indexTable[j][i],BIN);
}//close for i
}//close for j
} //close loop()]
table is ok just got to figure how to call the letters i want.
Index into the table like I showed in my code snippet.