ATNEL tech-forum

Re: Zmiana kierunku scrollowania tekstu LED 32X8 z MAX7219

2017-11-12T22:27:58+01:00

Mam problem w jaki sposób zapalić diodę tylko na jednym wyświetlaczu w tej funkcji .
[syntax=c]void SetPixel(int row, int col, uint8_t state)
{
if(state)
{
uint8_t val=0x00;
val |=(1< SendSpiWord(row+1, val); // Select column x, Set column to 0
}

}[/syntax]

[syntax=c]int main(void) {

InitSpi();
InitMatrix();
ClearMatrix();

while(1) {

//SetLed(3,0,0,1);//adres,wiersz,kolumna,status
SetPixel(0,0,1); //wiersz,kolumna,status

}

}[/syntax]

Wyświetla mi się dioda o współrzędnych 0,0 (prawy górny róg) na wszystkich czterech wyświetlaczach,w jaki sposób zmienić to żeby wyświetlała tylko na pierwszym?

Statystyki: Napisane przez mirek1968 — 12 lis 2017, o 22:27

Re: Zmiana kierunku scrollowania tekstu LED 32X8 z MAX7219

2017-11-01T23:01:13+01:00

Muszę nad tymi funkcjami głębiej pomyśleć.
Na razie u mnie jest wszystko odwrócone o 90 stopni według tego co pisałeś powyżej no i niewiem jak wyświetlić led tylko na danym wyświetlaczu.
[syntax=c]/*
* max7219.c
*
* Created on: 2017-10-30
* Author: Mirek
*/

#include
#include
#include
#include "max7219.h"
#include "../SPI/spi.h"

// Initializes all cascaded devices
void InitMatrix()
{
uint8_t i;// Var used in for loops

// Set display brighness
for(i = 0; i < LICZBA_MATRYC; i++) // Loop through number of cascaded devices
{
SendSpiWord(INTENSITY, 2); // Select Intensity register,Set brightness
}

// Set display refresh

for(i = 0; i < LICZBA_MATRYC; i++)
{
SendSpiWord(SCANLIMIT, 7); // Select Scan-Limit register,Select columns 0-7
}

// Turn on the display

for(i = 0; i < LICZBA_MATRYC; i++)
{
SendSpiWord(SHUTDOWN, 1); // Select Shutdown register, Select Normal Operation mode
}

// Disable Display-Test

for(i = 0; i < LICZBA_MATRYC; i++)
{
SendSpiWord(DISPLAYTEST, 0); // Select Display-Test register,Disable Display-Test
}

}

// Clears all columns on all devices
void ClearMatrix(void)
{
for(uint8_t x = 1; x < 9; x++) // for all columns
{

for(uint8_t i = 0; i < LICZBA_MATRYC; i++)
{
SendSpiWord(x, 0); // Select column x, Set column to 0
}
}
}

void SetLed(uint8_t adres, uint8_t wiersz, uint8_t kolumna, uint8_t stan)
{
uint8_t val=0x00;

if(adres<0 || adres>=LICZBA_MATRYC)
return;
if(wiersz<0 || wiersz>7 || kolumna<0 || kolumna>7)
return;

val=0b10000000 >> kolumna;
if(stan)
status[wiersz]=status[wiersz]|val;
else {
val=~val;
status[wiersz]=status[wiersz]&val;
}
SendSpiWord(wiersz+1,status[wiersz]);
}[/syntax]

[syntax=c]/*
* main.c
*
* Created on: 2017-10-30
* Author: Mirek
*/

#include
#include
#include
#include "SPI/spi.h"
#include "MAX_7219/max7219.h"

int main(void) {

InitSpi();
InitMatrix();
ClearMatrix();

while(1) {

SetLed(0,0,2,1);//adres,wiersz,kolumna,status

}

}[/syntax]

Statystyki: Napisane przez mirek1968 — 1 lis 2017, o 23:01

Re: Zmiana kierunku scrollowania tekstu LED 32X8 z MAX7219

2017-10-31T19:17:10+01:00

No to na początek jeszcze raz musisz pomyśleć nad funkcją, która zapala/gasi pojedynczy piksel. Ale nie w ten sposób , że na wszystkich wyświetlaczach się on powtarza. Masz cztery matryce 8x8 pikseli. Cały wyświetlacz ma zatem 32x8 pikseli. W układzie współrzędnych x, y, lewy dolny piksel ma współrzędne
(0, 0), lewy górny (0, 7), prawy dolny całego wyświetlacza (31,0), prawy górny (31, 7). Jakiś piksel w środku np. (15, 4). Jak zapalić poszczególne piksele, jak zgasić?
Powinieneś zadeklarować taką tablicę, która będzie odpowiadała wielkością Twojemu wyświetlaczowi, a więc coś w rodzaju
uint8_t LED_display[liczba_matryc * 8]
I to w tym buforze funkcja odpowiedzialna za włączenie/wyłączenie piksela powinna w odpowiednim miejscu wstawiać jedynkę lub zero.
Następnie druga podstawowa funkcja powinna cały ten bufor przesyłać do układów MAX7219.
Układy MAX7219 masz połączone kaskadowo, jeden za drugim. Zatem przesyłane do nich dane przekazywane są kolejno od pierwszego do ostatniego wyświetlacza. Czyli jednym ze sposobów jest zapisywanie kolejno całych wierszy wyświetlacza od najniższego do najwyższego.
Pomyśl jak zorganizować dane w buforze i jak je potem wysłać. To jest podstawa.
Acha i w tej funkcji ustawiającej jakiś piksel wstaw zabezpieczenie, gdyby ktoś chciał zapalić/zgasić piksel gdzieś poza rozmiarami bufora wyświetlacza.

Statystyki: Napisane przez janusz17 — 31 paź 2017, o 19:17

Re: Zmiana kierunku scrollowania tekstu LED 32X8 z MAX7219

2017-10-31T18:29:57+01:00

Scrollowanie nie jest takie trudne,ale musisz koniecznie zrozumieć jak jest zorganizowany bufor pamięci obrazu. Jaki bajt i bit odpowiada jakiemu pixelowi obrazu. Bez tego sie nie obejdzie. Zresztą pisałem o tym wcześniej.

Statystyki: Napisane przez micky — 31 paź 2017, o 18:29

Re: Zmiana kierunku scrollowania tekstu LED 32X8 z MAX7219

2017-10-31T17:08:24+01:00

Muszę Ci przyznać rację, zauważyłem że muszę rozpocząć pisanie swojego kodu w C-AVR od podstaw a nie męczyć się i zgadywać co autor miał na myśli w kodzie adoptowanym z arduino.
Już rozpocząłem nowy projekt w Eclipse od podstaw zaczynając od dateshita Max 7219.
Jak poczytam więcej i obejrzę poradniki to może poradzę sobie sam z tym kodem.
Szkoda że niema nigdzie w sieci porządnego poradnika dotyczącego tego układu i scrollowania wyświetlaczy LED 8X8 tak od podstaw,łopatologicznie dla mniej zaawansowanych czyli takich ja a:-)
Pomimo tego zachęcam Wszystkich forumowiczów do kolejnych wpisów na moim wątku,każda nawet drobna porada będzie mile widziana.

Statystyki: Napisane przez mirek1968 — 31 paź 2017, o 17:08

Re: Zmiana kierunku scrollowania tekstu LED 32X8 z MAX7219

2017-10-31T16:06:02+01:00

Widzę, że adaptujesz wciąż funkcje z arduino. Ale niestety przy Twoim układzie matryc one nie zadziałają poprawnie. Są na rynku dwa rodzaje modułów z matrycami LED 8x8 sterowane przez układ MAX7219. Różnią się one ustawieniem samej matrycy (przestawione są one o 90 stopni). W związku z tym jeśli łączysz kilka modułów i chcesz stworzyć z nich jeden większy wyświetlacz musisz zastosować odpowiednie oprogramowanie niestety różne dla każdego rodzaju modułu wyświetlacza. W pierwszym poście prosisz, żeby Cię nie odsyłać do książek ale nie oczekujesz też gotowca. I to są chyba prośby nie do pogodzenia. Bez zapoznania się ze sposobami tworzenia obrazów w buforze, tworzenia wzorów fontów w pamięci mikrokontrolera i na koniec przesyłaniem całego bufora obrazu na wyświetlacz, ciężko będzie do czegoś dojść. Właściwie to we wszystkich Mirkowych książkach jest to w jakimś zakresie opisywane, choć nie ma konkretnie mowy o układach MAX7219. Ale to tylko kwestia jednej funkcji, która wyśle bufor wyświetlacza do układów matryc, reszta pozostaje aktualna dla praktycznie wszystkich rodzajów wyświetlaczy matrycowych. Tak więc książki , to jednak podstawa dalszych działań.

Statystyki: Napisane przez janusz17 — 31 paź 2017, o 16:06

Re: Zmiana kierunku scrollowania tekstu LED 32X8 z MAX7219

2017-10-30T19:10:45+01:00

Myślę że stworzyłem taką funkcje dla wyświetlania pojedynczego piksela na współrzędnych ale od 0 do 7.
[syntax=c]void setLed(int addr, int row, int column, uint8_t state) {
int offset;
uint8_t val=0x00;

if(addr<0 || addr>=NUM_DEVICES)
return;
if(row<0 || row>7 || column<0 || column>7)
return;
offset=addr*8;
val=0b10000000 >> column;
if(state)
status[offset+row]=status[offset+row]|val;
else {
val=~val;
status[offset+row]=status[offset+row]&val;
}
SLAVE_SELECT;
writeWord(row+1,status[offset+row]);
SLAVE_DESELECT;
}[/syntax]

i wpisująć np: do tej funkcji w pętli while
[syntax=c]while(1) {

//displayMessage(messagePointer, messageSize);// Display the message;
setLed(0,0,6,1);//adres,wiersz,kolumna,status

}[/syntax]

zapala mi się dioda na każdym wyświetlaczu taka sama czyli w wierszu zerowym (czyli pierwszym) w kolumnie 7 (czyli w szóstej) tak jak na fotce.

Proszę o pomoc co dalej robimy:-)

Statystyki: Napisane przez mirek1968 — 30 paź 2017, o 19:10

Re: Zmiana kierunku scrollowania tekstu LED 32X8 z MAX7219

2017-10-30T08:37:02+01:00

Quote:

Proszę jeszcze o sprecyzowanie co znaczy drugi rejestr układu MAX7219?

Chyba powinieneś zaglądnąć do noty pdf układu MAX7219, żeby zobaczyć jak on działa.
Podpowiem tylko, że w tym trybie jaki jest zastosowany w Twoim projekcie, aby cokolwiek wyświetlić, trzeba przesłać najpierw nr rejestru do którego będziemy zapisywali dane, a następnie tą daną do wyświetlenia. Masz tam nawet napisaną funkcję do tego:
[syntax=c]void writeWord(uint8_t address, uint8_t data);[/syntax]
Rejestry są numerowane od 1 do 8 i właśnie chodziło o to, jak one mają się do podłączenia samego wyświetlacza.
Jak widać z obrazka, który zamieściłeś, u Ciebie przesyłanie danych ułożone jest rzędami od dołu do góry. Na samym dole jest rząd, który odpowiada danej z rejestru 1 układu MAX7219. Widać też , że orientacja bajtu jest taka: najstarszy bit po lewej stronie , najmłodszy po prawej. I to jest odpowiedź na pytanie o mapę pamięci obrazu.
Teraz trzeba by stworzyć funkcję, która wyświetli pojedynczy piksel na określonych współrzędnych ekranu. Jeśli uda Ci się to zrobić, to będzie otwarta droga do wyświetlania znaków alfanumerycznych i innych np. jakichś figur geometrycznych.
Scrolowanie zostawimy na koniec.

Statystyki: Napisane przez janusz17 — 30 paź 2017, o 08:37

Re: Zmiana kierunku scrollowania tekstu LED 32X8 z MAX7219

2017-10-29T18:18:18+01:00

Proszę jeszcze o sprecyzowanie co znaczy drugi rejestr układu MAX7219??,abym mógł tam przesłać poprzez SPI tej przykładowy bajt 0b01100001 i dowiedzieć się co się zapali na wyświetlaczu LED.
Tu mam opisane wszystkie rejestry które wykorzystuję,czy chodzi o rejestr #define OP_DIGIT0 1 o wartości 1?

[syntax=c]#define OP_NOOP 0
#define OP_DIGIT0 1
#define OP_DIGIT1 2
#define OP_DIGIT2 3
#define OP_DIGIT3 4
#define OP_DIGIT4 5
#define OP_DIGIT5 6
#define OP_DIGIT6 7
#define OP_DIGIT7 8
#define OP_DECODEMODE 9
#define OP_INTENSITY 10
#define OP_SCANLIMIT 11
#define OP_SHUTDOWN 12
#define OP_DISPLAYTEST 15[/syntax]

A jeśli nie o to chodzi to proszę o sprostowanie.

Myślę że jak podam więcej szczegółów i kod programu będzie wszystkim łatwiej się porozumieć.
main.c

[syntax=c]/*
* main.c
*
* Created on: 2017-09-20
* Author: Mirek
*/

#include
#include
#include
#include "MAX_7219/max7219_8x8.h"

// Message to be displayed, stored in flash
const char message[] PROGMEM = "a";

int main( void ) {

initSPI();
initMatrix();
clearMatrix();
initBuffer();

// Pointer to beginning of message
const char *messagePointer = &message[0];

// Size of message matrix
uint16_t messageSize = sizeof(message);

while(1) {

displayMessage(messagePointer, messageSize);// Display the message;

}
}[/syntax]

max7219_8x8.c

[syntax=c]/*
* max7219_8x8.c
*
* Created on: 2017-09-20
* Author: Mirek
*/

#include
#include
#include
#include "max7219_8x8.h"

#define NUM_DEVICES 4 // Number of cascaded max7219's, or just 1
#define DEL 1400000000000000 // Delay for scrolling speed in microseconds 14000

// Array holding arrays of 5 Bytes for each representation of an ASCII character, stored in flash
char characters[96][5] PROGMEM = {
{0b00000000,0b00000000,0b00000000,0b00000000,0b00000000}, // space
{0b00000000,0b00000000,0b01001111,0b00000000,0b00000000}, // !
{0b00000000,0b00000111,0b00000000,0b00000111,0b00000000}, // "
{0b00010100,0b01111111,0b00010100,0b01111111,0b00010100}, // #
{0b00100100,0b00101010,0b01111111,0b00101010,0b00010010}, // $
{0b00100011,0b00010011,0b00001000,0b01100100,0b01100010}, // %
{0b00110110,0b01001001,0b01010101,0b00100010,0b01010000}, // &
{0b00000000,0b00000101,0b00000011,0b00000000,0b00000000}, // '
{0b00000000,0b00011100,0b00100010,0b01000001,0b00000000}, // (
{0b00000000,0b01000001,0b00100010,0b00011100,0b00000000}, // )
{0b00010100,0b00001000,0b00111110,0b00001000,0b00010100}, // *
{0b00001000,0b00001000,0b00111110,0b00001000,0b00001000}, // +
{0b00000000,0b01010000,0b00110000,0b00000000,0b00000000}, // ,
{0b00001000,0b00001000,0b00001000,0b00001000,0b00001000}, // -
{0b00000000,0b01100000,0b01100000,0b00000000,0b00000000}, // .
{0b00100000,0b00010000,0b00001000,0b00000100,0b00000010}, // /
{0b00111110,0b01010001,0b01001001,0b01000101,0b00111110}, // 0
{0b00000000,0b01000010,0b01111111,0b01000000,0b00000000}, // 1
{0b01000010,0b01100001,0b01010001,0b01001001,0b01000110}, // 2
{0b00100001,0b01000001,0b01000101,0b01001011,0b00110001}, // 3
{0b00011000,0b00010100,0b00010010,0b01111111,0b00010000}, // 4
{0b00100111,0b01000101,0b01000101,0b01000101,0b00111001}, // 5
{0b00111100,0b01001010,0b01001001,0b01001001,0b00110000}, // 6
{0b00000011,0b01110001,0b00001001,0b00000101,0b00000011}, // 7
{0b00110110,0b01001001,0b01001001,0b01001001,0b00110110}, // 8
{0b00000110,0b01001001,0b01001001,0b00101001,0b00011110}, // 9
{0b00000000,0b01101100,0b01101100,0b00000000,0b00000000}, // :
{0b00000000,0b01010110,0b00110110,0b00000000,0b00000000}, // ;
{0b00001000,0b00010100,0b00100010,0b01000001,0b00000000}, // <
{0b00010100,0b00010100,0b00010100,0b00010100,0b00010100}, // =
{0b00000000,0b01000001,0b00100010,0b00010100,0b00001000}, // >
{0b00000010,0b00000001,0b01010001,0b00001001,0b00000110}, // ?
{0b00110010,0b01001001,0b01111001,0b01000001,0b00111110}, // @
{0b01111110,0b00010001,0b00010001,0b00010001,0b01111110}, // A
{0b01111111,0b01001001,0b01001001,0b01001001,0b00111110}, // B
{0b00111110,0b01000001,0b01000001,0b01000001,0b00100010}, // C
{0b01111111,0b01000001,0b01000001,0b01000001,0b00111110}, // D
{0b01111111,0b01001001,0b01001001,0b01001001,0b01001001}, // E
{0b01111111,0b00001001,0b00001001,0b00001001,0b00000001}, // F
{0b00111110,0b01000001,0b01001001,0b01001001,0b00111010}, // G
{0b01111111,0b00001000,0b00001000,0b00001000,0b01111111}, // H
{0b01000001,0b01000001,0b01111111,0b01000001,0b01000001}, // I
{0b00110000,0b01000001,0b01000001,0b00111111,0b00000001}, // J
{0b01111111,0b00001000,0b00010100,0b00100010,0b01000001}, // K
{0b01111111,0b01000000,0b01000000,0b01000000,0b01000000}, // L
{0b01111111,0b00000010,0b00001100,0b00000010,0b01111111}, // M
{0b01111111,0b00000100,0b00001000,0b00010000,0b01111111}, // N
{0b00111110,0b01000001,0b01000001,0b01000001,0b00111110}, // O
{0b01111111,0b00001001,0b00001001,0b00001001,0b00000110}, // P
{0b00111110,0b01000001,0b01010001,0b00100001,0b01011110}, // Q
{0b01111111,0b00001001,0b00001001,0b00011001,0b01100110}, // R
{0b01000110,0b01001001,0b01001001,0b01001001,0b00110001}, // S
{0b00000001,0b00000001,0b01111111,0b00000001,0b00000001}, // T
{0b00111111,0b01000000,0b01000000,0b01000000,0b00111111}, // U
{0b00001111,0b00110000,0b01000000,0b00110000,0b00001111}, // V
{0b00111111,0b01000000,0b00111000,0b01000000,0b00111111}, // W
{0b01100011,0b00010100,0b00001000,0b00010100,0b01100011}, // X
{0b00000011,0b00000100,0b01111000,0b00000100,0b00000011}, // Y
{0b01100001,0b01010001,0b01001001,0b01000101,0b01000011}, // Z
{0b01111111,0b01000001,0b01000001,0b00000000,0b00000000}, // [
{0b00000010,0b00000100,0b00001000,0b00010000,0b00100000}, // '\'
{0b00000000,0b00000000,0b01000001,0b01000001,0b01111111}, // ]
{0b00000100,0b00000010,0b00000001,0b00000010,0b00000100}, // ^
{0b01000000,0b01000000,0b01000000,0b01000000,0b01000000}, // _
{0b00000000,0b00000001,0b00000010,0b00000100,0b00000000}, // `
{0b00000000,0b01100001,0b00000000,0b00000000,0b00000000}, // a
{0b01111111,0b01001000,0b01000100,0b01000100,0b00111000}, // 0b
{0b00111000,0b01000100,0b01000100,0b01000100,0b00100000}, // c
{0b00111000,0b01000100,0b01000100,0b01001000,0b01111111}, // d
{0b00111000,0b01010100,0b01010100,0b01010100,0b00011000}, // e
{0b00001000,0b01111110,0b00001001,0b00000001,0b00000010}, // f
{0b00001100,0b01010010,0b01010010,0b01010010,0b00111110}, // g
{0b01111111,0b00001000,0b00000100,0b00000100,0b01111000}, // h
{0b00000000,0b01000100,0b01111101,0b01000000,0b00000000}, // i
{0b00100000,0b01000000,0b01000100,0b00111101,0b00000000}, // j
{0b01111111,0b00010000,0b00101000,0b01000100,0b00000000}, // k
{0b00000000,0b01000001,0b01111111,0b01000000,0b00000000}, // l
{0b01111000,0b00000100,0b00001000,0b00000100,0b01111000}, // m
{0b01111100,0b00001000,0b00000100,0b00000100,0b01111000}, // n
{0b00111000,0b01000100,0b01000100,0b01000100,0b00111000}, // o
{0b01111100,0b00010100,0b00010100,0b00010100,0b00001000}, // p
{0b00001000,0b00010100,0b00010100,0b01111100,0b00000000}, // q
{0b01111100,0b00001000,0b00000100,0b00000100,0b00001000}, // r
{0b01001000,0b01010100,0b01010100,0b01010100,0b00100000}, // s
{0b00000100,0b00111111,0b01000100,0b01000000,0b00100000}, // t
{0b00111100,0b01000000,0b01000000,0b00100000,0b01111100}, // u
{0b00011100,0b00100000,0b01000000,0b00100000,0b00011100}, // v
{0b00111100,0b01000000,0b00110000,0b01000000,0b00111100}, // w
{0b01000100,0b00101000,0b00010000,0b00101000,0b01000100}, // x
{0b00001100,0b01010000,0b01010000,0b01010000,0b00111100}, // y
{0b01000100,0b01100100,0b01010100,0b01001100,0b01000100}, // z
{0b00000000,0b00001000,0b00110110,0b01000001,0b00000000}, // {
{0b00000000,0b00000000,0b01111111,0b00000000,0b00000000}, // |
{0b00000000,0b01000001,0b00110110,0b00001000,0b00000000}, // }
{0b00001000,0b00000100,0b00000100,0b00001000,0b00000100} // ~
}; // characters[95]

// Buffer array of bytes to store current display data for each column in each cascaded device
uint8_t buffer [NUM_DEVICES*8];

// Initializes SPI
void initSPI(void)
{

/* ustawienie kierunku wyjściowego dla linii MOSI, SCK i CS */
DDRB |= (1< /* aktywacja SPI, tryb pracy Master, prędkość zegara Fosc/64 */
SPCR |= (1<
}

// Send byte through SPI
void writeByte(uint8_t byte)
{
SPDR = byte; // SPI starts sending immediately
while(!(SPSR & (1 << SPIF))); // Loop until complete bit set
}

// Sends word through SPI
void writeWord(uint8_t address, uint8_t data)
{
writeByte(address);// Write first byte
writeByte(data); // Write Second byte
}

// Initializes all cascaded devices
void initMatrix()
{
uint8_t i;// Var used in for loops

// Set display brighness
SLAVE_SELECT;
for(i = 0; i < NUM_DEVICES; i++) // Loop through number of cascaded devices
{
writeByte(0x0A); // Select Intensity register
writeByte(0x07); // Set brightness
}
SLAVE_DESELECT;

// Set display refresh
SLAVE_SELECT;
for(i = 0; i < NUM_DEVICES; i++)
{
writeByte(0x0B); // Select Scan-Limit register
writeByte(0x07); // Select columns 0-7
}
SLAVE_DESELECT;

// Turn on the display
SLAVE_SELECT;
for(i = 0; i < NUM_DEVICES; i++)
{
writeByte(0x0C); // Select Shutdown register
writeByte(0x01); // Select Normal Operation mode
}
SLAVE_DESELECT;

// Disable Display-Test
SLAVE_SELECT;
for(i = 0; i < NUM_DEVICES; i++)
{
writeByte(0x0F); // Select Display-Test register
writeByte(0x00); // Disable Display-Test
}
SLAVE_DESELECT;
}

// Clears all columns on all devices
void clearMatrix(void)
{
for(uint8_t x = 1; x < 9; x++) // for all columns
{
SLAVE_SELECT;
for(uint8_t i = 0; i < NUM_DEVICES; i++)
{
writeByte(x); // Select column x
writeByte(0x00); // Set column to 0
}
SLAVE_DESELECT;
}
}

// Initializes buffer empty
void initBuffer(void)
{
for(uint8_t i = 0; i < NUM_DEVICES*8; i++)
buffer[i] = 0x00;
}

// Moves each byte forward in the buffer and adds next byte in at the end
void pushBuffer(uint8_t x)
{
for(uint8_t i = 0; i < NUM_DEVICES*8 - 1; i++)
buffer[i] = buffer[i+1];

buffer[NUM_DEVICES*8 - 1] = x;
}

// Pushes in 5 characters columns into the buffer.
void pushCharacter(uint8_t c)
{
for(uint8_t i = 0; i < 5; i++)// For 5 bytes representing each character
{
pushBuffer(pgm_read_byte(&characters[c][i])); // Push the byte from the characters array to the display buffer
displayBuffer();// Display the current buffer on the devices
_delay_us(DEL);// and delay
}
}

// Takes a pointer to the beginning of a char array holding message, and array size, scrolls message.
void displayMessage(const char *arrayPointer, uint16_t arraySize)
{
for(uint16_t i = 0; i < arraySize; i++)
{
pushCharacter(pgm_read_byte_near(arrayPointer + i) - 32);// Send converted ASCII value of character in message to index in characters array (-32 sends corrent index to characters array)
pushBuffer(0x00);// Add empty column after character for letter spacing
displayBuffer();// Display &
_delay_us(DEL); // Delay
}

}

// Displays current buffer on the cascaded devices
void displayBuffer()
{
for(uint8_t i = 0; i < NUM_DEVICES; i++) // For each cascaded device
{
for(uint8_t j = 1; j < 9; j++) // For each column
{
SLAVE_SELECT;

for(uint8_t k = 0; k < i; k++) // Write Pre No-Op code
writeWord(0x00, 0x00);

writeWord(j, buffer[j + i*8 - 1]); // Write column data from buffer

for(uint8_t k = NUM_DEVICES-1; k > i; k--) // Write Post No-Op code
writeWord(0x00, 0x00);

SLAVE_DESELECT;
}
}
}[/syntax]

max7219_8x8.h

[syntax=c]/*
* max7219_8x8.h
*
* Created on: 2017-09-20
* Author: Mirek
*/

#ifndef MAX7219_8X8_H_
#define MAX7219_8X8_H_

/* hardware SPI */
#define MOSI PB3// <---- DIN
#define SCK PB5// <---- SCK
#define CS PB2// <---- CS

#define SLAVE_SELECT PORTB &= ~(1 << CS)
#define SLAVE_DESELECT PORTB |= (1 << CS)

char characters[96][5];
// Function Prototypes

void initSPI(void);

void writeByte(uint8_t byte);

void writeWord(uint8_t address, uint8_t data);

void initMatrix(void);

void clearMatrix(void);

void initBuffer(void);

void pushBuffer(uint8_t x);

void pushCharacter(uint8_t c);

void displayMessage(const char *arrayPointer, uint16_t arraySize);

void displayBuffer(void);

#endif /* MAX7219_8X8_H_ */[/syntax]

Powiedzmy ze jak wyślę bajt 0b01100001 do rejestru funkcją displayMessage to na wyświetlaczu LED zaświecą się diody.

i będą się przesuwać z dołu do góry a następnie znowu od dołu do góry na następnym wyświetlaczu.

Statystyki: Napisane przez mirek1968 — 29 paź 2017, o 18:18

Re: Zmiana kierunku scrollowania tekstu LED 32X8 z MAX7219

2017-10-29T15:06:27+01:00

Koledze micky nie chodziło o schemat matrycy LED tylko o sposób podłączenia do sterownika MAX7219 i dokładniej o ułożenie bajtów i bitów przesyłanych do wyświetlacza. Powiedzmy, że wysyłasz bajt 0b01100001 do drugiego rejestru układu MAX7219. To które piksele zapalają się w Twojej matrycy?

Statystyki: Napisane przez janusz17 — 29 paź 2017, o 15:06

Re: Zmiana kierunku scrollowania tekstu LED 32X8 z MAX7219

2017-10-29T14:05:39+01:00

Pozostałe rzędy to dokładnie tak jak na tym zdjęciu pojedyńczego led 8X8.
Jak znajdę troszkę czasu to obejrzę filmik.MK.

Wyświetlacz składa się z takich czterech LED każdy ma w sobie układ MAX7219.

Statystyki: Napisane przez mirek1968 — 29 paź 2017, o 14:05

Re: Zmiana kierunku scrollowania tekstu LED 32X8 z MAX7219

2017-10-29T13:09:10+01:00

Rozpisz pozostałe rzędy. Dopóki nie będzie wiadomo jak ułożone bajty w stosunku do wyświetlacza oraz bity (również to gdzie najmłodszy a gdzie najstarszy) w tych bajtach to nic dalej nie zrobimy.
Obejrzyj filmik Mirka nt. Magic Matrixa - tam też były tego typu informacje - dotyczące organizacji.

Statystyki: Napisane przez micky — 29 paź 2017, o 13:09

Re: Zmiana kierunku scrollowania tekstu LED 32X8 z MAX7219

2017-10-29T12:54:41+01:00

Zastosowałem się do Twojej uwagi. Wstawiam screena z mapą bitowa mojego LED.

Proszę o dalszą pomoc co robimy dalej:-)

Statystyki: Napisane przez mirek1968 — 29 paź 2017, o 12:54

Re: Zmiana kierunku scrollowania tekstu LED 32X8 z MAX7219

2017-10-29T12:23:32+01:00

Zacznij od narysowania sobie mapy pamięci ekranu czyli w jakim bajcie bufora znajduje się każdy piksel. Bez tego nie ma co iść dalej.

Statystyki: Napisane przez micky — 29 paź 2017, o 12:23

Zmiana kierunku scrollowania tekstu LED 32X8 z MAX7219

2017-10-29T10:34:03+01:00

Napisałem nowy wątek ponieważ chciałbym zrozumieć zasadę działania funkcji zmiany kierunku scrollowania fontów na moim panelu czterech wyświetlaczy LED 8X8 z układami MAX7219.
Od razu zacznę od tego że nie chodzi mi o podanie gotowców ani o odsyłenie do przeczytania książek i do google ale o pomoc w zrozumieniu działania pewnych funkcji nie mojego autorstwa które przerobiłem sobie z Arduino-dostosowałem w c avr.
Tyle na wstępie teraz zacznę od konkretów.
Obecnie mój połączony kaskadowo wyświetlacz pokazuje tekst scrollowany od dołu w górę a ja chciałbym to zmienić tak abym mógł przesuwać np. w lewo lub prawo.
Podam kilka funkcji z mojego programu i proszę o pomoc w zrozumieniu co odpowiada za kierunek przesuwania tekstu.
Na razie nie będę to przedstawiał całego kodu ale tylko funkcję które jak mi się wydaje mogą mieć związek z moim problemem.
[syntax=c]// Inicjalizacja pustego bufora
void initBuffer(void)
{
for(uint8_t i = 0; i < NUM_DEVICES*8; i++)
buffer[i] = 0x00;
}

// Przenosi każdy bajt do przodu w buforze i dodaje na końcu następny bajt
void pushBuffer(uint8_t x)
{
for(uint8_t i = 0; i < NUM_DEVICES*8 - 1; i++)
buffer[i] = buffer[i+1];

buffer[NUM_DEVICES*8 - 1] = x;
}

// Wstawia bufor w postaci 5 znaków.
void pushCharacter(uint8_t c)
{
for(uint8_t i = 0; i < 5; i++)// Dla 5 bajtów reprezentujących każdy znak
{
pushBuffer(pgm_read_byte(&characters[c][i])); // Push the byte from the characters array to the display buffer
displayBuffer();// Display the current buffer on the devices
_delay_us(DEL);// and delay
}
}

// Takes a pointer to the beginning of a char array holding message, and array size, scrolls message.
void displayMessage(const char *arrayPointer, uint16_t arraySize)
{
for(uint16_t i = 0; i < arraySize; i++)
{
pushCharacter(pgm_read_byte_near(arrayPointer + i) - 32);// Send converted ASCII value of character in message to index in characters array (-32 sends corrent index to characters array)
pushBuffer(0x00);// Add empty column after character for letter spacing
displayBuffer();// Display &
_delay_us(DEL); // Delay
}

}

// Displays current buffer on the cascaded devices
void displayBuffer()
{
for(uint8_t i = 0; i < NUM_DEVICES; i++) // For each cascaded device
{
for(uint8_t j = 1; j < 9; j++) // For each column
{
SLAVE_SELECT;

for(uint8_t k = 0; k < i; k++) // Write Pre No-Op code
writeWord(0x00, 0x00);

writeWord(j, buffer[j + i*8 - 1]); // Write column data from buffer

for(uint8_t k = NUM_DEVICES-1; k > i; k--) // Write Post No-Op code
writeWord(0x00, 0x00);

SLAVE_DESELECT;
}
}
}[/syntax]

Proszę o jak potrzeba o dodatkowe pytania oraz oczywiście o pomoc w zrozumieniu co i w której funkcji odpowiedzialne jest za kierunek scrollowania bo tylko o sposób zmiany kierunku mi chodzi.

Statystyki: Napisane przez mirek1968 — 29 paź 2017, o 10:34