ATNEL tech-forum

Re: Mam dość matryc led

2015-06-14T18:55:53+01:00

witam

Problem rozwiązany. W sumie to banalna sprawa, ale jak się do tego dojdzie to każdy problem jest banalny.
Wielkie podziękowania dla Kolegi Krausera - za funkcje zapisujące fonty do bufora i na matryce
i dla Kolegi mokrowskiego - za ustawienie kolejności wierszy w przerwaniu
bez nich pewnie jeszcze bym się motał

Teraz dołączam kolejne matryce i zobaczę co z tego wyjdzie a całość przedstawię w dziale projektów.

pozdrawiam Marek

Statystyki: Napisane przez mczarny — 14 cze 2015, o 18:55

Re: Mam dość matryc led

2015-06-14T13:06:31+01:00

Jeszcze zauważyłem że u Ciebie font masz zdefiniowany w liniach pionowych
a w font.h chyba jest definiowany w liniach poziomych

Statystyki: Napisane przez Zaba — 14 cze 2015, o 13:06

Re: Mam dość matryc led

2015-06-14T12:32:48+01:00

Cześć,

mczarny napisał(a):

a próbowałeś ładować font do bufora wyświetlacza od końca fontu? powinien zniknąć efekt odbicia lustrzanego.

Marcin

Statystyki: Napisane przez marcin_c — 14 cze 2015, o 12:32

Re: Mam dość matryc led

2015-06-13T16:41:13+01:00

pobawiłem się trochę buforem i poustawiałem kolejność bitów, ale tak to nie może być bo przecież funkcja przepisywania kolumn korzysta z pliku "fonty.h" więc tam musiałbym ustawić ponownie fonty - bez sensu

wygląd bufora
[syntax=c]//bufor wyświetlacza
uint8_t display[] = {

0x00, 0x7E, 0x11, 0x11, 0x11, 0x7E, 0x00, 0x00,
0x04, 0x7F, 0x00, 0x01, 0x01, 0x7F, 0x01, 0x01,
0x49, 0x49, 0x49, 0x7F, 0x00, 0x7F, 0x10, 0x08,
0x00, 0x00, 0x40, 0x40, 0x40, 0x40, 0x7F, 0x00,

};[/syntax]

i widok matrycy

dodam jeszcze, że zmiana ustawienia fontów w buforze inaczej niż w osmiowierszowe pozycje daje totalną kaszanę na wyświetlaczu

Statystyki: Napisane przez mczarny — 13 cze 2015, o 16:41

Re: Mam dość matryc led

2015-06-13T08:38:36+01:00

cześć

Na razie chciałem zobaczyć jak działa funkcja Send_Row

po wpisaniu bufora i funkcji mamy coś takiego

mamy lustrzane odbicie znaków i w dodatku pomieszana kolejność

wpisałem do bufora same litery "A" to lepiej to widać

trzeba chyba wysyłać od razu cały wiersz i funkcja powinna pozwalać na budowanie dowolnie długiego wiersza....
w tej chwili to dla każdej matrycy budujemy osobny bajt - zgoda przy załóżmy 20 matrycach zbudujemy 20 bajtów, ale ta kolejność.....

Statystyki: Napisane przez mczarny — 13 cze 2015, o 08:38

Re: Mam dość matryc led

2015-06-11T22:49:44+01:00

Najlepiej to mieć bufor jako tablicę kolumn. Jest to bardziej naturalne można dowolnie rozszerzać i łatwo wtedy z jednego bufora kopiować do drugiego jednocześnie załatwiając sprawę przewijania. Skomplikuje to wysyłanie danych na wyświetlacz, ale uprości wpisywanie znaku do bufora:
[syntax=c]//bufor wyświetlacza
uint8_t display[32] = {
0x7E, 0x11, 0x11, 0x11, 0x7E,// A
0x00,
0x01, 0x01, 0x7F, 0x01, 0x01,// T
0x00,
0x7F, 0x04, 0x08, 0x10, 0x7F,// N
0x00,
0x7F, 0x49, 0x49, 0x49, 0x41,// E
0x00,
0x7F, 0x40, 0x40, 0x40, 0x40,// L
0x00,
0x00,
0x00,
};

void Send_Row(uint8_t rowNumber)
{
uint8_t buf;
for(uint8_t i = 0; i < 4; ++i) // 4 razy po 1/4 wiersza zostanie wysłane po SPI
{
buf = 0;
for(uint8_t k = 0; k < 8; ++k) //budowany bajt ma 8 bitów
{
buf |= ((display[i * 8 + k] >> rowNumber) & 0x01) << k; // 1/4 wiersza zbudowana z 8 bitów o numerze zgodnym z rowNumber
//jak rowNumber = 5 to każdy bit numer 5 z kolejnych 8 bajtów tworzy bajt do wysłania
}
Send_SPI(buf);
}
}

ISR(TIMER0_COMP_vect)
{
const static uint8_t multiplex_tablica1234[] PROGMEM = {~ROW1,~ROW2,~ROW3,~ROW4,255,255,255,255 };
const static uint8_t multiplex_tablica5678[] PROGMEM = {255,255,255,255,~ROW5,~ROW6,~ROW7,~ROW8 };
static uint8_t licznik = 0;
Row_Off();
Send_Row(licznik); //tylko numer wiersza
ROWPORT1234 = (ROWPORT1234 & ~ROW1234_MASK) | (pgm_read_byte(&multiplex_tablica1234[licznik]) & ROW1234_MASK);
ROWPORT5678 = (ROWPORT5678 & ~ROW5678_MASK) | (pgm_read_byte(&multiplex_tablica5678[licznik]) & ROW5678_MASK);
licznik++;
licznik &= 0x07;
}

//setPixel i clearPixel nie będą używane dla pracy tekstowej

void putChar(uint8_t x, char c, uint8_t * buf) //dodatkowo wskaźnik do bufora co pozwoli albo wprost wyświetlić albo użyć bufora pośredniczącego
{
for(uint8_t col = 0; col < 5; ++col) //5 kolumn
{
*(buf + x + col) = pgm_read_byte(font5x8 + (c - ' ') * 5 + col); //font5x8 - tablica czcionek, ' ' - 1 znak w tablicy spacja
//kolumna znaku jest kopiowana w wybrane miejsce w buforze
}
}

void putStringP(uint8_t x, const char * s, uint8_t * buf)
{
char c;
while( (c = pgm_read_byte(s++) ) )
{
putChar(x, c, buf);
x += 6;
}
}[/syntax]

Jak to zadziała to można pokusić się o coś takiego:
[syntax=c]const char PROGMEM dlugiNapis[]= {"Dlugi napis"};
uint8_t textBuffer[11*6]; //musi pomieścić wszystkie znaki

//gdzieś w main
putStringP(0, dlugiNapis, textBuffer); //nie na wyświetlacz tylko do bufora pośredniczącego
while(1)
{
for(uint8_t i = 0; i < 30; ++i)
{
_delay_ms(100);
for(uint8_t k = 0; k < 32; ++k) //opcja for(uint8_t k = 0; k < sizeof(display); ++k)
{
display[k] = textBuffer[k + i]; //skopiowanie tylko 32 bajtów do bufora wyświetlacza
}
}

for(uint8_t i = 30; i > 0; --i)
{
_delay_ms(100);
for(uint8_t k = 0; k < 32; ++k)
{
display[k] = textBuffer[k + i];
}
}
}[/syntax]

Statystyki: Napisane przez Krauser — 11 cze 2015, o 22:49

Re: Mam dość matryc led

2015-06-11T12:24:59+01:00

mokrowski napisał(a):

A long int, a long long int

taaak
jak mam wybierać to na zajętości pamięci mi nie zależy

Statystyki: Napisane przez mczarny — 11 cze 2015, o 12:24

Re: Mam dość matryc led

2015-06-11T09:57:32+01:00

ok. wiem już wszystko, ale mam jeszcze jedną wątpliwość

bufor "display" jest typu uint32_t i wiem dlaczego, ale jakbym chciał dołączyć kolejne matryce czy nawet powiększyć bufor do przewijania napisu tak żeby napis się chował to zabraknie mi typu nie sądzisz?
chyba, że ja to źle rozumiem

pozdrawiam Marek

Statystyki: Napisane przez mczarny — 11 cze 2015, o 09:57

Re: Mam dość matryc led

2015-06-10T20:02:43+01:00

W funkcjach setPixel i clearPixel zmieniany jest bit w buforze o nazwie display

Statystyki: Napisane przez Krauser — 10 cze 2015, o 20:02

Re: Mam dość matryc led

2015-06-10T12:05:08+01:00

cześć

patrzę na te funkcje i mam jeszcze jedno pytanie - w którym momencie są zapisywane dane do bufora wyświetlacza?

Statystyki: Napisane przez mczarny — 10 cze 2015, o 12:05

Re: Mam dość matryc led

2015-06-09T21:35:38+01:00

mczarny napisał(a):

Jak będę miał pytania jeszcze to mogę pisać na PW?

Jak chcesz pytać o sprawy związane z programowaniem czy mikrokontolerami to pisz w temacie, bo w końcu od tego jest forum. Jak chcesz wyskoczyć na soczek to pisz na PW.

Statystyki: Napisane przez Krauser — 9 cze 2015, o 21:35

Re: Mam dość matryc led

2015-06-09T04:44:22+01:00

cześć Krauser

no tak wyświetlacze 7-segmentowe, ale to nie różni się niczym od tego co napisałem w pierwszym poście tylko zamiast wierszy mamy anody lub katody wyświetlaczy

Muszę teraz to wszystko przetrawić.....
Jak będę miał pytania jeszcze to mogę pisać na PW?
Należy Ci się dobra flaszka

Statystyki: Napisane przez mczarny — 9 cze 2015, o 04:44

Re: Mam dość matryc led

2015-06-08T20:18:31+01:00

Quote:

jestem w szoku - napisałeś to na poczekaniu czy już miałeś?

Kolega programek pokazał mi swoje wypociny, więc miałem dużo łatwiej.

mczarny napisał(a):

może za wcześnie się porwałem na matryce?

Pomiędzy diodami a matrycami są jeszcze wyświetlacze 7-segmentowe.

Pomyśl o przewijaniu tego napisu albo i dłuższego. W zasadzie to już tylko operacje na tym buforze.

Statystyki: Napisane przez Krauser — 8 cze 2015, o 20:18

Re: Mam dość matryc led

2015-06-08T19:44:59+01:00

Krauser

jestem w szoku - napisałeś to na poczekaniu czy już miałeś?
zresztą nieważne - wielkie dzięki

Ja sprzętowo daję radę, ale programowanie mi jeszcze trochę nie idzie
może za wcześnie się porwałem na matryce? ale nie chce mi się już migać diodami

pozdrawiam Marek

Statystyki: Napisane przez mczarny — 8 cze 2015, o 19:44

Re: Mam dość matryc led

2015-06-08T18:56:04+01:00

To się funkcja wpisywania danych znaku do bufora zmieni:
[syntax=c]void putChar(uint8_t x, char c)
{
uint8_t charCol;
for(uint8_t col = 0; col < 5; ++col) //5 kolumn
{
charCol = pgm_read_byte(font5x8 + (c - ' ') * 5 + col); //font5x8 - tablica czcionek, ' ' - 1 znak w tablicy spacja
for(uint8_t row = 0; row < 8; ++row) //8 pikseli w kolumnie
{
if(charCol & (1< else clearPixel(x + col, row);
}
}
}[/syntax]

Dodatkowo należy dorobić funkcję dla łańcuchów znaków z pamięci programu:
[syntax=c]void putStringP(uint8_t x, const char * s)
{
char c;
while( (c = pgm_read_byte(s++) ) )
{
putChar(x, c);
x += 6;
}
}[/syntax]

Wywołanie:
[syntax=c]putStringP(0, Napis);[/syntax]

Statystyki: Napisane przez Krauser — 8 cze 2015, o 18:56

Re: Mam dość matryc led

2015-06-08T17:46:37+01:00

dzięki Krauser

w sumie to zamiast moich "ifów" napisałeś fajną funkcję, ale chodziło mi też o to żeby można było napisać:
[syntax=c]static const char PROGMEM Napis[]= {"MAREK"}[/syntax]

i z wykorzystaniem tablicy fontów 5x7
[syntax=c]// font.h
//
// Tablica czcionek 5x7
//
#include
static const char PROGMEM font5x8[] = {
0x00, 0x00, 0x00, 0x00, 0x00,// (spacja)
0x00, 0x00, 0x5F, 0x00, 0x00,// !
0x00, 0x07, 0x00, 0x07, 0x00,// "
0x14, 0x7F, 0x14, 0x7F, 0x14,// #
0x24, 0x2A, 0x7F, 0x2A, 0x12,// $
0x23, 0x13, 0x08, 0x64, 0x62,// %
0x36, 0x49, 0x55, 0x22, 0x50,// &
0x00, 0x05, 0x03, 0x00, 0x00,// '
0x00, 0x1C, 0x22, 0x41, 0x00,// (
0x00, 0x41, 0x22, 0x1C, 0x00,// )
0x08, 0x2A, 0x1C, 0x2A, 0x08,// *
0x08, 0x08, 0x3E, 0x08, 0x08,// +
0x00, 0x50, 0x30, 0x00, 0x00,// ,
0x08, 0x08, 0x08, 0x08, 0x08,// -
0x00, 0x30, 0x30, 0x00, 0x00,// .
0x20, 0x10, 0x08, 0x04, 0x02,// /
0x3E, 0x51, 0x49, 0x45, 0x3E,// 0
0x00, 0x42, 0x7F, 0x40, 0x00,// 1
0x42, 0x61, 0x51, 0x49, 0x46,// 2
0x21, 0x41, 0x45, 0x4B, 0x31,// 3
0x18, 0x14, 0x12, 0x7F, 0x10,// 4
0x27, 0x45, 0x45, 0x45, 0x39,// 5
0x3C, 0x4A, 0x49, 0x49, 0x30,// 6
0x01, 0x71, 0x09, 0x05, 0x03,// 7
0x36, 0x49, 0x49, 0x49, 0x36,// 8
0x06, 0x49, 0x49, 0x29, 0x1E,// 9
0x00, 0x36, 0x36, 0x00, 0x00,// :
0x00, 0x56, 0x36, 0x00, 0x00,// ;
0x00, 0x08, 0x14, 0x22, 0x41,// <
0x14, 0x14, 0x14, 0x14, 0x14,// =
0x41, 0x22, 0x14, 0x08, 0x00,// >
0x02, 0x01, 0x51, 0x09, 0x06,// ?
0x32, 0x49, 0x79, 0x41, 0x3E,// @
0x7E, 0x11, 0x11, 0x11, 0x7E,// A
0x7F, 0x49, 0x49, 0x49, 0x36,// B
0x3E, 0x41, 0x41, 0x41, 0x22,// C
0x7F, 0x41, 0x41, 0x22, 0x1C,// D
0x7F, 0x49, 0x49, 0x49, 0x41,// E
0x7F, 0x09, 0x09, 0x01, 0x01,// F
0x3E, 0x41, 0x41, 0x51, 0x32,// G
0x7F, 0x08, 0x08, 0x08, 0x7F,// H
0x00, 0x41, 0x7F, 0x41, 0x00,// I
0x20, 0x40, 0x41, 0x3F, 0x01,// J
0x7F, 0x08, 0x14, 0x22, 0x41,// K
0x7F, 0x40, 0x40, 0x40, 0x40,// L
0x7F, 0x02, 0x04, 0x02, 0x7F,// M
0x7F, 0x04, 0x08, 0x10, 0x7F,// N
0x3E, 0x41, 0x41, 0x41, 0x3E,// O
0x7F, 0x09, 0x09, 0x09, 0x06,// P
0x3E, 0x41, 0x51, 0x21, 0x5E,// Q
0x7F, 0x09, 0x19, 0x29, 0x46,// R
0x46, 0x49, 0x49, 0x49, 0x31,// S
0x01, 0x01, 0x7F, 0x01, 0x01,// T
0x3F, 0x40, 0x40, 0x40, 0x3F,// U
0x1F, 0x20, 0x40, 0x20, 0x1F,// V
0x7F, 0x20, 0x18, 0x20, 0x7F,// W
0x63, 0x14, 0x08, 0x14, 0x63,// X
0x03, 0x04, 0x78, 0x04, 0x03,// Y
0x61, 0x51, 0x49, 0x45, 0x43,// Z
0x00, 0x00, 0x7F, 0x41, 0x41,// [
0x02, 0x04, 0x08, 0x10, 0x20,// "\"
0x41, 0x41, 0x7F, 0x00, 0x00,// ]
0x04, 0x02, 0x01, 0x02, 0x04,// ^
0x40, 0x40, 0x40, 0x40, 0x40,// _
0x00, 0x01, 0x02, 0x04, 0x00,// `
0x20, 0x54, 0x54, 0x54, 0x78,// a
0x7F, 0x48, 0x44, 0x44, 0x38,// b
0x38, 0x44, 0x44, 0x44, 0x20,// c
0x38, 0x44, 0x44, 0x48, 0x7F,// d
0x38, 0x54, 0x54, 0x54, 0x18,// e
0x08, 0x7E, 0x09, 0x01, 0x02,// f
0x08, 0x14, 0x54, 0x54, 0x3C,// g
0x7F, 0x08, 0x04, 0x04, 0x78,// h
0x00, 0x44, 0x7D, 0x40, 0x00,// i
0x20, 0x40, 0x44, 0x3D, 0x00,// j
0x00, 0x7F, 0x10, 0x28, 0x44,// k
0x00, 0x41, 0x7F, 0x40, 0x00,// l
0x7C, 0x04, 0x18, 0x04, 0x78,// m
0x7C, 0x08, 0x04, 0x04, 0x78,// n
0x38, 0x44, 0x44, 0x44, 0x38,// o
0x7C, 0x14, 0x14, 0x14, 0x08,// p
0x08, 0x14, 0x14, 0x18, 0x7C,// q
0x7C, 0x08, 0x04, 0x04, 0x08,// r
0x48, 0x54, 0x54, 0x54, 0x20,// s
0x04, 0x3F, 0x44, 0x40, 0x20,// t
0x3C, 0x40, 0x40, 0x20, 0x7C,// u
0x1C, 0x20, 0x40, 0x20, 0x1C,// v
0x3C, 0x40, 0x30, 0x40, 0x3C,// w
0x44, 0x28, 0x10, 0x28, 0x44,// x
0x0C, 0x50, 0x50, 0x50, 0x3C,// y
0x44, 0x64, 0x54, 0x4C, 0x44,// z
0x00, 0x08, 0x36, 0x41, 0x00,// {
0x00, 0x00, 0x7F, 0x00, 0x00,// |
0x00, 0x41, 0x36, 0x08, 0x00,// }
0x08, 0x08, 0x2A, 0x1C, 0x08,// ->
0x08, 0x1C, 0x2A, 0x08, 0x08 // <-
};
//[/syntax]

móc tworzyć dowolny napis.

Taki sposób jak Ty przedstawiłeś z fontami też jest ok. ale fonty są bardziej pracochłonne - chyba
Chodzi też o to żebym mógł podmienić napis w trakcie wyświetlania no ale z tym to sobie poradzę - mam nadzieję

Statystyki: Napisane przez mczarny — 8 cze 2015, o 17:46

Re: Mam dość matryc led

2015-06-07T21:22:05+01:00

Trochę bym zmienił organizację danych, aby łatwiej manipulować buforem wyświetlacza:
[syntax=c]uint32_t display[8]={
0x89cf3e88,
0xda28a090,
0xaa28a0a0,
0x8bef38c0,
0x8a2a20a0,
0x8a292090,
0x8a28be88,
0x00000000
};

void Send_Row(uint32_t row)
{
Send_SPI( (uint8_t)(row>>24) );
Send_SPI( (uint8_t)(row>>16) );
Send_SPI( (uint8_t)(row>>8) );
Send_SPI( (uint8_t)(row) );
}

ISR(TIMER0_COMP_vect)
{
const static uint8_t multiplex_tablica1234[] PROGMEM = {~ROW1,~ROW2,~ROW3,~ROW4,255,255,255,255 };
const static uint8_t multiplex_tablica5678[] PROGMEM = {255,255,255,255,~ROW5,~ROW6,~ROW7,~ROW8 };
static uint8_t licznik = 0;
Row_Off();
Send_Row(display[licznik]);
ROWPORT1234 = (ROWPORT1234 & ~ROW1234_MASK) | (pgm_read_byte(&multiplex_tablica1234[licznik]) & ROW1234_MASK);
ROWPORT5678 = (ROWPORT5678 & ~ROW5678_MASK) | (pgm_read_byte(&multiplex_tablica5678[licznik]) & ROW5678_MASK);
licznik++;
licznik &= 0x07;
}[/syntax]

Należy wyjść od najprostszych funkcji:
[syntax=c]void setPixel(uint8_t x, uint8_t y) //lewy górny róg to 0,0
{
y &= 7; //ograniczenie
x &= 31; //ograniczenie
display[y] |= (1UL<}

void clearPixel(uint8_t x, uint8_t y) //lewy górny róg to 0,0
{
y &= 7; //ograniczenie
x &= 31; //ograniczenie
display[y] &= ~(1UL<}[/syntax]
Potem znak:
[syntax=c]void putChar(uint8_t x, char c)
{
uint8_t charRow;
for(uint8_t row = 0; row < 8; ++row) //8 wierszy
{
charRow = pgm_read_byte(tab + (c - START_CHAR)*8 + row); //tab - tablica czcionek, START_CHAR - 1 znak w tablicy
for(uint8_t col = 0; col < 5; ++col) //5 pikseli w wierszu
{
if(charRow & (1< else clearPixel(x + col, row);
}
}
}[/syntax]
A na końcu napis:
[syntax=c]void putString(uint8_t x, char * s)
{
while(*s)
{
putChar(x, *s++);
x += 6;
}
}[/syntax]
Przykładowa tablica:
[syntax=c]#define START_CHAR !
const uint8_t tab[] PROGMEM = {
//!
0b00100,
0b00100,
0b00100,
0b00100,
0b00100,
0b00000,
0b00100,
0b00000,
//"
0b01010,
0b01010,
0b00000,
0b00000,
0b00000,
0b00000,
0b00000,
0b00000,
//...

//M
0b10001,
0b11011,
0b10101,
0b10001,
0b10001,
0b10001,
0b10001,
0b00000,
}[/syntax]

Statystyki: Napisane przez Krauser — 7 cze 2015, o 21:22

Re: Mam dość matryc led

2015-06-07T20:41:46+01:00

[syntax=c]void LCD_writeChar (unsigned char ch)
{
unsigned char j;

for(j=0; j<5; j++)
LCD_writeData(smallFont [(ch-32)*5 + j]);
LCD_writeData(0x00);

}[/syntax]

Przykład z biblioteki do wyświetlacza z nokii 3310

Statystyki: Napisane przez 1bobik1 — 7 cze 2015, o 20:41

Mam dość matryc led

2015-06-07T19:10:00+01:00

witam
piszę w dziale rybnym bo liczę na to, że Ktoś się pochyli nad moim problemem.

Zmontowałem sobie matrycę led składającą się z czterech modułów czyli 32x8
Do sterowania wierszy trochę nieszczęśliwie wybrałek kolejność pinów w procku i nie mogłem tego multipleksować za pomocą prostego przesunięcia bitowego tak jak opisuje to P.Mirek w BB, ale pomógł mi Kol.mokrowski za co wielkie dzięki.
Napisałem obsługę przerwania i prostą funkcję wysyłającą napis na matrycę i to działa:

fragmenty kodu
funkcje wysyłające napis do matrycy
[syntax=c]void Send_SPI(uint8_t a ) //funkcja wysyłająca pojedynczy bajt
{
SPDR=a;
while(!(SPSR&(1<
LATCH_ON;
LATCH_OFF;
}

void Send_Napis(uint8_t *napis,uint8_t col) //funkcja wysyłająca dowolną ilosć bajtów
{
for(uint8_t i=0; i{

Send_SPI(*napis++);

}
}[/syntax]

obsługa przerwania

[syntax=c]ISR(TIMER0_COMP_vect)

{

const static uint8_t multiplex_tablica1234[] PROGMEM = {~ROW1,~ROW2,~ROW3,~ROW4,255,255,255,255 };

const static uint8_t multiplex_tablica5678[] PROGMEM = {255,255,255,255,~ROW5,~ROW6,~ROW7,~ROW8 };

static uint8_t licznik = 0;

Row_Off();

if(licznik==0)
Send_Napis(napis0,4);
if(licznik==1)
Send_Napis(napis1,4);
if(licznik==2)
Send_Napis(napis2,4);
if(licznik==3)
Send_Napis(napis3,4);
if(licznik==4)
Send_Napis(napis4,4);
if(licznik==5)
Send_Napis(napis5,4);
if(licznik==6)
Send_Napis(napis6,4);
if(licznik==7)
Send_Napis(napis7,4);

ROWPORT1234 = (ROWPORT1234 & ~ROW1234_MASK) | (pgm_read_byte(&multiplex_tablica1234[licznik]) & ROW1234_MASK);
ROWPORT5678 = (ROWPORT5678 & ~ROW5678_MASK) | (pgm_read_byte(&multiplex_tablica5678[licznik]) & ROW5678_MASK);

licznik++;
licznik &= 0x07;
}[/syntax]

i zdefiniowane tablice poszczególnych wierszy

[syntax=c]uint8_t napis0[]={0x89,0xcf,0x3e,0x88};
uint8_t napis1[]={0xda,0x28,0xa0,0x90};
uint8_t napis2[]={0xaa,0x28,0xa0,0xa0};
uint8_t napis3[]={0x8b,0xef,0x38,0xc0};
uint8_t napis4[]={0x8a,0x2a,0x20,0xa0};
uint8_t napis5[]={0x8a,0x29,0x20,0x90};
uint8_t napis6[]={0x8a,0x28,0xbe,0x88};
uint8_t napis7[]={0x00,0x00,0x00,0x00};[/syntax]

Wiem, że wyświetlanie w ten sposób to masakra jak powiedzą zawodowcy.
Potrafię stworzyć tablicę fontów, ale za cholerę nie wiem jak napisać funkcję która będzie mi pobierała dany znak z tablicy i pozwalała go wyświetlić na matrycy.
Pomożecie?

pozdrawiam Marek

Statystyki: Napisane przez mczarny — 7 cze 2015, o 19:10