Fórum témák

» Több friss téma
Fórum » LED mátrixos kijelző
Lapozás: OK   25 / 27
(#) 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.

  1. #include <MaxMatrix.h>
  2. #include <avr/pgmspace.h>
  3.  
  4.  
  5.  
  6. PROGMEM const unsigned char CH[] = {
  7. 3, 8, B00000000, B00000000, B00000000, B00000000, B00000000, // space
  8. 1, 8, B01011111, B00000000, B00000000, B00000000, B00000000, // !
  9. 3, 8, B00000011, B00000000, B00000011, B00000000, B00000000, // "
  10. 5, 8, B00010100, B00111110, B00010100, B00111110, B00010100, // #
  11. 4, 8, B00100100, B01101010, B00101011, B00010010, B00000000, // $
  12. 5, 8, B01100011, B00010011, B00001000, B01100100, B01100011, // %
  13. 5, 8, B00110110, B01001001, B01010110, B00100000, B01010000, // &
  14. 1, 8, B00000011, B00000000, B00000000, B00000000, B00000000, // '
  15. 3, 8, B00011100, B00100010, B01000001, B00000000, B00000000, // (
  16. 3, 8, B01000001, B00100010, B00011100, B00000000, B00000000, // )
  17. 5, 8, B00101000, B00011000, B00001110, B00011000, B00101000, // *
  18. 5, 8, B00001000, B00001000, B00111110, B00001000, B00001000, // +
  19. 2, 8, B10110000, B01110000, B00000000, B00000000, B00000000, // ,
  20. 4, 8, B00001000, B00001000, B00001000, B00001000, B00000000, // -
  21. 2, 8, B01100000, B01100000, B00000000, B00000000, B00000000, // .
  22. 4, 8, B01100000, B00011000, B00000110, B00000001, B00000000, // /
  23. 4, 8, B00111110, B01000001, B01000001, B00111110, B00000000, // 0
  24. 3, 8, B01000010, B01111111, B01000000, B00000000, B00000000, // 1
  25. 4, 8, B01100010, B01010001, B01001001, B01000110, B00000000, // 2
  26. 4, 8, B00100010, B01000001, B01001001, B00110110, B00000000, // 3
  27. 4, 8, B00011000, B00010100, B00010010, B01111111, B00000000, // 4
  28. 4, 8, B00100111, B01000101, B01000101, B00111001, B00000000, // 5
  29. 4, 8, B00111110, B01001001, B01001001, B00110000, B00000000, // 6
  30. 4, 8, B01100001, B00010001, B00001001, B00000111, B00000000, // 7
  31. 4, 8, B00110110, B01001001, B01001001, B00110110, B00000000, // 8
  32. 4, 8, B00000110, B01001001, B01001001, B00111110, B00000000, // 9
  33. 2, 8, B01010000, B00000000, B00000000, B00000000, B00000000, // :
  34. 2, 8, B10000000, B01010000, B00000000, B00000000, B00000000, // ;
  35. 3, 8, B00010000, B00101000, B01000100, B00000000, B00000000, // <
  36. 3, 8, B00010100, B00010100, B00010100, B00000000, B00000000, // =
  37. 3, 8, B01000100, B00101000, B00010000, B00000000, B00000000, // >
  38. 4, 8, B00000010, B01011001, B00001001, B00000110, B00000000, // ?
  39. 5, 8, B00111110, B01001001, B01010101, B01011101, B00001110, // @
  40. 4, 8, B01111110, B00010001, B00010001, B01111110, B00000000, // A
  41. 4, 8, B01111111, B01001001, B01001001, B00110110, B00000000, // B
  42. 4, 8, B00111110, B01000001, B01000001, B00100010, B00000000, // C
  43. 4, 8, B01111111, B01000001, B01000001, B00111110, B00000000, // D
  44. 4, 8, B01111111, B01001001, B01001001, B01000001, B00000000, // E
  45. 4, 8, B01111111, B00001001, B00001001, B00000001, B00000000, // F
  46. 4, 8, B00111110, B01000001, B01001001, B01111010, B00000000, // G
  47. 4, 8, B01111111, B00001000, B00001000, B01111111, B00000000, // H
  48. 3, 8, B01000001, B01111111, B01000001, B00000000, B00000000, // I
  49. 4, 8, B00110000, B01000000, B01000001, B00111111, B00000000, // J
  50. 4, 8, B01111111, B00001000, B00010100, B01100011, B00000000, // K
  51. 4, 8, B01111111, B01000000, B01000000, B01000000, B00000000, // L
  52. 5, 8, B01111111, B00000010, B00001100, B00000010, B01111111, // M
  53. 5, 8, B01111111, B00000100, B00001000, B00010000, B01111111, // N
  54. 4, 8, B00111110, B01000001, B01000001, B00111110, B00000000, // O
  55. 4, 8, B01111111, B00001001, B00001001, B00000110, B00000000, // P
  56. 4, 8, B00111110, B01000001, B01000001, B10111110, B00000000, // Q
  57. 4, 8, B01111111, B00001001, B00001001, B01110110, B00000000, // R
  58. 4, 8, B01000110, B01001001, B01001001, B00110010, B00000000, // S
  59. 5, 8, B00000001, B00000001, B01111111, B00000001, B00000001, // T
  60. 4, 8, B00111111, B01000000, B01000000, B00111111, B00000000, // U
  61. 5, 8, B00001111, B00110000, B01000000, B00110000, B00001111, // V
  62. 5, 8, B00111111, B01000000, B00111000, B01000000, B00111111, // W
  63. 5, 8, B01100011, B00010100, B00001000, B00010100, B01100011, // X
  64. 5, 8, B00000111, B00001000, B01110000, B00001000, B00000111, // Y
  65. 4, 8, B01100001, B01010001, B01001001, B01000111, B00000000, // Z
  66. 2, 8, B01111111, B01000001, B00000000, B00000000, B00000000, // [
  67. 4, 8, B00000001, B00000110, B00011000, B01100000, B00000000, // \ backslash
  68. 2, 8, B01000001, B01111111, B00000000, B00000000, B00000000, // ]
  69. 3, 8, B00000010, B00000001, B00000010, B00000000, B00000000, // hat
  70. 4, 8, B01000000, B01000000, B01000000, B01000000, B00000000, // _
  71. 2, 8, B00000001, B00000010, B00000000, B00000000, B00000000, // `
  72. 4, 8, B00100000, B01010100, B01010100, B01111000, B00000000, // a
  73. 4, 8, B01111111, B01000100, B01000100, B00111000, B00000000, // b
  74. 4, 8, B00111000, B01000100, B01000100, B00101000, B00000000, // c
  75. 4, 8, B00111000, B01000100, B01000100, B01111111, B00000000, // d
  76. 4, 8, B00111000, B01010100, B01010100, B00011000, B00000000, // e
  77. 3, 8, B00000100, B01111110, B00000101, B00000000, B00000000, // f
  78. 4, 8, B10011000, B10100100, B10100100, B01111000, B00000000, // g
  79. 4, 8, B01111111, B00000100, B00000100, B01111000, B00000000, // h
  80. 3, 8, B01000100, B01111101, B01000000, B00000000, B00000000, // i
  81. 4, 8, B01000000, B10000000, B10000100, B01111101, B00000000, // j
  82. 4, 8, B01111111, B00010000, B00101000, B01000100, B00000000, // k
  83. 3, 8, B01000001, B01111111, B01000000, B00000000, B00000000, // l
  84. 5, 8, B01111100, B00000100, B01111100, B00000100, B01111000, // m
  85. 4, 8, B01111100, B00000100, B00000100, B01111000, B00000000, // n
  86. 4, 8, B00111000, B01000100, B01000100, B00111000, B00000000, // o
  87. 4, 8, B11111100, B00100100, B00100100, B00011000, B00000000, // p
  88. 4, 8, B00011000, B00100100, B00100100, B11111100, B00000000, // q
  89. 4, 8, B01111100, B00001000, B00000100, B00000100, B00000000, // r
  90. 4, 8, B01001000, B01010100, B01010100, B00100100, B00000000, // s
  91. 3, 8, B00000100, B00111111, B01000100, B00000000, B00000000, // t
  92. 4, 8, B00111100, B01000000, B01000000, B01111100, B00000000, // u
  93. 5, 8, B00011100, B00100000, B01000000, B00100000, B00011100, // v
  94. 5, 8, B00111100, B01000000, B00111100, B01000000, B00111100, // w
  95. 5, 8, B01000100, B00101000, B00010000, B00101000, B01000100, // x
  96. 4, 8, B10011100, B10100000, B10100000, B01111100, B00000000, // y
  97. 3, 8, B01100100, B01010100, B01001100, B00000000, B00000000, // z
  98. 3, 8, B00001000, B00110110, B01000001, B00000000, B00000000, // {
  99. 1, 8, B01111111, B00000000, B00000000, B00000000, B00000000, // |
  100. 3, 8, B01000001, B00110110, B00001000, B00000000, B00000000, // }
  101. 4, 8, B00001000, B00000100, B00001000, B00000100, B00000000, // ~
  102. };
  103.  
  104. int data = 5;    // DIN pin of MAX7219 module
  105. int load = 6;    // CS pin of MAX7219 module
  106. int clock = 7;  // CLK pin of MAX7219 module
  107.  
  108. int maxInUse = 4;  //how many MAX7219 are connected
  109.  
  110. MaxMatrix m(data, load, clock, maxInUse); // define Library
  111.  
  112. byte buffer[10];
  113.  
  114. char string1[] = "Sziasztok!!   ";  // Scrolling Text
  115.  
  116.  
  117. void setup(){
  118.   m.init(); // module MAX7219
  119.   m.setIntensity(5); // LED Intensity 0-15
  120. }
  121.  
  122. void loop(){
  123.  
  124.   byte c;
  125.   delay(20);
  126.   m.shiftLeft(false, true);
  127.   printStringWithShift(string1, 100);  // Send scrolling Text
  128.  
  129. }
  130.  
  131. // Put extracted character on Display
  132. void printCharWithShift(char c, int shift_speed){
  133.   if (c < 32) return;
  134.   c -= 32;
  135.   memcpy_P(buffer, CH + 7*c, 7);
  136.   m.writeSprite(maxInUse*8, 0, buffer);
  137.   m.setColumn(maxInUse*8 + buffer[0], 0);
  138.  
  139.   for (int i=0; i<buffer[0]+1; i++)
  140.   {
  141.     delay(shift_speed);
  142.     m.shiftLeft(false, false);
  143.   }
  144. }
  145.  
  146. // Extract characters from Scrolling text
  147. void printStringWithShift(char* s, int shift_speed){
  148.   while (*s != 0){
  149.     printCharWithShift(*s, shift_speed);
  150.     s++;
  151.   }
  152. }
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
Következő: »»   25 / 27
Bejelentkezés

Belépés

Hirdetés
Lapoda.hu     XDT.hu     HEStore.hu
Az oldalon sütiket használunk a helyes működéshez. Bővebb információt az adatvédelmi szabályzatban olvashatsz. Megértettem