Arduino.ru

JasKo   Спасибо огромное!  взял вашу библиотеку, ваш пример, все заняло 2 минуты и сразу же заработало!  а вчера бился целый час и не работало, в чем была причина непонятно. но главное результат есть! 

а не подскажите как можно сделать привязку к кнопкам? или даже к коду. есть у меня такие кнопки, пример Б

хочу сделать, чтобы при наборе определенного кода на дисплее высвечивался определенный текст.  дающий задание детям на следующую игру, и таких заданий чтоб было порядка 6-10. 

SLOM почитай вот здесь о подключении такой клавы через pcf8574 там все подробно описано какие библиотеки взять что исправить и как использовать. Я сейчас не возле своего компа и скинуть коды и библиотеки сейчас не смогу.

в 47 строке 
m[0] = n; target = target + String(m); 
исправил на
m[0] = n+1; target = target + String(m);
в итоге буквы правильные, но и вместо пробелов - !, вместо ? - @
я уже не знаю что сделать...
вот видео
https://www.dropbox.com/s/6nou2thpwi1kzmh/2016-04-22%2023.53.12.mov?dl=0

Заменил содержимое adafruit_GFX полностью на приложенное в вашем посте (а не только 2 файла (.h .cpp) как в первый раз), и все заработало!
Нашел Excel-шаблон для содания точечных шрифтов.
Я правильно понимаю что его можно использовать для создания своих символов, добавив сгенерированные строки в glcdfont.c? Или 255 символов - предел, и нельзя добавить ничего, не удалив что-то? В таком случае как отобразить все символы и их коды/номер из текущего glcdfont.c? это ведь он?

для библиотеки

#include <SPI.h>
#include <Adafruit_GFX.h>
#include <Max72xxPanel.h>
 

заменяем строку 36 на эту

for ( int i = width * tape.length() + matrix.width() - spacer ; i > 1; i-- ) {
 

буквы будут выводится слева направо.

Здравствуйте. Я совсем новичек. Попытался на Arduino Uno и двух блоках по 4 матрицы 8х8 с  MAX7219 сделать бегущую строку. Перепробовал многое, но или вообще просто все диоды горят- не горят, либо текст движется поперек. После долгих поисков нашел наконец скетч, в котором и текст бежит как надо, и даже русификация есть. Но вот беда, скетч работает корректно только с одним блоком из 4 матриц. При включении второго блока не получается единой бегущей строки, на каждом блоке текст бежит отдельно. Изменение значения const int numDevices = 4 на 8 ничего не дает. Не владея языками программирования, не могу понять, что нужно изменить в скетче, чтобы все 8 матриц заработали, как одна строка. Подскажите, пожалуйста.

#include <avr/pgmspace.h>
#include <LedControl.h>

const int numDevices = 4;      // number of MAX7219s used
const long scrollDelay = 150;   // adjust scrolling speed

unsigned long bufferLong [14] = {0}; 

LedControl lc=LedControl(12,11,10,numDevices);

const unsigned char scrollText[] PROGMEM ={" GjmjUbnT... "}; //текст
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,2);       // 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)
 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,
 B00000000,
 B11111000,
 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,


 B10001000,  //B(И)
 B10001000,
 B10011000,
 B10101000,
 B11001000,
 B10001000,
 B10001000,
 6,


 B01110000,  //C
 B10001000,
 B10000000,
 B10000000,
 B10000000,
 B10001000,
 B01110000,
 6,


 B11110000,  //D(В)
 B10001000,
 B10001000,
 B11110000,
 B10001000,
 B10001000,
 B11110000,
 6,


 B10001000,  //E(У)
 B10001000,
 B10001000,
 B11111000,
 B00001000,
 B00001000,
 B01110000,
 6,


 B01110000,  //F(А)
 B10001000,
 B10001000,
 B10001000,
 B11111000,
 B10001000,
 B10001000,
 6,


 B11111000,  //G(П)
 B10001000,
 B10001000,
 B10001000,
 B10001000,
 B10001000,
 B10001000,
 6,


 B11110000,  //H(Р)
 B10001000,
 B10001000,
 B11110000,
 B10000000,
 B10000000,
 B10000000,
 6,


 B11100000,  //I
 B01000000,
 B01000000,
 B01000000,
 B01000000,
 B01000000,
 B11100000,
 4,


 B01110000,  //J(О)
 B10001000,
 B10001000,
 B10001000,
 B10001000,
 B10001000,
 B01110000,
 6,


 B00111000,  //K(Л)
 B01001000,
 B01001000,
 B01001000,
 B01001000,
 B01001000,
 B10001000,
 6,


 B10000000,  //L
 B10000000,
 B10000000,
 B10000000,
 B10000000,
 B10000000,
 B11111000,
 6,


 B10001000,  //M
 B11011000,
 B10101000,
 B10101000,
 B10001000,
 B10001000,
 B10001000,
 6,


 B11111000,  //N(Т)
 B00100000,
 B00100000,
 B00100000,
 B00100000,
 B00100000,
 B00100000,
 6,


 B01110000,  //O
 B10001000,
 B10001000,
 B10001000,
 B10001000,
 B10001000,
 B01110000,
 6,


 B11110000,  //P
 B10001000,
 B10001000,
 B11110000,
 B10000000,
 B10000000,
 B10000000,
 6,


 B01110000,  //Q(Й)
 B10001000,
 B10011000,
 B10101000,
 B11001000,
 B10001000,
 B10001000,
 6,


 B10001000,  //R(К)
 B10010000,
 B10100000,
 B11000000,
 B10100000,
 B10010000,
 B10001000,
 6,


 B01111000,  //S
 B10000000,
 B10000000,
 B01110000,
 B00001000,
 B00001000,
 B11110000,
 6,


 B11111000,  //T(Е)
 B10000000,
 B10000000,
 B11110000,
 B10000000,
 B10000000,
 B11111000,
 6,


 B11111000,  //U(Г)
 B10001000,
 B10000000,
 B10000000,
 B10000000,
 B10000000,
 B10000000,
 6,


 B10001000,  //V(М)
 B11011000,
 B10101000,
 B10001000,
 B10001000,
 B10001000,
 B10001000,
 6,


 B10001000,  //W
 B10001000,
 B10001000,
 B10101000,
 B10101000,
 B10101000,
 B01010000,
 6,


 B10001000,  //X
 B10001000,
 B01010000,
 B00100000,
 B01010000,
 B10001000,
 B10001000,
 6,


 B10001000,  //Y(Н)
 B10001000,
 B10001000,
 B11111000,
 B10001000,
 B10001000,
 B10001000,
 6,


 B01111000,  //Z(Я)
 B10001000,
 B10001000,
 B01111000,
 B00101000,
 B01001000,
 B10001000,
 6,


 B00000000,  //[(х)
 B00000000,
 B10001000,
 B01010000,
 B00100000,
 B01010000,
 B10001000,
 6,


 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,


 B00000000,  //b(и)
 B00000000,
 B10001000,
 B10011000,
 B10101000,
 B11001000,
 B10001000,
 6,


 B00000000,  //c
 B00000000,
 B01110000,
 B10001000,
 B10000000,
 B10001000,
 B01110000,
 6,


 B00001000,  //d
 B00001000,
 B01101000,
 B10011000,
 B10001000,
 B10001000,
 B01111000,
 6,


 B00000000,  //e(у)
 B00000000,
 B10001000,
 B10001000,
 B11111000,
 B00001000,
 B01110000,
 6,


 B00000000,  //f(а)
 B00000000,
 B01110000,
 B00001000,
 B01111000,
 B10001000,
 B01111000,
 6,


 B00000000,  //g(п)
 B00000000,
 B11110000,
 B10001000,
 B10001000,
 B10001000,
 B10001000,
 6,


 B10000000,  //h
 B10000000,
 B10110000,
 B11001000,
 B10001000,
 B10001000,
 B10001000,
 6,


 B01000000,  //i
 B00000000,
 B11000000,
 B01000000,
 B01000000,
 B01000000,
 B11100000,
 4,


 B00000000,  //j(о)
 B00000000,
 B01110000,
 B10001000,
 B10001000,
 B10001000,
 B01110000,
 6,


 B00000000,  //k(л)
 B00000000,
 B00111000,
 B01001000,
 B01001000,
 B01001000,
 B10001000,
 6,


 B11000000,  //l
 B01000000,
 B01000000,
 B01000000,
 B01000000,
 B01000000,
 B11100000,
 4,


 B00000000,  //m
 B00000000,
 B11010000,
 B10101000,
 B10101000,
 B10001000,
 B10001000,
 6,


 B00000000,  //n(т)
 B00000000,
 B11111000,
 B00100000,
 B00100000,
 B00100000,
 B00100000,
 6,


 B00000000,  //o
 B00000000,
 B01110000,
 B10001000,
 B10001000,
 B10001000,
 B01110000,
 6,


 B00000000,  //p
 B00000000,
 B11110000,
 B10001000,
 B11110000,
 B10000000,
 B10000000,
 6,


 B00000000,  //q(й)
 B01110000,
 B10001000,
 B10011000,
 B10101000,
 B11001000,
 B10001000,
 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,
 B11111000,
 B10001000,
 B10001000,
 6,


 B00000000,  //z
 B00000000,
 B11111000,
 B00010000,
 B00100000,
 B01000000,
 B11111000,
 6,


 B10001000,  //{(Х)
 B10001000,
 B01010000,
 B00100000,
 B01010000,
 B10001000,
 B10001000,
 6,


 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 <=0xff){
 for (int a=0;a<7;a++){                      // Loop 7 times for a 5x7 font
 unsigned long c = pgm_read_byte_near(font5x7 + ((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(font5x7 +((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
 }
}

Все доброго здравия!

подскажите, как сделать статичный вывод на матричный индикатор? max7219, 4 матрицы 8x8 в ряд.

С уважением 

У вас тут нет русификации, просто знакогенератор перепахан. " GjmjUbnT... " - это не русский текст. Я сейчас тем же озадачился:

http://arduino.ru/forum/programmirovanie/i-snova-pro-begushchuyu-stroku-na-svetodiodnykh-matritsakh-dlya-novichkov

Поменяйте тут 4 на 8 (если там нет каких-то других ограничений)

const int numDevices = 4;      // number of MAX7219s used

http://2150692.ru/product/view/15/290

Здесь было по кадрам и для 1 индикатора, я добавил по строкам и для 4-х:

unsigned char i;
unsigned char j;
unsigned char n;

int Max7219_pinCLK = 10; // назначение пина тактовых импульсов (у ATM328 это 16-й вывод)
int Max7219_pinCS = 9;   // назначение пина импульсов загрузки (у ATM328 это 15-й вывод)
int Max7219_pinDIN = 8;  // назначение пина вывода данных (у ATM328 это 14-й вывод)

unsigned char disp1[33][8] = {
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // рисунок сердца по кадрам (только данные)
  0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x40, 0x40, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x80, 0x40, 0x40, 0x00, 0x00, 0x00,
  0x00, 0x80, 0x80, 0x40, 0x40, 0x00, 0x00, 0x00,
  0x40, 0x80, 0x80, 0x40, 0x40, 0x00, 0x00, 0x00,
  0x60, 0x80, 0x80, 0x40, 0x40, 0x00, 0x00, 0x00,
  0x60, 0x90, 0x80, 0x40, 0x40, 0x00, 0x00, 0x00,
  0x60, 0x90, 0x88, 0x40, 0x40, 0x00, 0x00, 0x00,
  0x60, 0x90, 0x88, 0x44, 0x40, 0x00, 0x00, 0x00,
  0x60, 0x90, 0x88, 0x44, 0x44, 0x00, 0x00, 0x00,
  0x60, 0x90, 0x88, 0x44, 0x44, 0x08, 0x00, 0x00,
  0x60, 0x90, 0x88, 0x44, 0x44, 0x08, 0x10, 0x00,
  0x60, 0x90, 0x88, 0x44, 0x44, 0x08, 0x10, 0x20,
  0x60, 0x90, 0x88, 0x44, 0x44, 0x08, 0x10, 0x60,
  0x60, 0x90, 0x88, 0x44, 0x44, 0x08, 0x90, 0x60,
  0x60, 0x90, 0x88, 0x44, 0x44, 0x88, 0x90, 0x60 // рисунок сердца по кадрам (только данные)
};

unsigned char disp2[16][2] = {
  0x05, 0x40,  // рисунок сердца по строкам (адрес строки, данные)
  0x04, 0x40,
  0x03, 0x80,
  0x02, 0x80,
  0x01, 0x40,
  0x01, 0x60,
  0x02, 0x90,
  0x03, 0x88,
  0x04, 0x44,
  0x05, 0x44,
  0x06, 0x08,
  0x07, 0x10,
  0x08, 0x20,
  0x08, 0x60,
  0x07, 0x90,
  0x06, 0x88,  // рисунок сердца по строкам (адрес строки, данные)
};

void Write_Max7219_byte(unsigned char DATA) {  // подпрограмма записи байта DATA от старшего бита
  unsigned char i;
  digitalWrite(Max7219_pinCS, LOW);
  for (i = 8; i >= 1; i--) {
    digitalWrite(Max7219_pinCLK, LOW);
    digitalWrite(Max7219_pinDIN, DATA & 0x80);
    DATA = DATA << 1;
    digitalWrite(Max7219_pinCLK, HIGH);
  }
}

void Write_Max7219(unsigned char address, unsigned char dat) { // подпрограмма записи байта адреса и байта данных
digitalWrite(Max7219_pinCS, LOW);     // установка сигнала CS (пин 9) в логический 0
for (n = 1; n < 5; n++) {             // повторяем для 4-х матричных модулей
Write_Max7219_byte(address);          // запись байта адреса в индикатор (в регистр сдвига)
Write_Max7219_byte(dat);              // запись байта данных в индикатор (в регистр сдвига)
}
digitalWrite(Max7219_pinCS, HIGH);    // установка сигнала CS (пин 9) в логическую 1 (защёлкивание)
}

void Init_MAX7219(void) {             // подпрограмма инициализации MAX7219
  Write_Max7219(0x09, 0x00);          // регистр управления режимом декодирования данных - отключено
  Write_Max7219(0x0a, 0x03);          // регистр настройки яркости - 7/32 (меньше четверти)
  Write_Max7219(0x0b, 0x07);          // регистр количества активных индикаторов - максимум (8)
  Write_Max7219(0x0c, 0x01);          // режим работы: 0 - shutdown, 1 - включено
  Write_Max7219(0x0f, 0x00);          // регистр тестирования - не отображать тест
}

void setup() {                        // установка пинов в режим вывода
  pinMode(Max7219_pinCLK, OUTPUT);
  pinMode(Max7219_pinCS, OUTPUT);
  pinMode(Max7219_pinDIN, OUTPUT);
  delay(50);
  Init_MAX7219();                     // обращение к подпрограмме инициализации
}

void loop() {
  //рисуем сердце по кадрам
  for (j = 0; j < 17; j++) {
    for (i = 1; i < 9; i++)
      Write_Max7219(i, disp1[j][i - 1]);
    delay(100);
  }

    delay(500);

//все стираем
  for (i = 1; i < 9; i++) {  // i для 4-х модулей - строка снизу вверх (сердца на боку)
    Write_Max7219(i, 0x00);
    delay(100);
  }

    delay(500);

   //рисуем сердце  по строкам
    for (j = 0; j < 16; j++) {
      Write_Max7219(disp2[j][0], disp2[j][1]);
    delay(100);  
  }

    delay(500);

  //все закрашиваем
  for (i = 1; i < 9; i++) {  // i для сердца - столбец справа налево
    Write_Max7219(i, 0xFF);
    delay(100);
  }

  //все стираем
  for (i = 1; i < 9; i++) { 
    Write_Max7219(i, 0x00);
    delay(100);
  }

  //пауза
  delay(800);               // вроде в миллисекундах
}

Всем добрый!

Прошу не пинать ногами - с Arduino первый день:)

У меня с вышеуказанными библиотеками вот такая штука получилась: https://youtu.be/3-ZLO2NLIbY

Вот код: 

#include <SPI.h>
#include <Adafruit_GFX.h>
#include <Max72xxPanel.h>

int pinCS = 10; // Attach CS to this pin, DIN to MOSI and CLK to SCK (cf http://arduino.cc/en/Reference/SPI )
int numberOfHorizontalDisplays = 1;
int numberOfVerticalDisplays = 4;

Max72xxPanel matrix = Max72xxPanel(pinCS, numberOfHorizontalDisplays, numberOfVerticalDisplays);

String tape = "Arduino";
int wait = 50; // In milliseconds

int spacer = 1;
int width = 5 + spacer; // The font width is 5 pixels

void setup() {

  matrix.setIntensity(0); // Use a value between 0 and 15 for brightness
  matrix.setRotation(3);    // The same hold for the last display
}

void loop() {

  for ( int i = 0 ; i < width * tape.length() + matrix.width() - 1 - spacer; i++ ) {

    matrix.fillScreen(LOW);

    int letter = i / width;
    int x = (matrix.width() - 1) - i % width;
    int y = (matrix.height() - 8) / 2; // center the text vertically

    while ( x + width - spacer >= 0 && letter >= 0 ) {
      if ( letter < tape.length() ) {
        matrix.drawChar(x, y, tape[letter], HIGH, LOW, 1);
      }

      letter--;
      x -= width;
    }

    matrix.write(); // Send bitmap to display

    delay(wait);
  }
}

Может кто сталкивался и подскажет? 

попробуйте matrix.setRotation(3) поменять на 0 или 1 или 2

По русификации светодиодной матрицы 4х8х8 ссылку уже давал:

http://arduino.ru/forum/programmirovanie/i-snova-pro-begushchuyu-stroku-...

(пост 42)

а тут окончательный вариант:

http://radiokot.ru/forum/viewtopic.php?f=57&t=136296

(пост от 9 октября)

У кого-то сразу возникает желание подцепить 2 таких матрицы, но у меня она только одна и такими проектами я не озадачивался.

0

приветсвую!  проблема. Перечитал все посты, заменил все библиотеки и файлы. В итоге буквы сдвинуты на 1 символ как в посте № 53. Дальше сдинуться в этом вопросе ни как не получается. В чем загвоздка не догоняю. Нужен совет

приветсвую!  проблема. Перечитал все посты, заменил все библиотеки и файлы. В итоге буквы сдвинуты на 1 символ как в посте № 53. Дальше сдинуться в этом вопросе ни как не получается. В чем загвоздка не догоняю. Нужен совет

Пример подключения матриц к драйверу MAX7219 http://radiolaba.ru/microcotrollers/podklyuchenie-svetodiodnyih-matrits-na-max7219.html

Вот тут достаточно подробно о работе с матрицами http://zlitos.com/publ/ehlektronika/arduino_i_t_p/arduino_i_svetodiodnye_matricy_8kh8_max7219/12-1-0-35

там и русификация есть

а вот как шрифт на две строки величиной сделать?

Все эти повороты делает скетч по ссылке в моём последнем посте. И русский шрифт я туда (в сам скетч) тоже добавил.

Это бегущий текст, а если нужны эффекты, тогда да, нужна библиотека помощнее, типа Паролы.

а как вывести статичную строку, допустим на 10 матриц.

т.е. бегущая строка не нужна. просто в зависимости от события выводится та или иная надпись?

В данном скетче можно просто остановить текст, когда он забежит на дисплей (только он работает с 4-я матрицами, на 10 его надо переделывать), а в начале моего поста на котах есть ссылки и код рисования сердечек - таким образом что угодно можно нарисовать, если оно должно быть постоянным.

из записи #50 

скачал библиотеки скопировал скетч 

вместо слова "привет" пишет "рсйгжу"

Diglator ты решил проблемму с 2-мя матрицами? У меня такая же...?!

Если решил проблемму подскажи как...

Если честно, я просто забросил эту проблему. 

Жаль а то код такой же а проблемма не решилась...

Вопрос с 2-мя матрицами на русском языке решен Все ссылки из этого видео https://www.youtube.com/watch?v=Mo1SbWxoeWg

Проверено работает! Только на платформе arduino 1.5.2 не пошло выдавал ошибки поставил на 1.8.5 и все пошло прекрасно!? Может кому пригодится....

Соврал не ту ссылку на видео дал ...Вообщем вот ссылка но уже на архив со скетчем и библиотеками http://klenyaw.ucoz.ru/files/begushhaja_stroka_russkij_jazyk.rar

добрый всем вечер данный скетч с этой ветки работает хорошо но есть несколько вопросов 

1 сколько вообще матриц можно подключить по горизонтали и по вертикалм какие ограничения

2 как в этот код дописать датчик ds18b20 и вывести значения на дисплей

3 вывести текущее время

  0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x04, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x06, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x06, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x06, 0x19, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x06, 0x19, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00,
  0x06, 0x19, 0x01, 0x01, 0x02, 0x00, 0x00, 0x00,
  0x06, 0x19, 0x01, 0x01, 0x02, 0x04, 0x00, 0x00, 
  0x06, 0x19, 0x01, 0x01, 0x02, 0x04, 0x08, 0x00,
  0x06, 0x19, 0x01, 0x01, 0x02, 0x04, 0x18, 0x00,
  0x06, 0x19, 0x01, 0x01, 0x02, 0x24, 0x18, 0x00,
  0x06, 0x19, 0x01, 0x01, 0x42, 0x24, 0x18, 0x00,
  0x06, 0x19, 0x01, 0x81, 0x42, 0x24, 0x18, 0x00,
  0x06, 0x19, 0x81, 0x81, 0x42, 0x24, 0x18, 0x00,
  0x06, 0x99, 0x81, 0x81, 0x42, 0x24, 0x18, 0x00,
  0x46, 0x99, 0x81, 0x81, 0x42, 0x24, 0x18, 0x00,
  0x66, 0x99, 0x81, 0x81, 0x42, 0x24, 0x18, 0x00, 

нормальные сердечки-вертикально

Спасибо, всё работает нормально

Друзья помогите (, я как начинающий (, у меня мультиплексор  на 8 входов , помогите каждый пин отабразить по 5 светодиодов , чтобы один вольт соответствовал одному светодиоду на матрице , 8 портов на 8сми строчках , или подскажите последовательность действий, шашлык вино и жаркое солнце анапы с меня )

#define ANALOG_PIN A0
#define OUT_A 2
#define OUT_B 3
#define OUT_C 4
#include "LedControl.h"
LedControl LC = LedControl(12, 11, 10, 4); 
 int val;
 
void setup() { 


   LC.shutdown(0, false); //Активируем 0ю матрицу
   LC.setIntensity(0, 8);
   LC.clearDisplay(0);
      
  pinMode(OUT_A, OUTPUT);
  pinMode(OUT_B, OUTPUT);
  pinMode(OUT_C, OUTPUT);
  Serial.begin(9600);
}

void loop() { 

     

       LC.setColumn(0, 0, B11111111);
       LC.setColumn(0, 1, B11111111);
      
   for (int i = 0b000; i <= 0b111; i++) {
     digitalWrite(OUT_A, bitRead(i, 0));
     digitalWrite(OUT_B, bitRead(i, 1));
     digitalWrite(OUT_C, bitRead(i, 2));

     val = analogRead(ANALOG_PIN);
     val = map(val,0,700,0,5);
     val = constrain(val,0,5);
     
     Serial.print(val);
     Serial.print(" | ");
   }  
   Serial.println();
   delay(1000);

}

Я бы сделал это точками, что бы не лезть в нюансы кодирования символов.

скачать и библиотеку, подключить её, и посмотреть в файле .h  что-нибудь вроде setDot(x,y,...)

Нет ардуины под рукой, увы - не могу конкретно написать, как должно быть.

Я бы сделал это точками, что бы не лезть в нюансы кодирования символов.

скачать и библиотеку, подключить её, и посмотреть в файле .h  что-нибудь вроде setDot(x,y,...)

Нет ардуины под рукой, увы - не могу конкретно написать, как должно быть.

Всем привет

Я тоже помучался с данной матрицей и ардуино. То криво, то косо. То русского нет, то еще какая халера :)

Случилось мне прикупить на али модули ESP-01. Я думаю все знают, что это такое. На одном модуле собрал термометр с выводом на Народмон. А намучавшись с матрицей набрел на просторах тырнета на сайт wifi-iot dot com (не реклама). Там есть конструктор прошивок для ESP-шек. Кому интересно просто пройдите на сайт и вам будет все понятно. 

А вот видос того, что у меня получилось : https://youtu.be/pGIOAEGxwn0 Звук не очень, микрофон не настроен.

С уважением, Александр

ЗЫ Забыл опубликовать :). теперь можно смотреть 

Привет я тут всю голову сломал уже , мне точками и и надо , не  могу понять как проиходит вывод в матрицу , помоги пожалуйста )

Глянь по этой ссылке. там вроде все понятно - https://geektimes.ru/post/255686/

с этим я тоже разобрался  спасибо полезная информация , до меняне не доходит как переменную val выташить на матрицу  чтобы каждый столбик  соответствовал выводу мульти плексора , я так понимаю val  как то надо складывать в массив  а потом его вываливать в матрицу ? Вот  это до моего понимания ни как не доходит 

я на 72** делал с 7 сигментными индикаторами - но сить не меняет - вам надо отправлять по 1 байту для каждого символа - у вас на матрице - строки

соответственно 1 и 0 указывают какой диод вкл/выкл

8 строк - 8 байт

отправляйте из циклом 0-8 из заранее собранного массива например.

можете взять мою небольшую переделку библиотеки

https://cloud.mail.ru/public/6sDD/PGQw5yChd

в ней добавлена работа с байтами 

setByte(№_дисплей, символ/строка, байт_данных); 

как пример

я в массив собираю что отправлять 

databute[0]|=B00000101;

databute[1]|=B00000101;

databute[2]|=B01001111;

//для 7с индикатора это "Err" для матрицы будет 3 строки - вам надо будет сделать 8

//и да у меня 2 дисплей - собираю 16 байт (databute[0-7] первый и databute[8-16] второй)

и отправка на дисплей

ну и чтобы вам на матрицу выводить что хотите - можно сделать базу символов (по 8 байт для каждого)

а из кода просто вызывать нужный массив и его отправлять на матрицу

я это понимаю как с вот тут переменную val перевести в  биты  и отправить в матрицу , я сам механизм понять не могу 

Val это данные приходять с мультиплексора 

чтобы не мерцало - не надо делать  m.clear() а надо заменять вкл диоды на выкл

т.к.  m.clear() по сути отправляет 8 байт 0х00000000 - тоесть гасит все диоды и на это надо время

а потом вы заново из зажигаете - опять время - вот и мерцание сильное

А так попробуем через столбцы:

 - открываем библиотеку (заранее скачанную и установленную на компе или https://github.com/riyas-org/max7219/blob/master/MaxMatrix/MaxMatrix.cpp)

- находим void MaxMatrix::setColumn(byte col, byte value)

- подготавливаем данные для него

    byte tmp;
    for (int i = 0; i <= 7; i++) {
      val = constrain(val,0,5);

      tmp = 0;
      for (uint8_t row = 0; row < 5 , row++) {
        if (val > row) {
            bitWrite(tmp, row, 1);
        } 
      }
      m.setColumn(i, tmp)
    } 

Проверить не могу, поэтому возможны мелкие косячки. Сорри.

по

Советовал constrain не я, но акцентировать внимание новичка на этом не стал.

http://arduino.ru/Reference/Constrain

Насколько я вижу из описания, функция всё равно вернёт val, поэтому нет смысла перепроверять после map

Что бы не мерцало - я в библиотеке не увидел, как погасить точку.

Ребят  я  constrain использовал для того что бы в порту было видно , что значения меняються и потом решил что так и вывести  можно будет и в место 5 планировалось поставить 8  так как в матрице столбик и из 8 светиков , смысл должен получиться таков , 8 портов мультиплексора должны соответствовать 8и столбикам матрици и в зависимости изменения напряжения , столбики должны были увеличиваться или уменьшаться  

допустим у вас строка матрицы горит 4 левых диода = это будет  В00001111

вам надо покасить левый крайний

тогда вы отправляете экрану В00001110  только и всего

тоесть при каждой отправке данных вы отправляете все строки полностью, а не только нужную

а еще более верно - перед отправкой сравнивать - что было и что будет - и отправлять только если есть отличия данных - это ускорит вывод

у вас после val = constrain(val,0,5); будет val = 1 или val = 0 т.к. constrain логический оператор