LED-матрица + MAX7219 + MaxMatrix.lib

SLOM
Offline
Зарегистрирован: 06.11.2014

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

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

 

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

JasKo
Offline
Зарегистрирован: 21.11.2015

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

iGonch
Offline
Зарегистрирован: 17.04.2016
Спасибо огромное! почти работает
вот видео того что получилось
 
если приглядеться, то каждая буква в фразе "Привет мир как поживаешь?" - ровно предыдущая по алфавиту перед той, что должна быть. Вместо П - О, и т.д.

 

что подправить? 
iGonch
Offline
Зарегистрирован: 17.04.2016

в 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

iGonch
Offline
Зарегистрирован: 17.04.2016

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

 

 

MacSim
Offline
Зарегистрирован: 28.11.2012

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

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

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

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

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

Diglator
Offline
Зарегистрирован: 17.06.2016

Здравствуйте. Я совсем новичек. Попытался на 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
 }
}
Alman
Offline
Зарегистрирован: 03.03.2014

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

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

С уважением 

NfO
NfO аватар
Offline
Зарегистрирован: 20.09.2016

Diglator пишет:

 После долгих поисков нашел наконец скетч, в котором и текст бежит как надо, и даже русификация есть. Но вот беда, скетч работает корректно только с одним блоком из 4 матриц.

У вас тут нет русификации, просто знакогенератор перепахан. " 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

 

NfO
NfO аватар
Offline
Зарегистрирован: 20.09.2016

Alman пишет:

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

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

С уважением 

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);               // вроде в миллисекундах
}

 

AlexVM
Offline
Зарегистрирован: 21.11.2016

Всем добрый!

Прошу не пинать ногами - с 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);
  }
}

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

iGobch
Offline
Зарегистрирован: 07.04.2016

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

AlexVM
Offline
Зарегистрирован: 21.11.2016

iGobch пишет:

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


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

NfO
NfO аватар
Offline
Зарегистрирован: 20.09.2016

По русификации светодиодной матрицы 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 таких матрицы, но у меня она только одна и такими проектами я не озадачивался.

glukhoff
Offline
Зарегистрирован: 01.12.2016

0

glukhoff
Offline
Зарегистрирован: 01.12.2016

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

glukhoff
Offline
Зарегистрирован: 01.12.2016

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

ruslan55
Offline
Зарегистрирован: 26.11.2015

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

Voventy
Offline
Зарегистрирован: 07.02.2015

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

Voventy
Offline
Зарегистрирован: 07.02.2015

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

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

NfO
NfO аватар
Offline
Зарегистрирован: 20.09.2016

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

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

Voventy
Offline
Зарегистрирован: 07.02.2015

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

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

 

NfO
NfO аватар
Offline
Зарегистрирован: 20.09.2016

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

laric
Offline
Зарегистрирован: 06.03.2017

из записи #50 

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

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

Klepa
Offline
Зарегистрирован: 18.04.2017

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

Klepa
Offline
Зарегистрирован: 18.04.2017

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

Diglator
Offline
Зарегистрирован: 17.06.2016

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

Klepa
Offline
Зарегистрирован: 18.04.2017

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

Klepa
Offline
Зарегистрирован: 18.04.2017

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

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

Klepa
Offline
Зарегистрирован: 18.04.2017

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

artemon25
Offline
Зарегистрирован: 25.12.2015

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

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

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

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

Gogi
Offline
Зарегистрирован: 17.09.2017
  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, 

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

Дим
Offline
Зарегистрирован: 05.05.2017

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

Jenek_Anapa
Offline
Зарегистрирован: 13.02.2018

Друзья помогите (, я как начинающий (, у меня мультиплексор  на 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);

}

 

DenKis
Offline
Зарегистрирован: 20.05.2015

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

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

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

DenKis
Offline
Зарегистрирован: 20.05.2015

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

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

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

Alman
Offline
Зарегистрирован: 03.03.2014

Всем привет

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

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

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

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

 

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

Jenek_Anapa
Offline
Зарегистрирован: 13.02.2018

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

Alman
Offline
Зарегистрирован: 03.03.2014

Jenek_Anapa пишет:

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

 

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

Jenek_Anapa
Offline
Зарегистрирован: 13.02.2018

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

 

ELITE
ELITE аватар
Offline
Зарегистрирован: 11.01.2018

я на 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] второй)

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

  for (int i=0; i<8;  i++){ 
       lc.setByte(0, i, (databute[i]));    //первый дисплей
       lc.setByte(1, i, (databute[i+8])); // 2й дисплей
  }   
  

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

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

Jenek_Anapa
Offline
Зарегистрирован: 13.02.2018

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

01 #define ANALOG_PIN A0
02 #define OUT_A 2
03 #define OUT_B 3
04 #define OUT_C 4
05 #include "LedControl.h"
06 LedControl LC = LedControl(12, 11, 10, 4);
07  int val;
08  
09 void setup() {
10  
11  
12    LC.shutdown(0, false); //Активируем 0ю матрицу
13    LC.setIntensity(0, 8);
14    LC.clearDisplay(0);
15       
16   pinMode(OUT_A, OUTPUT);
17   pinMode(OUT_B, OUTPUT);
18   pinMode(OUT_C, OUTPUT);
19   Serial.begin(9600);
20 }
21  
22 void loop() {
23  
24      
25  
26        LC.setColumn(0, 0, B11111111);
27        LC.setColumn(0, 1, B11111111);
28       
29    for (int i = 0b000; i <= 0b111; i++) {
30      digitalWrite(OUT_A, bitRead(i, 0));
31      digitalWrite(OUT_B, bitRead(i, 1));
32      digitalWrite(OUT_C, bitRead(i, 2));
33  
34      val = analogRead(ANALOG_PIN);
35      val = map(val,0,700,0,5);
36      val = constrain(val,0,5);
37      
38      Serial.print(val);
39      Serial.print(" | ");
40    
41    Serial.println();
42    delay(1000);
43  
44 }

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

DenKis
Offline
Зарегистрирован: 20.05.2015
Вот пример того, как не стоит писать (будет медленно и с мерцанием), но зато понятно
 
#include <MaxMatrix.h>
MaxMatrix m(8, 9, 10, 1); // wiring: DIN:8, CS:9, CLK:10; 1 модуль);

/// vars

void setup() {
  m.init();
  m.setIntensity(7); //m.setIntensity(intensityMatrixLed); //  яркость 0..15
  m.clear();
}

void loop() {
    m.clear()   // ???
    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);

      for (uint8_t x = 0; x < 5, x++) {
        if (val > x) {
            m.setDot(i, 8-x, 1); 
        } 
      }

      Serial.print(val);
      Serial.print(" | ");
    } 

}

 

 

ELITE
ELITE аватар
Offline
Зарегистрирован: 11.01.2018

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

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

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

DenKis
Offline
Зарегистрирован: 20.05.2015

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

 - открываем библиотеку (заранее скачанную и установленную на компе или 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)
    } 

 

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

ELITE
ELITE аватар
Offline
Зарегистрирован: 11.01.2018

по

 val = analogRead(ANALOG_PIN);

//вы считали значение от 0 до 1023

val = map(val,0,700,0,5) 

вы перенести val в диапазон 0-5

val = constrain(val,0,5);

//а тут проверяете входит val в диапазон или нет и у вас будет или true или false!!! тоесть val = 1 или 0

 

DenKis
Offline
Зарегистрирован: 20.05.2015

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

http://arduino.ru/Reference/Constrain

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

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

Jenek_Anapa
Offline
Зарегистрирован: 13.02.2018

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

ELITE
ELITE аватар
Offline
Зарегистрирован: 11.01.2018

DenKis пишет:

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

http://arduino.ru/Reference/Constrain

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

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

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

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

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

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

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

ELITE
ELITE аватар
Offline
Зарегистрирован: 11.01.2018

Jenek_Anapa пишет:

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

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