И снова про бегущую строку на светодиодных матрицах (для новичков)
- Войдите на сайт для отправки комментариев
Чт, 22/09/2016 - 00:01
Доброе время суток!
Сам я не программист, но может кто подскажет что может ... )))
В общем, ситуация стандартная: захотелось мне ардуину уну помучить, заодно купил блок из 4-х светодиодных матриц 8х8, которые уже соединены друг с другом. То бишь, не сверху вытыкается, а снизу втыкается в макетку, а сбоку продолжается на другую матрицу... Под каждой матрицей, как вы знаете, установлены чипы MAX7219. Полазил по ссылкам - дельной информации оказалось немного. Мне же просто бегущая строка нужна, а нафига - и сам не знаю ) чтоб было ). Ну и надо когда-то начинать осваивать микроконтроллеры. Самым продуктивным в этом плане оказался данный скотч (или как там его...) ... а почему "вставка кода" его вставляет просто как текст? ... тогда в самом конце вставлю. Он уже в исправленном виде. Но всё было не так просто, отчего возникли вопросы.
Сначала там было не const unsigned char ХХХХХ[] PROGMEM, а prog_char PROGMEM ХХХХХ[]
Соответственно, компилятор ругался жуткими английскими словами. И это же я находил и в других скотчах (или как там их ...). В других случаях проблема решилась так: const PROGMEM char ХХХХХ[], а здесь и так не получилось. Вот и непонятно, почему у других prog_char работает, а у меня нет. По какому принципу эти чары обзываются?
Ну и после суточного просмотра прыгающей лисы захотелось также булочек и чаю, в смысле - кириллицы. Как обычно. На этой почве переименовал font5x7 в font5x7e с мыслью нарисовать аналогичный массив font5x7r. И потом их как-то переключать, в зависимости от текста (не знаю как). Попутно прочитал всякие страшные вещи: что другая кодировка в этот самый чар не влезет и уже нужна переменная byte. Но если в этом байте старший байт будет отвечать за кириллицу, а младший - за латиницу, то может и двух массивов не надо? А? Что посоветуете?
====================================================================
// based on an orginal sketch by Arduino forum member "danigom"
// http://forum.arduino.cc/index.php?action=profile;u=188950
#include <avr/pgmspace.h>
#include <LedControl.h>
const int numDevices = 4; // number of MAX7219s used
const long scrollDelay = 75; // adjust scrolling speed
unsigned long bufferLong [14] = {0};
LedControl lc=LedControl(8,10,9,numDevices); // DIN, CLK, CS - поменял номера выводов - там были 12,11,10, а у меня так
const unsigned char scrollText[] PROGMEM = {
" THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG 1234567890 the quick brown fox jumps over the lazy dog "};
void setup(){
for (int x=0; x<numDevices; x++){
lc.shutdown(x,false); //The MAX72XX is in power-saving mode on startup
lc.setIntensity(x,8); // Set the brightness to default value
lc.clearDisplay(x); // and clear the display
}
}
void loop(){
scrollMessage(scrollText);
// scrollFont(); // если не закомментировано, то выводит весь шрифт после текста, причём замедленно
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const unsigned char font5x7e[] PROGMEM = { //Numeric Font Matrix (Arranged as 7x font data + 1x kerning data)
B00000000, //Space (Char 0x20)
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
6,
B10000000, //!
B10000000,
B10000000,
B10000000,
B00000000,
B00000000,
B10000000,
2,
B10100000, //"
B10100000,
B10100000,
B00000000,
B00000000,
B00000000,
B00000000,
4,
B01010000, //#
B01010000,
B11111000,
B01010000,
B11111000,
B01010000,
B01010000,
6,
B00100000, //$
B01111000,
B10100000,
B01110000,
B00101000,
B11110000,
B00100000,
6,
B11000000, //%
B11001000,
B00010000,
B00100000,
B01000000,
B10011000,
B00011000,
6,
B01100000, //&
B10010000,
B10100000,
B01000000,
B10101000,
B10010000,
B01101000,
6,
B11000000, //'
B01000000,
B10000000,
B00000000,
B00000000,
B00000000,
B00000000,
3,
B00100000, //(
B01000000,
B10000000,
B10000000,
B10000000,
B01000000,
B00100000,
4,
B10000000, //)
B01000000,
B00100000,
B00100000,
B00100000,
B01000000,
B10000000,
4,
B00000000, //*
B00100000,
B10101000,
B01110000,
B10101000,
B00100000,
B00000000,
6,
B00000000, //+
B00100000,
B00100000,
B11111000,
B00100000,
B00100000,
B00000000,
6,
B00000000, //,
B00000000,
B00000000,
B00000000,
B11000000,
B01000000,
B10000000,
3,
B00000000, //-
B00000000,
B11111000,
B00000000,
B00000000,
B00000000,
B00000000,
6,
B00000000, //.
B00000000,
B00000000,
B00000000,
B00000000,
B11000000,
B11000000,
3,
B00000000, ///
B00001000,
B00010000,
B00100000,
B01000000,
B10000000,
B00000000,
6,
B01110000, //0
B10001000,
B10011000,
B10101000,
B11001000,
B10001000,
B01110000,
6,
B01000000, //1
B11000000,
B01000000,
B01000000,
B01000000,
B01000000,
B11100000,
4,
B01110000, //2
B10001000,
B00001000,
B00010000,
B00100000,
B01000000,
B11111000,
6,
B11111000, //3
B00010000,
B00100000,
B00010000,
B00001000,
B10001000,
B01110000,
6,
B00010000, //4
B00110000,
B01010000,
B10010000,
B11111000,
B00010000,
B00010000,
6,
B11111000, //5
B10000000,
B11110000,
B00001000,
B00001000,
B10001000,
B01110000,
6,
B00110000, //6
B01000000,
B10000000,
B11110000,
B10001000,
B10001000,
B01110000,
6,
B11111000, //7
B10001000,
B00001000,
B00010000,
B00100000,
B00100000,
B00100000,
6,
B01110000, //8
B10001000,
B10001000,
B01110000,
B10001000,
B10001000,
B01110000,
6,
B01110000, //9
B10001000,
B10001000,
B01111000,
B00001000,
B00010000,
B01100000,
6,
B00000000, //:
B11000000,
B11000000,
B00000000,
B11000000,
B11000000,
B00000000,
3,
B00000000, //;
B11000000,
B11000000,
B00000000,
B11000000,
B01000000,
B10000000,
3,
B00010000, //<
B00100000,
B01000000,
B10000000,
B01000000,
B00100000,
B00010000,
5,
B00000000, //=
B00000000,
B11111000,
B00000000,
B11111000,
B00000000,
B00000000,
6,
B10000000, //>
B01000000,
B00100000,
B00010000,
B00100000,
B01000000,
B10000000,
5,
B01110000, //?
B10001000,
B00001000,
B00010000,
B00100000,
B00000000,
B00100000,
6,
B01110000, //@
B10001000,
B00001000,
B01101000,
B10101000,
B10101000,
B01110000,
6,
B01110000, //A
B10001000,
B10001000,
B10001000,
B11111000,
B10001000,
B10001000,
6,
B11110000, //B
B10001000,
B10001000,
B11110000,
B10001000,
B10001000,
B11110000,
6,
B01110000, //C
B10001000,
B10000000,
B10000000,
B10000000,
B10001000,
B01110000,
6,
B11100000, //D
B10010000,
B10001000,
B10001000,
B10001000,
B10010000,
B11100000,
6,
B11111000, //E
B10000000,
B10000000,
B11110000,
B10000000,
B10000000,
B11111000,
6,
B11111000, //F
B10000000,
B10000000,
B11110000,
B10000000,
B10000000,
B10000000,
6,
B01110000, //G
B10001000,
B10000000,
B10111000,
B10001000,
B10001000,
B01111000,
6,
B10001000, //H
B10001000,
B10001000,
B11111000,
B10001000,
B10001000,
B10001000,
6,
B11100000, //I
B01000000,
B01000000,
B01000000,
B01000000,
B01000000,
B11100000,
4,
B00111000, //J
B00010000,
B00010000,
B00010000,
B00010000,
B10010000,
B01100000,
6,
B10001000, //K
B10010000,
B10100000,
B11000000,
B10100000,
B10010000,
B10001000,
6,
B10000000, //L
B10000000,
B10000000,
B10000000,
B10000000,
B10000000,
B11111000,
6,
B10001000, //M
B11011000,
B10101000,
B10101000,
B10001000,
B10001000,
B10001000,
6,
B10001000, //N
B10001000,
B11001000,
B10101000,
B10011000,
B10001000,
B10001000,
6,
B01110000, //O
B10001000,
B10001000,
B10001000,
B10001000,
B10001000,
B01110000,
6,
B11110000, //P
B10001000,
B10001000,
B11110000,
B10000000,
B10000000,
B10000000,
6,
B01110000, //Q
B10001000,
B10001000,
B10001000,
B10101000,
B10010000,
B01101000,
6,
B11110000, //R
B10001000,
B10001000,
B11110000,
B10100000,
B10010000,
B10001000,
6,
B01111000, //S
B10000000,
B10000000,
B01110000,
B00001000,
B00001000,
B11110000,
6,
B11111000, //T
B00100000,
B00100000,
B00100000,
B00100000,
B00100000,
B00100000,
6,
B10001000, //U
B10001000,
B10001000,
B10001000,
B10001000,
B10001000,
B01110000,
6,
B10001000, //V
B10001000,
B10001000,
B10001000,
B10001000,
B01010000,
B00100000,
6,
B10001000, //W
B10001000,
B10001000,
B10101000,
B10101000,
B10101000,
B01010000,
6,
B10001000, //X
B10001000,
B01010000,
B00100000,
B01010000,
B10001000,
B10001000,
6,
B10001000, //Y
B10001000,
B10001000,
B01010000,
B00100000,
B00100000,
B00100000,
6,
B11111000, //Z
B00001000,
B00010000,
B00100000,
B01000000,
B10000000,
B11111000,
6,
B11100000, //[
B10000000,
B10000000,
B10000000,
B10000000,
B10000000,
B11100000,
4,
B00000000, //(Backward Slash)
B10000000,
B01000000,
B00100000,
B00010000,
B00001000,
B00000000,
6,
B11100000, //]
B00100000,
B00100000,
B00100000,
B00100000,
B00100000,
B11100000,
4,
B00100000, //^
B01010000,
B10001000,
B00000000,
B00000000,
B00000000,
B00000000,
6,
B00000000, //_
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B11111000,
6,
B10000000, //`
B01000000,
B00100000,
B00000000,
B00000000,
B00000000,
B00000000,
4,
B00000000, //a
B00000000,
B01110000,
B00001000,
B01111000,
B10001000,
B01111000,
6,
B10000000, //b
B10000000,
B10110000,
B11001000,
B10001000,
B10001000,
B11110000,
6,
B00000000, //c
B00000000,
B01110000,
B10001000,
B10000000,
B10001000,
B01110000,
6,
B00001000, //d
B00001000,
B01101000,
B10011000,
B10001000,
B10001000,
B01111000,
6,
B00000000, //e
B00000000,
B01110000,
B10001000,
B11111000,
B10000000,
B01110000,
6,
B00110000, //f
B01001000,
B01000000,
B11100000,
B01000000,
B01000000,
B01000000,
6,
B00000000, //g
B01111000,
B10001000,
B10001000,
B01111000,
B00001000,
B01110000,
6,
B10000000, //h
B10000000,
B10110000,
B11001000,
B10001000,
B10001000,
B10001000,
6,
B01000000, //i
B00000000,
B11000000,
B01000000,
B01000000,
B01000000,
B11100000,
4,
B00010000, //j
B00000000,
B00110000,
B00010000,
B00010000,
B10010000,
B01100000,
5,
B10000000, //k
B10000000,
B10010000,
B10100000,
B11000000,
B10100000,
B10010000,
5,
B11000000, //l
B01000000,
B01000000,
B01000000,
B01000000,
B01000000,
B11100000,
4,
B00000000, //m
B00000000,
B11010000,
B10101000,
B10101000,
B10001000,
B10001000,
6,
B00000000, //n
B00000000,
B10110000,
B11001000,
B10001000,
B10001000,
B10001000,
6,
B00000000, //o
B00000000,
B01110000,
B10001000,
B10001000,
B10001000,
B01110000,
6,
B00000000, //p
B00000000,
B11110000,
B10001000,
B11110000,
B10000000,
B10000000,
6,
B00000000, //q
B00000000,
B01101000,
B10011000,
B01111000,
B00001000,
B00001000,
6,
B00000000, //r
B00000000,
B10110000,
B11001000,
B10000000,
B10000000,
B10000000,
6,
B00000000, //s
B00000000,
B01110000,
B10000000,
B01110000,
B00001000,
B11110000,
6,
B01000000, //t
B01000000,
B11100000,
B01000000,
B01000000,
B01001000,
B00110000,
6,
B00000000, //u
B00000000,
B10001000,
B10001000,
B10001000,
B10011000,
B01101000,
6,
B00000000, //v
B00000000,
B10001000,
B10001000,
B10001000,
B01010000,
B00100000,
6,
B00000000, //w
B00000000,
B10001000,
B10101000,
B10101000,
B10101000,
B01010000,
6,
B00000000, //x
B00000000,
B10001000,
B01010000,
B00100000,
B01010000,
B10001000,
6,
B00000000, //y
B00000000,
B10001000,
B10001000,
B01111000,
B00001000,
B01110000,
6,
B00000000, //z
B00000000,
B11111000,
B00010000,
B00100000,
B01000000,
B11111000,
6,
B00100000, //{
B01000000,
B01000000,
B10000000,
B01000000,
B01000000,
B00100000,
4,
B10000000, //|
B10000000,
B10000000,
B10000000,
B10000000,
B10000000,
B10000000,
2,
B10000000, //}
B01000000,
B01000000,
B00100000,
B01000000,
B01000000,
B10000000,
4,
B00000000, //~
B00000000,
B00000000,
B01101000,
B10010000,
B00000000,
B00000000,
6,
B01100000, // (Char 0x7F)
B10010000,
B10010000,
B01100000,
B00000000,
B00000000,
B00000000,
5
};
void scrollFont() {
for (int counter=0x20;counter<0x80;counter++){
loadBufferLong(counter);
delay(500);
}
}
// Scroll Message
void scrollMessage(const unsigned char * messageString) {
int counter = 0;
int myChar=0;
do {
// read back a char
myChar = pgm_read_byte_near(messageString + counter);
if (myChar != 0){
loadBufferLong(myChar);
}
counter++;
}
while (myChar != 0);
}
// Load character into scroll buffer
void loadBufferLong(int ascii){
if (ascii >= 0x20 && ascii <=0x7f){
for (int a=0;a<7;a++){ // Loop 7 times for a 5x7 font
unsigned long c = pgm_read_byte_near(font5x7e + ((ascii - 0x20) * 8) + a); // Index into character table to get row data
unsigned long x = bufferLong [a*2]; // Load current scroll buffer
x = x | c; // OR the new character onto end of current
bufferLong [a*2] = x; // Store in buffer
}
byte count = pgm_read_byte_near(font5x7e +((ascii - 0x20) * 8) + 7); // Index into character table for kerning data
for (byte x=0; x<count;x++){
rotateBufferLong();
printBufferLong();
delay(scrollDelay);
}
}
}
// Rotate the buffer
void rotateBufferLong(){
for (int a=0;a<7;a++){ // Loop 7 times for a 5x7 font
unsigned long x = bufferLong [a*2]; // Get low buffer entry
byte b = bitRead(x,31); // Copy high order bit that gets lost in rotation
x = x<<1; // Rotate left one bit
bufferLong [a*2] = x; // Store new low buffer
x = bufferLong [a*2+1]; // Get high buffer entry
x = x<<1; // Rotate left one bit
bitWrite(x,0,b); // Store saved bit
bufferLong [a*2+1] = x; // Store new high buffer
}
}
// Display Buffer on LED matrix
void printBufferLong(){
for (int a=0;a<7;a++){ // Loop 7 times for a 5x7 font
unsigned long x = bufferLong [a*2+1]; // Get high buffer entry
byte y = x; // Mask off first character
lc.setRow(3,a,y); // Send row to relevent MAX7219 chip
x = bufferLong [a*2]; // Get low buffer entry
y = (x>>24); // Mask off second character
lc.setRow(2,a,y); // Send row to relevent MAX7219 chip
y = (x>>16); // Mask off third character
lc.setRow(1,a,y); // Send row to relevent MAX7219 chip
y = (x>>8); // Mask off forth character
lc.setRow(0,a,y); // Send row to relevent MAX7219 chip
}
}
купил блок из 4-х светодиодных матриц 8х8, которые уже соединены друг с другом. То бишь, не сверху вытыкается, а снизу втыкается в макетку, а сбоку продолжается на другую матрицу... Под каждой матрицей, как вы знаете
Не знаем. Матриц этих вагон и маленькая тележка разных. Вы впредь указывайте конкретно какую именно.
нужна переменная byte. Но если в этом байте старший байт будет отвечать за кириллицу, а младший - за латиницу,
Перечитайте сами внимательно. Вас тут ничего не смущает? Вы не задумывались как это "в байте" есть старший байт и младший? Как они в один байт помещаются?
Что посоветуете?
Не лазать по ссылкам, а начать с прочтения какой-нидудь серьёзной книжки по программированию. Вот такой, например.
Библиотека для панели: https://github.com/markruys/arduino-Max72xxPanel
Руссификация здесь: http://arduino.ru/forum/programmirovanie/rusifikatsiya-biblioteki-adafru...
Тут при цитировании всё ранее написанное теряется?
Ну, на 7219, наверное, и на тележку не наберётся ... вот та, которая "сверху вытыкается, а снизу втыкается":
http://2150692.ru/faq/114-led-matrix-8x8
а купил я такую:
https://ru.aliexpress.com/item/MAX7219-Dot-Matrix-Module-For-Arduino-Mic...
тут уже сбоку втыкается-вытыкается, т.е. матрицы повёрнуты на 90 град.
byte - это вроде как тип переменной, как я понял, более вместительной, т.е. в неё помещаются уже 2 байта, потому что для кириллицы 1 байта не хватит ... неправильно понял? Но если туда поместятся 2 байта, то может туда же можно и латиницу загнать ... тоже неправильно понял?
Библиотека для панели: https://github.com/markruys/arduino-Max72xxPanel
Руссификация здесь: http://arduino.ru/forum/programmirovanie/rusifikatsiya-biblioteki-adafruit-gfx-i-vyvod-russkikh-bukv-na-displei-v-kodi
У вас там ЖК дисплей, а у меня светодиодная матрица с библиотекой LedControl. Пока хочется доделать то, что есть, а ЖК уже может быть потом, по мере развития.
byte - это вроде как тип переменной, как я понял, более вместительной, т.е. в неё помещаются уже 2 байта, потому что для кириллицы 1 байта не хватит ... неправильно понял? Но если туда поместятся 2 байта, то может туда же можно и латиницу загнать ... тоже неправильно понял?
:))) Как в один байт могут поместиться два байта знают только бармены, которые напитки по стопарям разливают. Вы не бармен случаем? :)))
Я виже мой совет про книжку проигнорирован? ну, .... Вам жить.
Дописывал ответ, получил "доступ запрещён" и текст потерялся ... весело тут у вас ...
За ссылку спасибо, почитаю, но пока я больше электронщик (ответ на ваш вопрос) и там язык С, а тут, опять же, как я понимаю, С++. Хотя приверженность к истокам я тоже понимаю, самому как-то пришлось по работе сочинить программку на VB для Экселя и по-наивности полез хелп читать ... во-от, как говорит Задорнов ... лирику опускаю, а в итоге пришлось включать макрос на запись логов, потом в этих логах копаться и выяснять как оно на самом деле пишется ... Отсюда, кстати, и мой первый вопрос: почему prog_char у других нормально воспринимается, а у меня нет?
Собственно, спрашивал про переменные, а бармены не знают, как, к примеру, в переменную "двойной точности" может поместиться больше битов.
Библиотека для панели: https://github.com/markruys/arduino-Max72xxPanel
Руссификация здесь: http://arduino.ru/forum/programmirovanie/rusifikatsiya-biblioteki-adafru...
Или Вы имели в виду, что можно Вашим способом перекодировать из UTF-8 в Windows 1251 и написать ещё один массив для русских букв?
А может мне не надо 1251? Я тут чё подумал ... (так бывает) ... если я просто продолжу существующий массив символов русскими буквами ... Сейчас там 96 латинских букв и других символов (от 0020 до 007F), а я допишу ещё 64 русских буквы ... Тут весь вопрос в том, как их ардуина понимает.
Согласно этой клинописи:
http://unicode-table.com/ru/#greek-coptic
получается, что если я в тексте напишу букву Ж(о), то компилятор её воспримет как код 0416? И мне останется только вычесть из этого кода 57 раз по 16 (если ничего не напутал), чтобы продолжить существующий массив (знакогенератор)?
А, вот ещё такую фигню нашёл (а говорят, что по ссылкам лазить не надо ) ):
http://i.voenmeh.ru/kafi5/Kam.loc/inform/UTF-8.htm
Вы можете подтвердить правильность этой кодировки? Тогда буду продолжать знакогенератор. Просто понаставлю тут других if'ов:
if (ascii >= 0x20 && ascii <=0x7f){ for (int a=0;a<7;a++){ // Loop 7 times for a 5x7 font unsigned long c = pgm_read_byte_near(font5x7e + ((ascii - 0x20) * 8) + a); // Index into character table to get row data unsigned long x = bufferLong [a*2]; // Load current scroll buffer x = x | c; // OR the new character onto end of current bufferLong [a*2] = x; // Store in buffer } byte count = pgm_read_byte_near(font5x7e +((ascii - 0x20) * 8) + 7); // Index into character table for kerning data for (byte x=0; x<count;x++){ rotateBufferLong(); printBufferLong(); delay(scrollDelay); } }А как компилятор воспринимает цифры и прочие скобки с двоеточиями в русской раскладке?
А может мне не надо 1251? Я тут чё подумал ... (так бывает) ... если я просто продолжу существующий массив символов русскими буквами ... Сейчас там 96 латинских букв и других символов (от 0020 до 007F), а я допишу ещё 64 русских буквы ...
Я в своей библиотечке (правда для другой железки) так и сделал. Если интеоесно, http://arduino.ru/forum/programmirovanie/kirillitsa-na-displee-ili-chto-...
получается, что если я в тексте напишу букву Ж(о), то компилятор её воспримет как код 0416?
Нет.
0416 - это в UTF-16, а в Arduino IDE используется UTF-8, там код другой.
А как компилятор воспринимает цифры и прочие скобки с двоеточиями в русской раскладке?
Раскладка клавиатуры - проблема исключительно ОС. Да и нас она особо волновать не должна. Для нас важна кодировка. ОС же вне зависимости от раскладки для цифр, знаков препинания и т.п. использует стандартные коды, которые, кстати, от кодировки тоже не зависят.
получается, что если я в тексте напишу букву Ж(о), то компилятор её воспримет как код 0416?
Нет.
0416 - это в UTF-16, а в Arduino IDE используется UTF-8, там код другой.
А как компилятор воспринимает цифры и прочие скобки с двоеточиями в русской раскладке?
Раскладка клавиатуры - проблема исключительно ОС. Да и нас она особо волновать не должна. Для нас важна кодировка. ОС же вне зависимости от раскладки для цифр, знаков препинания и т.п. использует стандартные коды, которые, кстати, от кодировки тоже не зависят.
Ну я про это и спрашиваю - как Ардуина это воспринимает. UTF-8 - такая? Хочется, чтобы кто-то из знающих подтвердил.
http://i.voenmeh.ru/kafi5/Kam.loc/inform/UTF-8.htm
И про раскладку вопрос тоже в смысле кодировки. Если я печатаю цифры-скобки-двоеточия с английской раскладкой, а потом их же - с русской раскладкой, то коды у них будут одинаковые даже если клавиши разные?
Библиотека для панели: https://github.com/markruys/arduino-Max72xxPanel
Руссификация здесь: http://arduino.ru/forum/programmirovanie/rusifikatsiya-biblioteki-adafru...
Или Вы имели в виду, что можно Вашим способом перекодировать из UTF-8 в Windows 1251 и написать ещё один массив для русских букв?
Библиотека позволяет выводить на панель с чипом MAX7219 буквы. А так как библиотека при работе использует другую библиотеку Adafruit-GFX, то при руссификации последней мы получаем русские буквы на панели и заодно на всех дисплеях, библиотеки которых ипользуют Adafruit-GFX.
Про UTF-8 можно почитать в Википедии: https://ru.wikipedia.org/wiki/UTF-8
Это я видел, там они описывают какие возникают "сомнения" - большие или не очень, а мне сейчас интересна конечная таблица символов. По ссылке она правильная? Я пока начинаю с малого - есть скетч, в котором я что-то понимаю, хотя и не до конца (типа того же prog_char). Тут я сам вижу знакогенератор и могу его дополнить. А если он где-то в другой библотеке, да ещё непонятно (для меня) как исправленной, то я смогу всё это только как-то соединить и то с чужой помощью. А мне хочется поучаствовать в процессе. Знакогенератор отдельно от типовой библиотеки LedControl - это хуже, чем переделанные библиотеки? А если это не кириллица, а какая-нибудь "грузиница"? Ну ладно, это лирика, а свой скетч я всё-таки хочу доделать. Я ведь не какое-то изделие сооружаю, а просто учусь на примере. Некоторые вообще светодиодами мигают ... А потом, по мере роста, приду и к более масштабным проектам.
Так какие будут коды у двоеточий - у всех одинаковые?
Ну я про это и спрашиваю - как Ардуина это воспринимает. UTF-8 - такая? Хочется, чтобы кто-то из знающих подтвердил.
http://i.voenmeh.ru/kafi5/Kam.loc/inform/UTF-8.htm
1. Ардуине это глубоко фиолетово. Воспринимать в любом случае будет человек. И что этот человек увидит - буквы или кракозябры, зависит от программиста, а не от Ардуины. Правда, разработчики как могли поднапакостили пользователям кириллицы - в IDE и в консоли используются разные кодировки. Хотя, конечно, это можно перенастроить самому. Но я предпочел написать библиотеку, отображающую текс в UTF-8, а не перенастраивать IDE. Второе было бы проще, но теряется совместимость с остальными ардуинщиками, а мне этого не хотелось.
2. На вид кодировка похожа. Посимвольно не сравнивал - лень. Только, должен заметить, там не вся кириллица. Я, когда делал поддержку кириллицы, позаботился, чтобы она была полностью - включая буквы украинского, белорусского, македонского, болгарского и т.д. алфавитов. Кстати, можно скачать мою библиотеку и посмотреть. Заодно там находится фонт 6х8 со всеми нужными буквами и еще несколькими полезными значками.
И про раскладку вопрос тоже в смысле кодировки. Если я печатаю цифры-скобки-двоеточия с английской раскладкой, а потом их же - с русской раскладкой, то коды у них будут одинаковые даже если клавиши разные?
Коды одинаковые. От клавиш это никак не зависит.
Не, болгарскую не хочу - они в нато вступают, от газа отказались и вообще ... ) А про фиолетовость ардуины - всё же от неё тоже зависит - вот UTF-8 вместо 16, например. Соответственно, программист должен ориентироваться на эту ардуину и её пакости. А в консоли - это то, что видно на мониторе ком-порта? Я этим ещё не занимался, но уже хотел, чтобы проверить таблицу символов. Можно поподробнее? а то не хочется напечатать А, а увидеть бе-бе-бе ) Сейчас я на той стадии, где хочется понять, что нужно вычесть из переменной char чтобы получить номер символа в массиве. Т.е. пишем символ в тексте - получаем конкретное число и как-то его обрабатываем (это уже дело техники).
В первых строчках скетча ссылка на первоисточник, который уже многими переделан, как, например, в конце этой ветки:
http://arduino.ru/forum/programmirovanie/led-matritsa-max7219-maxmatrixl...
тоже нашли одну из переделок и говорят, что она русифицирована ... А тут должно получиться что-то реально русифицированное и для новичков это будет полезнее первоисточника. А потом пойдём дальше. Например, символы по 7 пикселей в высоту, а хочется по 8 ... В знакогенераторе 8-й элемент обозначает ширину символа - так может сделать массив двумерным и засунуть этот элемент во второй столбец? Но это уже потом )
http://www.youtube.com/watch?v=LNCTVBVhw4s
http://www.youtube.com/watch?v=LNCTVBVhw4s
Ну, у меня так же бежит. Библиотеки сами по себе интересные, ещё интереснее ссылка на этот сайт:
http://arduinocode.codeplex.com/releases
и ... там тоже буквы по 7 точек в высоту, а не по 8 - почему? (в книжках по С это не написано ) )
Вот у человека руки дрожат после вчерашнего - он и то символы на всю панель нарисовал:
www.crossroadsfencing.com/BobuinoRev17/Scroll_Test.AVI
(отвечают автору библиотеки - http://forum.arduino.cc/index.php?topic=165747.0)
По каждой библиотеке куча споров. И самих библиотек куча - у меня уже 6 штук (LedControl, MaxMatrix, MD_MAX72xx, Max72xxPanel, Adafruit-GFX, Parola ...). Если ещё какие есть - можно обсудить ... только в рамках конкретной светодиодной железки плиз, чтобы не искать "то число", в том числе которого MAX7219 тоже может работать )
Оказывается с prog_char не только у меня проблемы:
http://arduino.ru/forum/programmirovanie/oshibki-pri-kompilirovanii
И про PROGMEM тоже не новость:
Поскольку PROGMEM — это модификатор переменных, то какого-то четкого правила о том, куда его поставить, нет. Следовательно, компилятор Arduino примет любую из конструкций, описанных ниже. Они, по сути, являются синонимами.
Впрочем, ряд экспериментов выявил, что в разных версиях Arduino (в зависимости от версии GCC) PROGMEM нужно ставить по-разному, потому что если поставить его в одном месте, то он будет работать, а если в другом — нет. К примеру, конструкции, указанные ниже, протестированы для работы с Arduino 13 (1 и 2 можно использовать, а 3 лучше не надо). Кроме того, в ранних версиях IDE модификатор будет работать лучше, если поставить его после имени переменной.
И никто не подсказал (
Может подскажут как коды символов получить ...
Сейчас есть такое:
void loadBufferLong(int ascii){ if (ascii >= 0x20 && ascii <=0xff){Отсюда: http://i.voenmeh.ru/kafi5/Kam.loc/inform/UTF-8.htm беру коды и пишу:
void loadBufferLong(int ascii){ if (ascii >= D0x90 && ascii <=D0xBF){- компилятор ругается на D0x90 и D0xBF.
sketch_string_4_1.ino: In function 'void loadBufferLong(int)':
sketch_string_4_1.ino:948:34: error: 'D0xff' was not declared in this scope
Ошибка компиляции.
Ну ладно, это больше, чем 32К, тогда заменяю int ascii на unsigned int ascii. Вроде должны быть положительные 2 байта (вместо плюс/минус байт у просто int), но ругательства остаются. Что я делаю не так? Тип MyChar тоже менял, чтобы соответствовал ...
Что я делаю не так?
Игнорируете мой совет, данный в посте №1.
и ... там тоже буквы по 7 точек в высоту, а не по 8 - почему? (в книжках по С это не написано ) )
Может, потому, что есть символ, которые имеют "подстрочные" фрагменты: "p", "q", "у", "д", "щ". Нет?
Что я делаю не так?
Вот спросите у меня что-нибудь по электронике - я вам посоветую Хоровица и Хилла почитать. Хороший такой двухтомник. Про PROGMEM я тоже должен был узнать из этой книжки, если бы не "проигнорировал совет"? Кстати, если тут форум только для того чтобы к книжкам отсылать, то скажите почему именно Керниган и Ричти? А Уэйт, Прайта, Мартин "Язык Си", Вайнер, Пинсон "С++ изнутри", Дьюхарст, Старк "Программирование на С++", ИВК "Язык СИ для профессионалов" - хуже? Если я стану программистом, то вы без работы останетесь - не боитесь? Но пока я электронщик (хотя в соседней ветке уже предложил работающий скетч с подробнейшими комментариями ... даже спасибо не сказали). И почему в пособиях по изучению ардуино к книжкам по С не отсылают ... даже странно (щас именно к этой фразе придерутся и найдут пособие, где в т.ч. рекомендуют, но не просто отсылают ) )
И да, а как вы учили английский? Тупо зубрили словарь от А до Z? Или учили слова по мере необходимости и постепенно увеличивали словарный запас? А то желающие отослать вас к словарю и сказать, что это ценный совет, тоже найдутся. Для этого, кстати, даже не нужно быть специалистом.
и ... там тоже буквы по 7 точек в высоту, а не по 8 - почему? (в книжках по С это не написано ) )
Может, потому, что есть символ, которые имеют "подстрочные" фрагменты: "p", "q", "у", "д", "щ". Нет?
Нет, в этом скетче мелкие p, q, g, y просто сдвинуты вверх на один пиксель. А восьмой элемент в этом шрифте - цифра, обозначающая ширину буквы+1. Думал, может её в другой столбец перенести. Как раз для хвостиков и хотел освободить место.
Про переменное количество байт я тоже прочитал. И что? Мне нужен РУССКИЙ шрифт и больше НИЧЕГО добавлять не буду. Сегодня код буквы А будет не такой, как вчера? (как у Газманова) Я исхожу из того, что каждый раз, когда я ввожу символы русского алфавита, компилятор их воспринимает как одни и те же коды. И мне просто нужно эти коды получить и как-то обработать. И всё, на данном этапе. Второй вопрос - в данном скетче английские буквы обрабатываются компилятором в той же самой кодировке UTF-8 и всё работает нормально, не обращая внимания на "переменное количество байт". Я понимаю, что английские символы в любом случае занимают 1 байт (а не переменное количество), а русские займут 2 байта. Неправильно понимаю? Ссылка на таблицу, в которой указаны КОНКРЕТНЫЕ коды, тоже неправильная? Если неправильная, то почему Вы сразу не сказали (я несколько раз спрашивал), а если всё правильно, то, как Вы и написали, вся загвоздка в переменных и именно это я и просил подсказать, а вы только ехидничаете. pgm_read_byte_near - это не я, а первоисточник (я бы так нагло в память не полез) ), туда я тоже уже смотрел, но самостоятельно разбираться долго, тогда и форум не нужен.
И, как я уже писал, свой велосипед на замену уже изобретённым велосипедам я не леплю и лепить не собираюсь. Просто сам для себя хочу сделать бегущую строку и заодно "выучить несколько иностранных слов". Ну и другим новичкам, которые ищут что-то подобное (а таких немало) это может быть полезно. Или вы опасаетесь, что этот "велосипед" будет конкурировать с вашими проектами? Вряд ли, но могу и не публиковать конечный результат, если это нужно для дела )
Ой, а вот, не вникая в подробности, увидел Вы писали: " ...компилятор ругается на D0x90 и D0xBF." А если таки 0xD90 и 0xDBF?
Странно, а я раньше думал, что после "искусства схемотехники" люди всё же видят разницу между rc-цепью и колебательным контуром, между триггером и мультивибратором, и наконец, между байтом и словом, даже, если они "электронщики". :)
Люди уже дважды предложили вам решение, ну, не хватает знаний на осознание и реализацию - вот вам третье - сохраните ваш скетч в однобайтовой кодировке, например 1251, радостно допилите свой велознакогенератор и будьте счастливы, все всё будут воспринимать нормально и работать нормально. А так - полностью расписывать вам решение вашей задачи долго и не менее, чем вам, лень ))
Жал на стрелки чтобы прокрутить, а это типа лайков? Неудобно, что при цитировании только одно сообщение отображается.
Сейчас этим занялся - поправил синтаксис, за что спасибо и особенно unlexus за то, что он нормально посоветовал, без стёба. Ошибка пропала. Дальше надо разбираться с переменными.
Странно, а я раньше думал, что после "искусства схемотехники" люди всё же видят разницу между rc-цепью и колебательным контуром, между триггером и мультивибратором, и наконец, между байтом и словом, даже, если они "электронщики". :)
Люди уже дважды предложили вам решение, ну, не хватает знаний на осознание и реализацию - вот вам третье - сохраните ваш скетч в однобайтовой кодировке, например 1251, радостно допилите свой велознакогенератор и будьте счастливы, все всё будут воспринимать нормально и работать нормально. А так - полностью расписывать вам решение вашей задачи долго и не менее, чем вам, лень ))
Странно, что вы в одной фразе уложили содержание двухтомника и жизненную концепцию, а про мелкую программку из пары процедур вам писать долго и лень ))) Про то, что буква А - это D090, то бишь 2 байта, тоже сильно напряжно было написать? Либо нет, либо да (тогда к чему рассуждения про переменное количество байтов?) Ответа нет. Ну хоть поясните какие были дважды предложенные решения - выучить учебник по С? А сюда посмотреть нельзя? - http://www.myrobot.ru/stepbystep/pr_variables.php И какими словами выражается 8-битный контроллер? А знаний не хватает, да, потому я сюда и забрёл, вместо того, чтобы учебники штудировать. Знания ведь можно по-разному получать, о чём вы в своей концепции не упомянули.
Пока мои недостаточные знания говорят мне о том, что надо:
1 - массив шрифта сделать двухбайтовым (например, вместо char - unsigned int, о чём я тоже раньше спрашивал),
2 - переменные, являющиеся аргументами-символами тоже сделать двухбайтовыми,
3 - согласовать все индексы-аргументы-переменные во всех процедурах,
4 - корректно описать процедуру считывания этого массива (вместо pgm_read_byte_near)
Что-то жутко сложное типа такого:
"Следующий фрагмент кода иллюстрируют, как читать и писать данные типа unsigned char (размер 1 байт) и int (размер 2 байта) в PROGMEM.
#include <avr/pgmspace.h>//создаем некоторые беззнаковые целыеPROGMEM prog_uint16_t charSet[] = { 65000, 32796, 16843, 10, 11234};//создаем некоторые символыprog_uchar signMessage[] PROGMEM = {"I AM PREDATOR, UNSEEN COMBATANT. CREATED BY THE UNITED STATES DEPART"};unsignedintdisplayInt;intk;// переменная-счетчикcharmyChar;// считываем по 2 байта в переменную intdisplayInt = pgm_read_word_near(charSet + k)// считываем символmyChar = pgm_read_byte_near(signMessage + k); ""Как упоминалось выше, важно использовать типы данных, описанные в pgmspace.h . Если использовать обычные типы данных для вызовов данных из программного пространства, то могут генирироваться непонятные ошибки. Ниже представлен список поддерживаемых типов переменных. Числа с плавающей точкой в памяти программ не поддерживается.
Жутко вставилось ...
Да, очередной дилетантский вопрос: в идейном компиляторе (IDE) 26:29: error: означает 26-ю строку и 29-й символ? А как строки считаются - с пустыми и комментариями?
Говорите ascii и MyChar где-то там близко не сидели? А ничего, что это просто номер символьного элемента в массиве шрифта? Потому что scrollFont() тут работает прекрасно. А вот scrollMessage(scrollText) нормально отображает только английский текст (а вместо русских букв всякая хрень).
MyChar для русских букв просто некорректно определяется. Далее надо разбираться, что такое messageString ... А в loadBufferLong я напрасно полез - просто фонт по порядку отлично выводится. Там пофиг: что byte, что word.
Я восхищён Вашими телепатическими способностями, основанными на чтении этой ветки, только вот не помню где это я писал, что считаю, что в один байт можно запихать два ... видно и правда не знаю, что такое память ) Вопросы задавал - было дело, ответы не получил. Про переменные сам нашёл информацию - http://www.myrobot.ru/stepbystep/pr_variables.php - там недостаточно написано про char? Я же только и делаю, что спрашиваю, как мне получить коды русских символов. Хорошо, вот ещё один риторический вопрос "из учебника":
вот тут http://robocraft.ru/blog/892.html написали такой код:
#include <glcd.h> #include "fonts/SystemFont5x7.h" char myString[] = "АБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯабвгдежзийклмнопрстуфхцчшщъыьэюя"; void setup () { GLCD.Init(); GLCD.SelectFont(System5x7,BLACK); } void loop() { byte i=0; while (i<120) { GLCD.print(myString[i]); GLCD.print(" == "); GLCD.print(myString[i],HEX); GLCD.println(); delay(100); i++; } GLCD.println(); GLCD.println(myString); delay(5000); }Char - однобайтовый тип, а русские буквы в UTF-8 двухбайтовые. И всё у него работает. У меня тоже:
const unsigned char scrollText[] PROGMEM = {
" THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG 1234567890 the quick brown fox jumps over the lazy dog АБВ"};
Почему компилятор не ругается на АБВ? А вот если заменю char на int - он будет ругаться. Про ардуиновскую кодировку в учебнике по С тоже написано?
Кстати, за Хоровица и Хилла Вы "благодарны" - и что дальше? Вы её за год выучили наизусть и теперь с лёгкостью применяете всё, что там написано, на практике? Прочитали и стали электронщиком? Тоже риторический вопрос. Электроника - прикладная дисциплина, как и программирование. А если не стали электронщиком, тогда зачем Вам эта книга? Стоит на полке и Вы в неё временами заглядываете? Смею Вас заверить, этого недостаточно, чтобы разрабатывать что-либо серьёзное. Разве что "любимый мультивибратор" спаять ) Теперь всё это же надо перевернуть наоборот - для меня подобные программки - такой же "мультивибратор".
Вы тоже не обижайтесь, но практическая польза от Ваших ответов пока только такая: 1. сама книжка "пригодится в хозяйстве", потому как всё что я перечислил, у меня на полке стоит, а этой книжки нет и 2. информация, что именно эта книжка более доступна для начального освоения. Спасибо. Только написать можно было быстрее и проще: "мне с этой фигнёй разбираться некогда (в частности, я спрашивал не про PROGMEM, а про prog_char, а процитированный вопрос был про книжку), могу только посоветовать книжку, которую считаю лучшей для начального изучения С (а для тех, кто программировал на Фортране и Бейсике?), т.к. начинать лучше именно с С, потому что, с одной стороны, ардуина одинаково хорошо понимает и С и С++ (о чём Вы писали в другой ветке, но не тут), а, с другой стороны, у этих языков много общего (то-то и то-то) и глубокая преемственность (в том-то и том-то)". А разбираться с фигнёй и подсказывать что-то конкретное уже будут другие. Ну и от стёба перешли к нормальному разговору - тоже хорошо. А что касается таких примитивных "проектов", где нужно, как я писал, что-то сделать и попутно узнать "пару иностранных слов", то просто вспоминайте про Ваш опыт в электронике.
NfO, Вам уже написали, что в utf-8 символы переменной длины. Не пытайтесь описать их как двухбайтовые - все равно не получится. Не говоря обо всем остальном, пробелы и знаки препинания без вариантов остаются однобайтовыми, поэтому у Вас в любом случае в строке будут присутствовать символы разной длины.
В коде строка текста описывается аналогично обнобайтовой, но в процессе разбора необходимо следить, сколько байт занимает очередной символ.
PS. По поводу аналогий: Хоровиц и Хилл, конечно, хорошая книжка, но много ли из нее может почерпнуть человек не знакомый с законом Ома?
Вот за это спасибо! Я понял, что длина у английских и русских символов разная, но что нельзя описать английские двумя байтами (один байт нулевой) - не знал. Т.е. русскую букву в char надо считывать дважды - первый и второй байт? Первый - это старший? А как же в вышеприведённом примере - там считывают по байту, но по одному элементу массива char, а не по два.
PS. По поводу аналогий: Хоровиц и Хилл, конечно, хорошая книжка, но много ли из нее может почерпнуть человек не знакомый с законом Ома?
Вот именно. Книжка - это такой же информационный ресурс, как электронные. Вопрос только в качестве того или иного ресурса. Я дал ссылку на описание переменных - оно неправильное? А если правильное, то я получил нужную информацию, просто другим путём. Советы специалистов и профильные форумы - это ещё один путь получения информации. Тем более, что в книжках по С не пишут про ардуино и UTF-8. В данном случае информация мне нужна для конкретной игрушки, не более того. Я уже писал, что сделал программку на VB ... и уже забыл. Потому что это мне больше не нужно. (но что сильно ругался по поводу хелпа, помню хорошо ) ) Программка, кстати, была не самая простая: считывание из файла, проведение измерений с записью данных, обработка результатов измерений с построением графика, добавление новой информации и запись в другой файл и при этом получение коэффициентов уравнения линии тренда на графике Экселя в числовом виде. Попробуйте их оттуда достать - интересно сколько времени это у Вас займёт ) Учебников по VB не читал, программистом не стал, но локальный результат получил. А законы Ома и последующие учебники - это путь в специальность. Нельзя прочитать книжку и стать специалистом. Тут я тоже не хочу стать специалистом "с наскока", просто интересно сделать сию игрушку.
Эта зараза берёт два байта русской буквы (для А - d0 и 90, для Б - d0 и 91, для В - d0 и 92 ...) из ОБОИХ байтов вычитает константу и потом ОБА байта печатает как символы, т.е. одной букве соответствуют два символа из массива шрифта. И ей пофиг, что массив символов (строка) однобайтовый, что читают оттуда как pgm_read_byte_near и что я потом myChar = lowByte(myCharCurrent) ... Или там действительно на одну русскую букву два элемента массива (о чём я выше спросил) и counter надо на 2 инкрементировать? А как тогда вышеприведенный пример работает? Там
myString[i]- и баста.// Scroll Message void scrollMessage(const unsigned char * messageString) { int counter = 0; unsigned int myCharCurrent=0; int myChar=0; do { // read back a char myCharCurrent = pgm_read_byte_near(messageString + counter); myChar = lowByte(myCharCurrent) ; if (myChar > 0x7F){myChar = myChar - 89 ; } if (myChar != 0){ loadBufferLong(myChar); } counter++; } while (myChar != 0); }// Scroll Message void scrollMessage(const unsigned char * messageString) { int counter = 0; int myChar = 0; do { // read back a char myChar = pgm_read_byte_near(messageString + counter); if (myChar > 0xc7) { // пропуск байта } else if (myChar > 0x7f) { myChar = myChar - 16 ; if (myChar != 0){loadBufferLong(myChar); } } else { if (myChar != 0){loadBufferLong(myChar); } } counter++; } while (myChar != 0); }Хорошо, что младший байт больше всех английских ... кроме Ё ... ну там разберёмся ...
Кроме торжественных слов про велосипед, упомяните, плиз, о 8-пиксельных символах по высоте. Если в каждый символ дописать ещё одну строку B00000000, (и потом в вычислениях заменить 8 на 9) никакой пакости не случится? А то мне весь шрифт перелопачивать ...
Массив там const unsigned int, сейчас в нём 96 х 8 = 768 элементов (байт). Добавится ещё 66 русских и все будут по 9 элементов, итого - 162 х 9 = 1458 ... никто не будет против?
ПСы: так и не понял, почему этого нет в процитированном примере. Или там старший байт тоже выводился на эран, просто он об этом умолчал?
Вот за это спасибо! Я понял, что длина у английских и русских символов разная, но что нельзя описать английские двумя байтами (один байт нулевой) - не знал.
Можно и двумя. Но это будет другая кодировка. Например, utf-16 устроена именно так - все символы двухбайтовые. Но в Arduino IDE используется utf-8. Так что разве что перекодировать. Но тогда уж лучше в какую-нибудь однобайтовую.
Т.е. русскую букву в char надо считывать дважды - первый и второй байт? Первый - это старший? А как же в вышеприведённом примере - там считывают по байту, но по одному элементу массива char, а не по два.
Символ - не число, у него нет старшего и младшего байта. Может быть первый и второй. Или первый, второй и третий...
Вопроса, честно говоря, не понял. Возможно потому, что не смотрел этот вышеприведенный пример. Мне кажется, лучше понять, как устроена кодировка и, исходя из этого, ее обрабатывать, а не пытаться слепить свой скетч из кусочков чужих.
И еще: я, когда писал библиотеку для utf-8, понял, что в ней не может быть функции вывода отдельного символа именно потому, что символы имеют разную длину. Когда мы выводим строку, берем очередной байт и решаем, что с ним делать: если это однобайтовый символ - выводим, а если двух или многобайтовый - запоминаем и ждем следующего.
Можно и двумя. Но это будет другая кодировка. Например, utf-16 устроена именно так - все символы двухбайтовые. Но в Arduino IDE используется utf-8. Так что разве что перекодировать. Но тогда уж лучше в какую-нибудь однобайтовую.
Символ - не число, у него нет старшего и младшего байта. Может быть первый и второй. Или первый, второй и третий...
Вопроса, честно говоря, не понял. Возможно потому, что не смотрел этот вышеприведенный пример. Мне кажется, лучше понять, как устроена кодировка и, исходя из этого, ее обрабатывать, а не пытаться слепить свой скетч из кусочков чужих.
И еще: я, когда писал библиотеку для utf-8, понял, что в ней не может быть функции вывода отдельного символа именно потому, что символы имеют разную длину. Когда мы выводим строку, берем очередной байт и решаем, что с ним делать: если это однобайтовый символ - выводим, а если двух или многобайтовый - запоминаем и ждем следующего.
Так я и не леплю из кусочков чужих ... я леплю из одного англоязычного ) Если бы лепил из кусочков, то читал бы массив символов по номеру элемента. Вы посмотрите примеры - в последнем коде уже всё работает. Для двухбайтовых (русских) символов пропускаю старший байт. Теперь мне нужно увеличить высоту шрифта и дописать русский шрифт. Просто пока отвлёкся на китайца, который прислал неработающий микронасос.
А насчёт "символ - не число" - удивили ... Символ - это то, что выводится из знакогенератора для отображения, а в памяти он лежит в виде кода, т.е. числа. Про кодировку я понял. Просто подумал, что если сделать массив из двухбайтовых элементов, то в него можно будет положить и однобайтовые и двухбайтовые коды символов. Если символ однобайтовый, то один байт элемента массива, в котором лежит этот символ, будет нулевым. Может не так клал, может так вообще нельзя делать, в силу каких-то ограничений (пакостей) - этого я пока не знаю. А в существующий однобайтовый массив каждый из двух байтов русской буквы записывается как отдельный элемент. Первый элемент (старший байт) пропускаю и всё выводится нормально.
Для русских букв может быть третий байт? Я же писал, что мне только русские нужны, а прочие болгарские перебьются. Пусть сами для себя кодируют. Или Вашей библиотекой пользуются. Только они ведь быстро забудут, что это Ваша библиотека и будут говорить, что всем обязаны "американским друзьям".
Обиделся одни массив, но я его уговорил ) Вот этот: unsigned long bufferLong [16] = {0};
У него была размерность 14 и в нижней строке были посторонние коды. Сейчас всё в порядке, используется вся высота строки и все английские хвостики уже опустил до плинтуса. Дальше - финишная прямая - рисование русского шрифта и дораспознавание русских символов. Когда дорисую, выложу.
Просто подумал, что если сделать массив из двухбайтовых элементов, то в него можно будет положить и однобайтовые и двухбайтовые коды символов. Если символ однобайтовый, то один байт элемента массива, в котором лежит этот символ, будет нулевым.
Зачем такие сложности?
Есть полностью двухбайтовыа кодировка utf-16. Они полностью однозгачно перекодируются друг в друга utf-8 и utf-16, только если в первой переменная длина символа от 1 до 6 байт, то во второй все символы строго двухбайтовые. Так что наиболее правильный вариант - это правильно перекодировать строку из utf-8 в utf-16. Но, боюсь, для Ардуино он слишком ресурсоемкий. А когда я на ПК работаю с utf-8, всегда перекодирую ее в utf-16.
Первый элемент (старший байт) пропускаю и всё выводится нормально.
Это как?
Если байт просто пропускать, нормально выводиться не може никак.
Для русских букв может быть третий байт?
Все символы кириллицы (включая белорусские, македоеские и прочие другие) кодируются исключительно двухбайтовыми последовательностями. Правда, среди некоторых "вкусных" символов, которые хотелось бы иметь, есть и трехбайтовые. Но я, например, в своей библиотеке от них отказался, Ардуина не обладает ресурасами, чтобы поддерживать юникод в полном объеме, поэтому я лично делал поддержку только всех однобайтовых и некоторых двухбайтовых символов.
Вот так: (не окончательный вариант)
// Scroll Message void scrollMessage(const unsigned char * messageString) { int counter = 0; int myChar = 0; int CharRange = 0; do { // read back a char myChar = pgm_read_byte_near(messageString + counter); if (myChar == 0xd0 || myChar == 0xd1) // первые байты русских символов { CharRange = myChar - 0xd0 + 1 ; // байт не выводится, запоминается его признак } else if (myChar == 0x80) // второй байт русского символа { myChar = myChar + 15 ; // код 0xd180 - буква р в UTF-8 if (myChar != 0){loadBufferLong(myChar); CharRange = 0 ; // признак обнуляется после вывода второго байта символа } } else if (myChar == 0x81) { switch (CharRange) { case 1: // код 0xd081 - буква Ё в UTF-8 myChar = myChar - 1 ; break; case 2: // код 0xd181 - буква с в UTF-8 myChar = myChar + 5 ; break; } if (myChar != 0){loadBufferLong(myChar); CharRange = 0 ; } } else if (myChar > 0x8f) // русские буквы А - Я (0xd090 - 0xd0af в UTF-8) { myChar = myChar - 15 ; if (myChar != 0){loadBufferLong(myChar); CharRange = 0 ; } } else { if (myChar != 0){loadBufferLong(myChar); CharRange = 0 ; } } counter++; } while (myChar != 0); }Код символа - это число, причём в разных кодировках оно разное. Просто договорились, что в UTF-8 код буквы Ё D081 (кстати, по той ссылке, про которую я всё время спрашивал он указан ошибочно). В другой кодировке это другой код. А я решил, что второму байту 81 в моём знакогенераторе соответствует рисунок Ё, если первый байт D0 или буква р, если первый байт D1. С другими символами всё прощё, хотя тоже подпакостили.
Тут myChar - это уже просто номер символа в знакогенераторе.
В посте 2 данной темы указана функция utf8rus, которая перекодирует из UTF-8 в в однобайтовую русскую кодировку Windows-1251:
String utf8rus(String source) { int i,k; String target; unsigned char n; char m[2] = { '0', '\0' }; k = source.length(); i = 0; while (i < k) { n = source[i]; i++; if (n >= 0xC0) { switch (n) { case 0xD0: { n = source[i]; i++; if (n == 0x81) { n = 0xA8; break; } if (n >= 0x90 && n <= 0xBF) n = n + 0x30; break; } case 0xD1: { n = source[i]; i++; if (n == 0x91) { n = 0xB8; break; } if (n >= 0x80 && n <= 0x8F) n = n + 0x70; break; } } } m[0] = n; target = target + String(m); } return target; }Применять ее можно внутри команд печати строк:
display.println(utf8rus("Тест"));
В посте 2 данной темы указана функция utf8rus, которая перекодирует из UTF-8 в в однобайтовую русскую кодировку Windows-1251:
Вопрос на засыпку: много ли в Инете безграмотного кода?
Второй вопрос: а много ли его на этом форуме?
Третий: а по каким признакам отличать грамотный код от безграмотного?
Вот на третий вопрос я всегда отвецаю примерно так: грамотность человека не зависит от языка, на котором он пишет. Если он не в сотоянии грамотно назвать функцию, то вряд ли способен ее грамотно написать. Поэтому лично я никогда функциями с такими навзваниями пользоваться не буду.
Но у каждого читателя форума, естественно, есть выбор: как оценивать грамотность публикуемого кода чем пользоваться, а чем - нет.
Вот так работает:
B00000000, // м русская (Char D0xBC) B00000000, B10001000, B11011000, B10101000, B10001000, B10001000, B00000000, 5 + 1,а вот так уже - нет:
int erval = 1; B00000000, // м русская (Char D0xBC) B00000000, B10001000, B11011000, B10101000, B10001000, B10001000, B00000000, 5 + lowByte(erval),некраСИвый язык )
ПСы: ха, а когда описываю erval как const unsigned int (как массив) или const unsigned char, то работает (и без лоубайта) ... там же вроде один байт должен быть ...
В посте 2 данной темы указана функция utf8rus, которая перекодирует из UTF-8 в в однобайтовую русскую кодировку Windows-1251:
Применять ее можно внутри команд печати строк:
display.println(utf8rus("Тест"));
Это я понял, но тут у меня другая задача. Уже есть готовый скетч для вывода английских символов на светодиодную матрицу, со своим знакогенератором, заточенный под UTF-8 (без перекодировки). Мне надо было только добавить русские символы, т.е. для любой кодировки надо определить соответствие между кодом символа и номером этого символа в знакогенераторе. Поэтому лишний раз куда-то перекодировать здесь просто не имеет смысла.
Да, кстати, качественная ссылка на таблицу символов:
http://www.utf8-chartable.de/unicode-utf8-table.pl
Функционабельный код номер раз, ещё не оптимизированный. Критика приветствуется.
С одной стороны, хочется максимально упростить, а с другой - отрезать все символы, отсутствующие в знакогенераторе.
Напомню: сие делалось для светодиодной матрицы 8х8х4 под управлением MAX7219, вот такой:
https://ru.aliexpress.com/item/MAX7219-Dot-Matrix-Module-For-Arduino-Microcontroller-4-In-One-Display-with-5P-Line/32623588535.html?spm=2114.10010208.1000014.3.JV5KIf&scm=1007.13338.46806.0&pvid=b948a6d9-244e-4962-a973-ae5e51225a0a&tpp=1
(чтобы по постам не искать)
И ещё важное замечание про железо (тут я уже даю совет, а не спрашиваю) - сей девайс потребляет ток до 300 мА (когда горят все светодиоды, но там ещё и яркость установлена почти минимальная). Поэтому, несмотря на все спецификации, которые пишутся не для китайцев, я сильно не рекомендую подключать его напрямую к USB-порту, особенно к тому, что на передней панели у desktop'ных компьютеров. Для подключения сильноточных нагрузок используйте USB-разветвитель с дополнительным питанием.
Скетч исправлен, согласно замечаниям. Ещё забыл опустить запятую - исправил и подкорректировал буквы Уу.
// based on an orginal sketch by Arduino forum member "danigom" // h t t p://forum.arduino.cc/index.php?action=profile;u=188950 // Русифицированная "бегущая строка" для светодиодных матриц 8х8 с чипом MAX7219. // Вот скетч, который слепил "danigom" (см выше). // А вот кириллица, которая в длинном массиве хранится, в скетче, который слепил "danigom". // А вот Николай, которому мёду с утра не давай, а дай лишь добавить вот эту кириллицу, // которая в длинном массиве хранится, к скетчу, который слепил "danigom"... // Русифицированная версия называется "Велосипед". На странице обсуждения мне сказали, что я изобретаю велосипед // и я подумал: зачем строке пешком бежать? - пусть едет на велосипеде :) Обсуждали тут: // h t t p://arduino.ru/forum/programmirovanie/i-snova-pro-begushchuyu-stroku-na-svetodiodnykh-matritsakh-dlya-novichkov // В строке scrollText можно использовать русские и английские буквы и другие стандартные символы, вводимые // с русскоязычной клавиатуры, в любой последовательности. #include <avr/pgmspace.h> #include <LedControl.h> const int numDevices = 4; // number of MAX7219s used (количество соединённых матриц 8х8) const long scrollDelay = 75; // adjust scrolling speed (задержка сдвига текста в мс) const unsigned char interval = 1; // интервал между символами (в исходном варианте было только число, // на 1 превышающее ширину символа) unsigned long bufferLong [16] = {0}; LedControl lc=LedControl(8,10,9,numDevices); // Номера выводов платы Arduino Uno, на которые поступают // сигналы DIN, CLK, CS (можно выбрать другие) const unsigned char scrollText[] PROGMEM = { " -=* The quick brown fox still jumps, но это её проблемы, а пока съешь же ещё этих мягких французских булок, да выпей чаю. А если не хватит, закуси круассанами, лягушачьими лапками, e.t.c... *=- "}; void setup(){ for (int x=0; x<numDevices; x++){ lc.shutdown(x,false); //The MAX72XX is in power-saving mode on startup lc.setIntensity(x,3); // Set the brightness to default value lc.clearDisplay(x); // and clear the display } } void loop(){ scrollMessage(scrollText); // scrollFont(); // тестовая подпрограмма вывода всего шрифта } /////////////////////////////////////////////////////////////////////////////////////////////////////////////////// const unsigned char font5x7[] PROGMEM = { // Numeric Font Matrix (Arranged as 7x font data + 1x kerning data) B00000000, //Space (Char 0x20) // Массив шрифта переделан на 8х, чтобы высота текста была 8 точек, B00000000, // вместо 7, при этомпоявилась возможность правильно расположить B00000000, // символы с "подстрочными" элементами (в т.ч. английские); B00000000, // также вместо 1x kerning data можно задать свой интервал. B00000000, B00000000, B00000000, B00000000, 5 + interval, B10000000, //! B10000000, B10000000, B10000000, B00000000, B00000000, B10000000, B00000000, 1 + interval, B10100000, //" B10100000, B10100000, B00000000, B00000000, B00000000, B00000000, B00000000, 3 + interval, B01010000, //# B01010000, B11111000, B01010000, B11111000, B01010000, B01010000, B00000000, 5 + interval, B00100000, //$ B01111000, B10100000, B01110000, B00101000, B11110000, B00100000, B00000000, 5 + interval, B11000000, //% B11001000, B00010000, B00100000, B01000000, B10011000, B00011000, B00000000, 5 + interval, B01100000, //& B10010000, B10100000, B01000000, B10101000, B10010000, B01101000, B00000000, 5 + interval, B11000000, //' B01000000, B10000000, B00000000, B00000000, B00000000, B00000000, B00000000, 2 + interval, B00100000, //( B01000000, B10000000, B10000000, B10000000, B01000000, B00100000, B00000000, 3 + interval, B10000000, //) B01000000, B00100000, B00100000, B00100000, B01000000, B10000000, B00000000, 3 + interval, B00000000, //* B00100000, B10101000, B01110000, B10101000, B00100000, B00000000, B00000000, 5 + interval, B00000000, //+ B00100000, B00100000, B11111000, B00100000, B00100000, B00000000, B00000000, 5 + interval, B00000000, //, B00000000, B00000000, B00000000, B00000000, B11000000, B01000000, B10000000, 2 + interval, B00000000, //- B00000000, B00000000, B11111000, B00000000, B00000000, B00000000, B00000000, 5 + interval, B00000000, //. B00000000, B00000000, B00000000, B00000000, B11000000, B11000000, B00000000, 2 + interval, B00000000, /// B00001000, B00010000, B00100000, B01000000, B10000000, B00000000, B00000000, 5 + interval, B01110000, //0 B10001000, B10011000, B10101000, B11001000, B10001000, B01110000, B00000000, 5 + interval, B01000000, //1 B11000000, B01000000, B01000000, B01000000, B01000000, B11100000, B00000000, 3 + interval, B01110000, //2 B10001000, B00001000, B00010000, B00100000, B01000000, B11111000, B00000000, 5 + interval, B11111000, //3 B00010000, B00100000, B00010000, B00001000, B10001000, B01110000, B00000000, 5 + interval, B00010000, //4 B00110000, B01010000, B10010000, B11111000, B00010000, B00010000, B00000000, 5 + interval, B11111000, //5 B10000000, B11110000, B00001000, B00001000, B10001000, B01110000, B00000000, 5 + interval, B00110000, //6 B01000000, B10000000, B11110000, B10001000, B10001000, B01110000, B00000000, 5 + interval, B11111000, //7 B10001000, B00001000, B00010000, B00100000, B00100000, B00100000, B00000000, 5 + interval, B01110000, //8 B10001000, B10001000, B01110000, B10001000, B10001000, B01110000, B00000000, 5 + interval, B01110000, //9 B10001000, B10001000, B01111000, B00001000, B00010000, B01100000, B00000000, 5 + interval, B00000000, //: B11000000, B11000000, B00000000, B11000000, B11000000, B00000000, B00000000, 2 + interval, B00000000, //; B11000000, B11000000, B00000000, B11000000, B01000000, B10000000, B00000000, 2 + interval, B00010000, //< B00100000, B01000000, B10000000, B01000000, B00100000, B00010000, B00000000, 4 + interval, B00000000, //= B00000000, B11111000, B00000000, B11111000, B00000000, B00000000, B00000000, 5 + interval, B10000000, //> B01000000, B00100000, B00010000, B00100000, B01000000, B10000000, B00000000, 4 + interval, B01110000, //? B10001000, B00001000, B00010000, B00100000, B00000000, B00100000, B00000000, 5 + interval, B01110000, //@ B10001000, B00001000, B01101000, B10101000, B10101000, B01110000, B00000000, 5 + interval, B01110000, //A B10001000, B10001000, B10001000, B11111000, B10001000, B10001000, B00000000, 5 + interval, B11110000, //B B10001000, B10001000, B11110000, B10001000, B10001000, B11110000, B00000000, 5 + interval, B01110000, //C B10001000, B10000000, B10000000, B10000000, B10001000, B01110000, B00000000, 5 + interval, B11100000, //D B10010000, B10001000, B10001000, B10001000, B10010000, B11100000, B00000000, 5 + interval, B11111000, //E B10000000, B10000000, B11110000, B10000000, B10000000, B11111000, B00000000, 5 + interval, B11111000, //F B10000000, B10000000, B11110000, B10000000, B10000000, B10000000, B00000000, 5 + interval, B01110000, //G B10001000, B10000000, B10111000, B10001000, B10001000, B01111000, B00000000, 5 + interval, B10001000, //H B10001000, B10001000, B11111000, B10001000, B10001000, B10001000, B00000000, 5 + interval, B11100000, //I B01000000, B01000000, B01000000, B01000000, B01000000, B11100000, B00000000, 3 + interval, B00111000, //J B00010000, B00010000, B00010000, B00010000, B10010000, B01100000, B00000000, 5 + interval, B10001000, //K B10010000, B10100000, B11000000, B10100000, B10010000, B10001000, B00000000, 5 + interval, B10000000, //L B10000000, B10000000, B10000000, B10000000, B10000000, B11111000, B00000000, 5 + interval, B10001000, //M B11011000, B10101000, B10101000, B10001000, B10001000, B10001000, B00000000, 5 + interval, B10001000, //N B10001000, B11001000, B10101000, B10011000, B10001000, B10001000, B00000000, 5 + interval, B01110000, //O B10001000, B10001000, B10001000, B10001000, B10001000, B01110000, B00000000, 5 + interval, B11110000, //P B10001000, B10001000, B11110000, B10000000, B10000000, B10000000, B00000000, 5 + interval, B01110000, //Q B10001000, B10001000, B10001000, B10101000, B10010000, B01101000, B00000000, 5 + interval, B11110000, //R B10001000, B10001000, B11110000, B10100000, B10010000, B10001000, B00000000, 5 + interval, B01111000, //S B10000000, B10000000, B01110000, B00001000, B00001000, B11110000, B00000000, 5 + interval, B11111000, //T B00100000, B00100000, B00100000, B00100000, B00100000, B00100000, B00000000, 5 + interval, B10001000, //U B10001000, B10001000, B10001000, B10001000, B10001000, B01110000, B00000000, 5 + interval, B10001000, //V B10001000, B10001000, B10001000, B10001000, B01010000, B00100000, B00000000, 5 + interval, B10001000, //W B10001000, B10001000, B10101000, B10101000, B10101000, B01010000, B00000000, 5 + interval, B10001000, //X B10001000, B01010000, B00100000, B01010000, B10001000, B10001000, B00000000, 5 + interval, B10001000, //Y B10001000, B10001000, B01010000, B00100000, B00100000, B00100000, B00000000, 5 + interval, B11111000, //Z B00001000, B00010000, B00100000, B01000000, B10000000, B11111000, B00000000, 5 + interval, B11100000, //[ B10000000, B10000000, B10000000, B10000000, B10000000, B11100000, B00000000, 3 + interval, B00000000, //(Backward Slash) B10000000, B01000000, B00100000, B00010000, B00001000, B00000000, B00000000, 5 + interval, B11100000, //] B00100000, B00100000, B00100000, B00100000, B00100000, B11100000, B00000000, 3 + interval, B00100000, //^ B01010000, B10001000, B00000000, B00000000, B00000000, B00000000, B00000000, 5 + interval, B00000000, //_ B00000000, B00000000, B00000000, B00000000, B00000000, B11111000, B00000000, 5 + interval, B10000000, //` B01000000, B00100000, B00000000, B00000000, B00000000, B00000000, B00000000, 3 + interval, B00000000, //a B00000000, B01110000, B00001000, B01111000, B10001000, B01111000, B00000000, 5 + interval, B10000000, //b B10000000, B10110000, B11001000, B10001000, B10001000, B11110000, B00000000, 5 + interval, B00000000, //c B00000000, B01110000, B10001000, B10000000, B10001000, B01110000, B00000000, 5 + interval, B00001000, //d B00001000, B01101000, B10011000, B10001000, B10001000, B01111000, B00000000, 5 + interval, B00000000, //e B00000000, B01110000, B10001000, B11111000, B10000000, B01110000, B00000000, 5 + interval, B00110000, //f B01001000, B01000000, B11100000, B01000000, B01000000, B01000000, B00000000, 5 + interval, B00000000, //g B00000000, B01110000, B10001000, B10001000, B01111000, B00001000, B01110000, 5 + interval, B10000000, //h B10000000, B10110000, B11001000, B10001000, B10001000, B10001000, B00000000, 5 + interval, B01000000, //i B00000000, B11000000, B01000000, B01000000, B01000000, B11100000, B00000000, 3 + interval, B00010000, //j B00000000, B00110000, B00010000, B00010000, B10010000, B01100000, B00000000, 4 + interval, B10000000, //k B10000000, B10010000, B10100000, B11000000, B10100000, B10010000, B00000000, 4 + interval, B11000000, //l B01000000, B01000000, B01000000, B01000000, B01000000, B11100000, B00000000, 3 + interval, B00000000, //m B00000000, B11010000, B10101000, B10101000, B10001000, B10001000, B00000000, 5 + interval, B00000000, //n B00000000, B10110000, B11001000, B10001000, B10001000, B10001000, B00000000, 5 + interval, B00000000, //o B00000000, B01110000, B10001000, B10001000, B10001000, B01110000, B00000000, 5 + interval, B00000000, //p B00000000, B11110000, B10001000, B10001000, B11110000, B10000000, B10000000, 5 + interval, B00000000, //q B00000000, B01101000, B10011000, B10011000, B01101000, B00001000, B00001000, 5 + interval, B00000000, //r B00000000, B10110000, B11001000, B10000000, B10000000, B10000000, B00000000, 5 + interval, B00000000, //s B00000000, B01110000, B10000000, B01110000, B00001000, B11110000, B00000000, 5 + interval, B01000000, //t B01000000, B11100000, B01000000, B01000000, B01001000, B00110000, B00000000, 5 + interval, B00000000, //u B00000000, B10001000, B10001000, B10001000, B10011000, B01101000, B00000000, 5 + interval, B00000000, //v B00000000, B10001000, B10001000, B10001000, B01010000, B00100000, B00000000, 5 + interval, B00000000, //w B00000000, B10001000, B10101000, B10101000, B10101000, B01010000, B00000000, 5 + interval, B00000000, //x B00000000, B10001000, B01010000, B00100000, B01010000, B10001000, B00000000, 5 + interval, B00000000, //y B00000000, B10001000, B10001000, B10001000, B01111000, B00001000, B01110000, 5 + interval, B00000000, //z B00000000, B11111000, B00010000, B00100000, B01000000, B11111000, B00000000, 5 + interval, B00100000, //{ B01000000, B01000000, B10000000, B01000000, B01000000, B00100000, B00000000, 3 + interval, B10000000, //| B10000000, B10000000, B10000000, B10000000, B10000000, B10000000, B00000000, 1 + interval, B10000000, //} B01000000, B01000000, B00100000, B01000000, B01000000, B10000000, B00000000, 3 + interval, B00000000, //~ B00000000, B00000000, B01101000, B10010000, B00000000, B00000000, B00000000, 5 + interval, B01100000, // (Char 0x7F) B10010000, B10010000, B01100000, B00000000, B00000000, B00000000, B00000000, 5 + interval, B01010000, // Ё русская (Char D0x01) B11111000, B10000000, B11110000, B10000000, B10000000, B11111000, B00000000, 5 + interval, B00111000, // А русская (Char D0x90) B01001000, B10001000, B10001000, B11111000, B10001000, B10001000, B00000000, 5 + interval, B11111000, // Б русская (Char D0x91) B10001000, B10000000, B11110000, B10001000, B10001000, B11110000, B00000000, 5 + interval, B11110000, // В русская (Char D0x92) B10001000, B10001000, B11110000, B10001000, B10001000, B11110000, B00000000, 5 + interval, B11111000, // Г русская (Char D0x93) B10001000, B10000000, B10000000, B10000000, B10000000, B10000000, B00000000, 5 + interval, B00111000, // Д русская (Char D0x94) B01001000, B01001000, B01001000, B01001000, B01001000, B11111100, B10000100, 6 + interval, B11111000, // Е русская (Char D0x95) B10000000, B10000000, B11110000, B10000000, B10000000, B11111000, B00000000, 5 + interval, B10101000, // Ж русская (Char D0x96) B10101000, B01110000, B00100000, B01110000, B10101000, B10101000, B00000000, 5 + interval, B01110000, // З русская (Char D0x97) B10001000, B00001000, B00110000, B00001000, B10001000, B01110000, B00000000, 5 + interval, B10001000, // И русская (Char D0x98) B10001000, B10011000, B10101000, B11001000, B10001000, B10001000, B00000000, 5 + interval, B10101000, // Й русская (Char D0x99) B10001000, B10011000, B10101000, B11001000, B10001000, B10001000, B00000000, 5 + interval, B10001000, // К русская (Char D0x9a) B10010000, B10100000, B11000000, B10100000, B10010000, B10001000, B00000000, 5 + interval, B00011000, // Л русская (Char D0x9b) B00101000, B01001000, B01001000, B01001000, B01001000, B10001000, B00000000, 5 + interval, B10000100, // М русская (Char D0x9c) B11001100, B10110100, B10000100, B10000100, B10000100, B10000100, B00000000, 6 + interval, B10001000, // Н русская (Char D0x9d) B10001000, B10001000, B11111000, B10001000, B10001000, B10001000, B00000000, 5 + interval, B01110000, // О русская (Char D0x9e) B10001000, B10001000, B10001000, B10001000, B10001000, B01110000, B00000000, 5 + interval, B11111000, // П русская (Char D0x9f) B10001000, B10001000, B10001000, B10001000, B10001000, B10001000, B00000000, 5 + interval, B11110000, // Р русская (Char D0xA0) B10001000, B10001000, B10001000, B11110000, B10000000, B10000000, B00000000, 5 + interval, B01110000, // С русская (Char D0xA1) B10001000, B10000000, B10000000, B10000000, B10001000, B01110000, B00000000, 5 + interval, B11111000, // Т русская (Char D0xA2) B10101000, B00100000, B00100000, B00100000, B00100000, B00100000, B00000000, 5 + interval, B10001000, // У русская (Char D0xA3) B10001000, B10001000, B10001000, B01010000, B00100000, B11000000, B00000000, 5 + interval, B00100000, // Ф русская (Char D0xA4) B01110000, B10101000, B10101000, B01110000, B00100000, B00100000, B00000000, 5 + interval, B10001000, // Х русская (Char D0xA5) B10001000, B01010000, B00100000, B01010000, B10001000, B10001000, B00000000, 5 + interval, B10010000, // Ц русская (Char D0xA6) B10010000, B10010000, B10010000, B10010000, B10010000, B11111000, B00001000, 5 + interval, B10001000, // Ч русская (Char D0xA7) B10001000, B10001000, B10001000, B01111000, B00001000, B00001000, B00000000, 5 + interval, B10001000, // Ш русская (Char D0xA8) B10101000, B10101000, B10101000, B10101000, B10101000, B11111000, B00000000, 5 + interval, B10001000, // Щ русская (Char D0xA9) B10101000, B10101000, B10101000, B10101000, B10101000, B11111100, B00000100, 6 + interval, B11000000, // Ъ русская (Char D0xAA) B01000000, B01000000, B01110000, B01001000, B01001000, B01110000, B00000000, 5 + interval, B10001000, // Ы русская (Char D0xAB) B10001000, B10001000, B11101000, B10011000, B10011000, B11101000, B00000000, 6 + interval, B10000000, // Ь русская (Char D0xAC) B10000000, B10000000, B11100000, B10010000, B10010000, B11100000, B00000000, 4 + interval, B01110000, // Э русская (Char D0xAD) B10001000, B00001000, B01111000, B00001000, B10001000, B01110000, B00000000, 5 + interval, B10011000, // Ю русская (Char D0xAE) B10100100, B10100100, B11100100, B10100100, B10100100, B10011000, B00000000, 6 + interval, B01111000, // Я русская (Char D0xAF) B10001000, B10001000, B01111000, B00101000, B01001000, B10001000, B00000000, 5 + interval, B00000000, // а русская (Char D0xB0) B00000000, B01110000, B00001000, B01111000, B10001000, B01111000, B00000000, 5 + interval, B00111000, // б русская (Char D0xB1) B01000000, B10110000, B11001000, B10001000, B10001000, B01110000, B00000000, 5 + interval, B00000000, // в русская (Char D0xB2) B00000000, B11110000, B10001000, B11110000, B10001000, B11110000, B00000000, 5 + interval, B00000000, // г русская (Char D0xB3) B00000000, B01110000, B00001000, B01110000, B10000000, B01110000, B00000000, 5 + interval, B11100000, // д русская (Char D0xB4) B00010000, B01101000, B10011000, B10001000, B10001000, B01110000, B00000000, 5 + interval, B00000000, // е русская (Char D0xB5) B00000000, B01110000, B10001000, B11111000, B10000000, B01110000, B00000000, 5 + interval, B00000000, // ж русская (Char D0xB6) B00000000, B10101000, B10101000, B01110000, B10101000, B10101000, B00000000, 5 + interval, B00000000, // з русская (Char D0xB7) B00000000, B01110000, B10001000, B00110000, B10001000, B01110000, B00000000, 5 + interval, B00000000, // и русская (Char D0xB8) B00000000, B10001000, B10001000, B10001000, B10011000, B01101000, B00000000, 5 + interval, B00010000, // й русская (Char D0xB9) B00100000, B10001000, B10001000, B10001000, B10011000, B01101000, B00000000, 5 + interval, B00000000, // к русская (Char D0xBA) B00000000, B10010000, B10100000, B11000000, B10100000, B10010000, B00000000, 4 + interval, B00000000, // л русская (Char D0xBB) B00000000, B00111000, B01001000, B01001000, B01001000, B10001000, B00000000, 5 + interval, B00000000, // м русская (Char D0xBC) B00000000, B10001000, B11011000, B10101000, B10001000, B10001000, B00000000, 5 + interval, B00000000, // н русская (Char D0xBD) B00000000, B10001000, B10001000, B11111000, B10001000, B10001000, B00000000, 5 + interval, B00000000, // о русская (Char D0xBE) B00000000, B01110000, B10001000, B10001000, B10001000, B01110000, B00000000, 5 + interval, B00000000, // п русская (Char D0xBF) B00000000, B10110000, B11001000, B10001000, B10001000, B10001000, B00000000, 5 + interval, B00000000, // р русская (Char D1x80) B00000000, B10110000, B11001000, B10001000, B11001000, B10110000, B10000000, 5 + interval, B00000000, // с русская (Char D1x81) B00000000, B01110000, B10001000, B10000000, B10001000, B01110000, B00000000, 5 + interval, B00000000, // т русская (Char D1x82) B00000000, B11010000, B10101000, B10101000, B10101000, B10101000, B00000000, 5 + interval, B00000000, // у русская (Char D1x83) B00000000, B10001000, B01001000, B00101000, B00010000, B00100000, B01000000, 5 + interval, B00000000, // ф русская (Char D1x84) B00000000, B00100000, B01110000, B10101000, B10101000, B01110000, B00100000, 5 + interval, B00000000, // х русская (Char D1x85) B00000000, B10001000, B01010000, B00100000, B01010000, B10001000, B00000000, 5 + interval, B00000000, // ц русская (Char D1x86) B00000000, B10010000, B10010000, B10010000, B10010000, B01101000, B00001000, 5 + interval, B00000000, // ч русская (Char D1x87) B00000000, B10010000, B10010000, B01110000, B00010000, B00010000, B00000000, 4 + interval, B00000000, // ш русская (Char D1x88) B00000000, B10001000, B10101000, B10101000, B10101000, B01110000, B00000000, 5 + interval, B00000000, // щ русская (Char D1x89) B00000000, B10001000, B10101000, B10101000, B10101000, B01110100, B00000100, 6 + interval, B00000000, // ъ русская (Char D1x8A) B00000000, B11000000, B01000000, B01110000, B01001000, B01110000, B00000000, 5 + interval, B00000000, // ы русская (Char D1x8B) B00000000, B10001000, B10001000, B11101000, B10011000, B11101000, B00000000, 5 + interval, B00000000, // ь русская (Char D1x8C) B00000000, B10000000, B10000000, B11100000, B10010000, B11100000, B00000000, 4 + interval, B00000000, // э русская (Char D1x8D) B00000000, B01110000, B10001000, B00111000, B10001000, B01110000, B00000000, 5 + interval, B00000000, // ю русская (Char D1x8E) B00000000, B10011000, B10100100, B11100100, B10100100, B10011000, B00000000, 6 + interval, B00000000, // я русская (Char D1x8F) B00000000, B01111000, B10001000, B01111000, B00101000, B11001000, B00000000, 5 + interval, B01010000, // ё русская (Char D1x91) B00000000, B01110000, B10001000, B11111000, B10000000, B01110000, B00000000, 5 + interval, }; void scrollFont() { for (int counter=0x20;counter<0xс2;counter++){ loadBufferLong(counter); delay(200); } } // Scroll Message void scrollMessage(const unsigned char * messageString) { int counter = 0; int myChar = 0; int CharRange = 0; do { // read back a char myChar = pgm_read_byte_near(messageString + counter); if (myChar < 0x20 || myChar > 0xbf) // байт не выводится, т.к. либо не включён в шрифт, { if (myChar == 0xd0 || myChar == 0xd1) // либо это первый байт русских символов { CharRange = myChar - 0xd0 + 1 ; // запоминается признак первого байта русских символов } } else if (myChar == 0x80) // второй байт русского символа { myChar = myChar + 49 ; // код 0xd180 - буква р в UTF-8 if (myChar != 0 && CharRange ==2){loadBufferLong(myChar); } CharRange = 0 ; // признак обнуляется после вывода второго байта символа } else if (myChar == 0x81) { switch (CharRange) { case 1: // код 0xd081 - буква Ё в UTF-8 myChar = myChar - 1 ; break; case 2: // код 0xd181 - буква с в UTF-8 myChar = myChar + 49 ; break; } if (myChar != 0){loadBufferLong(myChar); CharRange = 0 ; } } else if (myChar > 0x81 && myChar < 0x90) // русские буквы т - я (0xd182 - 0xd18f в UTF-8) { myChar = myChar + 49 ; if (myChar != 0){loadBufferLong(myChar); CharRange = 0 ; } } else if (myChar > 0x8f && myChar < 0xc0) { switch (CharRange) { case 1: // русские буквы А - Я (0xd090 - 0xd0af в UTF-8) myChar = myChar - 15 ; // и русские буквы а - п (0xd0b0 - 0xd0bf в UTF-8) break; case 2: // код 0xd191 - буква ё в UTF-8 myChar = myChar + 48 ; break; } if (myChar != 0){loadBufferLong(myChar); CharRange = 0 ; } } else // английские буквы и прочие символы (0x20 - 0x7f в UTF-8) { if (myChar != 0){loadBufferLong(myChar); CharRange = 0 ; } } counter++; } while (myChar != 0); } // Load character into scroll buffer void loadBufferLong(int ascii){ if (ascii >= 0x0020 && ascii <=0x00ff){ for (int a=0;a<8;a++){ // Loop 7 times for a 5x7 font // Index into character table to get row data unsigned long c = pgm_read_byte_near(font5x7 + ((ascii - 0x20) * 9) + a); unsigned long x = bufferLong [a*2]; // Load current scroll buffer x = x | c; // OR the new character onto end of current bufferLong [a*2] = x; // Store in buffer } // Index into character table for kerning data byte count = pgm_read_byte_near(font5x7 +((ascii - 0x20) * 9) + 8); for (byte x=0; x<count;x++){ rotateBufferLong(); printBufferLong(); delay(scrollDelay); } } } // Rotate the buffer void rotateBufferLong(){ for (int a=0;a<8;a++){ // Loop 7 times for a 5x7 font unsigned long x = bufferLong [a*2]; // Get low buffer entry byte b = bitRead(x,31); // Copy high order bit that gets lost in rotation x = x<<1; // Rotate left one bit bufferLong [a*2] = x; // Store new low buffer x = bufferLong [a*2+1]; // Get high buffer entry x = x<<1; // Rotate left one bit bitWrite(x,0,b); // Store saved bit bufferLong [a*2+1] = x; // Store new high buffer } } // Display Buffer on LED matrix void printBufferLong(){ for (int a=0;a<8;a++){ // Loop 7 times for a 5x7 font unsigned long x = bufferLong [a*2+1]; // Get high buffer entry byte y = x; // Mask off first character lc.setRow(3,a,y); // Send row to relevent MAX7219 chip x = bufferLong [a*2]; // Get low buffer entry y = (x>>24); // Mask off second character lc.setRow(2,a,y); // Send row to relevent MAX7219 chip y = (x>>16); // Mask off third character lc.setRow(1,a,y); // Send row to relevent MAX7219 chip y = (x>>8); // Mask off forth character lc.setRow(0,a,y); // Send row to relevent MAX7219 chip } }Так ... (звук чесания репы) ... а чё будет, ежели эту строку не в скетч вставлять, а передавать по ком-порту или ваю-фаю? Только не говорите, что придётся её в/из ascii перекодировать )
И ещё хотел спросить: сколько логических условий можно в ifы запихнуть? if(a == 1 || a == 3 || a==9 ... ?
В посте 2 данной темы указана функция utf8rus, которая перекодирует из UTF-8 в в однобайтовую русскую кодировку Windows-1251:
грамотность человека не зависит от языка, на котором он пишет. Если он не в сотоянии грамотно назвать функцию, то вряд ли способен ее грамотно написать. Поэтому лично я никогда функциями с такими навзваниями пользоваться не буду.
andriano ты на этом форуме давно и иногда даёшь полезные советы, но в данном случае у тебя был словесный понос.
Название функции ему не понравилось, значит она плохая. Так переименуй её. Несколько десятков человек на форуме её используют (без переименования). Даже топикстартер в своём коде практически её же и реализовал (а мог бы не тратить время и сразу готовую использовать).
Функционабельный код номер раз, ещё не оптимизированный. Критика приветствуется.
Зачем у массива const unsigned int font5x7[] PROGMEM размерность int когда в него только байты вводяться.
С одной стороны, хочется максимально упростить, а с другой - отрезать все символы, отсутствующие в знакогенераторе.
Во-первых, откуда взялся знакогенератор? Во-вторых, зачем отрезать символы, которые и так отсутствуют?
Функционабельный код номер раз, ещё не оптимизированный. Критика приветствуется.
Зачем у массива const unsigned int font5x7[] PROGMEM размерность int когда в него только байты вводяться.
С одной стороны, хочется максимально упростить, а с другой - отрезать все символы, отсутствующие в знакогенераторе.
Во-первых, откуда взялся знакогенератор? Во-вторых, зачем отрезать символы, которые и так отсутствуют?
Размерность - это не я, так было в первоисточнике. Я сам на это напоролся, когда пытался интервал в байт загнать ... Можно поменять?
... поменял ) на const unsigned char font5x7[] PROGMEM и const unsigned char erval = 1 - всё работает, спасибо за подсказку. Теперь придётся заменять erval на interval, схохмить не получилось (, но истина дороже )
Знакогенератор тоже был в первоисточнике. Наверное, для того, чтобы использовать только стандартную библиотеку LedControl, возможно ещё для наглядности и чтобы эти символы можно было исправлять как угодно. Я к нему же добавил русские буквы. Кстати, русские буквы тоже можно исправлять (мне, например, буква у не очень нравится ... может как английскую сделать). А вот с "её же и реализовал" не соглашусь. Я не пытался менять кодировку, а в плане декодирования действительно велосипед - те же коды символов, тот же язык - ничего нового. Только на выходе - номер символа в массиве. Зачем отрезать ... это уже велосипед с мотором ) ... А вдруг этот скетч какой-нибудь польский пан скачает? У него-то эти символы не отсутствуют. И будет всем говорить, что у нас ещё и коды кривые вдобавок.
Кстати, русские буквы тоже можно исправлять (мне, например, буква у не очень нравится ... может как английскую сделать).
В теме (из поста 2) http://arduino.ru/forum/programmirovanie/rusifikatsiya-biblioteki-adafru... есть русский шрифт и код для "перевода" его в визуальный вид и обратно.
А вдруг этот скетч какой-нибудь польский пан скачает? У него-то эти символы не отсутствуют. И будет всем говорить, что у нас ещё и коды кривые вдобавок.
Ну так уж не надо заморачиваться, форум всё таки русскоязычный.
Не, ну у меня шрифт покрасивее ) Например, хвост буквы р на одном уровне с буквой ф, хвосты у Щщ выступают вправо (эти буквы шире других), а мягкий знак, наоборот, более узкий и выглядит так же, как и твёрдый знак и т.п. ...