LED mátrixos kijelző - Hobbielektronika.hu - online elektronikai magazin és fórum

(#)	Istvanpisti válasza david10 hozzászólására (»)	Ápr 24, 2017		/

Szívesen, használd egészséggel!
Azért XMEGA, mert az utóbbi időben ezt tanulgatom, tulajdonképpen lehetett volna pl. ATMEG328p is, az is van itthon. Árban 100 Ft a különbség, de mind SRAM, timer, és egyéb perifériák terén jobban el van látva az XMEGA, és a sebessége is kétszerese lehet az ATMEGA-nak. Ezek miatt nekem jobban tetszik, bár igaz az, hogy egy kicsit bonyolultabb is (EVENT SYSTEM, DMA).

(#)	Kovidivi válasza Istvanpisti hozzászólására (»)		Ápr 24, 2017		/

Szia. Atmega32a4-ra gondolsz biztosan? Mert az szinte ugyanaz, mint a 328, csak 16 helyett 20MHz-en tud járni, és több lába van.

A hozzászólás módosítva: Ápr 24, 2017

(#)	Istvanpisti válasza Kovidivi hozzászólására (»)	Ápr 24, 2017		/

Szia!
Nem ATMEGA32, hanem ATXMEGA32A4, ennek az adatlap szerint 32 MHz a maximális működési frekvenciája, de próbából járattam már 56 MHz-en is üzembiztosan, valahol 60 MHz felett lett bizonytalan. Ennek 4 kB SRAM-ja van és még számtalan a különbség az ATMEGA32-höz, vagy az ATMEGA328-hoz képest.

(#)	dbalazs hozzászólása	Jún 17, 2017		/

Sziasztok!

Egy multiplex 2szer 8x8 mátrix alap kapcsolásról kérdeznék.
Véleményeket, ötleteket.
Itt úgy igazából a TTL/CMOS rész lenne a lényeg hogy így működhet-e?

A mellékelt rajzon, a baloldal a vevő (IR receiver).
A jobb oldal a visszajelzés (LED-ek).

A lényeg az lenne, hogy minél kevesebb lábat "vezetéket" keljen használni a mikrokontroller "LED" vezérlés között!

Akkor az elmélet:
Ha D10 a baloldali mátrixnál aktív, az-az jelet érzékel...
A jobboldali mátrixnál a LED232 világít.
Vagy a baloldalon a D44 "aktív" a jobb oldali mátrixnál a LED201 világít.

Úgy összességében ez lenne a lényeg.
Itt csak az elméleti részt kell nézni!!!!!!
A program az más téma az ATmega8-nál.

A jobb oldali ledes résznek elméletileg jónak kell lennie.
De a bal oldal (vevő) résszel nem vagyok biztos.

A lényeg, hogy a vevő (receiver) is 8x8-as mátrix legyen!

Ja és a másik!!!
A jobb oldali "led-es" résznél mennyit bírnak az "IC-k"?
Szóval 1 led helyett 4db lenne a végén. (Csak nem volt kedven így megrajzolni.)
Az-az PL: A LED232 az nem 1db lenne, hanem 4db párhuzamosan.
És így tovább az összes.
A végén nem 64db lenne, hanem 256db.
Vagy inkább tranziszoros vagy MosFet-es meghajtás kellene?
A Ledeket nagyjából lehet számolni úgy 1,8V 20mA-al.

Igaz az IC1 kimeneténél elmaradtak az ellenállások, de majd korrigálom.

A segítő szándékot előre is köszönöm.

A hozzászólás módosítva: Jún 17, 2017

elmelet.pdf

(#)	Lucifer válasza dbalazs hozzászólására (»)	Jún 17, 2017		/

Használj buszokat, meg net labeleket mert ez így elsőre átláthatatlan. Egyszerű alkatrészeken kívül nem forgatunk el semmit.

(#)	ha1drp válasza dbalazs hozzászólására (»)	Jún 17, 2017		/

Idézet:
„A jobb oldali "led-es" résznél mennyit bírnak az "IC-k"?”

Katalógus adat a hc595 kb. 25mA-35mA

A bemeneti oldal nem jó, mindkét IC csak "kimenet"

(#)	Sebi válasza dbalazs hozzászólására (»)	Jún 17, 2017		/

A talajra húzó (sink) ULN2003 -nak van hasonló képességű, de H-szintet adó (source) testvére is - igaz eddig csak Allegro gyártmánnyal találkoztam. Ez kell az 595 kimenetére, hogy bírja a terhelést.

(#)	Bakman válasza Sebi hozzászólására (»)	Jún 17, 2017		/

UDN2981 az alkatrész típusa.

(#)	wbt válasza Sebi hozzászólására (»)	Jún 17, 2017		/

Furcsa a kínálat, sajnos a hazai árak mellett nekem úgy kellett döntenem, hogy "akármilyen" meghajtó (OC, pl az említett 2003-as) és utána egy digitális tranzisztor. Olcsóbb volt, mint a forrás típusú Allegro IC, de persze nézz körbe, talán szerencséd lesz. Sajnos, többet kell forrasztgatni... Ha 2-300-as tételben veszel, azt hiszem nekem 2.3Ft volt egy tranzisztor, szóval verhetetlen. nem is értem az árképzéseket, igaz tudni kellene a fesz/áram viszonyokat. Minőségben az Allegro jó, de más-más a kérés, ha nagy fesz kell, de kis áram (VFD) vagy Nagy forrásáram, ami nem induktív pl. Én a végén (balfék módon) L293-at használtam, mindenre, mert 100db-nál olcsóbb volt, mint a forrásmeghajtó. (gondolom gyártási darabszám függő, normál LED mátrixhoz olcsóbb volt, mint az egzotikus "csak" forrás drv.) Mire kell?

(#)	dbalazs válasza ha1drp hozzászólására (»)	Jún 17, 2017		/

Szia!

Nekem még az is jó lenne, ha esetleg a kommunikáció I2C-n menne, mint vevő rész.
Csak egy a lényeg, hogy minél kevesebb szálat "vezetéket" keljen használni a RECEIVER és MICROCONTROLLER közt.

Szóval maradna a 8x8-as felállás.
Csak nem mindegy, hogy 16 szálat használok, vagy csak 4-6-ot mint kommunikáció.

A 74HC595 és 74HC259-nek létezik esetleg párja?
Szóval bemenetként használni?

A hozzászólás módosítva: Jún 17, 2017

(#)	Kari55 hozzászólása	Nov 16, 2017		/

Sziasztok!

Hogyan tudnék beszúrni magyar ékezetes karaktereket az alábbi kódba a meglévők közé?
Ez egy futó szöveg Max7219 8x8 LEDmatrix panelekkel arduinoval.

Még valami: Mit jelentenek a karakterkódo elején a számok. Pl.:1, 8 3, 8 stb
Előre is köszönöm.

#include <MaxMatrix.h>
#include <avr/pgmspace.h>
PROGMEM const unsigned char CH[] = {
3, 8, B00000000, B00000000, B00000000, B00000000, B00000000, // space
1, 8, B01011111, B00000000, B00000000, B00000000, B00000000, // !
3, 8, B00000011, B00000000, B00000011, B00000000, B00000000, // "
5, 8, B00010100, B00111110, B00010100, B00111110, B00010100, // #
4, 8, B00100100, B01101010, B00101011, B00010010, B00000000, // $
5, 8, B01100011, B00010011, B00001000, B01100100, B01100011, // %
5, 8, B00110110, B01001001, B01010110, B00100000, B01010000, // &
1, 8, B00000011, B00000000, B00000000, B00000000, B00000000, // '
3, 8, B00011100, B00100010, B01000001, B00000000, B00000000, // (
3, 8, B01000001, B00100010, B00011100, B00000000, B00000000, // )
5, 8, B00101000, B00011000, B00001110, B00011000, B00101000, // *
5, 8, B00001000, B00001000, B00111110, B00001000, B00001000, // +
2, 8, B10110000, B01110000, B00000000, B00000000, B00000000, // ,
4, 8, B00001000, B00001000, B00001000, B00001000, B00000000, // -
2, 8, B01100000, B01100000, B00000000, B00000000, B00000000, // .
4, 8, B01100000, B00011000, B00000110, B00000001, B00000000, // /
4, 8, B00111110, B01000001, B01000001, B00111110, B00000000, // 0
3, 8, B01000010, B01111111, B01000000, B00000000, B00000000, // 1
4, 8, B01100010, B01010001, B01001001, B01000110, B00000000, // 2
4, 8, B00100010, B01000001, B01001001, B00110110, B00000000, // 3
4, 8, B00011000, B00010100, B00010010, B01111111, B00000000, // 4
4, 8, B00100111, B01000101, B01000101, B00111001, B00000000, // 5
4, 8, B00111110, B01001001, B01001001, B00110000, B00000000, // 6
4, 8, B01100001, B00010001, B00001001, B00000111, B00000000, // 7
4, 8, B00110110, B01001001, B01001001, B00110110, B00000000, // 8
4, 8, B00000110, B01001001, B01001001, B00111110, B00000000, // 9
2, 8, B01010000, B00000000, B00000000, B00000000, B00000000, // :
2, 8, B10000000, B01010000, B00000000, B00000000, B00000000, // ;
3, 8, B00010000, B00101000, B01000100, B00000000, B00000000, // <
3, 8, B00010100, B00010100, B00010100, B00000000, B00000000, // =
3, 8, B01000100, B00101000, B00010000, B00000000, B00000000, // >
4, 8, B00000010, B01011001, B00001001, B00000110, B00000000, // ?
5, 8, B00111110, B01001001, B01010101, B01011101, B00001110, // @
4, 8, B01111110, B00010001, B00010001, B01111110, B00000000, // A
4, 8, B01111111, B01001001, B01001001, B00110110, B00000000, // B
4, 8, B00111110, B01000001, B01000001, B00100010, B00000000, // C
4, 8, B01111111, B01000001, B01000001, B00111110, B00000000, // D
4, 8, B01111111, B01001001, B01001001, B01000001, B00000000, // E
4, 8, B01111111, B00001001, B00001001, B00000001, B00000000, // F
4, 8, B00111110, B01000001, B01001001, B01111010, B00000000, // G
4, 8, B01111111, B00001000, B00001000, B01111111, B00000000, // H
3, 8, B01000001, B01111111, B01000001, B00000000, B00000000, // I
4, 8, B00110000, B01000000, B01000001, B00111111, B00000000, // J
4, 8, B01111111, B00001000, B00010100, B01100011, B00000000, // K
4, 8, B01111111, B01000000, B01000000, B01000000, B00000000, // L
5, 8, B01111111, B00000010, B00001100, B00000010, B01111111, // M
5, 8, B01111111, B00000100, B00001000, B00010000, B01111111, // N
4, 8, B00111110, B01000001, B01000001, B00111110, B00000000, // O
4, 8, B01111111, B00001001, B00001001, B00000110, B00000000, // P
4, 8, B00111110, B01000001, B01000001, B10111110, B00000000, // Q
4, 8, B01111111, B00001001, B00001001, B01110110, B00000000, // R
4, 8, B01000110, B01001001, B01001001, B00110010, B00000000, // S
5, 8, B00000001, B00000001, B01111111, B00000001, B00000001, // T
4, 8, B00111111, B01000000, B01000000, B00111111, B00000000, // U
5, 8, B00001111, B00110000, B01000000, B00110000, B00001111, // V
5, 8, B00111111, B01000000, B00111000, B01000000, B00111111, // W
5, 8, B01100011, B00010100, B00001000, B00010100, B01100011, // X
5, 8, B00000111, B00001000, B01110000, B00001000, B00000111, // Y
4, 8, B01100001, B01010001, B01001001, B01000111, B00000000, // Z
2, 8, B01111111, B01000001, B00000000, B00000000, B00000000, // [
4, 8, B00000001, B00000110, B00011000, B01100000, B00000000, // \ backslash
2, 8, B01000001, B01111111, B00000000, B00000000, B00000000, // ]
3, 8, B00000010, B00000001, B00000010, B00000000, B00000000, // hat
4, 8, B01000000, B01000000, B01000000, B01000000, B00000000, // _
2, 8, B00000001, B00000010, B00000000, B00000000, B00000000, // `
4, 8, B00100000, B01010100, B01010100, B01111000, B00000000, // a
4, 8, B01111111, B01000100, B01000100, B00111000, B00000000, // b
4, 8, B00111000, B01000100, B01000100, B00101000, B00000000, // c
4, 8, B00111000, B01000100, B01000100, B01111111, B00000000, // d
4, 8, B00111000, B01010100, B01010100, B00011000, B00000000, // e
3, 8, B00000100, B01111110, B00000101, B00000000, B00000000, // f
4, 8, B10011000, B10100100, B10100100, B01111000, B00000000, // g
4, 8, B01111111, B00000100, B00000100, B01111000, B00000000, // h
3, 8, B01000100, B01111101, B01000000, B00000000, B00000000, // i
4, 8, B01000000, B10000000, B10000100, B01111101, B00000000, // j
4, 8, B01111111, B00010000, B00101000, B01000100, B00000000, // k
3, 8, B01000001, B01111111, B01000000, B00000000, B00000000, // l
5, 8, B01111100, B00000100, B01111100, B00000100, B01111000, // m
4, 8, B01111100, B00000100, B00000100, B01111000, B00000000, // n
4, 8, B00111000, B01000100, B01000100, B00111000, B00000000, // o
4, 8, B11111100, B00100100, B00100100, B00011000, B00000000, // p
4, 8, B00011000, B00100100, B00100100, B11111100, B00000000, // q
4, 8, B01111100, B00001000, B00000100, B00000100, B00000000, // r
4, 8, B01001000, B01010100, B01010100, B00100100, B00000000, // s
3, 8, B00000100, B00111111, B01000100, B00000000, B00000000, // t
4, 8, B00111100, B01000000, B01000000, B01111100, B00000000, // u
5, 8, B00011100, B00100000, B01000000, B00100000, B00011100, // v
5, 8, B00111100, B01000000, B00111100, B01000000, B00111100, // w
5, 8, B01000100, B00101000, B00010000, B00101000, B01000100, // x
4, 8, B10011100, B10100000, B10100000, B01111100, B00000000, // y
3, 8, B01100100, B01010100, B01001100, B00000000, B00000000, // z
3, 8, B00001000, B00110110, B01000001, B00000000, B00000000, // {
1, 8, B01111111, B00000000, B00000000, B00000000, B00000000, // |
3, 8, B01000001, B00110110, B00001000, B00000000, B00000000, // }
4, 8, B00001000, B00000100, B00001000, B00000100, B00000000, // ~
};
int data = 5; // DIN pin of MAX7219 module
int load = 6; // CS pin of MAX7219 module
int clock = 7; // CLK pin of MAX7219 module
int maxInUse = 4; //how many MAX7219 are connected
MaxMatrix m(data, load, clock, maxInUse); // define Library
byte buffer[10];
char string1[] = "Sziasztok!! "; // Scrolling Text
void setup(){
m.init(); // module MAX7219
m.setIntensity(5); // LED Intensity 0-15
}
void loop(){
byte c;
delay(20);
m.shiftLeft(false, true);
printStringWithShift(string1, 100); // Send scrolling Text
}
// Put extracted character on Display
void printCharWithShift(char c, int shift_speed){
if (c < 32) return;
c -= 32;
memcpy_P(buffer, CH + 7*c, 7);
m.writeSprite(maxInUse*8, 0, buffer);
m.setColumn(maxInUse*8 + buffer[0], 0);
for (int i=0; i<buffer[0]+1; i++)
{
delay(shift_speed);
m.shiftLeft(false, false);
}
}
// Extract characters from Scrolling text
void printStringWithShift(char* s, int shift_speed){
while (*s != 0){
printCharWithShift(*s, shift_speed);
s++;
}
}

A hozzászólás módosítva: Nov 16, 2017

(#)	Kovidivi válasza Kari55 hozzászólására (»)	Nov 16, 2017		/

Az egyik szám a szélesség, a másik a magasságot jelöli. Így egymás után ha kiírod a betűket a kijelzőre, pontosan tudod, hány oszlopot kell kimásolnod, és pontosan 1db üres oszlop lesz a betűk között. Akár "i", akár "m" betűről van szó. Az ékezetes betűket megnézed, hogy az ascii táblázatban milyen pozícióban helyezkednek el, és oda kell raknod őket. kiterjesztett ascii tablázat. A gond ezzel csak annyi, hogy rengeteg felesleges helyet használ fel. Így a megoldás az lenne, ha közvetlenül a táblázat utolsó sora után raknád be az ékezetes betűket, majd a függvényt, ami a kijelzőre ír, kibővítenéd, hogy ha ékezetes betűvel találkozik, akkor a táblázat speciális helyéről vegye az karakter képét. Normál esetben a táblázatnak azt az elemét veszi, amelyiknek a sorszáma megegyezik a betű ascii kódjával.

(#)	proba válasza Kari55 hozzászólására (»)	Nov 16, 2017		/

Durvább, ha egy nem használt karaktert módosítasz, és a szövegben arra hivatkozol. Pl autó helyett aut> és a > jel kinézetét szabod testre. Ehhez kevésbé kell módosítani, érteni a program felépítését.

(#)	Kari55 hozzászólása	Nov 16, 2017		/

Köszi a gyors választ, de nem tudom mit hova kellene írnom.

A számokat megértettem, de a többi nekem "magas" ugyanis átkódolom a pl. "é" betűt binárissá, akkor csak 8 számjegyet kapok, a többi oszlopba mit kell írnom?

4, 8, B00001000, B00000100, B00001000, B00000100, B00000000, // ~
Ide };
vagy ide?

(#)	proba válasza Kari55 hozzászólására (»)	Nov 16, 2017		/

Nem binárissá kell kódolnod, hanem ha a B betűvel kezdődő sorokat egymás mellé rakod függőlegesen, és a nullákat kitörlöd. ha jól nézem az utánna lévő karakter képe marad.Ennek analógiájára az É betű képét neked kell előállítanod a hiányzó rácspontokat nullával pótolni visszaforgatni, kicserélni és már kész is.

(#)	kaqkk válasza Kari55 hozzászólására (»)	Nov 16, 2017		/

Ha ascci kóddal programozható akkor lehet hogy ez is segít

LCD_char.rar

(#)	Kari55 válasza proba hozzászólására (»)	Nov 17, 2017		/

Köszönöm a segítő szándéko(ka)t, de nekem ez nagyon nem megy. Ha valaki be tudná írni a bemásolt kódba, hogy mit, hová írjak, az nagyon jó lenne, és esetleg tanulhatnék is belőle
köszönöm.

(#)	proba válasza Kari55 hozzászólására (»)	Nov 17, 2017		/

Egy 5*8 as kockás papír jól jöhet. Kiválasztod pl a '// a' végü sort.az itt található B-vel kezdődő sorokkal szépen kitöltöd a lapot. Ahol 1 van ott kiszinezed az adott kockát ha 0 kihagyod. Lám kirajzolódik egy a betü. Ha a lapon átszinezel egy másik kockát, és visszaírod értelemszerűen ( üres kocka 0 teli 1) akkor minden 'a' betü helyett a te rajzod jelenik meg.
Ha a '#' jelet rajzolod át, akkor a te rajzod a '#' kiiratásakor jelenik meg.

(#)	Kari55 válasza proba hozzászólására (»)	Nov 17, 2017		/

Idézet:
„Egy 5*8 as kockás papír”

Miért 5*8-as, mert a mátrixom 8*8-as?

(#)	Gafly válasza Kari55 hozzászólására (»)	Nov 17, 2017		/

Mert a mellékelt kódrészletben egy sorban, egy karaktehez 5 byte van, és egy byte-ben pedig 8 bit

(#)	Kari55 válasza Gafly hozzászólására (»)	Nov 17, 2017		/

Nálam így adta ki az "a" betűt. melléklet Ez így már jó lehet, ha egy meglévő(nem használt) karaktert átírok, vagy újat csinálok?

a-betü.png

(#)	Kari55 válasza Kari55 hozzászólására (»)	Nov 17, 2017		/

Ez a módszer sikerült.

Idézet:
„Pl autó helyett aut> és a > jel kinézetét szabod testre”

Ha új sorként szúrom be, akkor miért nem működik?
Egyébként köszönöm a segítségeteket.

(#)	kaqkk válasza Kari55 hozzászólására (»)	Nov 17, 2017		/

A karaktergenerátort nézted ?

(#)	proba válasza Kari55 hozzászólására (»)	Nov 17, 2017		/

Mert ahhoz magát a kiírás módját is módosítani kellene.

(#)	Gafly válasza proba hozzászólására (»)	Nov 17, 2017		/

Ahhoz meg kellene a teljes forráskód, meg programozni tudni...
Önfarkunkba haraptunk

(#)	proba válasza Gafly hozzászólására (»)	Nov 17, 2017		/

Azt is mintha belinkelte volna, de ez a módszer egyszerűbb számomra, mint a program átírásán megértésén agyalni. ( bár kevésbé elegáns, de a lustaság nagy úr )

(#)	Gafly válasza proba hozzászólására (»)	Nov 17, 2017		/

Szerintem nem volt belinkelve, de lényegtelen is.
A lustaság tényleg nagy úr. Megírhatjuk helyette is, de akkor még több információ kell tőle

(#)	Kari55 válasza kaqkk hozzászólására (»)	Nov 18, 2017		/

Ezt hol találom?

(#)	kaqkk válasza Kari55 hozzászólására (»)	Nov 18, 2017		/

Az előző hozzászólásomban ....

(#)	Kari55 hozzászólása	Nov 25, 2017		/

Sziasztok!
Ebben a programban mit kellene - ha lehet - átírni, hogy ne egymás alatt menjen a szöveg, hanem egymás után.

A 0044 ez két darab

A 0046 ezzel

Nem tudom érthető-e mit szeretnék, Köszönöm

A hozzászólás módosítva: Nov 25, 2017

MVI_0044[1].AVI

MVI_0046[1].AVI