ATNEL tech-forum

Re: Scrolowanie tekstu matryca LED 4x 8*8 max7219

2016-12-23T21:55:49+01:00

mirekk36 napisał(a):

Mysteziz napisał(a):

natomiast po podłączeniu kolejnej na obu wyświetla mi się to samo.

To znaczy, że pewnikiem żeś pan to źle połączył elektrycznie - nie ma innego wyjścia

Okazało się że źle zrozumiałem jedno zdanie z PDF-a i miałem błąd w programie, a przy tym źle zrobione zasilanie(za mała moc i był spadek napięcia jak ledy dały czadu) i wszystko głupiało. Więc elektrycznie też było źle-dziękuję za podpowiedź:)

Statystyki: Napisane przez Mysteziz — 23 gru 2016, o 21:55

Re: Scrolowanie tekstu matryca LED 4x 8*8 max7219

2016-12-21T20:55:35+01:00

Mysteziz napisał(a):

natomiast po podłączeniu kolejnej na obu wyświetla mi się to samo.

To znaczy, że pewnikiem żeś pan to źle połączył elektrycznie - nie ma innego wyjścia

Statystyki: Napisane przez mirekk36 — 21 gru 2016, o 20:55

Re: Scrolowanie tekstu matryca LED 4x 8*8 max7219

2016-12-21T20:27:13+01:00

Hmm temat dawno nie ruszany ale poczytałem niestety w listingach bez komentarzy trochę się gubię. Proszę o pomoc, czy ktoś może mi wyjaśnić jak wysłać dane do kilku matryc połączonych szeregowo? Tzn te z układem MAX7219 czyli sterowanie przez spi. Nie chcę gotowego kodu, jedną matrycę z takim sterownikiem potrafię obsłużyć natomiast po podłączeniu kolejnej na obu wyświetla mi się to samo.Czy na 2 wyświetlacze ramka danych na spi ma mieć długość 4 bajty? Czy jakiś odstęp pomiędzy ramkami? Czy jakoś inaczej zaadresować linię drugiej matrycy?

Statystyki: Napisane przez Mysteziz — 21 gru 2016, o 20:27

Re: Scrolowanie tekstu matryca LED 4x 8*8 max7219

2014-07-03T09:05:54+01:00

iframe

Statystyki: Napisane przez BIGjack — 3 lip 2014, o 09:05

Re: Scrolowanie tekstu matryca LED 4x 8*8 max7219

2014-06-27T10:59:53+01:00

W chwili obecnej robię tak że pobieram 8 bajtów przedstawiających dany znak z tablicy;

[syntax=c]static const char disp1[][8] PROGMEM ={

{0B01110000, 0B10001000, 0B10011000, 0B10101000, 0B11001000, 0B10001000, 0B01110000, 0B00000000}, //0
{0B00100000, 0B01100000, 0B00100000, 0B00100000, 0B00100000, 0B00100000, 0B01110000, 0B00000000},//1
{0B01110000, 0B10001000, 0B00001000, 0B00010000, 0B00100000, 0B01000000, 0B11111000, 0B00000000}, //2
{0B11111000, 0B00010000, 0B00100000, 0B00010000, 0B00001000, 0B10001000, 0B01110000, 0B00000000}, //3
{0B00010000, 0B00110000, 0B01010000, 0B10010000, 0B11111000, 0B00010000, 0B00010000, 0B00000000}, //4
{0B11111000, 0B10000000, 0B11110000, 0B00001000, 0B00001000, 0B10001000, 0B01110000, 0B00000000}, //5
{0B00110000, 0B01000000, 0B10000000, 0B11110000, 0B10001000, 0B10001000, 0B01110000, 0B00000000}, //6
{0B11111000, 0B10001000, 0B00001000, 0B00010000, 0B00100000, 0B00100000, 0B00100000, 0B00000000}, //7
{0B01110000, 0B10001000, 0B10001000, 0B01110000, 0B10001000, 0B10001000, 0B01110000, 0B00000000}, //8
{0B01110000, 0B10001000, 0B10001000, 0B01111000, 0B00001000, 0B00010000, 0B01100000, 0B00000000}, //9
;[/syntax]

natępnie napełniam danymi z tej tablicy bufor hmm i tu pewnie będzie zonk bufor jest 64 bitowy

[syntax=c]uint64_t bufor_temp[8];[/syntax]

i dopiero na tym robię przesunięcia bitowe po czym napełniam bufor matrycy również 64bit hmm..

Wydaje mi się że to nie tak powinno wyglądać pomimo tego że działa

Statystyki: Napisane przez BIGjack — 27 cze 2014, o 10:59

Re: Scrolowanie tekstu matryca LED 4x 8*8 max7219

2014-06-27T09:53:59+01:00

BIGjack napisał(a):

Czy mam tworzyć struktury bitowe

Nigdy w życiu ... tworzysz mapę pamięci w bajtach, gdzie każdy bit odpowiada jednemu pixelowi. Możesz więc układać bajty albo pionowo albo poziomo - zależy jak będzie ci wygodniej później pisać funkcje obsługi znaków czy też w ogóle operowania na tej pamięci buforowanej ...

------------------------ [ Dodano po: 2 minutach ]

aha no chyba że korzystasz z generatora znaków w tym układzie max to sprawa się jeszcze bardziej upraszcza bo potrzebujesz pamięci tylko na kody ASCII znaków a nie na piksele

Statystyki: Napisane przez mirekk36 — 27 cze 2014, o 09:53

Re: Scrolowanie tekstu matryca LED 4x 8*8 max7219

2014-06-27T09:34:16+01:00

Krauser napisał(a):

i zobaczyłem to:

tak jest to majstersztyk jeżeli chodzi o wyświetlanie na lcd.
Mnie nurtuje cały czas jak podejść do tego bufora wyświetlacza led matrix. Czy mam tworzyć struktury bitowe,
czy może operacje na całych bajtach - maskowanie,przesunięcia itp.

Statystyki: Napisane przez BIGjack — 27 cze 2014, o 09:34

Re: Scrolowanie tekstu matryca LED 4x 8*8 max7219

2014-06-26T21:55:06+01:00

Doskonale Cię rozumiem. Kiedyś kombinowałem ze scrollowaniem na LCD 2*16 i zobaczyłem to:

iframe

W każdym przypadku zawsze należy używać funkcji, która bufor z danymi wysyła na wyświetlacz, a cała zabawa, która polega przykładowo na: przesuwaniu napisu, rozpadaniu się napisu, układaniu napisu z kawałków i wreszcie operacjach 3D odbywa się na tym buforze. Jakie proste, a zarazem genialne.

Statystyki: Napisane przez Krauser — 26 cze 2014, o 21:55

Re: Scrolowanie tekstu matryca LED 4x 8*8 max7219

2014-06-26T19:57:25+01:00

Siedzę sobie nad moimi matrycami, kombinuje jak tu zrobić fajne skrolowanie a tu nagle na YT zobaczyłem to;

iframe

Wbiło mnie w fotel, koleś pisze ze to są matryce sterowanie przez max-y7219.
Ręce mi opadły

Statystyki: Napisane przez BIGjack — 26 cze 2014, o 19:57

Re: Scrolowanie tekstu matryca LED 4x 8*8 max7219

2014-06-25T15:40:03+01:00

Zrobiłem krok naprzód Wyświetlają mi się nazwy dni tygodnia tak jak zakładałem.

iframe

Nie wiem jednak czy idę w dobrym kierunku bo pakuję linie znaków z tablicy do buforów 64bitowych i stosuje przesunięcia bitowe aby poustawiać
je w odpowiednie miejsca no i skrolować oczywiście hmmmm....

Statystyki: Napisane przez BIGjack — 25 cze 2014, o 15:40

Re: Scrolowanie tekstu matryca LED 4x 8*8 max7219

2014-06-14T10:28:45+01:00

Może bufor większy. U mnie w tym przykładzie było chyba kolo 200 B.

Wysłane z mojego GT-I9505 przy użyciu Tapatalka

Statystyki: Napisane przez sq8dsr — 14 cze 2014, o 10:28

Re: Scrolowanie tekstu matryca LED 4x 8*8 max7219

2014-06-13T18:52:01+01:00

mokrowski napisał(a):

Niech zgadnę. Wydłużyć bufor tak aby był "jeden wyświetlacz wirtualny z prawej" ?

Tak, między innymi.
Koniec radosnej twórczości Wszystko jest ok dopóki wyświetlany tekst ma nie więcej
niż 4 znaki ponieważ mój bufor to 8 bajtów z czego 4 są wyświetlane a pozostałe z prawej strony poza wyświetlaczem
czekają na wsunięcie do matrycy. Nie mam pomysłu jak zrobić przewijanie dłuższego napisu

Statystyki: Napisane przez BIGjack — 13 cze 2014, o 18:52

Re: Scrolowanie tekstu matryca LED 4x 8*8 max7219

2014-06-13T18:43:14+01:00

rozwiązanie jest co najmniej banalne właśnie robię testy.

iframe

Statystyki: Napisane przez BIGjack — 13 cze 2014, o 15:15

Re: Scrolowanie tekstu matryca LED 4x 8*8 max7219

2014-06-13T12:30:58+01:00

Tak czy inaczej na samej matrycy osiągnąłeś efekt przesuwania się "bit bo bicie". Coś z tym przesuwaniem bufora jest jeszcze nie do końca dobrze. Nie bardzo rozumiem czemu się tak dzieje. Sam się przymierzam do czegoś takiego ale nie mam matryc...

Statystyki: Napisane przez sq8dsr — 13 cze 2014, o 12:30

Re: Scrolowanie tekstu matryca LED 4x 8*8 max7219

2014-06-11T21:52:05+01:00

Zrobiłem maleńki kroczek do przodu. Wbijając sobie do głowy wskazówki sq8dsr napisałem funkcję która z bufora w ram wysyła pojedyncze znaki
do sterownika matryc max7219. Wygląda to tak (z lekką dozą nieśmiałości wklejam swoje wypociny )
[syntax=c]void led_output(uint8_t cy1) {

uint8_t bufor_temp[8];
for (uint8_t i = 1; i < 9; i++) {

bufor_temp[i - 1] = pgm_read_byte(&disp1[cy1][i-1]);
bufor_scroll[i - 1] = bufor_scroll[i - 1] | bufor_temp[i - 1];

}

for (uint8_t j = 0; j < 8; j++) {
for (unsigned char i = 0; i < 8; i++) {

bufor_scroll[i] = (bufor_scroll[i] << 1);
_delay_ms(10);
}

for (uint8_t i = 1; i < 9; i++) {

MAX7219_LOAD0;
MAX7219_writeData1(i, bufor_scroll[i - 1] >> 0);
MAX7219_writeData1(i, bufor_scroll[i - 1] >> 8);
MAX7219_writeData1(i, bufor_scroll[i - 1] >> 16);
MAX7219_writeData1(i, bufor_scroll[i - 1] >> 24);
MAX7219_LOAD1;

}
_delay_ms(1);
}[/syntax]

Problem w tym że nie potrafię zrobić aby znaki pojawiały się poza matrycą i wsuwały się bit po bicie.
Teraz jest tak że znak pojawia się na ostatniej matrycy następnie przesuwa się na ułamek sekundy
zatrzymuje i pojawia się następny ale to nie wygląda dobrze. Na filmie jest to trochę "uwypuklone"

iframe

Statystyki: Napisane przez BIGjack — 11 cze 2014, o 21:52

Re: Scrolowanie tekstu matryca LED 4x 8*8 max7219

2014-06-09T14:58:43+01:00

To jest tylko użycie SPI do wysłania bitów do rejestru. To nie jest pełna komunikacja SPI.

To jest taka funkcja:
[syntax=c]void led_disp(uint8_t anodes, uint16_t segments) {

SPDR = anodes;//wysłanie danych do włączenia anod
while( !(SPSR & (1<
SPCR |= (1<
SPDR = segments>>8;//wysłanie danych do włączenia segmentów
while( !(SPSR & (1<
SPDR = segments;//wysłanie danych do włączenia segmentów
while( !(SPSR & (1<
SPCR &= ~(1<

PORTB |= (1<PORTB &= ~(1<
}[/syntax]

Tam w niej jest tylko jeden taki myk z odwróceniem kolejności bitów. (Ustawienie bitu DORD w SPCR) Wynika to z tego, że robiąc wyświetlacz pomyliłem kolejność wyprowadzeń jednego z rejestrów. Prościej więc było po przesłaniu pierwszego bajtu odwrócić kolejność niż zmieniać wszystkie wzorce bitowe dla znaków.

Statystyki: Napisane przez sq8dsr — 9 cze 2014, o 14:58

Re: Scrolowanie tekstu matryca LED 4x 8*8 max7219

2014-06-09T14:32:37+01:00

sq8dsr, jakiej biblioteki używasz do SPI?

Statystyki: Napisane przez BIGjack — 9 cze 2014, o 14:32

Re: Scrolowanie tekstu matryca LED 4x 8*8 max7219

2014-06-07T10:12:53+01:00

Dzięki za pomoc, niestety dopiero w poniedziałek będę mógł zasiąść do projektu.

Statystyki: Napisane przez BIGjack — 7 cze 2014, o 10:12

Re: Scrolowanie tekstu matryca LED 4x 8*8 max7219

2014-06-06T18:46:45+01:00

BIGjack napisał(a):

No i jeszcze o ile dobrze rozumiem kod to Ty przewijasz całe bajty a ja na swoich matrycach muszę przwijać bity.

No ja przewijam zawartość tablicy charowej. Ale kody znaków (jest ASCII) są podpięte pod wzorce bitowe znaków dla wyświetlacza 14-seg. Nie stosuje bowiem specjalizowanego kontrolera takich wyświetlaczy (Maxim takie robi) który posiadałby wbudowany dekoder znaków. Tutaj jest tablica, która zawiera 16 bitowe wzorce znaków. Analogiczne do takich do wyświetlacza 7 seg, tylko że tutaj potrzeba 15 bitów na znak.

Kod mogę odszukać i zobaczysz jak to wygląda.

------------------------ [ Dodano po: 13 minutach ]

To jest jakaś stara wersja kodu z pierwszych prób.

[syntax=c]/*
* common.c
*
* Created on: 18-10-2013
* Author: Michał Uryga
*/

#include
#include
#include
#include

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

uint8_t k1,k2,k3,k4; // deklaracja zmiennych stanu klawiszy
volatile uint16_t Timer1, Timer2=0; //timery
volatile uint8_t state; //flaga odczytu czasu z RTC
volatile uint8_t disp_flag; //flaga wywietlacza

char tekst[9]; //bufor do konwersji na kody 14_seg
uint16_t i=0; //licznik do scrolla

char scroll[64] = " GODZINA -> XX-XX-XX DATA -> XX/XX/XXXX "; //tablica z całym tekstem
char modes[9] = "SET H ";
char days [8][14] = { {"NIEDZIELA "},{"PONIEDZIALEK "},{"WTOREK "},{"SRODA "},{"CZWARTEK "},{"PIATEK "},{"SOBOTA "}};

char okno[9]; //tablica zawierająca aktualny fragment wyswietlanego tekstu

// tablica wzorów znaków
const uint16_t znak[] = {
0b0000000000000000,
0b0000000001001010,
0b0100010000000000,
0b0000000000000000,
0b1011011101001000,
0b0000000000000000,
0b0000000000000000,
0b0000010000000000,
0b0000010000000000,
0b0000010000000000,
0b0000001111111100,
0b0000001101001000,
0b0000000000000100,
0b0000001100000000,
0b0000000000000010,
0b0000000000100100,

0b1111110000100100,// 0
0b0110000000100000,// 1
0b1101000100000100,// 2
0xf100, // 3
0b0110011100000000,// 4
0b1011011100000000,// 5
0b1011111100000000,// 6
0b1000000000101000,// 7
0xFF00,// 8
0b1111011100000000,// 9
0b0000000000000000,
0b0000000000000000,
0b0000000000110000,
0b0001000000000000,
0b0000000010000100,
0b1100000100001010,
0b1101110101000000,

0b1110111100000000, // A - 11
0b1111000101001000, // B - 12
0b1001110000000000, // C - 13
0b1111000001001000, // D - 14
0b1001111100000000, // E
0b1000111000000000, // F
0b1011110100000000, // G
0b0110111100000000, // H
0b1001000001001000, // I
0b0111100000000000, // J
0b0000111000110000, // K
0b0001110000000000, // L
0b0110110010100000, // M
0b0110110010010000, // N
0b1111110000000000, // O
0b1100111100000000, // P
0b1111110000010000, // Q
0b1100111100010000, // R
0b1011011100000000, // S
0b1000000001001000, // T
0b0111110000000000, // U
0b0000110000100100, // V
0b0110110000010100, // W
0b0000000010110100, // X
0b0100011100001000, // Y
0b1001000000100100, // Z
};

// tablica sterowania anodami
const uint8_t anody[] = {
1, 2, 4, 8, 16, 32, 64, 128, 255
};

// tablica do konwersji liczb 32 bit
char liczba[9];

// tablica zawartości pozycji
uint8_t cy[9];

void INT1_ON(void){
MCUCR |= (1<GICR |= (1<}

void INT1_OFF(void){
GICR &= ~(1<}

// funkcja konwersji liczby do pozycji 7seg
void convert_new(uint32_t value){
uint8_t i; //zmienna do pętli FOR

ltoa(value, liczba, 10);

for (i=0; i<8; i++){
if(liczba[i]==0) cy[i]=10; else
cy[i] = liczba[i] - '0'; //magiczna konwersja :P
}
}

void led_str(char *s, char *bufor) {
uint8_t i=0;
while(*s) *bufor++ = *s++;

for (i=0;i<8;i++){
cy[i] = tekst[i]-32;
}
}

void timer_init(void){

// ustawienie TIMER0
TCCR0 |= (1<TCCR0 |= (1<OCR0 = 38;// wartosć do porównania (dotaktowy podział przez 80)
TIMSK |= (1<}

void tablica (char *x, char *scrol){

while(*x) *scrol++ = *x++;
}

void przewijanie (void){
static uint8_tj;

while (scroll[i] && !(disp_flag)) { //przesuwanie się o jeden znak po dużej tablicy

if (Timer2==200) { //opóźnienie nieblokujące

for (j=0; j<8; j++){ //napełnianianie tablicy aktualnej zawartosci disp
okno[j] = scroll[i+j];
}

i++; //kolejny element dużej tablicy

led_str(okno, tekst ); //konwersja na znaki disp
Timer2=0; //zerujemy timer

}
}
if (scroll[i]==0) i=0; //Cofnięcie do pierwszego elementu po zakończeniu
}

void multiplex(void) {

if (disp_flag) {
static uint8_t licznik=0; // zmienna licznik - wzkazuje poszczególnie katody

if (licznik==0){ // załącznie wyświtelacza 1
led_disp(anody[licznik], znak[cy[0]]); //wysłanie danych do rejestrów przez SPI
}

if (licznik==1){ // załącznie wyświtelacza 2
led_disp(anody[licznik], znak[cy[1]]);
}

if (licznik==2){ // załącznie wyświtelacza 3
led_disp(anody[licznik], znak[cy[2]]);
}

if (licznik==3){ // załącznie wyświtelacza 4
led_disp(anody[licznik], znak[cy[3]]);
}

if (licznik==4){ // załącznie wyświtelacza 5
led_disp(anody[licznik], znak[cy[4]]);
}

if (licznik==5){ // załącznie wyświtelacza 6
led_disp(anody[licznik], znak[cy[5]]);
}

if (licznik==6){ // załącznie wyświtelacza 7
led_disp(anody[licznik], znak[cy[6]]);
}

if (licznik==7){ // załącznie wyświtelacza 8
led_disp(anody[licznik], znak[cy[7]]);
}

licznik++; //przesunięcie załączonej anody

if(licznik==8) { //powrót do pierwszej anody
licznik=0;
}
disp_flag=0;

} // koniec sprawdzania disp_flag
}

// PRZERWANIA
ISR(TIMER0_COMP_vect){

//ustawienie flagi do funkcji multipleksowania wywietlacza.
disp_flag=1;

//obsługa Timera1 programowego do obługi klawiszy
uint16_t n;
n = Timer1;
if (n) Timer1 = --n;

//obsługa Timera2 programowego
Timer2++;

}

ISR(INT1_vect) {

state=0; //ustawienie flagi wykonania odczytu czasu
led_tog;

//if (mode>8) mode=0; else mode++; //ustawienie flagi przełączania czas/data

}[/syntax]

[syntax=c]/*
* pcf_8583.c
*
* Created on: 23-10-2013
* Author: Michał Uryga
*/
#include
#include
#include
#include

#include "../I2C/i2c_twi.h"
#include "../common.h"
#include "ds_1307.h"

enum {ss, mm, hh};
uint8_t bufor[3]; // bufor do odczytu czasu
uint8_t sec, min, hou, yea, mth, day;
uint8_t s[3];
uint8_t m[3];
uint8_t h[3];
uint8_t date[4]; // bufor do odczytu daty
uint8_t ustawienie[4];

// zmienne do dzielenia div
div_t divmod_h,
divmod_m,
divmod_s,
divmod_yea,
divmod_mth,
divmod_day;

uint8_t mode=0;

void set_mode(void){

if(mode>3) {
mode=0;

}
else {
mode++;

}
}

void get_time_scroll(void){
TWI_read_buf( 0xD0, 0x00, 3, bufor);

sec = bcd2dec( bufor[ss]);
min = bcd2dec( bufor[mm]);
hou = bcd2dec( bufor[hh]);

divmod_m = div(min,10);
divmod_h = div(hou,10);
divmod_s = div(sec,10);

if(divmod_h.quot == 0) {
scroll[19]=0+32;} else {
scroll[19]=divmod_h.quot+48;}
scroll[20]=divmod_h.rem+48;

scroll[22]=divmod_m.quot+48;
scroll[23]=divmod_m.rem+48;

scroll[25]=divmod_s.quot+48;
scroll[26]=divmod_s.rem+48;

}

void get_date_scroll(void) {
uint8_t i=0;
TWI_read_buf( 0xD0, 0x03, 4, date);

//rok
yea = date[3];
yea = bcd2dec(yea);
divmod_yea = div(yea,10);
//zapis danych na odpowiednie pozycje do tablicy w RAM
scroll[45]=divmod_yea.quot+48;
scroll[46]=divmod_yea.rem+48;

//miesiąc
mth = date[2];
mth = bcd2dec(mth);
divmod_mth = div(mth,10);
//zapis danych na odpowiednie pozycje do tablicy w RAM
scroll[40] = divmod_mth.quot+48;
scroll[41] = divmod_mth.rem+48;

//dzień
day = date[1];
day = bcd2dec(day);
divmod_day = div(day,10);
//zapis danych na odpowiednie pozycje do tablicy w RAM
scroll[37] = divmod_day.quot+48;
scroll[38] = divmod_day.rem+48;

//dzien tygodnia
for (i=0; i<12; i++) {
scroll[49+i] = days[date[0]][i];
}

}

void set_date(uint8_t day, uint8_t mth, uint8_t year, uint8_t day_o_w) {

uint8_t zapis_daty[4];

zapis_daty[0] = day_o_w;
zapis_daty[1] = dec2bcd(day);
zapis_daty[2] = dec2bcd(mth);
zapis_daty[3] = dec2bcd(year);

TWI_write_buf(0xD0, 0x03, 4, zapis_daty);

}

void set_time (uint8_t hh, uint8_t mm){

ustawienie[0]=0;
ustawienie[1]=dec2bcd(mm); //minuta
ustawienie[2]=dec2bcd(hh); //godzina
TWI_write_buf(0xD0, 0x00, 3, ustawienie);

}[/syntax]

Myślę, że podobnie trzeba podejść do matryc.
Zrobić funkcję, która będzie wyświetlać znaki ASCII na matrycach. A przewijanie zrobić na tablicach. Niech ta funkcja "martwi" się o to jaki bity wysyłać żeby pokazała się litera. Mechanizm z tablicami powinien być poziom wyżej.

Statystyki: Napisane przez sq8dsr — 6 cze 2014, o 18:46

Re: Scrolowanie tekstu matryca LED 4x 8*8 max7219

2014-06-06T17:15:52+01:00

sq8dsr napisał(a):

W tym samym wątku masz mój kolejny przykłąd właśnie z zegarem, w którym scrollowanie odbywa się dynamicznie. Czyli przesuwające się liczby mogą zmieniać się podczas przesuwania się.
Odbywa się to tak, że wszystkie operacje odbyuwają się na buforze. A "okienko" cyklicznie przesuwa się po nim.

Różnica będzie tylko w sposobie sterowania wyświetlaczy.

Pięknie kolego to wygląda ale do drugiego przykładu już nawet interesującego mnie fragmentu kodu brak

No i jeszcze o ile dobrze rozumiem kod to Ty przewijasz całe bajty a ja na swoich matrycach muszę przwijać bity.
Nie mam problemu z wyświetleniem znaku z tablicy na matrycy i scrolowaniem ale nie wiem jak zrobić aby znak wsunąć na tablicę i po niej przesunąć.

Statystyki: Napisane przez BIGjack — 6 cze 2014, o 17:15

Re: Scrolowanie tekstu matryca LED 4x 8*8 max7219

2014-06-06T11:25:20+01:00

Może z tego coś Ci się przyda.

http://forum.atnel.pl/topic6879.html

Mechanizm uważam, że powinien być podobny. Czyli tablica (bufor) z tym co jest scrollowane. Na wyświetlacz wyrzucane jest "okienko" czyli mała tablica o długości takiej jak wyświetlacz i to się dzieje cały czas w tle (oczywiście z jakimś opóźnieniem).

W tym samym wątku masz mój kolejny przykłąd właśnie z zegarem, w którym scrollowanie odbywa się dynamicznie. Czyli przesuwające się liczby mogą zmieniać się podczas przesuwania się.
Odbywa się to tak, że wszystkie operacje odbyuwają się na buforze. A "okienko" cyklicznie przesuwa się po nim.

Różnica będzie tylko w sposobie sterowania wyświetlaczy.

Statystyki: Napisane przez sq8dsr — 6 cze 2014, o 11:25

Re: Scrolowanie tekstu matryca LED 4x 8*8 max7219

2014-06-06T10:57:56+01:00

dambo napisał(a):

Na forum wklejałem już tu swój kod w temacie odnośnie matryc 8x8

Możesz dać linka bo znalazłem tylko filmik z działania Twoich matryc.

Statystyki: Napisane przez BIGjack — 6 cze 2014, o 10:57

Scrolowanie tekstu matryca LED 4x 8*8 max7219

2014-06-06T09:59:34+01:00

Zrobiłem zegar z datą na matrycach 4x 8x8led sterowanych maxem7219, atmega8 ds3231.
Niestety nie wiem ja zrobić scrolowanie tekstu. Jest mi to potrzebne do wyświetlania daty z dniem tygodnia, scrolowanie dlatego że
data + dzień tygodnia nie mieści się na wyświetlaczach. Kiedyś jak robiłem na rejestrach 74hc595 to nie było problemu ponieważ
tam wstawiałem pojedyńcze kolumny dla całego wyświetlacza a w przypadku maxa "wypluwam" najpierw wszystkie linie dla pierwszego nastepnie dla kolejnych.
Chodzi mi konkretnie o sposób w którym napis zaczyna się poza prawą stroną matryc i przesuwa się w lewo w pętli.
Nie wiem jak do tego się zabrać hmmm.....

Oto fimik zegara na maxie;

iframe

Statystyki: Napisane przez BIGjack — 6 cze 2014, o 09:59