ATNEL tech-forum

Re: Matryca LED 8X8

2015-05-17T21:23:18+01:00

Ok dzięki za pomoc! W takim razie muszę się wyposażyć w te układy sct2110. Muszę teraz przerobić trochę układ w takim razie. Zgodnie z zaleceniami do sterowania kolumn użyję tych driverów sct2110, a wiersze będę multipleksował tranzystorami PNP bezpośrednio z portu uC. Część cyfrową zasilę 5V, a część zasilającą matrycę myślę że 7V wystarczy. Jutro się wezmę za przeróbki.
Dodatkowo do matrycy planuję dorobić bluetooth rtc i czujnik temperatury i jak czasu starczy to może jakiś program na android

Statystyki: Napisane przez svistak2000 — 17 maja 2015, o 21:23

Re: Matryca LED 8X8

2015-05-17T19:07:31+01:00

cześć

układy z serii SCT mają tą przewagę nad 74595, że nie musisz dodatkowo stosować tranzystorów lub driverów z serii ULN

Część cyfrowa jest zasilana tradycyjnie z 5V natomiast na drivery możesz podać napięcie w bardzo szerokim zakresie.
Ja swoje matryce zasilam z 3V żeby ograniczyć straty mocy na tranzystorach sterujących wierszami, ale mogę tam podać nawet 17V (dla SCT2110)
Dodatkowo odpadają Ci rezystory ograniczające prąd bo prąd diod ustawiasz jednym rezystorem dla wszystkich ośmiu wyjść

Rozdzielenie zasilania dla części cyfrowej i diod to jak najbardziej dobry pomysł (sam tak zaprojektowałem płytkę)

Statystyki: Napisane przez mczarny — 17 maja 2015, o 19:07

Re: Matryca LED 8X8

2015-05-17T18:40:58+01:00

svistak2000 napisał(a):

W przyszłości zaprojektowałbym oddzielne zasilanie części cyfrowej i części zasilającej matrycy (2 napięcia 5V i 7V). Tylko teraz mi powiedzcie czy dobrze myślę?

I tak najlepiej już teraz rozpocznij od narysowania schematu. Po naszych uwagach, przeniesiesz go na płytkę.
Sterowanie katod to sprawa prosta. Przy anodach układ się rozrośnie o kolejne tranzystory(lub diody Zenera) oraz o dodatkowe oporniki.
Wydaje mi się, że te podstawy dopasowania wyjść cyfrowych do wyższych napięć warto pokazać.

Statystyki: Napisane przez Wirnick — 17 maja 2015, o 18:40

Re: Matryca LED 8X8

2015-05-17T18:02:50+01:00

tak teraz myślę sobie na spokojnie: całość zasilam 5V... w matrycy jeden piksel to dwie czerwone diody LED czyli spadek napięcia 4,4V, plus 2 tranzystory czyli kolejny spadek napięcia jakieś 1,2V. W sumie mam większy TEORETYCZNY spadek napięcia(5,6V) niż całkowite zasilanie (5V)... Czybym już sobie odpowiedział na swoje pytanie?
I teraz jak rozwiązać ten problem? Mógłbym rzeczywiście podnieść napięcie zasilania tranzystorów które sterują matrycą na wyższe (przykładowo 7V) a zasilanie części cyfrowej oddzielić 4-oma diodami połączonymi szeregowo, wtedy napięcie części cyfrowej wynosiłoby 4,6V. (Czyli powinno być ok.) W przyszłości zaprojektowałbym oddzielne zasilanie części cyfrowej i części zasilającej matrycy (2 napięcia 5V i 7V). Tylko teraz mi powiedzcie czy dobrze myślę?

P.S.
O tym układzie sct już myślałem tylko że w wersji sct-2024. Tylko że jeżeli problem tkwi w tym co napisałem powyżej i co napisał kolega "Wirnick" to chyba nawet sct tutaj nie pomoże... No chyba że się mylę, to proszę mnie poprawić

Statystyki: Napisane przez svistak2000 — 17 maja 2015, o 18:02

Re: Matryca LED 8X8

2015-05-16T09:08:20+01:00

svistak2000 napisał(a):

Jednak mam nadal problem ze stosunkowo słabą jasnośćią diod LED. Zastosowałem rezystory 33ohm na kolumnach. Czy mam je zmniejszyć? Wszystko zasilam 5V z zasilacza laboratoryjnego (3A)
Drugi problem to taki że nie wszystki diody mają równą jasność świecenia.

Myślę tak: 2*led RED to już 5V - praca na punkcie przewodzenia + spadki napięcia na R i tranzystorach, daje taki efekt.
Ja bym dał tranzystory pnp na zasilanie anod led i podniósł napięcie zasilania o 0,5V(mniej niż napięcie bazy). Część cyfrową zasilił przez diodę(napięcie przewodzenia 0,6V). Kolumny(katody) sterowane przez npn(do GND).
Zdaję sobie sprawę, że jest to rozwiązanie doraźne.

Statystyki: Napisane przez Wirnick — 16 maja 2015, o 09:08

Re: Matryca LED 8X8

2015-05-16T08:12:45+01:00

cześć
Już któryś raz piszę o tym, że do matryc trzeba stosować układy dedykowane jako drivery LED
SCT2110 to rejestr przesuwny plus drivery mocy ( 8 wyjść) w jednym - odpadają rezystory i problemy z jasnością świecenia

no, ale jak ktoś lubi komplikować sobie życie.....
pozdrawiam Marek

Statystyki: Napisane przez mczarny — 16 maja 2015, o 08:12

Re: Matryca LED 8X8

2015-05-15T12:04:31+01:00

Hmmm na bazach tranzystorów PNP i NPN mam rezystory 1K. Więc nie powinno być problemów. wczoraj zrobiłem eksperyment, tzn wywaliłem rejestr przesuwny (74hc595) i zapalałem diody tranzystorami. Wszystko świeciło jasno. Pod dodaniu rejestru przesuwnego dzieją się cuda. Rejestr przesuwny ma 70mA wydajności prądowej. Więc przy sterowaniu 5-cioma tranzystorami (BO TYLE JEST TRANZYSTORÓW NA KOLUMNACH) nie powinno być problemów. Spróbuje jeszcze zastosować mosfety (bo one są sterowane napięciowo). Dziwny przypadek ogólnie

Statystyki: Napisane przez svistak2000 — 15 maja 2015, o 12:04

Re: Matryca LED 8X8

2015-05-14T21:35:32+01:00

A może te tranzystory co sterują wierszami wychodzą ze stanu nasycenia. Jeśli rezystory na bazie są zbyt duże to prąd kolektora ze wzoru IC = B * IB jest mały i to na tyle mały, że prąd większej ilości LED byłby większy to napięcie UCE wzrośnie i jasność spadnie.

B = hFE ~= 300, ale zależy od tranzystora

Statystyki: Napisane przez Krauser — 14 maja 2015, o 21:35

Re: Matryca LED 8X8

2015-05-14T11:51:47+01:00

Multipleksuje wiersze matrycy. Rezystory mam wpięte od strony katod diod (na kolumnach). Więc wydaję mi się że raczej jest poprawnie.

Statystyki: Napisane przez svistak2000 — 14 maja 2015, o 11:51

Re: Matryca LED 8X8

2015-05-11T20:25:22+01:00

svistak2000 napisał(a):

Drugi problem to taki że nie wszystki diody mają równą jasność świecenia. Tzn jeżeli w jednym wierszu zapalone jest więcej niż jedna dioda to ten wiersz świeci słabiej od wiersza w którym zapalona jest tylko jedna dioda...

Rezystory ograniczające prąd powinny być tam, gdzie zapalasz od 1 do n LED w tym samym czasie. Wpięcie rezystora na linie które są multipleksowane jest błędem. Zobacz jak masz u siebie.

Statystyki: Napisane przez Krauser — 11 maja 2015, o 20:25

Re: Matryca LED 8X8

2015-05-11T16:52:42+01:00

Ok, udało mi się. Zmieniłem w programie trochę funkcje odpowiadającą za przerwanie:
[syntax=c]#include
#include
#include
#include
#include "font5x8.h"

//Te piny użyłem do sterowania rejestrem:
#define ShiftPort PORTC
#define ShiftDDR DDRC
#define LatchPin (1 << 0)
#define DataPin (1 << 1)
#define ClkPin (1 << 2)
#define OE (1 << 3)

//tymi pinami steruje wierszami:
#define RowPort PORTD
#define RowDDR DDRD
#define RowPin0 (1 << 0) //ustawianie pinów jako wyjcia
#define RowPin1 (1 << 1)
#define RowPin2 (1 << 2)
#define RowPin3 (1 << 3)
#define RowPin4 (1 << 4)
#define RowPin5 (1 << 5)
#define RowPin6 (1 << 6)
#define RowPin7 (1 << 7)

// dla łatwiejszego zrozumienia w kodzie używam oznaczeń anglojezycznych w nazwach
// row = wiersze
// col = kolumny
// Kolumny sa sterowane przez rejestr przesuwny

#define ScrollSpeed 80 // szybkość przewijania

typedef unsigned char u8;
typedef unsigned int u16;

u8 row_track = 0;

volatile u8 row_buffer[8] = { 0, 0, 0, 0, 0, 0, 0, 0 }; // bufor dla wierszy (row)

static const char PROGMEM Messages1[] = { "VACA GORDA !" };
static const char PROGMEM Messages2[] = { "" };

void Delay_ms(int cnt) //Funkcja podaje opóźnienie w milisekundach - jest zależna od F-CPU
{
while (cnt-->0) _delay_ms(1);
}

static inline void InitPorts(void) // Funkcja uzyta tylko raz w celu zainicjowania pinów
{
ShiftDDR |= (LatchPin | ClkPin | DataPin | OE); // ustawienie pinów controlnych rejestru jako wyjcia
RowDDR |= (RowPin0 | RowPin1 | RowPin2 | RowPin3 | RowPin4 | RowPin5 | RowPin6 | RowPin7); // Ustawienie pinów wierszy jako wyjcie

ShiftPort |= OE; //shift port sterowany "jedynkami"
RowPort |=(RowPin0); //row port sterowany "jedynkami"

ShiftPort |= LatchPin; //Ustawienie Zatrzasku na stan wysoki (hi)
ShiftPort &= ~(ClkPin | DataPin); //Ustawienie ClkPin i DataPin na stan niski (low)
}

static inline void InitTimers(void) // Funkcja ustawia Timer --- uzyta tylko raz
{
TCCR1B |= 1< TIMSK |= 1< OCR1A = 20; //wartość porównania ustawiona na 1 mSec
sei(); //Właczenie przerwań
}

void Shift_Int(u8 shiftData) // Funkcja przesuwania danych
{
ShiftPort &= ~(LatchPin | ClkPin | DataPin); //Wszystkie piny na (LOW) - LatchPin w stanie LOW = zapis

for (char i=0; i<8; i++)
{
ShiftPort &= ~ClkPin; //UStawienie CLKPin na stan LOW

if (shiftData & (1< else ShiftPort &= ~DataPin; //Jeśli aktualny bit = 0 to ustawia DataPin na LOW

ShiftPort |= ClkPin; //Ustawienie CLKPin na HI = incrementacja rejestru
ShiftPort &= ~DataPin; //UStawienie DataPin na LOW = przygotowanie do nastepnego zapisu
}

ShiftPort |= LatchPin; //Ustawienie Zatrzasku na HI sygnalizuje koniec zapisu
ShiftPort &= ~(ClkPin | DataPin); //Reset ClkPin i DataPin czyli dla obu stan niski (low)
}

void each_led(void) //Ta funkcja włacza diody pojedyńczo
{
for (u8 j=0; j<8; j++)
{
cli();
row_buffer[j] = 0x0001;
sei();
Delay_ms(50);
for (char i=0; i<8; i++)
{
cli();
row_buffer[j] <<= 1;
sei();
Delay_ms(50);
}
cli();
row_buffer[j] = 0x0000;
sei();
}
}

void Write_Char(u8 letter) //Funkcja zapisuje jeden znak do matrycy (bez przewijania)
{

//litery sa pobierane do tablicy font5x8[] z pliku (font5x8.h)
letter -= 32; //Ustawienie indeksów tablicy na odpowiednie znaki
char temp;
for (char i=0; i<5; i++) //odczyt jednej kolumny znaku
{
temp = pgm_read_byte((char *)((int)font5x8 + (5 * letter) + i)); //Pobranie kolumny z pamięci
for (char j=0; j<8; j++)
{
//Zapis bitów do odpowiednich komórek tablicy (row_buffer)
if (temp & (1< else row_buffer[7-j] &= ~(1<<(4-i));
}
}
}

void shift_row_buffer_left(u8 columns) //Funkcja przesuwa wszystkie wiersze w LEWO
{
for (u8 buffer_index=0; buffer_index<8; buffer_index++)
{
row_buffer[buffer_index] <<= columns;
}
}

void Scroll_Char (char myChar) //Funkcja przewija Znak na matrycy od PRAWEJ do LEWEJ
{
myChar -= 32; //Ustawienie wartości na odpowiednia z indexem
char temp;
shift_row_buffer_left(1); //Wstawianie pustej kolumny przed każdą nową literę
Delay_ms(ScrollSpeed);
for (u8 i=0; i<5; i++)
{
shift_row_buffer_left(1);
temp = pgm_read_byte((char *)((int)font5x8 + (5 * myChar) + i)); //Pobranie nowej kolumny
for (u8 j=0; j<8; j++)
{
if (temp & (1< else row_buffer[7-j] &= ~(1<<0);
}
Delay_ms(ScrollSpeed);
}
}
void Scroll_String(char * myString) //Funkcja przewija po ekranie zadany napis
{
while (*myString) //Powtarzanie aż zostanie napodkany znak NULL
{
Scroll_Char(*myString); //Przewijanie nastepnego znaku
++myString;

}
}

void Scroll_String_P(const char * myString) //Funkcja odczytuje łańcuch z pamieci i wyswietla go na matrycy
{
while (pgm_read_byte(myString))
{
Scroll_Char(pgm_read_byte(myString));
++myString;
}
}

void Scroll_Clear(void) //Funkcja czyści ekran
//w zasadzie przewijam wszystko w lewo
{
for(u8 i=0; i<8; i++)
{
shift_row_buffer_left(1);
Delay_ms(ScrollSpeed);
}
}

int main(void)
{
InitPorts();
InitTimers();
while(1)
{
//Scroll_String("POZDRAWIAM !"); //Troche mało optymalne wyświetlanie - zuzywa sporo ramu
//Scroll_Clear(); //Przewijanie w lewo aż do wyczyszczenia
Scroll_String_P(Messages1); //Wyswietlanie ciągu z pamieci programu -- zuzywa mało ramu
Scroll_Clear();
Scroll_String_P(Messages2);
// Scroll_Clear();

//each_led();

// for (char x=33; x<128; x++) //Zapis znaków ascii
// {
// Write_Char(x);
// Delay_ms(500);
// }
}
}

ISR(TIMER1_COMPA_vect) //Interrupt Service Routine -- praca w przerwaniu
{
if(++row_track == 8) row_track = 0; //Śledzenie wiersza (ROW)
Shift_Int(row_buffer[row_track]); //przewijanie danych do nastepnego wiersza

ShiftPort &= ~OE; //Uzyłem w celu zapobiegania zakłuceniom
//moze lepiej by było dać tu NOP ??
if (row_track == 0) //Wyłaczenie controli
{
RowPort |= (1<<7); //Jeśli ROW0 to zatrzymaj na ROW7 -- chyba wiadomo dlaczego
}
else
{
RowPort |= (1<<(row_track-1)); //Wyłacz poprzedni wiersz
}

ShiftPort |= LatchPin;
RowPort &= ~(1< ShiftPort |= OE;
}[/syntax]

Jednak mam nadal problem ze stosunkowo słabą jasnośćią diod LED. Zastosowałem rezystory 33ohm na kolumnach. Czy mam je zmniejszyć? Wszystko zasilam 5V z zasilacza laboratoryjnego (3A)
Drugi problem to taki że nie wszystki diody mają równą jasność świecenia. Tzn jeżeli w jednym wierszu zapalone jest więcej niż jedna dioda to ten wiersz świeci słabiej od wiersza w którym zapalona jest tylko jedna dioda...

Statystyki: Napisane przez svistak2000 — 11 maja 2015, o 16:52

Re: Matryca LED 8X8

2015-05-11T15:26:20+01:00

Witam!
Czy mógłby mi ktoś pomóc przerobić ten program (kolegi sunRiver):
[syntax=c]#include
#include
#include
#include
#include "font5x8.h"

//Te piny użyłem do sterowania rejestrem:
#define ShiftPort PORTC
#define ShiftDDR DDRC
#define LatchPin (1 << 0)
#define DataPin (1 << 1)
#define ClkPin (1 << 2)
#define OE (1 << 3)

//tymi pinami steruje wierszami:
#define RowPort PORTD
#define RowDDR DDRD
#define RowPin0 (1 << 0) //ustawianie pinów jako wyjcia
#define RowPin1 (1 << 1)
#define RowPin2 (1 << 2)
#define RowPin3 (1 << 3)
#define RowPin4 (1 << 4)
#define RowPin5 (1 << 5)
#define RowPin6 (1 << 6)
#define RowPin7 (1 << 7)

// dla łatwiejszego zrozumienia w kodzie używam oznaczeń anglojezycznych w nazwach
// row = wiersze
// col = kolumny
// Kolumny sa sterowane przez rejestr przesuwny

#define ScrollSpeed 80 // szybkość przewijania

typedef unsigned char u8;
typedef unsigned int u16;

u8 row_track = 0;

volatile u8 row_buffer[8] = { 0, 0, 0, 0, 0, 0, 0, 0 }; // bufor dla wierszy (row)

static const char PROGMEM Messages1[] = { "VACA GORDA !" };
static const char PROGMEM Messages2[] = { "" };

void Delay_ms(int cnt) //Funkcja podaje opóźnienie w milisekundach - jest zależna od F-CPU
{
while (cnt-->0) _delay_ms(1);
}

static inline void InitPorts(void) // Funkcja uzyta tylko raz w celu zainicjowania pinów
{
ShiftDDR |= (LatchPin | ClkPin | DataPin | OE); // ustawienie pinów controlnych rejestru jako wyjcia
RowDDR |= (RowPin0 | RowPin1 | RowPin2 | RowPin3 | RowPin4 | RowPin5 | RowPin6 | RowPin7); // Ustawienie pinów wierszy jako wyjcie

ShiftPort |= OE; //shift port sterowany "jedynkami"
RowPort |=(RowPin0); //row port sterowany "jedynkami"

ShiftPort |= LatchPin; //Ustawienie Zatrzasku na stan wysoki (hi)
ShiftPort &= ~(ClkPin | DataPin); //Ustawienie ClkPin i DataPin na stan niski (low)
}

static inline void InitTimers(void) // Funkcja ustawia Timer --- uzyta tylko raz
{
TCCR1B |= 1< TIMSK |= 1< OCR1A = 9; //wartość porównania ustawiona na 1 mSec
sei(); //Właczenie przerwań
}

void Shift_Int(u8 shiftData) // Funkcja przesuwania danych
{
ShiftPort &= ~(LatchPin | ClkPin | DataPin); //Wszystkie piny na (LOW) - LatchPin w stanie LOW = zapis

for (char i=0; i<8; i++)
{
ShiftPort &= ~ClkPin; //UStawienie CLKPin na stan LOW

if (shiftData & (1< else ShiftPort &= ~DataPin; //Jeśli aktualny bit = 0 to ustawia DataPin na LOW

ShiftPort |= ClkPin; //Ustawienie CLKPin na HI = incrementacja rejestru
ShiftPort &= ~DataPin; //UStawienie DataPin na LOW = przygotowanie do nastepnego zapisu
}

ShiftPort |= LatchPin; //Ustawienie Zatrzasku na HI sygnalizuje koniec zapisu
ShiftPort &= ~(ClkPin | DataPin); //Reset ClkPin i DataPin czyli dla obu stan niski (low)
}

void each_led(void) //Ta funkcja włacza diody pojedyńczo
{
for (u8 j=0; j<8; j++)
{
cli();
row_buffer[j] = 0x0001;
sei();
Delay_ms(50);
for (char i=0; i<8; i++)
{
cli();
row_buffer[j] <<= 1;
sei();
Delay_ms(50);
}
cli();
row_buffer[j] = 0x0000;
sei();
}
}

void Write_Char(u8 letter) //Funkcja zapisuje jeden znak do matrycy (bez przewijania)
{

//litery sa pobierane do tablicy font5x8[] z pliku (font5x8.h)
letter -= 32; //Ustawienie indeksów tablicy na odpowiednie znaki
char temp;
for (char i=0; i<5; i++) //odczyt jednej kolumny znaku
{
temp = pgm_read_byte((char *)((int)font5x8 + (5 * letter) + i)); //Pobranie kolumny z pamięci
for (char j=0; j<8; j++)
{
//Zapis bitów do odpowiednich komórek tablicy (row_buffer)
if (temp & (1< else row_buffer[7-j] &= ~(1<<(4-i));
}
}
}

void shift_row_buffer_left(u8 columns) //Funkcja przesuwa wszystkie wiersze w LEWO
{
for (u8 buffer_index=0; buffer_index<8; buffer_index++)
{
row_buffer[buffer_index] <<= columns;
}
}

void Scroll_Char (char myChar) //Funkcja przewija Znak na matrycy od PRAWEJ do LEWEJ
{
myChar -= 32; //Ustawienie wartości na odpowiednia z indexem
char temp;
shift_row_buffer_left(1); //Wstawianie pustej kolumny przed każdą nową literę
Delay_ms(ScrollSpeed);
for (u8 i=0; i<5; i++)
{
shift_row_buffer_left(1);
temp = pgm_read_byte((char *)((int)font5x8 + (5 * myChar) + i)); //Pobranie nowej kolumny
for (u8 j=0; j<8; j++)
{
if (temp & (1< else row_buffer[7-j] &= ~(1<<0);
}
Delay_ms(ScrollSpeed);
}
}
void Scroll_String(char * myString) //Funkcja przewija po ekranie zadany napis
{
while (*myString) //Powtarzanie aż zostanie napodkany znak NULL
{
Scroll_Char(*myString); //Przewijanie nastepnego znaku
++myString;

}
}

void Scroll_String_P(const char * myString) //Funkcja odczytuje łańcuch z pamieci i wyswietla go na matrycy
{
while (pgm_read_byte(myString))
{
Scroll_Char(pgm_read_byte(myString));
++myString;
}
}

void Scroll_Clear(void) //Funkcja czyści ekran
//w zasadzie przewijam wszystko w lewo
{
for(u8 i=0; i<8; i++)
{
shift_row_buffer_left(1);
Delay_ms(ScrollSpeed);
}
}

int main(void)
{
InitPorts();
InitTimers();
while(1)
{
//Scroll_String("POZDRAWIAM !"); //Troche mało optymalne wyświetlanie - zuzywa sporo ramu
//Scroll_Clear(); //Przewijanie w lewo aż do wyczyszczenia
Scroll_String_P(Messages1); //Wyswietlanie ciągu z pamieci programu -- zuzywa mało ramu
Scroll_Clear();
Scroll_String_P(Messages2);
// Scroll_Clear();

//each_led();

// for (char x=33; x<128; x++) //Zapis znaków ascii
// {
// Write_Char(x);
// Delay_ms(500);
// }
}
}

ISR(TIMER1_COMPA_vect) //Interrupt Service Routine -- praca w przerwaniu
{
if(++row_track == 8) row_track = 0; //Śledzenie wiersza (ROW)
Shift_Int(row_buffer[row_track]); //przewijanie danych do nastepnego wiersza

ShiftPort &= ~OE; //Uzyłem w celu zapobiegania zakłuceniom
//moze lepiej by było dać tu NOP ??
if (row_track == 0) //Wyłaczenie controli
{
RowPort &= ~(1<<7); //Jeśli ROW0 to zatrzymaj na ROW7 -- chyba wiadomo dlaczego
}
else
{
RowPort &= ~(1<<(row_track-1)); //Wyłacz poprzedni wiersz
}

ShiftPort |= LatchPin;
RowPort |= (1< ShiftPort |= OE;
}[/syntax]
Program działa jeżeli matryce podepnę bezpośrednio do portu mikrokontrolera. Jednak gdy zastosuje bufory w postaci tranzystorów pokazuje kompletne głupoty. Matrycę mam taką:

Kolumny steruję za pomocą rejestru 74hc595, wyjścia rejestru są podłączone do tranzystorów PNP. Wiersze natomiast steruję z tranzystorów NPN które są podłączone do uC. Bez tranzystorów wszystko działa. Z tranzystorami zapala wszystkie diody i nie wyświetla tego co chce..... Proszę o pomoc

Statystyki: Napisane przez svistak2000 — 11 maja 2015, o 15:26

Re: Matryca LED 8X8

2014-09-15T15:09:23+01:00

Tak właśnie mi się wydawało że bez ULN-a przy rejestrze się nie obejdzie.

Statystyki: Napisane przez BIGjack — 15 wrz 2014, o 15:09

Re: Matryca LED 8X8

2014-09-14T22:11:58+01:00

Wychodzi 22 mA na LED. Dla sterowania statycznego wystarczy, ale jak masz multipleksowanie wierszy to średni prąd jest 8 razy mniejszy. 74HC595 daje maksymalnie 35 mA więc dodaj tranzystory i zmniejsz rezystory, ale wtedy nie steruj już statycznie.

Statystyki: Napisane przez Krauser — 14 wrz 2014, o 22:11

Re: Matryca LED 8X8

2014-09-05T08:53:32+01:00

Projektuję właśnie urządzenie w którym wykorzystuję matryce czerwone matryce led8x8 podłączone w/g tego schematu;

Ze względu na matryce (LM-88HR07-CC) które posiadam użyłem UDN2981 zamiast ULN2803 i R z 220R0 na 150R0 .
Jednak przy włączeniu wszystkich punktów matrycy przygasa czy muszę dodatkowo pakować jeszcze
driver-y do każdego HC595 ?

Statystyki: Napisane przez BIGjack — 5 wrz 2014, o 08:53

Re: Matryca LED 8X8

2014-05-22T15:26:10+01:00

SunRiver napisał(a):

a w tym co niebawem pokażę użyłem układów MAX7219 po 1 na matrycę, dzięki czemu zasadniczo każda matryca jest niezależna i można je dowolnie konfigurować

Gdzie możemy to ustrojstwo zobaczyć?

Statystyki: Napisane przez BIGjack — 22 maja 2014, o 15:26

Re: Matryca LED 8X8

2013-09-16T20:52:05+01:00

Nareszcie znalazłem chwilę wolnego czasu aby zająć się moim projektem animowanego zegara z bezprzewodowym termometrem na matrycach led 8x8. Analiza i pisanie idzie mi strasznie opornie ale ją już pierwsze bardzo skromne
efekty

iframe

Statystyki: Napisane przez BIGjack — 16 wrz 2013, o 20:52

Re: Matryca LED 8X8

2013-09-15T18:47:26+01:00

Za dużo zmiennych z modyfikatorem zmiennych globalnych i z modyfikatorem volatile.
[syntax=c]volatile uint8_t timer0_licznik = 178; //to powinna być stała zdefiniowana z użyciem #define
volatile uint8_t temp = 0; //to powinna być zmienna lokalna w przerwaniu z modyfikatorem static
volatile uint16_t licznik = 1; //to powinna być zmienna lokalna w przerwaniu z modyfikatorem static
volatile uint8_t bufor[8]; //nie powinno być/nie potrzeba volatile, tablice obsługiwane są przez wskaźnik
volatile uint8_t nowy_bufor = 1; //tutaj oczywiście tak, nowy_bufor może się zmienić w przerwaniu i jest wykorzystywany w pętli głównej programu[/syntax]

Statystyki: Napisane przez Krauser — 15 wrz 2013, o 18:47

Re: Matryca LED 8X8

2013-08-17T12:20:52+01:00

Quote:

UDN2981A jest równoważny 8 tranzystorom pnp, a ULN2803 8 tranzystorom npn.

Czyli tak jak napisałem powyżej w tym konkretnym przypadku.

Krauser napisał(a):

Matryca LED nie ma ani wspólnej katody ani anody, to kwestia umowna jak traktujesz te 8 LED w jednej kolumnie/wierszu.

Dlatego dla jednej matrycy nie używam tego określenia ale dla kilku tak bo sugeruję w ten sposób jak je łączę a logika nakazuje połączyć wiersze więc jak mam anody na wierszach to piszę że mam wspólną anodę.

Krauser napisał(a):

Dla mikrokontrolera AVR to bez znaczenia czy podaje sygnał zanegowany czy nie.

Moje doświadczenia wykazały że zanegowanie sygnału wiersza zmienia mi tylko tyle że świecą te pola które były wygaszone i gasną te które świeciły.
Ciesze się że koledzy "zapodają" swoje uwagi i przepraszam jeżeli gdzies walnąłem byka ale pełnię dziś obowiązki super niani dla moich latorośli a to wiąże się ze znikomym czasem podejść do kompa

Statystyki: Napisane przez BIGjack — 17 sie 2013, o 12:20

Re: Matryca LED 8X8

2013-08-17T11:46:32+01:00

UDN2981A jest równoważny 8 tranzystorom pnp, a ULN2803 8 tranzystorom npn. Matryca LED nie ma ani wspólnej katody ani anody, to kwestia umowna jak traktujesz te 8 LED w jednej kolumnie/wierszu. Dla mikrokontrolera AVR to bez znaczenia czy podaje sygnał zanegowany czy nie.

Statystyki: Napisane przez Krauser — 17 sie 2013, o 11:46

Re: Matryca LED 8X8

2013-08-17T10:36:47+01:00

A mam pod łapką Jeden neguje sygnał a drugi nie. Aczkolwiek gdzieś czytałem że UDN się nie nadaje. Najprościej ale i najkosztowmniej było by zmenić matryce na wspólną katode.

Statystyki: Napisane przez BIGjack — 17 sie 2013, o 10:36

Re: Matryca LED 8X8

2013-08-16T15:46:17+01:00

Czy do w/w matrycy powinieniem użyć UDN2981A ?
Czy jest szansa zmiany w kodzie aby zadziałał ULN2803?

Statystyki: Napisane przez BIGjack — 16 sie 2013, o 15:46

Re: Matryca LED 8X8

2013-08-16T12:13:21+01:00

GwynBleidD, nie jestem sknerą, mam całą garść uln-ów Chodziło mi o czas, poprostu mam matryce na stykówce bez uln-a i szybciej dla celów testowych by było dopiąć drugą matryce anieżeli przerabiać prawie wszystko Mam jeszcze pytanie, bo nie wiem czy dobrze myślę. Jak zamienię od strony matrycy sterowanie wierszy z kolumnami to obraz wyświetlany będzie obrócony o 90 stopni czy się mylę? Pytanie to jest wynikiem zastosowania ULN2803A który neguje sygnał. Szukam teraz sposobu na ponowne podpięcie matryc i nic nie przychodzi mi do głowy poza szukaniem układu który nie będzie negował Hmm....

Statystyki: Napisane przez BIGjack — 16 sie 2013, o 12:13

Re: Matryca LED 8X8

2013-08-16T08:41:15+01:00

w/g noty niby bierze 60mA w/g info TME 25mA na diodę statycznie ale wydaje mi się że przy multiplexowaniu nie spalę procka.

------------------------ [ Dodano po: 10 minutach ]

Nie jestem pewien ale na IO megi max 40mA więc muszę właczyć przez ULN-a

Statystyki: Napisane przez BIGjack — 16 sie 2013, o 08:41

Re: Matryca LED 8X8

2013-08-16T08:33:17+01:00

już przy jednej powinieneś zastosować ULNa ...
choć mega da sobie radę jeszcze o tyle z 2ma ... zresztą twoja mega i twoje matryce
wystarczy sobie z noty odczytać ile bierze

Statystyki: Napisane przez SunRiver — 16 sie 2013, o 08:33