Fórum témák

» Több friss téma
Fórum » Arduino
A klónok CH340 Soros-USB illesztőjének drivere (Letöltés)
Lapozás: OK   317 / 853
(#) kissi válasza ludus hozzászólására (») Jan 27, 2017 /
 
Idézet:
„zt szeretném hogy ha a feltetel2 igaz akkor hajtsa végre az alatta lévő utasításokat de miközben ezeket végrehajtja (mert a feltétel még mindíg igaz) nézze meg a feltetel3-at is”
Na ez, a "miközben" nem megy, csak egymás után...!
Idézet:
„és ha az is igaz (miért is ne lehetna) akkor hajtsa végre azt is sőt ha a feltetel4 is igazzá válik (lehet hogy akkor már a feltetel3 nem igaz de a feltetel2 még mindíg akkor azzal is foglalkozzon).”

Ezeket viszont a feltetel2 után megvizsgálja és ha igaz, akkor végrehajtja, másképp nem tudja, csak egymás után !
Lehet, hogy nem jól értem, amit kérsz, de ez a programrészlet szerintem a kívánságodnak megfelelően működik !
(#) david10 válasza szeg76 hozzászólására (») Jan 28, 2017 /
 
Sajnos így is össze-vissza ír ki dolgokat.

Pethical: A mapot átneveztem ledmap-ra, mert nem tetszett a fordítónak.
A byte b[5] értékét/meghatározását áttettem kapcsos zárójelbe, mert nem tetszett neki, hogy nincs brace-enclosed zárójelben a meghatározása. ( byte b[5] = {map[c-'A']}; )
Végül ez lett belőle:
  1. byte ledmap[4][5]= // A 40 az persze csak hasraütés, ahány betűt akarsz (meg számot)
  2. {
  3.   {0x7F,0x08,0x08,0x08,0x7F}, //H
  4.   {0x7F,0x49,0x49,0x49,0x49}, //E
  5.   {0x7F,0x01,0x01,0x01,0x01}, //L
  6.   {0x3E,0x41,0x41,0x41,0x3E} //O
  7. };
  8.  
  9.  
  10. void print(char c){
  11.   byte b[5] = {map[c-'A']};
  12.   screen_refresh(25, b);
  13. }
  14.  
  15. void printString(char *s){
  16.   char *t = s;
  17.   while(*t) {
  18.     print(*t);
  19.     t++;
  20.   }
  21. }
  22.  
  23. void loop(){
  24.  
  25. printString("He");
  26.  
  27. }

A printString("He"); helyére akármit írhatok, nem változik semmi.
A map müködéséről/használatáról tudol-e linket adni? Sajnos nem tudom azt se, hogy hogyan keressem.
(#) Pethical válasza david10 hozzászólására (») Jan 28, 2017 /
 
Én úgy gondoltam, hogy feltöltöd a ledmap-ot az egész ABC-vel.
Ha átnevezed ledmap-ra akkor nevezd át a print függvényben is és akkor nem kell a {} sem, ez így nem ok!
A ledmap lényege, hogy fel van benne sorolva minden egyes betű bittérképe. A c-'A' meg azért van, mert nálam az 'A' betű bitjei az 0. elem a tömbben, így 'A'-'A' az a 0. index lesz, 'B'-'A' az 1-es. Tehát,ha ezt a megoldást szeretnéd, akkor fel kell töltened a ledmapot A-tól Z-ig. Ha kisbetűt is akarsz akkor Z után jön az a..z, ha számot is akkor meg 0..9-el kezdd, aztán A..Z, aztán a..z és akkor meg '0'-t kell kivonni, nem 'A'-t a c-ből. Mindig a tömb első elemének betűjét. De fontos a sorrend, ascii kód szerint kell (0..9, A-Z, a-z).
Lehet, hogy ez így elsőre bonyolultnak tűnik, de ez egyszerű karakterkódololás, vagy, ha úgy tesztik sima kódolás-dekódolás. Így működik a DOS-ban is a kódlap, vagy a windows-ban a fontok. Minden értékhez (betű) tartozik egy kód amit egy tömbből veszünk ki.
A hozzászólás módosítva: Jan 28, 2017
(#) david10 válasza Pethical hozzászólására (») Jan 28, 2017 /
 
Köszönöm a válaszod! Ez egyszerübb mint hittem!
A map-ot kijavítottam ledmap-ra (byte b[5] = ledmap[c-'A'];), de csak az array must be initialized with a brace-enclosed initializer hibát adja meg. Ha az A...Z, a...z sorrendben feltöltöm a ledmapot az ABC-vel, akkor ez a hiba el fog tünni? Ugy-e csak az amcsi betük kellenek? Magyar ékezetes betük nem kellenek?
A hozzászólás módosítva: Jan 28, 2017
(#) david10 válasza david10 hozzászólására (») Jan 28, 2017 /
 
Megcsináltam, de ugyanaz a hiba. Ez lett belőle:
  1. byte ledmap[52][5]= // A 40 az persze csak hasraütés, ahány betűt akarsz (meg számot)
  2. {
  3.   {0x7E, 0x11, 0x11, 0x11, 0x7E},// A
  4.   {0x7F, 0x49, 0x49, 0x49, 0x36},// B
  5.   {0x3E, 0x41, 0x41, 0x41, 0x22},// C
  6.   {0x7F, 0x41, 0x41, 0x22, 0x1C},// D
  7.   {0x7F, 0x49, 0x49, 0x49, 0x41},// E
  8.   {0x7F, 0x09, 0x09, 0x01, 0x01},// F
  9.   {0x3E, 0x41, 0x41, 0x51, 0x32},// G
  10.   {0x7F, 0x08, 0x08, 0x08, 0x7F},// H
  11.   {0x00, 0x41, 0x7F, 0x41, 0x00},// I
  12.   {0x20, 0x40, 0x41, 0x3F, 0x01},// J
  13.  
  14.   {0x7F, 0x08, 0x14, 0x22, 0x41},// K
  15.   {0x7F, 0x40, 0x40, 0x40, 0x40},// L
  16.   {0x7F, 0x02, 0x04, 0x02, 0x7F},// M
  17.   {0x7F, 0x04, 0x08, 0x10, 0x7F},// N
  18.   {0x3E, 0x41, 0x41, 0x41, 0x3E},// O
  19.   {0x7F, 0x09, 0x09, 0x09, 0x06},// P
  20.   {0x3E, 0x41, 0x51, 0x21, 0x5E},// Q
  21.   {0x7F, 0x09, 0x19, 0x29, 0x46},// R
  22.   {0x46, 0x49, 0x49, 0x49, 0x31},// S
  23.   {0x01, 0x01, 0x7F, 0x01, 0x01},// T
  24.  
  25.   {0x3F, 0x40, 0x40, 0x40, 0x3F},// U
  26.   {0x1F, 0x20, 0x40, 0x20, 0x1F},// V
  27.   {0x7F, 0x20, 0x18, 0x20, 0x7F},// W
  28.   {0x63, 0x14, 0x08, 0x14, 0x63},// X
  29.   {0x03, 0x04, 0x78, 0x04, 0x03},// Y
  30.   {0x61, 0x51, 0x49, 0x45, 0x43},// Z
  31.  
  32.   {0x20, 0x54, 0x54, 0x54, 0x78},// a
  33.   {0x7F, 0x48, 0x44, 0x44, 0x38},// b
  34.   {0x38, 0x44, 0x44, 0x44, 0x20},// c
  35.   {0x38, 0x44, 0x44, 0x48, 0x7F},// d
  36.   {0x38, 0x54, 0x54, 0x54, 0x18},// e
  37.   {0x08, 0x7E, 0x09, 0x01, 0x02},// f
  38.   {0x08, 0x14, 0x54, 0x54, 0x3C},// g
  39.   {0x7F, 0x08, 0x04, 0x04, 0x78},// h
  40.   {0x00, 0x44, 0x7D, 0x40, 0x00},// i
  41.   {0x20, 0x40, 0x44, 0x3D, 0x00},// j
  42.  
  43.   {0x00, 0x7F, 0x10, 0x28, 0x44},// k
  44.   {0x00, 0x41, 0x7F, 0x40, 0x00},// l
  45.   {0x7C, 0x04, 0x18, 0x04, 0x78},// m
  46.   {0x7C, 0x08, 0x04, 0x04, 0x78},// n
  47.   {0x38, 0x44, 0x44, 0x44, 0x38},// o
  48.   {0x7C, 0x14, 0x14, 0x14, 0x08},// p
  49.   {0x08, 0x14, 0x14, 0x18, 0x7C},// q
  50.   {0x7C, 0x08, 0x04, 0x04, 0x08},// r
  51.   {0x48, 0x54, 0x54, 0x54, 0x20},// s
  52.   {0x04, 0x3F, 0x44, 0x40, 0x20},// t
  53.  
  54.   {0x3C, 0x40, 0x40, 0x20, 0x7C},// u
  55.   {0x1C, 0x20, 0x40, 0x20, 0x1C},// v
  56.   {0x3C, 0x40, 0x30, 0x40, 0x3C},// w
  57.   {0x44, 0x28, 0x10, 0x28, 0x44},// x
  58.   {0x0C, 0x50, 0x50, 0x50, 0x3C},// y
  59.   {0x44, 0x64, 0x54, 0x4C, 0x44}// z
  60. };
(#) david10 válasza david10 hozzászólására (») Jan 28, 2017 /
 
Jelenleg ez a forráskód, ezzel megjelennek a betük egymás után, de csak nem a "HELLO" szöveg jelenik meg: videó
  1. byte ledmap[52][6]= // A 40 az persze csak hasraütés, ahány betűt akarsz (meg számot)
  2. {
  3.   {0x7E, 0x11, 0x11, 0x11, 0x7E,0x00},// A
  4.   {0x7F, 0x49, 0x49, 0x49, 0x36,0x00},// B
  5.   {0x3E, 0x41, 0x41, 0x41, 0x22,0x00},// C
  6.   {0x7F, 0x41, 0x41, 0x22, 0x1C,0x00},// D
  7.   {0x7F, 0x49, 0x49, 0x49, 0x41,0x00},// E
  8.   {0x7F, 0x09, 0x09, 0x01, 0x01,0x00},// F
  9.   {0x3E, 0x41, 0x41, 0x51, 0x32,0x00},// G
  10.   {0x7F, 0x08, 0x08, 0x08, 0x7F,0x00},// H
  11.   {0x00, 0x41, 0x7F, 0x41, 0x00,0x00},// I
  12.   {0x20, 0x40, 0x41, 0x3F, 0x01,0x00},// J
  13.  
  14.   {0x7F, 0x08, 0x14, 0x22, 0x41,0x00},// K
  15.   {0x7F, 0x40, 0x40, 0x40, 0x40,0x00},// L
  16.   {0x7F, 0x02, 0x04, 0x02, 0x7F,0x00},// M
  17.   {0x7F, 0x04, 0x08, 0x10, 0x7F,0x00},// N
  18.   {0x3E, 0x41, 0x41, 0x41, 0x3E,0x00},// O
  19.   {0x7F, 0x09, 0x09, 0x09, 0x06,0x00},// P
  20.   {0x3E, 0x41, 0x51, 0x21, 0x5E,0x00},// Q
  21.   {0x7F, 0x09, 0x19, 0x29, 0x46,0x00},// R
  22.   {0x46, 0x49, 0x49, 0x49, 0x31,0x00},// S
  23.   {0x01, 0x01, 0x7F, 0x01, 0x01,0x00},// T
  24.  
  25.   {0x3F, 0x40, 0x40, 0x40, 0x3F,0x00},// U
  26.   {0x1F, 0x20, 0x40, 0x20, 0x1F,0x00},// V
  27.   {0x7F, 0x20, 0x18, 0x20, 0x7F,0x00},// W
  28.   {0x63, 0x14, 0x08, 0x14, 0x63,0x00},// X
  29.   {0x03, 0x04, 0x78, 0x04, 0x03,0x00},// Y
  30.   {0x61, 0x51, 0x49, 0x45, 0x43,0x00},// Z
  31.  
  32.   {0x20, 0x54, 0x54, 0x54, 0x78,0x00},// a
  33.   {0x7F, 0x48, 0x44, 0x44, 0x38,0x00},// b
  34.   {0x38, 0x44, 0x44, 0x44, 0x20,0x00},// c
  35.   {0x38, 0x44, 0x44, 0x48, 0x7F,0x00},// d
  36.   {0x38, 0x54, 0x54, 0x54, 0x18,0x00},// e
  37.   {0x08, 0x7E, 0x09, 0x01, 0x02,0x00},// f
  38.   {0x08, 0x14, 0x54, 0x54, 0x3C,0x00},// g
  39.   {0x7F, 0x08, 0x04, 0x04, 0x78,0x00},// h
  40.   {0x00, 0x44, 0x7D, 0x40, 0x00,0x00},// i
  41.   {0x20, 0x40, 0x44, 0x3D, 0x00,0x00},// j
  42.  
  43.   {0x00, 0x7F, 0x10, 0x28, 0x44,0x00},// k
  44.   {0x00, 0x41, 0x7F, 0x40, 0x00,0x00},// l
  45.   {0x7C, 0x04, 0x18, 0x04, 0x78,0x00},// m
  46.   {0x7C, 0x08, 0x04, 0x04, 0x78,0x00},// n
  47.   {0x38, 0x44, 0x44, 0x44, 0x38,0x00},// o
  48.   {0x7C, 0x14, 0x14, 0x14, 0x08,0x00},// p
  49.   {0x08, 0x14, 0x14, 0x18, 0x7C,0x00},// q
  50.   {0x7C, 0x08, 0x04, 0x04, 0x08,0x00},// r
  51.   {0x48, 0x54, 0x54, 0x54, 0x20,0x00},// s
  52.   {0x04, 0x3F, 0x44, 0x40, 0x20,0x00},// t
  53.  
  54.   {0x3C, 0x40, 0x40, 0x20, 0x7C,0x00},// u
  55.   {0x1C, 0x20, 0x40, 0x20, 0x1C,0x00},// v
  56.   {0x3C, 0x40, 0x30, 0x40, 0x3C,0x00},// w
  57.   {0x44, 0x28, 0x10, 0x28, 0x44,0x00},// x
  58.   {0x0C, 0x50, 0x50, 0x50, 0x3C,0x00},// y
  59.   {0x44, 0x64, 0x54, 0x4C, 0x44,0x00}// z
  60. };
  61.  
  62.  
  63. void print(char c){
  64.   byte b[6] = {ledmap[c-'A']};
  65.   screen_refresh(25, b);
  66. }
  67.  
  68. void printString(char *s){
  69.   char *t = s;
  70.   while(*t) {
  71.     print(*t);
  72.     t++;
  73.   }
  74. }
  75.  
  76. void loop(){
  77.  
  78. printString("HELLO");
  79.  
  80. }
(#) Pethical válasza david10 hozzászólására (») Jan 28, 2017 /
 
Cseréld le a print függvényt erre:
  1. void print(char c){
  2.   screen_refresh(25, ledmap[c-'A']);
  3. }


Nekem ezzel jó. (Igaz én Serial monitorra írom ki a számokat).
(#) david10 válasza Pethical hozzászólására (») Jan 28, 2017 /
 
Sajnos így ezt csinálja.
(#) Pethical válasza david10 hozzászólására (») Jan 28, 2017 /
 
Én ezzel tesztelem:
  1. byte ledmap[52][6]= // A 40 az persze csak hasraütés, ahány betűt akarsz (meg számot)
  2. {
  3.   {0x7E, 0x11, 0x11, 0x11, 0x7E,0x00},// A
  4.   {0x7F, 0x49, 0x49, 0x49, 0x36,0x00},// B
  5.   {0x3E, 0x41, 0x41, 0x41, 0x22,0x00},// C
  6.   {0x7F, 0x41, 0x41, 0x22, 0x1C,0x00},// D
  7.   {0x7F, 0x49, 0x49, 0x49, 0x41,0x00},// E
  8.   {0x7F, 0x09, 0x09, 0x01, 0x01,0x00},// F
  9.   {0x3E, 0x41, 0x41, 0x51, 0x32,0x00},// G
  10.   {0x7F, 0x08, 0x08, 0x08, 0x7F,0x00},// H
  11.   {0x00, 0x41, 0x7F, 0x41, 0x00,0x00},// I
  12.   {0x20, 0x40, 0x41, 0x3F, 0x01,0x00},// J
  13.  
  14.   {0x7F, 0x08, 0x14, 0x22, 0x41,0x00},// K
  15.   {0x7F, 0x40, 0x40, 0x40, 0x40,0x00},// L
  16.   {0x7F, 0x02, 0x04, 0x02, 0x7F,0x00},// M
  17.   {0x7F, 0x04, 0x08, 0x10, 0x7F,0x00},// N
  18.   {0x3E, 0x41, 0x41, 0x41, 0x3E,0x00},// O
  19.   {0x7F, 0x09, 0x09, 0x09, 0x06,0x00},// P
  20.   {0x3E, 0x41, 0x51, 0x21, 0x5E,0x00},// Q
  21.   {0x7F, 0x09, 0x19, 0x29, 0x46,0x00},// R
  22.   {0x46, 0x49, 0x49, 0x49, 0x31,0x00},// S
  23.   {0x01, 0x01, 0x7F, 0x01, 0x01,0x00},// T
  24.  
  25.   {0x3F, 0x40, 0x40, 0x40, 0x3F,0x00},// U
  26.   {0x1F, 0x20, 0x40, 0x20, 0x1F,0x00},// V
  27.   {0x7F, 0x20, 0x18, 0x20, 0x7F,0x00},// W
  28.   {0x63, 0x14, 0x08, 0x14, 0x63,0x00},// X
  29.   {0x03, 0x04, 0x78, 0x04, 0x03,0x00},// Y
  30.   {0x61, 0x51, 0x49, 0x45, 0x43,0x00},// Z
  31.  
  32.   {0x20, 0x54, 0x54, 0x54, 0x78,0x00},// a
  33.   {0x7F, 0x48, 0x44, 0x44, 0x38,0x00},// b
  34.   {0x38, 0x44, 0x44, 0x44, 0x20,0x00},// c
  35.   {0x38, 0x44, 0x44, 0x48, 0x7F,0x00},// d
  36.   {0x38, 0x54, 0x54, 0x54, 0x18,0x00},// e
  37.   {0x08, 0x7E, 0x09, 0x01, 0x02,0x00},// f
  38.   {0x08, 0x14, 0x54, 0x54, 0x3C,0x00},// g
  39.   {0x7F, 0x08, 0x04, 0x04, 0x78,0x00},// h
  40.   {0x00, 0x44, 0x7D, 0x40, 0x00,0x00},// i
  41.   {0x20, 0x40, 0x44, 0x3D, 0x00,0x00},// j
  42.  
  43.   {0x00, 0x7F, 0x10, 0x28, 0x44,0x00},// k
  44.   {0x00, 0x41, 0x7F, 0x40, 0x00,0x00},// l
  45.   {0x7C, 0x04, 0x18, 0x04, 0x78,0x00},// m
  46.   {0x7C, 0x08, 0x04, 0x04, 0x78,0x00},// n
  47.   {0x38, 0x44, 0x44, 0x44, 0x38,0x00},// o
  48.   {0x7C, 0x14, 0x14, 0x14, 0x08,0x00},// p
  49.   {0x08, 0x14, 0x14, 0x18, 0x7C,0x00},// q
  50.   {0x7C, 0x08, 0x04, 0x04, 0x08,0x00},// r
  51.   {0x48, 0x54, 0x54, 0x54, 0x20,0x00},// s
  52.   {0x04, 0x3F, 0x44, 0x40, 0x20,0x00},// t
  53.  
  54.   {0x3C, 0x40, 0x40, 0x20, 0x7C,0x00},// u
  55.   {0x1C, 0x20, 0x40, 0x20, 0x1C,0x00},// v
  56.   {0x3C, 0x40, 0x30, 0x40, 0x3C,0x00},// w
  57.   {0x44, 0x28, 0x10, 0x28, 0x44,0x00},// x
  58.   {0x0C, 0x50, 0x50, 0x50, 0x3C,0x00},// y
  59.   {0x44, 0x64, 0x54, 0x4C, 0x44,0x00}// z
  60. };
  61.  
  62.  
  63. void print(char c){
  64.   for(int i=0;i<6;i++) {
  65.       Serial.print(ledmap[c-'A'][i], HEX);
  66.   }
  67.   Serial.println("");
  68. }
  69.  
  70. void printString(char *s){
  71.   char *t = s;
  72.   while(*t) {
  73.     print(*t);
  74.     t++;
  75.   }
  76. }
  77.  
  78. void loop(){
  79.  
  80.  
  81. }
  82.  
  83. void setup(){
  84.   Serial.begin(9600);
  85.   printString("HELLO");  
  86. }


Így a kimenetem a soros monitoron:
  1. 7F8887F0
  2. 7F494949410
  3. 7F404040400
  4. 7F404040400
  5. 3E4141413E0


Ami elvileg a HELLO. Nem nagyon értem nálad miért nem akarja.
(#) david10 válasza Pethical hozzászólására (») Jan 28, 2017 /
 
Szerintem a RAM-ból írja ki ezeket a véletlenszerü értékeket.
Megprobálok kifaragni a kódból ezt-azt.
(#) david10 válasza david10 hozzászólására (») Jan 28, 2017 /
 
A helyzet valójában, az az,hogy kétféle dolgot csinál, ezeket kommentáltam:
  1. void print(char c){
  2.   for(int i=0;i<6;i++) {
  3.       Serial.print(ledmap[c-'A'][i], HEX);
  4.    }
  5.   Serial.println("");
  6.  
  7.   screen_refresh(25,ledmap[c-'A']);  // Igy az ABC betuit irja ki, egymast felvaltva kezdve a nagy A-tol a nagy Z-ig.
  8.  
  9.   byte tarolo={ledmap[c-'A'][1]+ledmap[c-'A'][2]+ledmap[c-'A'][3]+ledmap[c-'A'][4]+ledmap[c-'A'][5]+ledmap[c-'A'][6]};
  10.   screen_refresh(25,tarolo); //Igy krix-krax-okat ir ki a RAM-bol.
  11. }
(#) Pethical válasza david10 hozzászólására (») Jan 28, 2017 /
 
Egy kérdés: Biztos, hogy össze akarod adni az alábbi hat bájtot?

  1. byte tarolo={ledmap[c-'A'][1]+ledmap[c-'A'][2]+ledmap[c-'A'][3]+ledmap[c-'A'][4]+ledmap[c-'A'][5]+ledmap[c-'A'][6]};


Ja, és túlindexeled a tömböt. 0-tól 5-ig vannak elemek, a 6-os index már invalid egy 6 elemű tömbnél.

Viszont azt, hogy miért írja ki az abc betűit sorba, na azt végképp nem értem.
(#) david10 válasza Pethical hozzászólására (») Jan 28, 2017 /
 
Össze szerettem volna és azt akartam kiiratni.
Megprobálom 0-tól 5-ig
(#) david10 válasza david10 hozzászólására (») Jan 28, 2017 /
 
Igy is ugyanazt csinálja. Ha csak a ledmap[c-'A'][0]-át iratom ki, akkor is össze-visszaságot ír ki.
A hozzászólás módosítva: Jan 28, 2017
(#) Pethical válasza david10 hozzászólására (») Jan 28, 2017 /
 
De, ha összeadod akkor a tarolo tartalma egy bájt lesz, a többi 6 összege. Ez a cél?
A hozzászólás módosítva: Jan 28, 2017
(#) david10 válasza Pethical hozzászólására (») Jan 28, 2017 /
 
Nem, a cél az lett volna, hogy egymás után teszem a ledmap-ból kivett értékeket, és ezeket iratom ki. De amint írtam,mår a ledmap [c-'A'][0]-át se írja ki.
Amiből mi most probálunk adatot kiolvasni majd kiíratni, azt minek hivják? Character table? Character map? Vagy milyen néven keressem?
(#) Pethical válasza david10 hozzászólására (») Jan 29, 2017 /
 
Ez egy jó kérdés, nem tudom hivatalosan mi a neve. A screen_refresh függvényben mi található?
(#) david10 válasza Pethical hozzászólására (») Jan 29, 2017 /
 
Ez, de egy pillanat és küldök még egy hozzászolást...
  1. void screen_refresh(int count,byte szoveg[]) {
  2.  
  3. for(int i=0;i<count;i++){
  4.  
  5.  for(int i=0;i<3;i++)
  6.     {
  7. /*************************** FIRST FRAME ***************************/
  8.     digitalWrite(latchPin, LOW);
  9.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[0]);
  10.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[8]);
  11.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[16]);
  12.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[24]);
  13.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[32]);
  14.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[40]);
  15.     digitalWrite(latchPin, HIGH);
  16.     Shift_Register_Emulator(254,LedPort); }
  17.     Shift_Register_Emulator(255,LedPort); //Turn off all the LEDs
  18.    
  19. /******************************* SECOND FRAME ********************************/  
  20.     for(int i=0;i<3;i++)
  21.     { digitalWrite(latchPin, LOW);
  22.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[1]);
  23.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[9]);
  24.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[17]);
  25.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[25]);
  26.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[33]);
  27.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[41]);
  28.     digitalWrite(latchPin, HIGH);
  29.   Shift_Register_Emulator(253,LedPort);}
  30.     Shift_Register_Emulator(255,LedPort); //Turn off all the LEDs
  31.   /**************************** THIRD FRAME *******************************/
  32.   for(int i=0;i<3;i++)
  33.     {
  34.     digitalWrite(latchPin, LOW);
  35.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[2]);
  36.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[10]);
  37.   //Serial.println(szoveg[11]);
  38.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[18]);
  39.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[26]);
  40.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[34]);
  41.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[42]);
  42.     digitalWrite(latchPin, HIGH);
  43.     Shift_Register_Emulator(251,LedPort);  }
  44.     Shift_Register_Emulator(255,LedPort); //Turn off all the LEDs
  45.    
  46. /************************* FOURTH FRAME *******************************/
  47.   for(int i=0;i<3;i++)
  48.     { digitalWrite(latchPin, LOW);
  49.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[3]);
  50.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[11]);
  51.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[19]);
  52.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[27]);
  53.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[35]);
  54.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[43]);
  55.     digitalWrite(latchPin, HIGH);    
  56.     Shift_Register_Emulator(247,LedPort);}
  57.     Shift_Register_Emulator(255,LedPort); //Turn off all the LEDs
  58.    
  59. /***************************** FIFTH FRAME ******************************/
  60.     for(int i=0;i<3;i++)
  61.     { digitalWrite(latchPin, LOW);
  62.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[4]);
  63.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[12]);
  64.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[20]);
  65.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[28]);
  66.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[36]);
  67.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[44]);
  68.     digitalWrite(latchPin, HIGH);
  69.     Shift_Register_Emulator(239,LedPort);   }
  70.     Shift_Register_Emulator(255,LedPort);
  71.  
  72. /**************************** SIXTH FRAME *****************************/
  73.     for(int i=0;i<3;i++)
  74.     { digitalWrite(latchPin, LOW);
  75.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[5]);
  76.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[13]);
  77.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[21]);
  78.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[29]);
  79.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[37]);
  80.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[45]);
  81.     digitalWrite(latchPin, HIGH);
  82.     Shift_Register_Emulator(223,LedPort);
  83.     }
  84.     Shift_Register_Emulator(255,LedPort);  //Turn off all the LEDs
  85.    
  86. /***************************  SEVENTH FRAME **************************/  
  87.    for(int i=0;i<3;i++)
  88.     {  digitalWrite(latchPin, LOW);
  89.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[6]);
  90.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[14]);
  91.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[22]);
  92.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[30]);
  93.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[38]);
  94.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[46]);
  95.     digitalWrite(latchPin, HIGH);
  96.          
  97.     Shift_Register_Emulator(191,LedPort);
  98.     }
  99.     Shift_Register_Emulator(255,LedPort); //Turn off all the LEDs
  100.    
  101. /**************************** EIGHTH FRAME ***************************/
  102.     for(int i=0;i<3;i++)
  103.     { digitalWrite(latchPin, LOW);
  104.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[7]);
  105.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[15]);
  106.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[23]);
  107.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[31]);
  108.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[39]);
  109.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[47]);
  110.     digitalWrite(latchPin, HIGH);
  111.     Shift_Register_Emulator(127,LedPort);}
  112.     Shift_Register_Emulator(255,LedPort); //Turn off all the LEDs
  113. }}
(#) david10 válasza david10 hozzászólására (») Jan 29, 2017 /
 
Fejlemények:
screen_refresh(25,ledmap[0]); kiírja az A betüvel kezdődően a betüket a H-ig (mert addig fér ki kijelzőre), nem ugrálnak a betük

screen_refresh(25,ledmap[2]); kiírja a C betüvel kezdődően a betüket a K-ig (mert addig fér ki kijelzőre) , nem ugrálnak a betük

Szerintem ha megtudnánk oldani azt, hogy csak az első 6 byte-ot írja ki, akkor már síkon lennénk.
Probáltam a
  1. byte dolog[6]={ledmap[2]};
  2. screen_refresh(25,dolog);
, de ettől csak 2 oszlopot ír ki, aminek semmi köze nincs a betükhöz.
(#) Pethical válasza david10 hozzászólására (») Jan 29, 2017 /
 
Azért, mert a dolog[6] = {} egy kétdimenziós tömböt hoz létre, neki meg egy kell.
Van egy ilyen ötletem:
  1. void printString(char *s){
  2.   char *t = s;
  3.   int size = strlen(s)*6;
  4.   byte * b = (byte *) malloc(size);
  5.   int i = 0;
  6.   while(*t) {
  7.     for(int j=0;j<6;j++){
  8.       b[i] = ledmap[*t-'A'][j];
  9.       i++;  
  10.     }
  11.     t++;
  12.   }
  13.   screen_refresh(25,b);
  14.   free(b);
  15. }


Ez a b-be egymás után beteszi a bájtokat, mintha ezt írnád:
byte b[size] = {0x7F, 0x40,...};
(#) david10 válasza Pethical hozzászólására (») Jan 29, 2017 /
 
Ez már nem kevéssel jobb, de még mindig nem az igazi. Kiírja a HELLO-t, de utána az ABCDEFGH-t is.
A void loop-ba írtam be a printString("HELLO");-t.
videó
(#) kapu48 válasza Pethical hozzászólására (») Jan 29, 2017 /
 
Ha karakterenként raksz össze stringet tömbbe, akkor a végére mindig kel '0'-át rakni.
Hogy a print rutin tudja hól a stringed vége.
A hozzászólás módosítva: Jan 29, 2017
(#) Pethical válasza david10 hozzászólására (») Jan 29, 2017 /
 
Ez már haladás.
Most nézem, hogy fixen 8 hosszú tömböt vár a screen_refresh.
  1. void printString(char *s){
  2.   char *t = s;
  3.  
  4.   int size = strlen(s)*6;
  5.   if(size<6*8) size = 6*8;
  6.  
  7.   byte * b = (byte *) malloc(size);
  8.   memset(b, 0, size);
  9.   int i = 0;
  10.   while(*t) {
  11.     for(int j=0;j<6;j++){
  12.       b[i] = ledmap[*t-'A'][j];
  13.       i++;  
  14.     }
  15.     t++;
  16.   }
  17.   // for(int i = 0;i<size;i++) Serial.print(b[i], HEX);
  18.   // Serial.println("");
  19.   screen_refresh(25,b);
  20.   free(b);
  21. }


A fenti kóddal megszabadulsz a szeméttől a hello előtt.
Nekem a fenti függvény loopban ezt nyomja a serial monitorra:
  1. 7F8887F07F4949494107F4040404007F4040404003E4141413E0000000000000000000
  2. 7F8887F07F4949494107F4040404007F4040404003E4141413E0000000000000000000
  3. 7F8887F07F4949494107F4040404007F4040404003E4141413E0000000000000000000
  4. 7F8887F07F4949494107F4040404007F4040404003E4141413E0000000000000000000
  5. 7F8887F07F4949494107F4040404007F4040404003E4141413E0000000000000000000
  6. 7F8887F07F4949494107F4040404007F4040404003E4141413E0000000000000000000
  7. 7F8887F07F4949494107F4040404007F4040404003E4141413E0000000000000000000
  8. 7F8887F07F4949494107F4040404007F4040404003E4141413E0000000000000000000
  9. 7F8887F07F4949494107F4040404007F4040404003E4141413E0000000000000000000
  10. 7F8887F07F4949494107F4040404007F4040404003E4141413E0000000000000000000
  11. 7F8887F07F4949494107F4040404007F4040404003E4141413E0000000000000000000
  12. 7F8887F07F4949494107F4040404007F4040404003E4141413E0000000000000000000
  13. 7F8887F07F4949494107F4040404007F4040404003E4141413E0000000000000000000
  14. 7F8887F07F4949494107F4040404007F4040404003E4141413E0000000000000000000
  15. 7F8887F07F4949494107F4040404007F4040404003E4141413E0000000000000000000
  16. 7F8887F07F4949494107F4040404007F4040404003E4141413E0000000000000000000
  17. 7F8887F07F4949494107F4040404007F4040404003E4141413E0000000000000000000
  18. 7F8887F07F4949494107F4040404007F4040404003E4141413E0000000000000000000
  19. 7F8887F07F4949494107F4040404007F4040404003E4141413E0000000000000000000
  20. 7F8887F07F4949494107F4040404007F4040404003E4141413E0000000000000000000
  21. 7F8887F07F4949494107F4040404007F4040404003E4141413E0000000000000000000
  22. 7F8887F07F4949494107F4040404007F4040404003E4141413E0000000000000000000
  23. 7F8887F07F4949494107F4040404007F4040404003E4141413E0000000000000000000


@kapu48: Ez hogy jön ide?
(#) david10 válasza Pethical hozzászólására (») Jan 29, 2017 /
 
Ez megint nagy haladás, mert a szemét eltünt, de az ABC-t csak kiírja.
Videjó
(#) Pethical válasza david10 hozzászólására (») Jan 29, 2017 / 1
 
Nem értem miért csinálja. Nagyon fura ez az abc, pedig nem is kap a ledmapra hivatkozást, valami mégis elkezd rá mutatni a hello után.
A loopban csak egy printString("HELLO"); van? Megosztod az egész teszt fájlodat amiben a hello kiíratása van? Ha egybe látnánk akkor talán...
(#) david10 válasza Pethical hozzászólására (») Jan 29, 2017 / 1
 
A screen_refresh(25,ledmap[0]); bent maradt és ez viselte magát.
Köszönöm szépen midenkinek a segítségét és elnézést kérek az ostobaságomért!
További szép estét mindenkinek.
Ha valaki hasznát veszi, akkor itt forráskód, a ledmatrix libet csatoltam:
  1. #include <Wire.h>
  2. #include <Eeprom24C32_64.h>
  3. #include <TimerOne.h>
  4. #include <ledmatrix.h>
  5. #include <dht.h>
  6. dht DHT;
  7. #define DHT22_PIN 4
  8. #define EEPROM_ADDRESS  0x51
  9. static Eeprom24C32_64 eeprom(EEPROM_ADDRESS);
  10. int clockPin = 2; int latchPin = 11; int dataPin = 12; int sor1 = 3; int sor2 = 7; int sor3 = 8; int sor4 = A2; int sor5 = A1; int sor6 = A0; int sor7 = 10; int sor8 = 9;
  11. int LedPort[] = {sor1, sor2, sor3, sor4,sor5,sor6, sor7, sor8};
  12. Ledmatrix  ledmatrix(2,11,12,LedPort);
  13. byte error, address; int nDevices;
  14. unsigned long previousMillis = 0;  
  15. const long interval = 1000;  
  16.  
  17. byte data[]={0x00,0x41,0x7f,0x7f,0x49,0x49,0x7f,0x36,0x00,0x3e,0x7f,0x41,0x41,0x41,0x7f,0x3e,0x00,0x7f,0x7f,0x30,0x18,0x0c,0x7f,0x7f,0x00,0x7e,0x7f,0x01,0x01,0x01,0x7f,0x7e,0x00,0x32,0x7b,0x49,0x49,0x49,0x6f,0x26,0x00,0x0c,0x22,0x02,0x02,0x22,0x0C,0x00};
  18. //byte szoveg[] = {255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,255, 255, 255, 255, 255,255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,255, 255, 255, 255, 255};
  19. byte error1[]={0x00,0x00,0x00,0x00,0x00,0x00,0x7F,0x49,0x49,0x49,0x41,0x00,0x3F,0x10,0x20,0x20,0x10,0x00,0x3F,0x10,0x20,0x20,0x10,0x00,0x1E,0x21,0x21,0x21,0x1E,0x00,0x3F,0x10,0x20,0x20,0x10,0x00,0x12,0x2A,0x7F,0x2A,0x24,0x00,0x00,0x21,0x7F,0x01,0x00,0x00};
  20. //byte tarolo[48];
  21. #define szam1 {0x00,0x00,0x21,0x7f,0x01,0x00,0x00,0x00}
  22. void setup() {
  23.   pinMode(6, OUTPUT);
  24.   digitalWrite(6, HIGH);
  25.   Serial.begin(9600);
  26.   /*Serial.println("Booting up...");
  27.   Serial.print("Clearing shift register ");
  28.   ledmatrix.clear();
  29.   Serial.println("OK!");
  30.   Serial.print("Initialising I2C... ");
  31.   Wire.begin(); // initialise the connection
  32.   Serial.println("OK!");
  33.   Serial.println("Scanning I2C devices...");
  34.   scani2c();
  35.   Serial.print("Initialising I2C EEPROM at 0x");
  36.   Serial.print(EEPROM_ADDRESS);
  37.   eeprom.initialize();
  38.   Serial.println("...OK!");
  39.   //for (int i=0; i<47;i++){
  40.   //    szoveg[i]=eeprom.readByte(i);
  41.   //  }
  42.   */
  43.   Serial.println("Led Matrix booted up!");
  44.   digitalWrite(6, LOW);
  45.   //Timer1.initialize(10000);
  46.   //Timer1.attachInterrupt(screen_update);
  47.   //printarray(data);
  48.   //copyFromArrayToArray48(data,temp);
  49.   //printarray(temp);
  50. }
  51. /*
  52. void scani2c(){
  53.   nDevices = 0;
  54.   for(address = 1; address < 127; address++ )  {
  55.     Wire.beginTransmission(address);
  56.     error = Wire.endTransmission();
  57.      if (error == 0){
  58.       Serial.print("I2C device found at address 0x");
  59.       if (address<16)
  60.         Serial.print("0");
  61.       Serial.print(address,HEX);
  62.       Serial.println("  !");
  63.        nDevices++; }
  64.     else if (error==4){
  65.       Serial.print("Unknow error at address 0x");
  66.       if (address<16)
  67.         Serial.print("0");
  68.       Serial.println(address,HEX);
  69.     } }
  70.   if (nDevices == 0){
  71.     Serial.println("No I2C devices found\n");}
  72.   else {
  73.   Serial.println("done");}
  74. }
  75. */
  76. void screen_refresh(int count,byte szoveg[]) {
  77.  
  78. for(int i=0;i<count;i++){
  79.  
  80.  for(int i=0;i<3;i++)
  81.     {
  82. /*************************** FIRST FRAME ***************************/
  83.     digitalWrite(latchPin, LOW);
  84.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[0]);
  85.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[8]);
  86.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[16]);
  87.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[24]);
  88.   shiftOut(dataPin, clockPin, MSBFIRST, szoveg[32]);
  89.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[40]);
  90.     digitalWrite(latchPin, HIGH);
  91.     ledmatrix.Shift_Register_Emulator(254,LedPort); }
  92.     ledmatrix.Shift_Register_Emulator(255,LedPort); //Turn off all the LEDs
  93.    
  94. /******************************* SECOND FRAME ********************************/  
  95.     for(int i=0;i<3;i++)
  96.     { digitalWrite(latchPin, LOW);
  97.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[1]);
  98.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[9]);
  99.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[17]);
  100.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[25]);
  101.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[33]);
  102.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[41]);
  103.     digitalWrite(latchPin, HIGH);
  104.   ledmatrix.Shift_Register_Emulator(253,LedPort);}
  105.     ledmatrix.Shift_Register_Emulator(255,LedPort); //Turn off all the LEDs
  106.   /**************************** THIRD FRAME *******************************/
  107.   for(int i=0;i<3;i++)
  108.     {
  109.     digitalWrite(latchPin, LOW);
  110.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[2]);
  111.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[10]);
  112.   //Serial.println(szoveg[11]);
  113.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[18]);
  114.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[26]);
  115.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[34]);
  116.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[42]);
  117.     digitalWrite(latchPin, HIGH);
  118.     ledmatrix.Shift_Register_Emulator(251,LedPort);  }
  119.     ledmatrix.Shift_Register_Emulator(255,LedPort); //Turn off all the LEDs
  120.    
  121. /************************* FOURTH FRAME *******************************/
  122.   for(int i=0;i<3;i++)
  123.     { digitalWrite(latchPin, LOW);
  124.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[3]);
  125.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[11]);
  126.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[19]);
  127.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[27]);
  128.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[35]);
  129.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[43]);
  130.     digitalWrite(latchPin, HIGH);    
  131.     ledmatrix.Shift_Register_Emulator(247,LedPort);}
  132.     ledmatrix.Shift_Register_Emulator(255,LedPort); //Turn off all the LEDs
  133.    
  134. /***************************** FIFTH FRAME ******************************/
  135.     for(int i=0;i<3;i++)
  136.     { digitalWrite(latchPin, LOW);
  137.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[4]);
  138.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[12]);
  139.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[20]);
  140.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[28]);
  141.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[36]);
  142.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[44]);
  143.     digitalWrite(latchPin, HIGH);
  144.     ledmatrix.Shift_Register_Emulator(239,LedPort);   }
  145.     ledmatrix.Shift_Register_Emulator(255,LedPort);
  146.  
  147. /**************************** SIXTH FRAME *****************************/
  148.     for(int i=0;i<3;i++)
  149.     { digitalWrite(latchPin, LOW);
  150.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[5]);
  151.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[13]);
  152.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[21]);
  153.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[29]);
  154.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[37]);
  155.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[45]);
  156.     digitalWrite(latchPin, HIGH);
  157.     ledmatrix.Shift_Register_Emulator(223,LedPort);
  158.     }
  159.     ledmatrix.Shift_Register_Emulator(255,LedPort);  //Turn off all the LEDs
  160.    
  161. /***************************  SEVENTH FRAME **************************/  
  162.    for(int i=0;i<3;i++)
  163.     {  digitalWrite(latchPin, LOW);
  164.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[6]);
  165.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[14]);
  166.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[22]);
  167.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[30]);
  168.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[38]);
  169.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[46]);
  170.     digitalWrite(latchPin, HIGH);
  171.          
  172.     ledmatrix.Shift_Register_Emulator(191,LedPort);
  173.     }
  174.     ledmatrix.Shift_Register_Emulator(255,LedPort); //Turn off all the LEDs
  175.    
  176. /**************************** EIGHTH FRAME ***************************/
  177.     for(int i=0;i<3;i++)
  178.     { digitalWrite(latchPin, LOW);
  179.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[7]);
  180.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[15]);
  181.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[23]);
  182.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[31]);
  183.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[39]);
  184.     shiftOut(dataPin, clockPin, MSBFIRST, szoveg[47]);
  185.     digitalWrite(latchPin, HIGH);
  186.     ledmatrix.Shift_Register_Emulator(127,LedPort);}
  187.     ledmatrix.Shift_Register_Emulator(255,LedPort); //Turn off all the LEDs
  188. }}
  189.  
  190.  
  191. void printarray(byte inarray[]){
  192. for (int g=0; g<47; g++){
  193.   if (inarray[g]<16){
  194.     Serial.print("0");
  195.   }
  196.    Serial.print(inarray[g],HEX);
  197.    //Serial.println(inarray[g],HEX);
  198.     }  
  199. }
  200.  
  201.  
  202.  
  203. /*
  204. void load(){
  205.   for (int i = 0; i < 47; i++) {
  206.   //szoveg[i]=i2c_eeprom_read_byte(0x51, i);
  207.   //Serial.print(i);
  208.   //Serial.print(":");
  209.   //Serial.print(i2c_eeprom_read_byte(0x51, i));
  210.   }
  211. }
  212.  
  213. void screen_update(){
  214.   //Serial.println(2);
  215.   screen_refresh(25,data);
  216.   }
  217.  
  218. void displaz(unsigned char c){
  219. //screen_refresh(25,error1);  
  220. //scr_rotate_left(25,szoveg);
  221. //displayDHT(25);
  222. //temp[i]
  223. //display_text();
  224.  
  225.  
  226. for(int i=0; i<5; i++)
  227. {
  228.          screen_refresh(25, &Font5x7[((c - 0x20) * 5) + i]);
  229. }
  230. }
  231. void loop(){
  232.   for (int ff=0;ff<254;ff++)
  233.   displaz(ff);
  234.   }
  235.  
  236. void scr_rotate_left(int count, byte data[]){ //A teljes kijelzõt srollozza önmagával
  237. for (int i = 0; i < count; i++) {
  238. screen_refresh(25,data);  
  239. }
  240.  
  241. for (int i = 0; i < 47; i++) {
  242.   data[i]=data[i]>>1;
  243. }}
  244.  
  245. void scr_rotate_left_funny(int count, byte data[]){ //A teljes kijelzõt srollozza önmagával
  246. for (int i = 0; i < 47; i++) {
  247.   data[i]=data[i]>>1;
  248.   screen_refresh(25,data);
  249. }}
  250.  
  251. void copyFromArrayToArray48(byte in[], byte out[]){
  252.   for (int i = 0; i < 47; i++) {
  253.     out[i]=in[i]; }
  254. Serial.println();
  255. }
  256.  
  257. void displayDHT(int count){
  258.  unsigned long currentMillis = millis();
  259.  if (currentMillis - previousMillis >= interval) {
  260.   previousMillis = currentMillis;
  261.   Serial.println(millis());
  262.   int chk = DHT.read22(DHT22_PIN);
  263.   switch (chk){
  264.     case DHTLIB_OK:  
  265.     Serial.print("OK,\t");
  266.     error=0;
  267.     break;
  268.     case DHTLIB_ERROR_CHECKSUM:
  269.     Serial.print("Checksum error,\t");
  270.     break;
  271.     case DHTLIB_ERROR_TIMEOUT:
  272.     Serial.print("Time out error,\t");
  273.     error=1;
  274.     break;
  275.     default:
  276.     Serial.print("Unknown error,\t");
  277.     error=1;
  278.     break;
  279.   }
  280.   if (error==0){
  281.    Serial.print(DHT.humidity, 1);
  282.    Serial.print(",\t");
  283.    Serial.println(DHT.temperature, 1);
  284.   }
  285.   else{
  286.    Serial.println("hiba");
  287.    for (int i = 0; i < count; i++) {
  288.     screen_refresh(25,error1);
  289.    }
  290.    for (int i = 0; i < 47; i++) {
  291.     data[i]=data[i]>>1;
  292.    }
  293.   }
  294.  
  295.    
  296.  }
  297.  
  298. }
  299. */
  300.  
  301. byte temp[48];
  302. //byte tarolo={ledmap[c-'A'][1]+ledmap[c-'A'][2]+ledmap[c-'A'][3]+ledmap[c-'A'][4]+ledmap[c-'A'][5]+ledmap[c-'A'][6]};
  303.  
  304.  
  305. void display(){
  306. //String input="Hello";
  307.  
  308. //char karaktere[]={"e"};
  309. //char karakterrCsillag[]={0x08, 0x2A, 0x00,0x2A,0x08,0};
  310. //input.replace("H",&ledmap[0][6]);
  311. //input.replace("e",&ledmap[1][5]);
  312.  
  313. // for(int j = 0; j < 5; j++){
  314. //  temp[j]=ledmap[1][j];
  315. //  }//close for j
  316.  
  317.   //for(int j = 0; j < 47; j++){
  318.   //  temp[j]=input[j];
  319.   //}
  320.    //screen_refresh(25, temp);
  321. }
  322.  
  323. byte ledmap[52][6]= // A 40 az persze csak hasraütés, ahány betűt akarsz (meg számot)
  324. {
  325.   {0x7E, 0x11, 0x11, 0x11, 0x7E,0x00},// A
  326.   {0x7F, 0x49, 0x49, 0x49, 0x36,0x00},// B
  327.   {0x3E, 0x41, 0x41, 0x41, 0x22,0x00},// C
  328.   {0x7F, 0x41, 0x41, 0x22, 0x1C,0x00},// D
  329.   {0x7F, 0x49, 0x49, 0x49, 0x41,0x00},// E
  330.   {0x7F, 0x09, 0x09, 0x01, 0x01,0x00},// F
  331.   {0x3E, 0x41, 0x41, 0x51, 0x32,0x00},// G
  332.   {0x7F, 0x08, 0x08, 0x08, 0x7F,0x00},// H
  333.   {0x00, 0x41, 0x7F, 0x41, 0x00,0x00},// I
  334.   {0x20, 0x40, 0x41, 0x3F, 0x01,0x00},// J
  335.  
  336.   {0x7F, 0x08, 0x14, 0x22, 0x41,0x00},// K
  337.   {0x7F, 0x40, 0x40, 0x40, 0x40,0x00},// L
  338.   {0x7F, 0x02, 0x04, 0x02, 0x7F,0x00},// M
  339.   {0x7F, 0x04, 0x08, 0x10, 0x7F,0x00},// N
  340.   {0x3E, 0x41, 0x41, 0x41, 0x3E,0x00},// O
  341.   {0x7F, 0x09, 0x09, 0x09, 0x06,0x00},// P
  342.   {0x3E, 0x41, 0x51, 0x21, 0x5E,0x00},// Q
  343.   {0x7F, 0x09, 0x19, 0x29, 0x46,0x00},// R
  344.   {0x46, 0x49, 0x49, 0x49, 0x31,0x00},// S
  345.   {0x01, 0x01, 0x7F, 0x01, 0x01,0x00},// T
  346.  
  347.   {0x3F, 0x40, 0x40, 0x40, 0x3F,0x00},// U
  348.   {0x1F, 0x20, 0x40, 0x20, 0x1F,0x00},// V
  349.   {0x7F, 0x20, 0x18, 0x20, 0x7F,0x00},// W
  350.   {0x63, 0x14, 0x08, 0x14, 0x63,0x00},// X
  351.   {0x03, 0x04, 0x78, 0x04, 0x03,0x00},// Y
  352.   {0x61, 0x51, 0x49, 0x45, 0x43,0x00},// Z
  353.  
  354.   {0x20, 0x54, 0x54, 0x54, 0x78,0x00},// a
  355.   {0x7F, 0x48, 0x44, 0x44, 0x38,0x00},// b
  356.   {0x38, 0x44, 0x44, 0x44, 0x20,0x00},// c
  357.   {0x38, 0x44, 0x44, 0x48, 0x7F,0x00},// d
  358.   {0x38, 0x54, 0x54, 0x54, 0x18,0x00},// e
  359.   {0x08, 0x7E, 0x09, 0x01, 0x02,0x00},// f
  360.   {0x08, 0x14, 0x54, 0x54, 0x3C,0x00},// g
  361.   {0x7F, 0x08, 0x04, 0x04, 0x78,0x00},// h
  362.   {0x00, 0x44, 0x7D, 0x40, 0x00,0x00},// i
  363.   {0x20, 0x40, 0x44, 0x3D, 0x00,0x00},// j
  364.  
  365.   {0x00, 0x7F, 0x10, 0x28, 0x44,0x00},// k
  366.   {0x00, 0x41, 0x7F, 0x40, 0x00,0x00},// l
  367.   {0x7C, 0x04, 0x18, 0x04, 0x78,0x00},// m
  368.   {0x7C, 0x08, 0x04, 0x04, 0x78,0x00},// n
  369.   {0x38, 0x44, 0x44, 0x44, 0x38,0x00},// o
  370.   {0x7C, 0x14, 0x14, 0x14, 0x08,0x00},// p
  371.   {0x08, 0x14, 0x14, 0x18, 0x7C,0x00},// q
  372.   {0x7C, 0x08, 0x04, 0x04, 0x08,0x00},// r
  373.   {0x48, 0x54, 0x54, 0x54, 0x20,0x00},// s
  374.   {0x04, 0x3F, 0x44, 0x40, 0x20,0x00},// t
  375.  
  376.   {0x3C, 0x40, 0x40, 0x20, 0x7C,0x00},// u
  377.   {0x1C, 0x20, 0x40, 0x20, 0x1C,0x00},// v
  378.   {0x3C, 0x40, 0x30, 0x40, 0x3C,0x00},// w
  379.   {0x44, 0x28, 0x10, 0x28, 0x44,0x00},// x
  380.   {0x0C, 0x50, 0x50, 0x50, 0x3C,0x00},// y
  381.   {0x44, 0x64, 0x54, 0x4C, 0x44,0x00}// z
  382. };
  383.  
  384.  
  385.  
  386.  
  387.  
  388.  
  389.  
  390. void printString(char *s){
  391.   char *t = s;
  392.  
  393.   int size = strlen(s)*6;
  394.   if(size<6*8) size = 6*8;
  395.  
  396.   byte * b = (byte *) malloc(size);
  397.   memset(b, 0, size);
  398.   int i = 0;
  399.   while(*t) {
  400.     for(int j=0;j<6;j++){
  401.       b[i] = ledmap[*t-'A'][j];
  402.       i++;
  403.     }
  404.     t++;
  405.   }
  406.   // for(int i = 0;i<size;i++) Serial.print(b[i], HEX);
  407.   // Serial.println("");
  408.   screen_refresh(25,b);
  409.   free(b);
  410. }
  411. void loop(){
  412. //screen_refresh(25,data);  
  413. //scr_rotate_left(25,szoveg);
  414. //displayDHT(25);
  415.  
  416. printString("HELLO");
  417.  
  418.  
  419.  
  420.  
  421. }

ledmatrix.rar
    
(#) Pethical válasza david10 hozzászólására (») Jan 29, 2017 /
 
Örülök, hogy sikerült!
(#) david10 válasza Pethical hozzászólására (») Jan 29, 2017 /
 
Én örülök a legjobban neki...
(#) jany1966 hozzászólása Jan 30, 2017 /
 
Sziasztok!
Biztos kérdezte már más is csak nem szeretnék több száz oldalt visszaolvasni.
220 voltos ac motor fordulatszámát szeretném pwm szabályzással megoldani.
Kapcsolási rajz valakinek?
Köszönöm!
(#) icserny válasza jany1966 hozzászólására (») Jan 30, 2017 /
 
Idézet:
„Biztos kérdezte már más is csak nem szeretnék több száz oldalt visszaolvasni.”

A jobb felső sarokban van egy legördülő lista, abban kattints a "Csak képek keresése" feliratra. Akkor a mostani 319 oldal helyett csak 8-at kell végignézni!

A másik lehetőség: ugyanabban a legördülő menüben a "Csak ebben a témában keresés" opció választása. Írd be a kívánt kulcsszavakat! Pl. "220 PWM topic:6978".

Egyébként a váltóáramú fogyasztóknál a PWM nem a legalkalmasabb módszer...
Következő: »»   317 / 853
Bejelentkezés

Belépés

Hirdetés
XDT.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