Бегущая строка на светодиодных матрицах
- Войдите на сайт для отправки комментариев
Пт, 30/01/2015 - 14:58
Добрый день!
Стоит задача: организовать вывод текстовой информации на светодиодную бегущую строку.
В принципе, работает. Но выводит только английский текст. Уже вторую неделю ломаю голову как "прикрутить" кириллицу.
Текст программы:
(на авторство абсолютно не претендую)
int x;
int y;
int latchPin1 = 5; //Arduino pin connected to blue 12 RCLK of 74HC595
int clockPin1 = 6; //Arduino pin connected to green 11 SRCLK of 74HC595
int dataPin1 = 7; //Arduino pin connected to violet 14 SER of 74HC595
//-- Rows (Positive Anodes) --
int latchPin2 = 9; //Arduino pin connected to yellow Latch 12 RCLK of 74HC595
int clockPin2 = 10; //Arduino pin connected to white Clock 11 SRCLK of 74HC595
int dataPin2 = 8; //Arduino pin connected to grey Data 14 SER of 74HC595
//=== B I T M A P ===
//Bits in this array represents one LED of the matrix
// 8 is # of rows, 7 is # of LED matrix we have
byte bitmap[8][8]; // Change the 7 to however many matrices you want to use.
int numZones = sizeof(bitmap) / 8; // I will refer to each group of 8 columns (represented by one matrix) as a Zone.
int maxZoneIndex = numZones-1;
int numCols = numZones * 8;
//=== F O N T ===
// Font courtesy of aspro648
byte alphabets[][5] = {
{0,0,0,0,0}, // ПРОБЕЛ ASCII 32
{0,0,253,0,0}, // ! ASCII 33
{0,96,0,96,0}, // " ASCII 34
{20,127,20,127,20}, // # ASCII 35
{36,42,127,42,18}, // $ ASCII 36
{17,2,4,8,17}, // % ASCII 37
{54,73,85,34,5}, // & ASCII 38
{0,0,104,112,0}, // ' ASCII 39
{28,34,65}, // ( ASCII 40
{65,34,28}, // ) ASCII 41
{20,8,62,8,20}, // * ASCII 42
{8,8,62,8,8}, // + ASCII 43
{0,0,5,6,0}, // , ASCII 44
{8,8,8,8,8}, // - ASCII 45
{0,0,1,0,0}, // . ASCII 46
{1,2,4,8,16}, // / ASCII 47
{62,69,73,81,62}, // 0 ASCII 48
{0,33,127,1,0}, // 1 ASCII 49
{33,67,69,73,49}, // 2 ASCII 50
{66,65,81,105,70}, // 3 ASCII 51
{12,20,36,127,4}, // 4 ASCII 52
{113,81,81,81,78}, // 5 ASCII 53
{30,41,73,73,6}, // 6 ASCII 54
{64,64,79,80,96}, // 7 ASCII 55
{54,73,73,73,54}, // 8 ASCII 56
{48,73,73,74,60}, // 9 ASCII 57
{0,0,54,54,0}, // : ASCII 58
{0,0,53,54,0}, // ; ASCII 59
{0,8,20,34,65}, // < ASCII 60
{20,20,20,20,20}, // = ASCII 61
{0,65,34,20,8}, // > ASCII 62
{32,64,69,72,48}, // ? ASCII 63
{38,73,77,65,62}, // @ ASCII 64
{31,36,68,36,31}, // A ASCII 65
{127,73,73,73,54}, // B ASCII 66
{62,65,65,65,34}, // C ASCII 67
{127,65,65,34,28}, // D ASCII 68
{127,73,73,65,65}, // E ASCII 69
{127,72,72,72,64}, // F ASCII 70
{62,65,65,69,38}, // G ASCII 71
{127,8,8,8,127}, // H ASCII 72
{0,65,127,65,0}, // I ASCII 73
{2,1,1,1,126}, // J ASCII 74
{127,8,20,34,65}, // K ASCII 75
{127,1,1,1,1}, // L ASCII 76
{127,32,16,32,127}, // M ASCII 77
{127,32,16,8,127}, // N ASCII 78
{62,65,65,65,62}, // O ASCII 79
{127,72,72,72,48}, // P ASCII 80
{62,65,69,66,61}, // Q ASCII 81
{127,72,76,74,49}, // R ASCII 82
{50,73,73,73,38}, // S ASCII 83
{64,64,127,64,64}, // T ASCII 84
{126,1,1,1,126}, // U ASCII 85
{124,2,1,2,124}, // V ASCII 86
{126,1,6,1,126}, // W ASCII 87
{99,20,8,20,99}, // X ASCII 88
{96,16,15,16,96}, // Y ASCII 89
{67,69,73,81,97}, // Z ASCII 90
{0,127,65,65,0}, // [ ASCII 91
{0,0,0,0,0}, // \ ASCII 92
{0,65,65,127,0}, // ] ASCII 93
{16,32,64,32,16}, // ^ ASCII 94
{1,1,1,1,1}, // _ ASCII 95
{0,64,32,16,0}, // ` ASCII 96
{2,21,21,21,15}, // a ASCII 97
{127,5,9,9,6}, // b ASCII 98
{14,17,17,17,0}, // c ASCII 99
{6,9,9,5,127}, // d ASCII 100
{14,21,21,21,12}, // e ASCII 101
{8,63,72,64,32}, // f ASCII 102
{24,37,37,37,62}, // g ASCII 103
{127,8,16,16,15}, // h ASCII 104
{0,0,47,0,0}, // i ASCII 105
{2,1,17,94,0}, // j ASCII 106
{127,4,10,17,0}, // k ASCII 107
{0,65,127,1,0}, // l ASCII 108
{31,16,12,16,31}, // m ASCII 109
{31,8,16,16,15}, // n ASCII 110
{14,17,17,17,14}, // o ASCII 111
{31,20,20,20,8}, // p ASCII 112
{8,20,20,12,31}, // q ASCII 113
{31,8,16,16,8}, // r ASCII 114
{9,21,21,21,18}, // s ASCII 115
{16,126,17,1,2}, // t ASCII 116
{30,1,1,2,31}, // u ASCII 117
{28,2,1,2,28}, // v ASCII 118
{30,1,6,1,30}, // w ASCII 119
{17,10,4,10,17}, // x ASCII 120
{24,5,5,5,30}, // y ASCII 121
{17,19,21,25,17}, // z ASCII 122
{0,0,8,54,65}, // { ASCII 123
{0,0,127,0,0}, // | ASCII 124
{65,54,8,0,0}, // } ASCII 125
{ 62, 80, 144, 144, 254}, //А 126
{ 254, 146, 146, 146, 12}, //Б 127
{ 254, 146, 146, 146, 108}, //В
{ 254, 128, 128, 128, 128}, //Г
{ 3, 126, 130, 130, 255}, //Д
{ 254, 146, 146, 146, 130}, //Е
{ 238, 16, 254, 16, 238}, //Ж
{ 68, 146, 146, 146, 108}, //З
{ 254, 4, 8, 16, 254}, //И
{ 254, 4, 136, 16, 254}, //Й
{ 254, 16, 40, 68, 130}, //К
{ 62, 64, 128, 128, 254}, //Л
{ 254, 64, 32, 64, 254}, //М
{ 254, 16, 16, 16, 254}, //Н
{ 124, 130, 130, 130, 124}, //О
{ 254, 128, 128, 128, 254}, //П
{ 254, 144, 144, 144, 96}, //Р
{ 124, 130, 130, 130, 68}, //С
{ 128, 128, 254, 128, 128}, //Т
{ 224, 18, 18, 18, 252}, //У
{ 96, 144, 254, 144, 96}, //Ф
{ 198, 40, 16, 40, 198}, //Х
{ 252, 2, 2, 2, 255}, //Ц
{ 224, 16, 16, 16, 254}, //Ч
{ 254, 2, 30, 2, 254}, //Ш
{ 254, 2, 30, 2, 255}, //Щ
{ 128, 254, 18, 18, 12}, //Ъ
{ 254, 18, 18, 12, 254}, //Ы
{ 0, 254, 18, 18, 12}, //Ь
{ 68, 146, 146, 146, 124}, //Э
{ 254, 16, 124, 130, 124}, //Ю
{ 98, 148, 152, 144, 254}, //Я
{ 4, 42, 42, 42, 30}, //а
{ 60, 98, 162, 162, 156}, //б
{ 62, 42, 42, 20, 0}, //в
{ 62, 32, 32, 32, 32}, //г
{ 3, 14, 50, 34, 63}, //д
{ 28, 42, 42, 42, 16}, //е
{ 62, 8, 62, 8, 62}, //ж ASCII -26
{ 20, 34, 42, 42, 20}, //з ASCII -25
{ 62, 4, 8, 16, 62}, //и ASCII -24
{ 62, 4, 72, 16, 62}, //й ASCII -23
{ 62, 8, 8, 20, 34}, //к ASCII -22
{ 14, 16, 32, 32, 62}, //л ASCII -21
{ 62, 16, 8, 16, 62}, //м ASCII -20
{ 62, 8, 8, 8, 62}, //н ASCII -19
{ 28, 34, 34, 34, 28}, //о ASCII -18
{ 62, 32, 32, 32, 62}, //п ASCII -17
{ 63, 34, 34, 34, 28}, //р ASCII -16
{ 28, 34, 34, 34, 20}, //с ASCII -15
{ 32, 32, 62, 32, 32}, //т ASCII -14
{ 57, 5, 5, 5, 62}, //у ASCII -13
{ 24, 36, 62, 36, 24}, //ф ASCII -12
{ 34, 20, 8, 20, 34}, //х ASCII -11
{ 62, 2, 2, 62, 3}, //ц ASCII -10
{ 48, 8, 8, 8, 62}, //ч ASCII -9
{ 62, 2, 14, 2, 62}, //ш ASCII -8
{ 62, 2, 14, 2, 63}, //щ ASCII -7
{ 32, 62, 10, 10, 4}, //ъ ASCII -6
{ 62, 10, 10, 4, 62}, //ы ASCII -5
{ 62, 10, 10, 10, 4}, //ь ASCII -4
{ 20, 34, 42, 42, 28}, //э ASCII -3
{62,8,28,34,28}, // ю ASCII -2
{18,42,44,40,62}, // я ASCII -1
};
//=== S E T U P ===
void setup() {
Serial.begin(9600);
pinMode(latchPin1, OUTPUT);
pinMode(clockPin1, OUTPUT);
pinMode(dataPin1, OUTPUT);
pinMode(latchPin2, OUTPUT);
pinMode(clockPin2, OUTPUT);
pinMode(dataPin2, OUTPUT);
//-- Clear bitmap --
for (int row = 0; row < 8; row++) {
for (int zone = 0; zone <= maxZoneIndex; zone++) {
bitmap[row][zone] = 0;
}
}
}
//=== F U N C T I O N S ===
// This routine takes whatever we've setup in the bitmap array and display it on the matrix
void RefreshDisplay()
{
for (int row = 0; row < 8; row++) {
int rowbit = 1 << row;
digitalWrite(latchPin2, LOW); //Hold latchPin LOW for as long as we're transmitting data
shiftOut(dataPin2, clockPin2, MSBFIRST, rowbit); //Transmit data
//-- Start sending column bytes --
digitalWrite(latchPin1, LOW); //Hold latchPin LOW for as long as we're transmitting data
//-- Shift out to each matrix (zone is 8 columns represented by one matrix)
for (int zone = maxZoneIndex; zone >= 0; zone--) {
shiftOut(dataPin1, clockPin1, MSBFIRST, bitmap[row][zone]);
}
//-- Done sending Column bytes, flip both latches at once to eliminate flicker
digitalWrite(latchPin1, HIGH); //Return the latch pin high to signal chip that it no longer needs to listen for information
digitalWrite(latchPin2, HIGH); //Return the latch pin high to signal chip that it no longer needs to listen for information
//-- Wait a little bit to let humans see what we've pushed out onto the matrix --
// delayMicroseconds(200);
}
}
// Converts row and colum to actual bitmap bit and turn it off/on
void Plot(int col, int row, bool isOn)
{
int zone = col / 8;
int colBitIndex = col % 8;
byte colBit = 1 << colBitIndex;
if (isOn)
bitmap[row][zone] = bitmap[row][zone] | colBit;
else
bitmap[row][zone] = bitmap[row][zone] & (~colBit);
}
// Plot each character of the message one column at a time, updated the display, shift bitmap left.
void AlphabetSoup()
{
char msg[] = "абв ";
// char msg[] = "1 abcdefghijklmnopqrstuvwxyz 2 abcdefghijklmnopqrstuvwxyz 3 abcdefghijklmnopqrstuvwxyz 4 abcdefghijklmnopqrstuvwxyz 5 abcdefghijklmnopqrstuvwxyz 6 abcdefghijklmnopqrstuvwxyz 7 abcdefghijklmnopqrstuvwxyz 8 abcdefghijklmnopqrstuvwxyz 9 abcdefghijklmnopqrstuvwxyz 10 abcdefghijklmnopqrstuvwxyz ";
// char msg[] = {"А "};
for (int charIndex=0; charIndex < (sizeof(msg)-1); charIndex++)
{
int alphabetIndex = msg[charIndex]-32;
// if (alphabetIndex<0) alphabetIndex=0;
Serial.println(alphabetIndex); //************************************************
//-- Draw one character of the message --
// Each character is only 5 columns wide, but I loop two more times to create 2 pixel space betwen characters
for (int col = 0; col < 6; col++)
{
for (int row = 0; row < 8; row++)
{
// Set the pixel to what the alphabet say for columns 0 thru 4, but always leave columns 5 and 6 blank.
bool isOn = 0;
if (col<5) {
isOn = bitRead( alphabets[alphabetIndex][col], 7-row ) == 1;}
Plot( numCols-1, row, isOn); // We ALWAYS draw on the rightmost column, the shift loop below will scroll it leftward.
// Plot( numCols-1, row, !isOn); // отображение символов на залитом фоне
}
//-- The more times you repeat this loop, the slower we would scroll --
for (int refreshCount=0; refreshCount < 10; refreshCount++)
RefreshDisplay();
//-- Shift the bitmap one column to left --
for (int row=0; row<8; row++)
{
for (int zone=0; zone < numZones; zone++)
{
// This right shift would show as a left scroll on display because leftmost column is represented by least significant bit of the byte.
bitmap[row][zone] = bitmap[row][zone] >> 1;
// Roll over lowest bit from the next zone as highest bit of this zone.
if (zone < maxZoneIndex) bitWrite(bitmap[row][zone], 7, bitRead(bitmap[row][zone+1],0));
}
}
}
}
}
//=== L O O P ===
void loop() {
AlphabetSoup();
}
Проблемы заключается в следующем:
1) строка (которая прокомментирована большим количеством ****) должна выдавать порядковый номер символа в ASCII раскладке (для массива alphabets[][5] ). Но при использованиии русских букв выдает два байта. Избавиться от старшего байта никак не получается.
2) так же смущает тот факт, что arduino "видит" раскладку ASCII только до 126 символов. А наличие "русских" и "английских" букв (с учетом регистра), цифр и дополнительных символов, ну никак в 126 не "влезает".
Очень прошу подсказать "как жить дальше" или направить на путь истинный
Насколько я помню два байта занимает код в кодировке unicode. Делайте преобразование таблиц или прописывайте кодовую таблицу напрямую.
Спасибо за отклик.
Извиняюсь за настойчивость, но просьба подсказать как это делается на arduino
char msg[] = "абв "; char заменить на byte русские символы с 128 начинаются чар их просто не поймет. Получите два байта первый надо пропускать второй это и есть искомое. т.е. для "абв" будет 208/176 208/177 208/178 208 пропускаете от второго отнимаете 49 и получите искомые 127,128,129 но это совсем приметивно и без заморочек.
Но это нифига не на всех символах будет работать. Сомтрите UTF-8 таблицу, там от р до я идёт 209/128 например
Стало интересно получилось вот так, такой код преобразует русские символы в нужные вам числа в соответствии с вашим масивом. Но это только с РУССКИМИ символами работает. Для янковских надо код оставить как был.
//byte msg[] = "абвгдежзийклмнопрстуфхцчшщъыьэюя"; byte msg[] = "АБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ"; char offset = 0; for (int charIndex=0; charIndex < (sizeof(msg)-1); charIndex++) { int alphabetIndex = msg[charIndex]; if(alphabetIndex==208) offset=-49; if(alphabetIndex==209) offset=15; charIndex++; alphabetIndex = msg[charIndex]+offset; Serial.println(alphabetIndex); }Вот в общем: это универсальное работает со смешанными строками хоть русские хоть янковские символы хоть все вместе
byte msg[] = "абв abc"; char offset = 0; for (int charIndex=0; charIndex < (sizeof(msg)-1); charIndex++) { int alphabetIndex = msg[charIndex]; if(alphabetIndex==208) { offset=-50; charIndex++; } if(alphabetIndex==209) { offset=14; charIndex++; } if(alphabetIndex<208) offset=-32; alphabetIndex = msg[charIndex]+offset; Serial.println(alphabetIndex); }я делал так. может поможет
//=====================================================Нарисовать букву void drawChar(byte x, byte y, boolean color, unsigned char c) { if((x >= LCD_X) ||(y >= LCD_Y) || ((x + 4) < 0) || ((y + 7) < 0)) return; if(c<128) c = c-32; if(c>=144 && c<=175) c = c-48; if(c>=128 && c<=143) c = c+16; if(c>=176 && c<=191) c = c-48; if(c>191) return; for (byte i=0; i<6; i++ ) { byte line; (i == 5)? line = 0x0 : line = pgm_read_byte(font+(c*5)+i); for (byte j = 0; j<8; j++) { (line & 0x1)? drawPixel(x+i, y+j, color) : drawPixel(x+i, y+j, !color); line >>= 1; } } }для такого массива
static const char font[] PROGMEM = { 0x00, 0x00, 0x00, 0x00, 0x00 , // 0x20 space 0x00, 0x00, 0x5f, 0x00, 0x00 , // 0x21 ! 0x00, 0x07, 0x00, 0x07, 0x00 , // 0x22 " 0x14, 0x7f, 0x14, 0x7f, 0x14 , // 0x23 # 0x24, 0x2a, 0x7f, 0x2a, 0x12 , // 0x24 $ 0x23, 0x13, 0x08, 0x64, 0x62 , // 0x25 % 0x36, 0x49, 0x55, 0x22, 0x50 , // 0x26 & 0x00, 0x05, 0x03, 0x00, 0x00 , // 0x27 ' 0x00, 0x1c, 0x22, 0x41, 0x00 , // 0x28 ( 0x00, 0x41, 0x22, 0x1c, 0x00 , // 0x29 ) 0x14, 0x08, 0x3e, 0x08, 0x14 , // 0x2a * 0x08, 0x08, 0x3e, 0x08, 0x08 , // 0x2b + 0x00, 0x50, 0x30, 0x00, 0x00 , // 0x2c , 0x08, 0x08, 0x08, 0x08, 0x08 , // 0x2d - 0x00, 0x60, 0x60, 0x00, 0x00 , // 0x2e . 0x20, 0x10, 0x08, 0x04, 0x02 , // 0x2f / 0x3e, 0x51, 0x49, 0x45, 0x3e , // 0x30 0 0x00, 0x42, 0x7f, 0x40, 0x00 , // 0x31 1 0x42, 0x61, 0x51, 0x49, 0x46 , // 0x32 2 0x21, 0x41, 0x45, 0x4b, 0x31 , // 0x33 3 0x18, 0x14, 0x12, 0x7f, 0x10 , // 0x34 4 0x27, 0x45, 0x45, 0x45, 0x39 , // 0x35 5 0x3c, 0x4a, 0x49, 0x49, 0x30 , // 0x36 6 0x01, 0x71, 0x09, 0x05, 0x03 , // 0x37 7 0x36, 0x49, 0x49, 0x49, 0x36 , // 0x38 8 0x06, 0x49, 0x49, 0x29, 0x1e , // 0x39 9 0x00, 0x36, 0x36, 0x00, 0x00 , // 0x3a : 0x00, 0x56, 0x36, 0x00, 0x00 , // 0x3b ; 0x08, 0x14, 0x22, 0x41, 0x00 , // 0x3c < 0x14, 0x14, 0x14, 0x14, 0x14 , // 0x3d = 0x00, 0x41, 0x22, 0x14, 0x08 , // 0x3e > 0x02, 0x01, 0x51, 0x09, 0x06 , // 0x3f ? 0x32, 0x49, 0x79, 0x41, 0x3e , // 0x40 @ 0x7e, 0x11, 0x11, 0x11, 0x7e , // 0x41 A 0x7f, 0x49, 0x49, 0x49, 0x36 , // 0x42 B 0x3e, 0x41, 0x41, 0x41, 0x22 , // 0x43 C 0x7f, 0x41, 0x41, 0x22, 0x1c , // 0x44 D 0x7f, 0x49, 0x49, 0x49, 0x41 , // 0x45 E 0x7f, 0x09, 0x09, 0x09, 0x01 , // 0x46 F 0x3e, 0x41, 0x49, 0x49, 0x7a , // 0x47 G 0x7f, 0x08, 0x08, 0x08, 0x7f , // 0x48 H 0x00, 0x41, 0x7f, 0x41, 0x00 , // 0x49 I 0x20, 0x40, 0x41, 0x3f, 0x01 , // 0x4a J 0x7f, 0x08, 0x14, 0x22, 0x41 , // 0x4b K 0x7f, 0x40, 0x40, 0x40, 0x40 , // 0x4c L 0x7f, 0x02, 0x0c, 0x02, 0x7f , // 0x4d M 0x7f, 0x04, 0x08, 0x10, 0x7f , // 0x4e N 0x3e, 0x41, 0x41, 0x41, 0x3e , // 0x4f O 0x7f, 0x09, 0x09, 0x09, 0x06 , // 0x50 P 0x3e, 0x41, 0x51, 0x21, 0x5e , // 0x51 Q 0x7f, 0x09, 0x19, 0x29, 0x46 , // 0x52 R 0x46, 0x49, 0x49, 0x49, 0x31 , // 0x53 S 0x01, 0x01, 0x7f, 0x01, 0x01 , // 0x54 T 0x3f, 0x40, 0x40, 0x40, 0x3f , // 0x55 U 0x1f, 0x20, 0x40, 0x20, 0x1f , // 0x56 V 0x3f, 0x40, 0x38, 0x40, 0x3f , // 0x57 W 0x63, 0x14, 0x08, 0x14, 0x63 , // 0x58 X 0x07, 0x08, 0x70, 0x08, 0x07 , // 0x59 Y 0x61, 0x51, 0x49, 0x45, 0x43 , // 0x5a Z 0x00, 0x7f, 0x41, 0x41, 0x00 , // 0x5b [ 0x02, 0x04, 0x08, 0x10, 0x20 , // 0x5c backslash 0x00, 0x41, 0x41, 0x7f, 0x00 , // 0x5d ] 0x04, 0x02, 0x01, 0x02, 0x04 , // 0x5e ^ 0x40, 0x40, 0x40, 0x40, 0x40 , // 0x5f _ 0x00, 0x01, 0x02, 0x04, 0x00 , // 0x60 ` 0x20, 0x54, 0x54, 0x54, 0x78 , // 0x61 a 0x7f, 0x48, 0x44, 0x44, 0x38 , // 0x62 b 0x38, 0x44, 0x44, 0x44, 0x20 , // 0x63 c 0x38, 0x44, 0x44, 0x48, 0x7f , // 0x64 d 0x38, 0x54, 0x54, 0x54, 0x18 , // 0x65 e 0x08, 0x7e, 0x09, 0x01, 0x02 , // 0x66 f 0x0c, 0x52, 0x52, 0x52, 0x3e , // 0x67 g 0x7f, 0x08, 0x04, 0x04, 0x78 , // 0x68 h 0x00, 0x44, 0x7d, 0x40, 0x00 , // 0x69 i 0x20, 0x40, 0x44, 0x3d, 0x00 , // 0x6a j 0x7f, 0x10, 0x28, 0x44, 0x00 , // 0x6b k 0x00, 0x41, 0x7f, 0x40, 0x00 , // 0x6c l 0x7c, 0x04, 0x18, 0x04, 0x78 , // 0x6d m 0x7c, 0x08, 0x04, 0x04, 0x78 , // 0x6e n 0x38, 0x44, 0x44, 0x44, 0x38 , // 0x6f o 0x7c, 0x14, 0x14, 0x14, 0x08 , // 0x70 p 0x08, 0x14, 0x14, 0x18, 0x7c , // 0x71 q 0x7c, 0x08, 0x04, 0x04, 0x08 , // 0x72 r 0x48, 0x54, 0x54, 0x54, 0x20 , // 0x73 s 0x04, 0x3f, 0x44, 0x40, 0x20 , // 0x74 t 0x3c, 0x40, 0x40, 0x20, 0x7c , // 0x75 u 0x1c, 0x20, 0x40, 0x20, 0x1c , // 0x76 v 0x3c, 0x40, 0x30, 0x40, 0x3c , // 0x77 w 0x44, 0x28, 0x10, 0x28, 0x44 , // 0x78 x 0x0c, 0x50, 0x50, 0x50, 0x3c , // 0x79 y 0x44, 0x64, 0x54, 0x4c, 0x44 , // 0x7a z 0x00, 0x08, 0x36, 0x41, 0x00 , // 0x7b { 0x00, 0x00, 0x7f, 0x00, 0x00 , // 0x7c | 0x00, 0x41, 0x36, 0x08, 0x00 , // 0x7d } 0x10, 0x08, 0x08, 0x10, 0x08 , // 0x7e ~ 0x00, 0x00, 0x00, 0x00, 0x00 , // 0x7f 0x7e, 0x11, 0x11, 0x11, 0x7e , // 0x80 A // Русские символы 0x7f, 0x49, 0x49, 0x49, 0x33 , // 0x81 Б 0x7f, 0x49, 0x49, 0x49, 0x36 , // 0x82 В 0x7f, 0x01, 0x01, 0x01, 0x03 , // 0x83 Г 0xe0, 0x51, 0x4f, 0x41, 0xff , // 0x84 Д 0x7f, 0x49, 0x49, 0x49, 0x41 , // 0x85 E 0x77, 0x08, 0x7f, 0x08, 0x77 , // 0x86 Ж 0x41, 0x49, 0x49, 0x49, 0x36 , // 0x87 З 0x7f, 0x10, 0x08, 0x04, 0x7f , // 0x88 И 0x7c, 0x21, 0x12, 0x09, 0x7c , // 0x89 Й 0x7f, 0x08, 0x14, 0x22, 0x41 , // 0x8A K 0x20, 0x41, 0x3f, 0x01, 0x7f , // 0x8B Л 0x7f, 0x02, 0x0c, 0x02, 0x7f , // 0x8C M 0x7f, 0x08, 0x08, 0x08, 0x7f , // 0x8D H 0x3e, 0x41, 0x41, 0x41, 0x3e , // 0x8E O 0x7f, 0x01, 0x01, 0x01, 0x7f , // 0x8F П 0x7f, 0x09, 0x09, 0x09, 0x06 , // 0x90 P 0x3e, 0x41, 0x41, 0x41, 0x22 , // 0x91 C 0x01, 0x01, 0x7f, 0x01, 0x01 , // 0x92 T 0x47, 0x28, 0x10, 0x08, 0x07 , // 0x93 У 0x1c, 0x22, 0x7f, 0x22, 0x1c , // 0x94 Ф 0x63, 0x14, 0x08, 0x14, 0x63 , // 0x95 X 0x7f, 0x40, 0x40, 0x40, 0xff , // 0x96 Ц 0x07, 0x08, 0x08, 0x08, 0x7f , // 0x97 Ч 0x7f, 0x40, 0x7f, 0x40, 0x7f , // 0x98 Ш 0x7f, 0x40, 0x7f, 0x40, 0xff , // 0x99 Щ 0x01, 0x7f, 0x48, 0x48, 0x30 , // 0x9A Ъ 0x7f, 0x48, 0x30, 0x00, 0x7f , // 0x9B Ы 0x00, 0x7f, 0x48, 0x48, 0x30 , // 0x9C Э 0x22, 0x41, 0x49, 0x49, 0x3e , // 0x9D Ь 0x7f, 0x08, 0x3e, 0x41, 0x3e , // 0x9E Ю 0x46, 0x29, 0x19, 0x09, 0x7f , // 0x9F Я 0x20, 0x54, 0x54, 0x54, 0x78 , // 0xA0 a 0x3c, 0x4a, 0x4a, 0x49, 0x31 , // 0xA1 б 0x7c, 0x54, 0x54, 0x28, 0x00 , // 0xA2 в 0x7c, 0x04, 0x04, 0x04, 0x0c , // 0xA3 г 0xe0, 0x54, 0x4c, 0x44, 0xfc , // 0xA4 д 0x38, 0x54, 0x54, 0x54, 0x18 , // 0xA5 e 0x6c, 0x10, 0x7c, 0x10, 0x6c , // 0xA6 ж 0x44, 0x44, 0x54, 0x54, 0x28 , // 0xA7 з 0x7c, 0x20, 0x10, 0x08, 0x7c , // 0xA8 и 0x7c, 0x41, 0x22, 0x11, 0x7c , // 0xA9 й 0x7c, 0x10, 0x28, 0x44, 0x00 , // 0xAA к 0x20, 0x44, 0x3c, 0x04, 0x7c , // 0xAB л 0x7c, 0x08, 0x10, 0x08, 0x7c , // 0xAC м 0x7c, 0x10, 0x10, 0x10, 0x7c , // 0xAD н 0x38, 0x44, 0x44, 0x44, 0x38 , // 0xAE o 0x7c, 0x04, 0x04, 0x04, 0x7c , // 0xAF п 0x7C, 0x14, 0x14, 0x14, 0x08 , // 0xB0 p 0x38, 0x44, 0x44, 0x44, 0x20 , // 0xB1 c 0x04, 0x04, 0x7c, 0x04, 0x04 , // 0xB2 т 0x0C, 0x50, 0x50, 0x50, 0x3C , // 0xB3 у 0x30, 0x48, 0xfc, 0x48, 0x30 , // 0xB4 ф 0x44, 0x28, 0x10, 0x28, 0x44 , // 0xB5 x 0x7c, 0x40, 0x40, 0x40, 0xfc , // 0xB6 ц 0x0c, 0x10, 0x10, 0x10, 0x7c , // 0xB7 ч 0x7c, 0x40, 0x7c, 0x40, 0x7c , // 0xB8 ш 0x7c, 0x40, 0x7c, 0x40, 0xfc , // 0xB9 щ 0x04, 0x7c, 0x50, 0x50, 0x20 , // 0xBA ъ 0x7c, 0x50, 0x50, 0x20, 0x7c , // 0xBB ы 0x7c, 0x50, 0x50, 0x20, 0x00 , // 0xBC ь 0x28, 0x44, 0x54, 0x54, 0x38 , // 0xBD э 0x7c, 0x10, 0x38, 0x44, 0x38 , // 0xBE ю 0x08, 0x54, 0x34, 0x14, 0x7c , // 0xBF я };Спасибо всем за помощь.
Истина, как всегда была рядом.
Отдельное спасибо Penni. Ваш код с некоторым изменением был опробован в "железе". Все ОК!
Код jeka_tm хорош для LCD дисплеев.
Чуть позже (после командировки) хочу на сайте выложить схему, код и видео работы устройства.
Всем еще раз огромное спасибо за помощь и участие.
Уважаемый, Penni. Все стесняюсь спросить. В какой среде вы программируете?
Уважаемый, Penni. Все стесняюсь спросить. В какой среде вы программируете?
По работе delphi xe7. Вне работы на всё понемногу. В основном тот же делфи и визуал студия с#. Под андроид пишу на эклипсе хотя сейчас начал немного на студию гугловскую перебираться.
Ардуино недавно купил, когда дом начал строить, планирую потом на нём сделать систему мониторинга параметров дома ну и некоторое управление им же. До ардуино собирал всё на атмегах и соответственно использовал CodeVision AVR.
Я имел ввиду: как называется программа, код из которой вы указали ранее. Там нумеруются строки и отделяются цветовыми эффектами
Вот вам файлик, который нужно заменить в папке "lib" и тогда можно выбрать кодировку самого скетча в настройках оболочки.
Файлик для среды 1.0.5.
Если нужен именно юникод, то гдето тут я уже показывал как избавиться от второго байта (где - не помню). Вобщем сложнотей там нет - главное понять что значат эти байты, а потом пара ифов, немного математики и все работает.
Я имел ввиду: как называется программа, код из которой вы указали ранее. Там нумеруются строки и отделяются цветовыми эффектами
Из Arduino IDE копирую, а на форуме когда сообщение пишите сверху есть кнопочки нажимаете {...}code и там вставляете код, он и пронумеруется и подсветится что надо и можно конкретные строки выделить
char msg[] = "абв "; // char msg[] = "1 abcdefghijklmnopqrstuvwxyz 2 abcdefghijklmnopqrstuvwxyz 3 abcdefghijklmnopqrstuvwxyz 4 abcdefghijklmnopqrstuvwxyz 5 abcdefghijklmnopqrstuvwxyz 6 abcdefghijklmnopqrstuvwxyz 7 abcdefghijklmnopqrstuvwxyz 8 abcdefghijklmnopqrstuvwxyz 9 abcdefghijklmnopqrstuvwxyz 10 abcdefghijklmnopqrstuvwxyz "; // char msg[] = {"А "};получилось.
Прошу не считать за флуд
int x; int y; int latchPin1 = 5; //Arduino pin connected to blue 12 RCLK of 74HC595 int clockPin1 = 6; //Arduino pin connected to green 11 SRCLK of 74HC595 int dataPin1 = 7; //Arduino pin connected to violet 14 SER of 74HC595 //-- Rows (Positive Anodes) -- int latchPin2 = 9; //Arduino pin connected to yellow Latch 12 RCLK of 74HC595 int clockPin2 = 10; //Arduino pin connected to white Clock 11 SRCLK of 74HC595 int dataPin2 = 8; //Arduino pin connected to grey Data 14 SER of 74HC595 //=== B I T M A P === //Bits in this array represents one LED of the matrix // 8 is # of rows, 7 is # of LED matrix we have byte bitmap[8][8]; // Change the 7 to however many matrices you want to use. int numZones = sizeof(bitmap) / 16; // I will refer to each group of 8 columns (represented by one matrix) as a Zone. int maxZoneIndex = numZones-1; int numCols = numZones * 8; byte alphabets[][5] = { {0,0,0,0,0}, // ПРОБЕЛ ASCII 32 {0,0,253,0,0}, // ! ASCII 33 {0,96,0,96,0}, // " ASCII 34 {20,127,20,127,20}, // # ASCII 35 {36,42,127,42,18}, // $ ASCII 36 {17,2,4,8,17}, // % ASCII 37 {54,73,85,34,5}, // & ASCII 38 {0,0,104,112,0}, // ' ASCII 39 {28,34,65}, // ( ASCII 40 {65,34,28}, // ) ASCII 41 {20,8,62,8,20}, // * ASCII 42 {8,8,62,8,8}, // + ASCII 43 {0,0,5,6,0}, // , ASCII 44 {8,8,8,8,8}, // - ASCII 45 {0,0,1,0,0}, // . ASCII 46 {1,2,4,8,16}, // / ASCII 47 {62,69,73,81,62}, // 0 ASCII 48 {0,33,127,1,0}, // 1 ASCII 49 {33,67,69,73,49}, // 2 ASCII 50 {66,65,81,105,70}, // 3 ASCII 51 {12,20,36,127,4}, // 4 ASCII 52 {113,81,81,81,78}, // 5 ASCII 53 {30,41,73,73,6}, // 6 ASCII 54 {64,64,79,80,96}, // 7 ASCII 55 {54,73,73,73,54}, // 8 ASCII 56 {48,73,73,74,60}, // 9 ASCII 57 {0,0,54,54,0}, // : ASCII 58 {0,0,53,54,0}, // ; ASCII 59 {0,8,20,34,65}, // < ASCII 60 {20,20,20,20,20}, // = ASCII 61 {0,65,34,20,8}, // > ASCII 62 {32,64,69,72,48}, // ? ASCII 63 {38,73,77,65,62}, // @ ASCII 64 {31,36,68,36,31}, // A ASCII 65 {127,73,73,73,54}, // B ASCII 66 {62,65,65,65,34}, // C ASCII 67 {127,65,65,34,28}, // D ASCII 68 {127,73,73,65,65}, // E ASCII 69 {127,72,72,72,64}, // F ASCII 70 {62,65,65,69,38}, // G ASCII 71 {127,8,8,8,127}, // H ASCII 72 {0,65,127,65,0}, // I ASCII 73 {2,1,1,1,126}, // J ASCII 74 {127,8,20,34,65}, // K ASCII 75 {127,1,1,1,1}, // L ASCII 76 {127,32,16,32,127}, // M ASCII 77 {127,32,16,8,127}, // N ASCII 78 {62,65,65,65,62}, // O ASCII 79 {127,72,72,72,48}, // P ASCII 80 {62,65,69,66,61}, // Q ASCII 81 {127,72,76,74,49}, // R ASCII 82 {50,73,73,73,38}, // S ASCII 83 {64,64,127,64,64}, // T ASCII 84 {126,1,1,1,126}, // U ASCII 85 {124,2,1,2,124}, // V ASCII 86 {126,1,6,1,126}, // W ASCII 87 {99,20,8,20,99}, // X ASCII 88 {96,16,15,16,96}, // Y ASCII 89 {67,69,73,81,97}, // Z ASCII 90 {0,127,65,65,0}, // [ ASCII 91 {0,0,0,0,0}, // \ ASCII 92 {0,65,65,127,0}, // ] ASCII 93 {16,32,64,32,16}, // ^ ASCII 94 {1,1,1,1,1}, // _ ASCII 95 {0,64,32,16,0}, // ` ASCII 96 {2,21,21,21,15}, // a ASCII 97 {127,5,9,9,6}, // b ASCII 98 {14,17,17,17,0}, // c ASCII 99 {6,9,9,5,127}, // d ASCII 100 {14,21,21,21,12}, // e ASCII 101 {8,63,72,64,32}, // f ASCII 102 {24,37,37,37,62}, // g ASCII 103 {127,8,16,16,15}, // h ASCII 104 {0,0,47,0,0}, // i ASCII 105 {2,1,17,94,0}, // j ASCII 106 {127,4,10,17,0}, // k ASCII 107 {0,65,127,1,0}, // l ASCII 108 {31,16,12,16,31}, // m ASCII 109 {31,8,16,16,15}, // n ASCII 110 {14,17,17,17,14}, // o ASCII 111 {31,20,20,20,8}, // p ASCII 112 {8,20,20,12,31}, // q ASCII 113 {31,8,16,16,8}, // r ASCII 114 {9,21,21,21,18}, // s ASCII 115 {16,126,17,1,2}, // t ASCII 116 {30,1,1,2,31}, // u ASCII 117 {28,2,1,2,28}, // v ASCII 118 {30,1,6,1,30}, // w ASCII 119 {17,10,4,10,17}, // x ASCII 120 {24,5,5,5,30}, // y ASCII 121 {17,19,21,25,17}, // z ASCII 122 {0,0,8,54,65}, // { ASCII 123 {0,0,127,0,0}, // | ASCII 124 {65,54,8,0,0}, // } ASCII 125 { 62, 80, 144, 144, 254}, //А 126 { 254, 146, 146, 146, 12}, //Б 127 { 254, 146, 146, 146, 108}, //В { 254, 128, 128, 128, 128}, //Г { 3, 126, 130, 130, 255}, //Д { 254, 146, 146, 146, 130}, //Е { 238, 16, 254, 16, 238}, //Ж { 68, 146, 146, 146, 108}, //З { 254, 4, 8, 16, 254}, //И { 254, 4, 136, 16, 254}, //Й { 254, 16, 40, 68, 130}, //К { 62, 64, 128, 128, 254}, //Л { 254, 64, 32, 64, 254}, //М { 254, 16, 16, 16, 254}, //Н { 124, 130, 130, 130, 124}, //О { 254, 128, 128, 128, 254}, //П { 254, 144, 144, 144, 96}, //Р { 124, 130, 130, 130, 68}, //С { 128, 128, 254, 128, 128}, //Т { 224, 18, 18, 18, 252}, //У { 96, 144, 254, 144, 96}, //Ф { 198, 40, 16, 40, 198}, //Х { 252, 2, 2, 2, 255}, //Ц { 224, 16, 16, 16, 254}, //Ч { 254, 2, 30, 2, 254}, //Ш { 254, 2, 30, 2, 255}, //Щ { 128, 254, 18, 18, 12}, //Ъ { 254, 18, 18, 12, 254}, //Ы { 0, 254, 18, 18, 12}, //Ь { 68, 146, 146, 146, 124}, //Э { 254, 16, 124, 130, 124}, //Ю { 98, 148, 152, 144, 254}, //Я { 4, 42, 42, 42, 30}, //а { 60, 98, 162, 162, 156}, //б { 62, 42, 42, 20, 0}, //в { 62, 32, 32, 32, 32}, //г { 3, 14, 50, 34, 63}, //д { 28, 42, 42, 42, 16}, //е { 62, 8, 62, 8, 62}, //ж ASCII -26 { 20, 34, 42, 42, 20}, //з ASCII -25 { 62, 4, 8, 16, 62}, //и ASCII -24 { 62, 4, 72, 16, 62}, //й ASCII -23 { 62, 8, 8, 20, 34}, //к ASCII -22 { 14, 16, 32, 32, 62}, //л ASCII -21 { 62, 16, 8, 16, 62}, //м ASCII -20 { 62, 8, 8, 8, 62}, //н ASCII -19 { 28, 34, 34, 34, 28}, //о ASCII -18 { 62, 32, 32, 32, 62}, //п ASCII -17 { 63, 34, 34, 34, 28}, //р ASCII -16 { 28, 34, 34, 34, 20}, //с ASCII -15 { 32, 32, 62, 32, 32}, //т ASCII -14 { 57, 5, 5, 5, 62}, //у ASCII -13 { 24, 36, 62, 36, 24}, //ф ASCII -12 { 34, 20, 8, 20, 34}, //х ASCII -11 { 62, 2, 2, 62, 3}, //ц ASCII -10 { 48, 8, 8, 8, 62}, //ч ASCII -9 { 62, 2, 14, 2, 62}, //ш ASCII -8 { 62, 2, 14, 2, 63}, //щ ASCII -7 { 32, 62, 10, 10, 4}, //ъ ASCII -6 { 62, 10, 10, 4, 62}, //ы ASCII -5 { 62, 10, 10, 10, 4}, //ь ASCII -4 { 20, 34, 42, 42, 28}, //э ASCII -3 {62,8,28,34,28}, // ю ASCII -2 {18,42,44,40,62}, // я ASCII -1 }; //=== S E T U P === void setup() { Serial.begin(9600); pinMode(latchPin1, OUTPUT); pinMode(clockPin1, OUTPUT); pinMode(dataPin1, OUTPUT); pinMode(latchPin2, OUTPUT); pinMode(clockPin2, OUTPUT); pinMode(dataPin2, OUTPUT); //-- Clear bitmap -- for (int row = 0; row < 8; row++) { for (int zone = 0; zone <= maxZoneIndex; zone++) { bitmap[row][zone] = 0; } } } //=== F U N C T I O N S === // This routine takes whatever we've setup in the bitmap array and display it on the matrix void RefreshDisplay() { for (int row = 0; row < 8; row++) { int rowbit = 1 << row; digitalWrite(latchPin2, LOW); //Hold latchPin LOW for as long as we're transmitting data shiftOut(dataPin2, clockPin2, MSBFIRST, rowbit); //Transmit data //-- Start sending column bytes -- digitalWrite(latchPin1, LOW); //Hold latchPin LOW for as long as we're transmitting data //-- Shift out to each matrix (zone is 8 columns represented by one matrix) for (int zone = maxZoneIndex; zone >= 0; zone--) { shiftOut(dataPin1, clockPin1, MSBFIRST, bitmap[row][zone]); } //-- Done sending Column bytes, flip both latches at once to eliminate flicker digitalWrite(latchPin1, HIGH); //Return the latch pin high to signal chip that it no longer needs to listen for information digitalWrite(latchPin2, HIGH); //Return the latch pin high to signal chip that it no longer needs to listen for information //-- Wait a little bit to let humans see what we've pushed out onto the matrix -- // delayMicroseconds(200); } } // Converts row and colum to actual bitmap bit and turn it off/on void Plot(int col, int row, bool isOn) { int zone = col / 8; int colBitIndex = col % 8; byte colBit = 1 << colBitIndex; if (isOn) bitmap[row][zone] = bitmap[row][zone] | colBit; else bitmap[row][zone] = bitmap[row][zone] & (~colBit); } // Plot each character of the message one column at a time, updated the display, shift bitmap left. void AlphabetSoup() { byte msg[] = " Форум Arduuino "; char offset = 0; for (int charIndex=0; charIndex < (sizeof(msg)-1); charIndex++) { int alphabetIndex = msg[charIndex]; if(alphabetIndex==208) { offset=-50; charIndex++; } if(alphabetIndex==209) { offset=14; charIndex++; } if(alphabetIndex<208) { offset=-32; } alphabetIndex = msg[charIndex]+offset; //-- Draw one character of the message -- // Each character is only 5 columns wide, but I loop two more times to create 2 pixel space betwen characters for (int col = 0; col < 6; col++) { for (int row = 0; row < 8; row++) { // Set the pixel to what the alphabet say for columns 0 thru 4, but always leave columns 5 and 6 blank. bool isOn = 0; if (col<5) { isOn = bitRead( alphabets[alphabetIndex][col], 7-row ) == 1;} Plot( numCols-1, row, isOn); // We ALWAYS draw on the rightmost column, the shift loop below will scroll it leftward. // Plot( numCols-1, row, !isOn); // отображение символов на залитом фоне } //-- The more times you repeat this loop, the slower we would scroll -- for (int refreshCount=0; refreshCount < 12; refreshCount++) // регулирование скорости движения текста RefreshDisplay(); //-- Shift the bitmap one column to left -- for (int row=0; row<8; row++) { for (int zone=0; zone < numZones; zone++) { // This right shift would show as a left scroll on display because leftmost column is represented by least significant bit of the byte. bitmap[row][zone] = bitmap[row][zone] >> 1; // Roll over lowest bit from the next zone as highest bit of this zone. if (zone < maxZoneIndex) bitWrite(bitmap[row][zone], 7, bitRead(bitmap[row][zone+1],0)); } } } } } //=== L O O P === void loop() { AlphabetSoup(); }Спасибо, проблема разрешилась.
Необходимо было поменять строку под номером 220 на:
for (int zone = 0; zone <= maxZoneIndex; zone++) {
А вы не можете кинуть снимок экрана,как вы подключали все к ардуино
Добрый день!
Кому-нибудь удалось выводить русский текст (кириллицу) на матрицы, управляемые max7219?
мы так сделали:
1. Взяли библиотеку, на которую ссылаются в статье
2. Доделали библиотеку под себя. Архив с библиотекой и примером.
Здравствуйте други!
Немного приподниму тему.
Я тоже ришил сделать бегущую строку.
Исходные данные такие.
Оборудование:
1. Ардуино
2. 10 матриц 8х8
3. Дешифратор CD4028 для управления строками
4. Сдвиговый регистр 74hc595 для управления столбцами 10шт
5. Транзисторная сборка ULN2803 для питания катодов (строк) всех матриц
Задача:
Сделать простую бегущую строку . Пока без каких либо доп возможностей (то есть без часов термометров управления со смартфона итд итп) то есть просто вывод текста, остальное прикручу позже. Сейчас эксперемнтирую пока только с одной матриценй на макетке для отработки схемы и кода.
Программа:
Есть большой двухмерный массив с 110 байтами, в каждом байте 8 бит (весь текст нарисовал сам. Только русский алфавит, заглавные и прописные, цифры и знаки пунктуации)
Дешифратор зажигает поочередно строки сверху в низ, функция ShiftOut выводит стачала позицию массива потом номер конкретного байта, таким образом за 1 проход функции рисуется отдна строчка с конкретным байтом.
Сейчас поочереди перебираются элементы массива. Все нормально светиться без засветок и прочего
Вот собственно теперь пара вопросов.
1. Правильны ли мои суждения? Массив большой и занимает половину места для переменных. В целом нестрашно вроде но видел пример где набор байт был задефайнен (#define) и не занимал места вообще. Это как вариант если придеться дорисовать английский алфавит и что то еще, пока остановился на массиве.
2. Как лучше двигать буквы? Выводить их поочереди можно нескольким путями и про это я подумаю позже. Сечас интересно как сдвигать буквы выводящиеся из массива хотя бы по очереди?. Сдвиг бита в самой функции ShiftOut работает как то однобоко, то есть сдвигает как бы всю картинку. Так что в этом вопросе у меня мозга за мозгу зашла немнога... Может нужно не просто двигать биты, а с помощью цикла for прибавлять нули в кажбый байт поочереди. Вообщем пока даже незнаю как подступиться. Еще раз оговрюсь что сейчас хотябы поняв принцып заставить бегать буквы по одной матрице.
Друзья, нехочу вас утруждать, по этому не нужно писать примеры кода, просто пальцем покажите, то есть сам принцип реализации. Направление в котором двигаться (только не Ленинским курсом пожалуйста =) )
Всем зарание спасибо!
Вот код
// Выводы регистра #define latch 10 //12 ST_CP защелка #define takt 11 //11 SH_CP синхронизация #define data 13 //14 DS данные // Входы дешифратора(CD4028) используем три входа #define outC 3 // Вход C дешифротора #define outB 4 // Вход B дешифротора #define outA 5 // Вход A дешифротора byte r; // Элемент (символ) массива byte s; // Байт для заталкивания в регистр byte letters[111][8] // Двухмерный массив с сивломами (буквами) { // Цифры большие {B00111100, B01111110, B01100110, B01101110, B01110110, B01100110, B01111110, B00111100}, // 0 {B00011000, B00111000, B01111000, B00011000, B00011000, B00011000, B00011000, B00011000}, // 1 {B00111100, B01111110, B01100110, B00000110, B00011100, B00110000, B01111110, B01111110}, // 2 {B00111100, B01111110, B01100110, B00001100, B00001100, B01100110, B01111110, B00111100}, // 3 {B00001100, B00011100, B00111100, B01101100, B01111110, B01111110, B00001100, B00001100}, // 4 {B01111110, B01111110, B01100000, B01111100, B00011110, B01100110, B01111110, B00111100}, // 5 {B00111100, B01111110, B01100110, B01111000, B01111110, B01100110, B01111110, B00111100}, // 6 {B01111110, B01111110, B01100110, B00001100, B00011000, B00011000, B00011000, B00011000}, // 7 {B00111100, B01111110, B01100110, B00111100, B00111100, B01100110, B01111110, B00111100}, // 8 {B00111100, B01111110, B01100110, B00111110, B00011110, B01100110, B01111110, B00111100}, // 9 // Цифры обычные {B00000000, B01111100, B11000110, B11001110, B11010110, B11100110, B11000110, B01111100}, // 0 {B00000000, B00011000, B00111000, B01111000, B00011000, B00011000, B00011000, B01111110}, // 1 {B00000000, B01111100, B11000110, B11000110, B00001100, B00110000, B01100110, B11111110}, // 2 {B00000000, B01111100, B11000110, B00000110, B00111100, B00000110, B11000110, B01111100}, // 3 {B00000000, B00001100, B00011100, B00101100, B01001100, B11001110, B11111110, B00001100}, // 4 {B00000000, B11111110, B11000110, B11000000, B11111110, B00000110, B11000110, B01111100}, // 5 {B00000000, B01111100, B11000110, B11000000, B11111100, B11000110, B11000110, B01111100}, // 6 {B00000000, B11111110, B11000110, B00000110, B00001100, B00001100, B00011000, B00011000}, // 7 {B00000000, B01111100, B11000110, B11000110, B01111100, B11000110, B11000110, B01111100}, // 8 {B00000000, B01111100, B11000110, B11000110, B00111110, B00000110, B11000110, B01111100}, // 9 // Буквы заглавные {B00000000, B00111110, B01000110, B11000110, B11000110, B11111110, B11000110, B11000110}, // А {B00000000, B11111110, B11000110, B11000000, B11111100, B11000110, B11000110, B11111100}, // Б {B00000000, B11111100, B11000110, B11000110, B11111100, B11000110, B11000110, B11111100}, // В {B00000000, B11111110, B11000110, B11000000, B11000000, B11000000, B11000000, B11000000}, // Г {B00000000, B00001110, B00010110, B00100110, B01100110, B01100110, B11111111, B11000011}, // Д {B00000000, B11111110, B11000110, B11000000, B11111000, B11000000, B11000110, B11111110}, // Е {B00101000, B11111110, B11000110, B11000000, B11111000, B11000000, B11000110, B11111110}, // Ё {B00000000, B11010110, B11010110, B01111100, B00111000, B01111100, B11010110, B11010110}, // Ж {B00000000, B01111100, B10000110, B00000110, B00011100, B00000110, B10000110, B01111100}, // З {B00000000, B11000110, B11000110, B11001110, B11011110, B11110110, B11100110, B11000110}, // И {B00010000, B11000110, B11000110, B11001110, B11011110, B11110110, B11100110, B11000110}, // Й {B00000000, B11000110, B11000110, B11001100, B11111000, B11001100, B11000110, B11000110}, // К {B00000000, B00111110, B01100110, B01100110, B01100110, B01100110, B01100110, B11000110}, // Л {B00000000, B11000110, B11000110, B11101110, B11010110, B11000110, B11000110, B11000110}, // М {B00000000, B11000110, B11000110, B11000110, B11111110, B11000110, B11000110, B11000110}, // Н {B00000000, B01111100, B11000110, B11000110, B11000110, B11000110, B11000110, B01111100}, // О {B00000000, B11111110, B11000110, B11000110, B11000110, B11000110, B11000110, B11000110}, // П {B00000000, B11111100, B11000110, B11000110, B11000110, B11111100, B11000000, B11000000}, // Р {B00000000, B01111100, B11000110, B11000000, B11000000, B11000000, B11000110, B01111100}, // С {B00000000, B01111110, B01011010, B00011000, B00011000, B00011000, B00011000, B00011000}, // Т {B00000000, B11000110, B11000110, B11000110, B01111110, B00000110, B11000110, B01111100}, // У {B00000000, B01111100, B11010110, B11010110, B11010110, B11010110, B01111100, B00010000}, // Ф {B00000000, B11000110, B11000110, B01000100, B00111000, B01000100, B11000110, B11000110}, // Х {B00000000, B11000110, B11000110, B11000110, B11000110, B11000110, B11111110, B00000011}, // Ц {B00000000, B11000110, B11000110, B11000110, B11000110, B01111110, B00000110, B00000110}, // Ч {B00000000, B11010110, B11010110, B11010110, B11010110, B11010110, B11010110, B11111110}, // Ш {B00000000, B11010110, B11010110, B11010110, B11010110, B11010110, B11111111, B00000011}, // Щ {B00000000, B11100000, B01100000, B01100000, B01111100, B01100110, B01100110, B01111100}, // Ъ {B00000000, B11000110, B11000110, B11100110, B11010110, B11010110, B11010110, B11100110}, // Ы {B00000000, B01100000, B01100000, B01100000, B01111100, B01100110, B01100110, B01111100}, // Ь {B00000000, B01111100, B11000110, B00000110, B00111110, B00000110, B11000110, B01111100}, // Э {B00000000, B11001110, B11010011, B11010011, B11110011, B11010011, B11010011, B11001110}, // Ю {B00000000, B00111111, B01100011, B01100011, B01100011, B00111111, B00110011, B11100011}, // Я // Буквы малые (приписные) {B00000000, B00000000, B00111000, B01000100, B01000100, B01000100, B00111010, B00000000}, // а {B01111100, B00100000, B00010000, B00111000, B01000100, B01000100, B00111000, B00000000}, // б {B00110000, B01001000, B01001000, B01111000, B01000100, B01000100, B00111000, B00000000}, // в {B00000000, B00000000, B00111000, B00000100, B00111000, B01000000, B00111100, B00000000}, // г {B00000000, B00000000, B00011100, B00100100, B00100100, B01111110, B01000010, B00000000}, // д {B00000000, B00000000, B00111000, B01000100, B01111000, B01000000, B00111000, B00000000}, // е {B00101000, B00000000, B00111000, B01000100, B01111000, B01000000, B00111000, B00000000}, // ё {B00000000, B00000000, B01010100, B01010100, B00111000, B01010100, B01010100, B00000000}, // ж {B00000000, B00000000, B00111000, B01000100, B00001000, B01000100, B00111000, B00000000}, // з {B00000000, B00000000, B01001000, B01001000, B01001000, B01001000, B00110100, B00000000}, // и {B00000000, B00010000, B01001000, B01001000, B01001000, B01001000, B00110100, B00000000}, // й {B00000000, B00000000, B01000100, B01001000, B01110000, B01001000, B01000100, B00000000}, // к {B00000000, B00000000, B00011100, B00100100, B00100100, B00100100, B01000100, B00000000}, // л {B00000000, B00000000, B01000100, B01101100, B01010100, B01000100, B01000100, B00000000}, // м {B00000000, B00000000, B01000100, B01000100, B01111100, B01000100, B01000100, B00000000}, // н {B00000000, B00000000, B00111000, B01000100, B01000100, B01000100, B00111000, B00000000}, // о {B00000000, B00000000, B01111100, B01000100, B01000100, B01000100, B01000100, B00000000}, // п {B00000000, B00000000, B01111000, B01000100, B01000100, B01111000, B01000000, B00000000}, // р {B00000000, B00000000, B00111000, B01000100, B01000000, B01000100, B00111000, B00000000}, // с {B00000000, B00000000, B01111100, B00010000, B00010000, B00010000, B00010000, B00000000}, // т {B00000000, B00000000, B01000100, B01000100, B00111100, B00000100, B01111000, B00000000}, // у {B00000000, B00010000, B00111000, B01010100, B01010100, B00111000, B00010000, B00000000}, // ф {B00000000, B00000000, B01000100, B00101000, B00010000, B00101000, B01000100, B00000000}, // х {B00000000, B00000000, B01001000, B01001000, B01001000, B01001000, B00111100, B00000100}, // ц {B00000000, B00000000, B01000100, B01000100, B01000100, B00111100, B00000100, B00000000}, // ч {B00000000, B00000000, B01010100, B01010100, B01010100, B01010100, B01111100, B00000000}, // ш {B00000000, B00000000, B01010100, B01010100, B01010100, B01010100, B01111110, B00000010}, // щ {B00000000, B00000000, B11000000, B01000000, B01111000, B01000100, B01111000, B00000000}, // ъ {B00000000, B00000000, B01000100, B01000100, B01100100, B01010100, B01100100, B00000000}, // ы {B00000000, B00000000, B01000000, B01000000, B01111000, B01000100, B01111000, B00000000}, // ь {B00000000, B00000000, B00111000, B01000100, B00011100, B01000100, B00111000, B00000000}, // э {B00000000, B00000000, B01001000, B01010100, B01100100, B01010100, B01001000, B00000000}, // ю {B00000000, B00000000, B00111100, B01000100, B00111100, B00010100, B01100100, B00000000}, // я // Знаки и символы {B00011000, B00011000, B00011000, B00011000, B00011000, B00000000, B00011000, B00011000}, // ! {B00111100, B01100110, B01100110, B00001100, B00011000, B00000000, B00011000, B00011000}, // ? {B00000000, B00011000, B00011000, B01111110, B01111110, B00011000, B00011000, B00000000}, // + {B00000000, B00000000, B00000000, B01111110, B01111110, B00000000, B00000000, B00000000}, // - {B00000000, B01111100, B01111100, B00000000, B01111100, B01111100, B00000000, B00000000}, // = {B11100011, B10100110, B11101100, B00011000, B00110111, B01100101, B11000111, B00000000}, // % {B00010000, B01010100, B00111000, B11111110, B00111000, B01010100, B00010000, B00000000}, // * {B11000000, B01100000, B00110000, B00011000, B00001100, B00000110, B00000011, B00000000}, // \ {B00000011, B00000110, B00001100, B00011000, B00110000, B01100000, B11000000, B00000000}, // / {B00001000, B00011000, B00010000, B00010000, B00010000, B00011000, B00001000, B00000000}, // ( {B00010000, B00011000, B00001000, B00001000, B00001000, B00011000, B00010000, B00000000}, // ) {B00000000, B00011100, B00011000, B00011000, B00011000, B00011000, B00011100, B00000000}, // [ {B00000000, B00011100, B00001100, B00001100, B00001100, B00001100, B00011100, B00000000}, // ] {B01100000, B00110000, B00011000, B00001100, B00011000, B00110000, B01100000, B00000000}, // > {B00001100, B00011000, B00110000, B01100000, B00110000, B00011000, B00001100, B00000000}, // < {B00000000, B01001000, B01101100, B00000000, B00000000, B00000000, B00000000, B00000000}, // “ отк кавычки {B00000000, B01101100, B00100100, B00000000, B00000000, B00000000, B00000000, B00000000}, // ” зак кавычки {B00000000, B00011000, B00011000, B00000000, B00000000, B00011000, B00001000, B00010000}, // ; точка с запятой {B00000000, B00011000, B00011000, B00000000, B00000000, B00011000, B00011000, B00000000}, // : двоеточие {B00000000, B00000000, B00000000, B00000000, B00000000, B00011000, B00001000, B00010000}, // , запятая {B00000000, B00000000, B00000000, B00000000, B00000000, B00011000, B00011000, B00000000}, // . точка {B11100000, B10100000, B11101110, B00011011, B00011000, B00011000, B00011011, B00001110}, // Цельсий большой {B00000000, B11000000, B11011100, B00100010, B00100000, B00100010, B00011100, B00000000}, // Цельсий малый {B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B11111111}, // _ Нижн подчерк {B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000}, // Пробел }; void setup() { // Управление регистром pinMode(latch, OUTPUT); pinMode(takt, OUTPUT); pinMode(data, OUTPUT); // Управление дешифратором pinMode(outC, OUTPUT); pinMode(outB, OUTPUT); pinMode(outA, OUTPUT); Serial.begin(9600); } void loop() { // Каждую секунду плюсуем 1 к 'r' static unsigned long prevMillis = 0; if ((millis() - prevMillis) > 1000) { prevMillis = millis(); r = r + 1; if (r > 110) r = 0; } show_Led(r); // Функция вывода Print(); // Для проверки переменных, на это можно не обращать внимания } void Print() { static unsigned long prevMillis; if ((millis() - prevMillis) > 1000) { prevMillis = millis(); Serial.println(r); } } void show_Led(byte r) { // Скаждым прохожом плюсуем 1 к 's' если > 7 то 's' опять = 0 s = s + 1; if (s > 7) s = 0; switch (s) // Управляем катодами матрицы (строками) через дешифротор { // Выставляем 3 бита на входе дешифратора case 0: // 000 -> выход 0 HIGH digitalWrite(outC, LOW); digitalWrite(outB, LOW); digitalWrite(outA, LOW); break; case 1: // 001 -> выход 1 HIGH digitalWrite(outC, LOW); digitalWrite(outB, LOW); digitalWrite(outA, HIGH); break; case 2: // 010 -> выход 2 HIGH digitalWrite(outC, LOW); digitalWrite(outB, HIGH); digitalWrite(outA, LOW); break; case 3: // 011 -> выход 3 HIGH digitalWrite(outC, LOW); digitalWrite(outB, HIGH); digitalWrite(outA, HIGH); break; case 4: // 100 -> выход 4 HIGH digitalWrite(outC, HIGH); digitalWrite(outB, LOW); digitalWrite(outA, LOW); break; case 5: // 101 -> выход 5 HIGH digitalWrite(outC, HIGH); digitalWrite(outB, LOW); digitalWrite(outA, HIGH); break; case 6: // 110 -> выход 6 HIGH digitalWrite(outC, HIGH); digitalWrite(outB, HIGH); digitalWrite(outA, LOW); break; case 7: // 111 -> выход 7 HIGH digitalWrite(outC, HIGH); digitalWrite(outB, HIGH); digitalWrite(outA, HIGH); break; } // Аноды (столбцы) работаем с регистром digitalWrite(latch, LOW); // Открываем защелку. // Заталкиваем байт в регистр, 'r' плюсуется от 0 до 110 каждую секунду // 's' плюсуется от 0 до 7 с каждыи проходом этой функции shiftOut(data, takt, LSBFIRST, letters[r][s]); digitalWrite(latch, HIGH); // Защелкиваем регистр delay(3); }Вот видео работы матрицы.
https://www.youtube.com/watch?v=MRSBLdgGbI4