|
A klónok CH340 Soros-USB illesztőjének drivere ( Letöltés)
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 !
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: byte ledmap[4][5]= // A 40 az persze csak hasraütés, ahány betűt akarsz (meg számot)
{
{0x7F,0x08,0x08,0x08,0x7F}, //H
{0x7F,0x49,0x49,0x49,0x49}, //E
{0x7F,0x01,0x01,0x01,0x01}, //L
{0x3E,0x41,0x41,0x41,0x3E} //O
};
void print(char c){
byte b[5] = {map[c-'A']};
screen_refresh(25, b);
}
void printString(char *s){
char *t = s;
while(*t) {
print(*t);
t++;
}
}
void loop(){
printString("He");
}
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.
É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
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
Megcsináltam, de ugyanaz a hiba. Ez lett belőle:
byte ledmap[52][5]= // A 40 az persze csak hasraütés, ahány betűt akarsz (meg számot)
{
{0x7E, 0x11, 0x11, 0x11, 0x7E},// A
{0x7F, 0x49, 0x49, 0x49, 0x36},// B
{0x3E, 0x41, 0x41, 0x41, 0x22},// C
{0x7F, 0x41, 0x41, 0x22, 0x1C},// D
{0x7F, 0x49, 0x49, 0x49, 0x41},// E
{0x7F, 0x09, 0x09, 0x01, 0x01},// F
{0x3E, 0x41, 0x41, 0x51, 0x32},// G
{0x7F, 0x08, 0x08, 0x08, 0x7F},// H
{0x00, 0x41, 0x7F, 0x41, 0x00},// I
{0x20, 0x40, 0x41, 0x3F, 0x01},// J
{0x7F, 0x08, 0x14, 0x22, 0x41},// K
{0x7F, 0x40, 0x40, 0x40, 0x40},// L
{0x7F, 0x02, 0x04, 0x02, 0x7F},// M
{0x7F, 0x04, 0x08, 0x10, 0x7F},// N
{0x3E, 0x41, 0x41, 0x41, 0x3E},// O
{0x7F, 0x09, 0x09, 0x09, 0x06},// P
{0x3E, 0x41, 0x51, 0x21, 0x5E},// Q
{0x7F, 0x09, 0x19, 0x29, 0x46},// R
{0x46, 0x49, 0x49, 0x49, 0x31},// S
{0x01, 0x01, 0x7F, 0x01, 0x01},// T
{0x3F, 0x40, 0x40, 0x40, 0x3F},// U
{0x1F, 0x20, 0x40, 0x20, 0x1F},// V
{0x7F, 0x20, 0x18, 0x20, 0x7F},// W
{0x63, 0x14, 0x08, 0x14, 0x63},// X
{0x03, 0x04, 0x78, 0x04, 0x03},// Y
{0x61, 0x51, 0x49, 0x45, 0x43},// Z
{0x20, 0x54, 0x54, 0x54, 0x78},// a
{0x7F, 0x48, 0x44, 0x44, 0x38},// b
{0x38, 0x44, 0x44, 0x44, 0x20},// c
{0x38, 0x44, 0x44, 0x48, 0x7F},// d
{0x38, 0x54, 0x54, 0x54, 0x18},// e
{0x08, 0x7E, 0x09, 0x01, 0x02},// f
{0x08, 0x14, 0x54, 0x54, 0x3C},// g
{0x7F, 0x08, 0x04, 0x04, 0x78},// h
{0x00, 0x44, 0x7D, 0x40, 0x00},// i
{0x20, 0x40, 0x44, 0x3D, 0x00},// j
{0x00, 0x7F, 0x10, 0x28, 0x44},// k
{0x00, 0x41, 0x7F, 0x40, 0x00},// l
{0x7C, 0x04, 0x18, 0x04, 0x78},// m
{0x7C, 0x08, 0x04, 0x04, 0x78},// n
{0x38, 0x44, 0x44, 0x44, 0x38},// o
{0x7C, 0x14, 0x14, 0x14, 0x08},// p
{0x08, 0x14, 0x14, 0x18, 0x7C},// q
{0x7C, 0x08, 0x04, 0x04, 0x08},// r
{0x48, 0x54, 0x54, 0x54, 0x20},// s
{0x04, 0x3F, 0x44, 0x40, 0x20},// t
{0x3C, 0x40, 0x40, 0x20, 0x7C},// u
{0x1C, 0x20, 0x40, 0x20, 0x1C},// v
{0x3C, 0x40, 0x30, 0x40, 0x3C},// w
{0x44, 0x28, 0x10, 0x28, 0x44},// x
{0x0C, 0x50, 0x50, 0x50, 0x3C},// y
{0x44, 0x64, 0x54, 0x4C, 0x44}// z
};
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ó
byte ledmap[52][6]= // A 40 az persze csak hasraütés, ahány betűt akarsz (meg számot)
{
{0x7E, 0x11, 0x11, 0x11, 0x7E,0x00},// A
{0x7F, 0x49, 0x49, 0x49, 0x36,0x00},// B
{0x3E, 0x41, 0x41, 0x41, 0x22,0x00},// C
{0x7F, 0x41, 0x41, 0x22, 0x1C,0x00},// D
{0x7F, 0x49, 0x49, 0x49, 0x41,0x00},// E
{0x7F, 0x09, 0x09, 0x01, 0x01,0x00},// F
{0x3E, 0x41, 0x41, 0x51, 0x32,0x00},// G
{0x7F, 0x08, 0x08, 0x08, 0x7F,0x00},// H
{0x00, 0x41, 0x7F, 0x41, 0x00,0x00},// I
{0x20, 0x40, 0x41, 0x3F, 0x01,0x00},// J
{0x7F, 0x08, 0x14, 0x22, 0x41,0x00},// K
{0x7F, 0x40, 0x40, 0x40, 0x40,0x00},// L
{0x7F, 0x02, 0x04, 0x02, 0x7F,0x00},// M
{0x7F, 0x04, 0x08, 0x10, 0x7F,0x00},// N
{0x3E, 0x41, 0x41, 0x41, 0x3E,0x00},// O
{0x7F, 0x09, 0x09, 0x09, 0x06,0x00},// P
{0x3E, 0x41, 0x51, 0x21, 0x5E,0x00},// Q
{0x7F, 0x09, 0x19, 0x29, 0x46,0x00},// R
{0x46, 0x49, 0x49, 0x49, 0x31,0x00},// S
{0x01, 0x01, 0x7F, 0x01, 0x01,0x00},// T
{0x3F, 0x40, 0x40, 0x40, 0x3F,0x00},// U
{0x1F, 0x20, 0x40, 0x20, 0x1F,0x00},// V
{0x7F, 0x20, 0x18, 0x20, 0x7F,0x00},// W
{0x63, 0x14, 0x08, 0x14, 0x63,0x00},// X
{0x03, 0x04, 0x78, 0x04, 0x03,0x00},// Y
{0x61, 0x51, 0x49, 0x45, 0x43,0x00},// Z
{0x20, 0x54, 0x54, 0x54, 0x78,0x00},// a
{0x7F, 0x48, 0x44, 0x44, 0x38,0x00},// b
{0x38, 0x44, 0x44, 0x44, 0x20,0x00},// c
{0x38, 0x44, 0x44, 0x48, 0x7F,0x00},// d
{0x38, 0x54, 0x54, 0x54, 0x18,0x00},// e
{0x08, 0x7E, 0x09, 0x01, 0x02,0x00},// f
{0x08, 0x14, 0x54, 0x54, 0x3C,0x00},// g
{0x7F, 0x08, 0x04, 0x04, 0x78,0x00},// h
{0x00, 0x44, 0x7D, 0x40, 0x00,0x00},// i
{0x20, 0x40, 0x44, 0x3D, 0x00,0x00},// j
{0x00, 0x7F, 0x10, 0x28, 0x44,0x00},// k
{0x00, 0x41, 0x7F, 0x40, 0x00,0x00},// l
{0x7C, 0x04, 0x18, 0x04, 0x78,0x00},// m
{0x7C, 0x08, 0x04, 0x04, 0x78,0x00},// n
{0x38, 0x44, 0x44, 0x44, 0x38,0x00},// o
{0x7C, 0x14, 0x14, 0x14, 0x08,0x00},// p
{0x08, 0x14, 0x14, 0x18, 0x7C,0x00},// q
{0x7C, 0x08, 0x04, 0x04, 0x08,0x00},// r
{0x48, 0x54, 0x54, 0x54, 0x20,0x00},// s
{0x04, 0x3F, 0x44, 0x40, 0x20,0x00},// t
{0x3C, 0x40, 0x40, 0x20, 0x7C,0x00},// u
{0x1C, 0x20, 0x40, 0x20, 0x1C,0x00},// v
{0x3C, 0x40, 0x30, 0x40, 0x3C,0x00},// w
{0x44, 0x28, 0x10, 0x28, 0x44,0x00},// x
{0x0C, 0x50, 0x50, 0x50, 0x3C,0x00},// y
{0x44, 0x64, 0x54, 0x4C, 0x44,0x00}// z
};
void print(char c){
byte b[6] = {ledmap[c-'A']};
screen_refresh(25, b);
}
void printString(char *s){
char *t = s;
while(*t) {
print(*t);
t++;
}
}
void loop(){
printString("HELLO");
}
Cseréld le a print függvényt erre:
void print(char c){
screen_refresh(25, ledmap[c-'A']);
}
Nekem ezzel jó. (Igaz én Serial monitorra írom ki a számokat).
Én ezzel tesztelem:
byte ledmap[52][6]= // A 40 az persze csak hasraütés, ahány betűt akarsz (meg számot)
{
{0x7E, 0x11, 0x11, 0x11, 0x7E,0x00},// A
{0x7F, 0x49, 0x49, 0x49, 0x36,0x00},// B
{0x3E, 0x41, 0x41, 0x41, 0x22,0x00},// C
{0x7F, 0x41, 0x41, 0x22, 0x1C,0x00},// D
{0x7F, 0x49, 0x49, 0x49, 0x41,0x00},// E
{0x7F, 0x09, 0x09, 0x01, 0x01,0x00},// F
{0x3E, 0x41, 0x41, 0x51, 0x32,0x00},// G
{0x7F, 0x08, 0x08, 0x08, 0x7F,0x00},// H
{0x00, 0x41, 0x7F, 0x41, 0x00,0x00},// I
{0x20, 0x40, 0x41, 0x3F, 0x01,0x00},// J
{0x7F, 0x08, 0x14, 0x22, 0x41,0x00},// K
{0x7F, 0x40, 0x40, 0x40, 0x40,0x00},// L
{0x7F, 0x02, 0x04, 0x02, 0x7F,0x00},// M
{0x7F, 0x04, 0x08, 0x10, 0x7F,0x00},// N
{0x3E, 0x41, 0x41, 0x41, 0x3E,0x00},// O
{0x7F, 0x09, 0x09, 0x09, 0x06,0x00},// P
{0x3E, 0x41, 0x51, 0x21, 0x5E,0x00},// Q
{0x7F, 0x09, 0x19, 0x29, 0x46,0x00},// R
{0x46, 0x49, 0x49, 0x49, 0x31,0x00},// S
{0x01, 0x01, 0x7F, 0x01, 0x01,0x00},// T
{0x3F, 0x40, 0x40, 0x40, 0x3F,0x00},// U
{0x1F, 0x20, 0x40, 0x20, 0x1F,0x00},// V
{0x7F, 0x20, 0x18, 0x20, 0x7F,0x00},// W
{0x63, 0x14, 0x08, 0x14, 0x63,0x00},// X
{0x03, 0x04, 0x78, 0x04, 0x03,0x00},// Y
{0x61, 0x51, 0x49, 0x45, 0x43,0x00},// Z
{0x20, 0x54, 0x54, 0x54, 0x78,0x00},// a
{0x7F, 0x48, 0x44, 0x44, 0x38,0x00},// b
{0x38, 0x44, 0x44, 0x44, 0x20,0x00},// c
{0x38, 0x44, 0x44, 0x48, 0x7F,0x00},// d
{0x38, 0x54, 0x54, 0x54, 0x18,0x00},// e
{0x08, 0x7E, 0x09, 0x01, 0x02,0x00},// f
{0x08, 0x14, 0x54, 0x54, 0x3C,0x00},// g
{0x7F, 0x08, 0x04, 0x04, 0x78,0x00},// h
{0x00, 0x44, 0x7D, 0x40, 0x00,0x00},// i
{0x20, 0x40, 0x44, 0x3D, 0x00,0x00},// j
{0x00, 0x7F, 0x10, 0x28, 0x44,0x00},// k
{0x00, 0x41, 0x7F, 0x40, 0x00,0x00},// l
{0x7C, 0x04, 0x18, 0x04, 0x78,0x00},// m
{0x7C, 0x08, 0x04, 0x04, 0x78,0x00},// n
{0x38, 0x44, 0x44, 0x44, 0x38,0x00},// o
{0x7C, 0x14, 0x14, 0x14, 0x08,0x00},// p
{0x08, 0x14, 0x14, 0x18, 0x7C,0x00},// q
{0x7C, 0x08, 0x04, 0x04, 0x08,0x00},// r
{0x48, 0x54, 0x54, 0x54, 0x20,0x00},// s
{0x04, 0x3F, 0x44, 0x40, 0x20,0x00},// t
{0x3C, 0x40, 0x40, 0x20, 0x7C,0x00},// u
{0x1C, 0x20, 0x40, 0x20, 0x1C,0x00},// v
{0x3C, 0x40, 0x30, 0x40, 0x3C,0x00},// w
{0x44, 0x28, 0x10, 0x28, 0x44,0x00},// x
{0x0C, 0x50, 0x50, 0x50, 0x3C,0x00},// y
{0x44, 0x64, 0x54, 0x4C, 0x44,0x00}// z
};
void print(char c){
for(int i=0;i<6;i++) {
Serial.print(ledmap[c-'A'][i], HEX);
}
Serial.println("");
}
void printString(char *s){
char *t = s;
while(*t) {
print(*t);
t++;
}
}
void loop(){
}
void setup(){
Serial.begin(9600);
printString("HELLO");
}
Így a kimenetem a soros monitoron:
7F8887F0
7F494949410
7F404040400
7F404040400
3E4141413E0
Ami elvileg a HELLO. Nem nagyon értem nálad miért nem akarja.
Szerintem a RAM-ból írja ki ezeket a véletlenszerü értékeket.
Megprobálok kifaragni a kódból ezt-azt.
A helyzet valójában, az az,hogy kétféle dolgot csinál, ezeket kommentáltam:
void print(char c){
for(int i=0;i<6;i++) {
Serial.print(ledmap[c-'A'][i], HEX);
}
Serial.println("");
screen_refresh(25,ledmap[c-'A']); // Igy az ABC betuit irja ki, egymast felvaltva kezdve a nagy A-tol a nagy Z-ig.
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]};
screen_refresh(25,tarolo); //Igy krix-krax-okat ir ki a RAM-bol.
}
Egy kérdés: Biztos, hogy össze akarod adni az alábbi hat bájtot?
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.
Össze szerettem volna és azt akartam kiiratni.
Megprobálom 0-tól 5-ig
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
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
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?
Ez egy jó kérdés, nem tudom hivatalosan mi a neve. A screen_refresh függvényben mi található?
Ez, de egy pillanat és küldök még egy hozzászolást... void screen_refresh(int count,byte szoveg[]) {
for(int i=0;i<count;i++){
for(int i=0;i<3;i++)
{
/*************************** FIRST FRAME ***************************/
digitalWrite(latchPin, LOW);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[0]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[8]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[16]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[24]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[32]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[40]);
digitalWrite(latchPin, HIGH);
Shift_Register_Emulator(254,LedPort); }
Shift_Register_Emulator(255,LedPort); //Turn off all the LEDs
/******************************* SECOND FRAME ********************************/
for(int i=0;i<3;i++)
{ digitalWrite(latchPin, LOW);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[1]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[9]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[17]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[25]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[33]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[41]);
digitalWrite(latchPin, HIGH);
Shift_Register_Emulator(253,LedPort);}
Shift_Register_Emulator(255,LedPort); //Turn off all the LEDs
/**************************** THIRD FRAME *******************************/
for(int i=0;i<3;i++)
{
digitalWrite(latchPin, LOW);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[2]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[10]);
//Serial.println(szoveg[11]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[18]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[26]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[34]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[42]);
digitalWrite(latchPin, HIGH);
Shift_Register_Emulator(251,LedPort); }
Shift_Register_Emulator(255,LedPort); //Turn off all the LEDs
/************************* FOURTH FRAME *******************************/
for(int i=0;i<3;i++)
{ digitalWrite(latchPin, LOW);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[3]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[11]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[19]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[27]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[35]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[43]);
digitalWrite(latchPin, HIGH);
Shift_Register_Emulator(247,LedPort);}
Shift_Register_Emulator(255,LedPort); //Turn off all the LEDs
/***************************** FIFTH FRAME ******************************/
for(int i=0;i<3;i++)
{ digitalWrite(latchPin, LOW);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[4]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[12]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[20]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[28]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[36]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[44]);
digitalWrite(latchPin, HIGH);
Shift_Register_Emulator(239,LedPort); }
Shift_Register_Emulator(255,LedPort);
/**************************** SIXTH FRAME *****************************/
for(int i=0;i<3;i++)
{ digitalWrite(latchPin, LOW);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[5]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[13]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[21]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[29]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[37]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[45]);
digitalWrite(latchPin, HIGH);
Shift_Register_Emulator(223,LedPort);
}
Shift_Register_Emulator(255,LedPort); //Turn off all the LEDs
/*************************** SEVENTH FRAME **************************/
for(int i=0;i<3;i++)
{ digitalWrite(latchPin, LOW);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[6]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[14]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[22]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[30]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[38]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[46]);
digitalWrite(latchPin, HIGH);
Shift_Register_Emulator(191,LedPort);
}
Shift_Register_Emulator(255,LedPort); //Turn off all the LEDs
/**************************** EIGHTH FRAME ***************************/
for(int i=0;i<3;i++)
{ digitalWrite(latchPin, LOW);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[7]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[15]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[23]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[31]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[39]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[47]);
digitalWrite(latchPin, HIGH);
Shift_Register_Emulator(127,LedPort);}
Shift_Register_Emulator(255,LedPort); //Turn off all the LEDs
}}
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 byte dolog[6]={ledmap[2]};
screen_refresh(25,dolog);
, de ettől csak 2 oszlopot ír ki, aminek semmi köze nincs a betükhöz.
Azért, mert a dolog[6] = {} egy kétdimenziós tömböt hoz létre, neki meg egy kell.
Van egy ilyen ötletem:
void printString(char *s){
char *t = s;
int size = strlen(s)*6;
byte * b = (byte *) malloc(size);
int i = 0;
while(*t) {
for(int j=0;j<6;j++){
b[i] = ledmap[*t-'A'][j];
i++;
}
t++;
}
screen_refresh(25,b);
free(b);
}
Ez a b-be egymás után beteszi a bájtokat, mintha ezt írnád:
byte b[size] = {0x7F, 0x40,...};
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ó
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
Ez már haladás.
Most nézem, hogy fixen 8 hosszú tömböt vár a screen_refresh.
void printString(char *s){
char *t = s;
int size = strlen(s)*6;
if(size<6*8) size = 6*8;
byte * b = (byte *) malloc(size);
memset(b, 0, size);
int i = 0;
while(*t) {
for(int j=0;j<6;j++){
b[i] = ledmap[*t-'A'][j];
i++;
}
t++;
}
// for(int i = 0;i<size;i++) Serial.print(b[i], HEX);
// Serial.println("");
screen_refresh(25,b);
free(b);
}
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:
7F8887F07F4949494107F4040404007F4040404003E4141413E0000000000000000000
7F8887F07F4949494107F4040404007F4040404003E4141413E0000000000000000000
7F8887F07F4949494107F4040404007F4040404003E4141413E0000000000000000000
7F8887F07F4949494107F4040404007F4040404003E4141413E0000000000000000000
7F8887F07F4949494107F4040404007F4040404003E4141413E0000000000000000000
7F8887F07F4949494107F4040404007F4040404003E4141413E0000000000000000000
7F8887F07F4949494107F4040404007F4040404003E4141413E0000000000000000000
7F8887F07F4949494107F4040404007F4040404003E4141413E0000000000000000000
7F8887F07F4949494107F4040404007F4040404003E4141413E0000000000000000000
7F8887F07F4949494107F4040404007F4040404003E4141413E0000000000000000000
7F8887F07F4949494107F4040404007F4040404003E4141413E0000000000000000000
7F8887F07F4949494107F4040404007F4040404003E4141413E0000000000000000000
7F8887F07F4949494107F4040404007F4040404003E4141413E0000000000000000000
7F8887F07F4949494107F4040404007F4040404003E4141413E0000000000000000000
7F8887F07F4949494107F4040404007F4040404003E4141413E0000000000000000000
7F8887F07F4949494107F4040404007F4040404003E4141413E0000000000000000000
7F8887F07F4949494107F4040404007F4040404003E4141413E0000000000000000000
7F8887F07F4949494107F4040404007F4040404003E4141413E0000000000000000000
7F8887F07F4949494107F4040404007F4040404003E4141413E0000000000000000000
7F8887F07F4949494107F4040404007F4040404003E4141413E0000000000000000000
7F8887F07F4949494107F4040404007F4040404003E4141413E0000000000000000000
7F8887F07F4949494107F4040404007F4040404003E4141413E0000000000000000000
7F8887F07F4949494107F4040404007F4040404003E4141413E0000000000000000000
@kapu48: Ez hogy jön ide?
Ez megint nagy haladás, mert a szemét eltünt, de az ABC-t csak kiírja.
Videjó
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...
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:
#include <Wire.h>
#include <Eeprom24C32_64.h>
#include <TimerOne.h>
#include <ledmatrix.h>
#include <dht.h>
dht DHT;
#define EEPROM_ADDRESS 0x51
static Eeprom24C32_64 eeprom(EEPROM_ADDRESS);
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;
int LedPort[] = {sor1, sor2, sor3, sor4,sor5,sor6, sor7, sor8};
Ledmatrix ledmatrix(2,11,12,LedPort);
byte error, address; int nDevices;
unsigned long previousMillis = 0;
const long interval = 1000;
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};
//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};
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};
//byte tarolo[48];
#define szam1 {0x00,0x00,0x21,0x7f,0x01,0x00,0x00,0x00}
void setup() {
pinMode(6, OUTPUT);
digitalWrite(6, HIGH);
Serial.begin(9600);
/*Serial.println("Booting up...");
Serial.print("Clearing shift register ");
ledmatrix.clear();
Serial.println("OK!");
Serial.print("Initialising I2C... ");
Wire.begin(); // initialise the connection
Serial.println("OK!");
Serial.println("Scanning I2C devices...");
scani2c();
Serial.print("Initialising I2C EEPROM at 0x");
Serial.print(EEPROM_ADDRESS);
eeprom.initialize();
Serial.println("...OK!");
//for (int i=0; i<47;i++){
// szoveg[i]=eeprom.readByte(i);
// }
*/
Serial.println("Led Matrix booted up!");
digitalWrite(6, LOW);
//Timer1.initialize(10000);
//Timer1.attachInterrupt(screen_update);
//printarray(data);
//copyFromArrayToArray48(data,temp);
//printarray(temp);
}
/*
void scani2c(){
nDevices = 0;
for(address = 1; address < 127; address++ ) {
Wire.beginTransmission(address);
error = Wire.endTransmission();
if (error == 0){
Serial.print("I2C device found at address 0x");
if (address<16)
Serial.print("0");
Serial.print(address,HEX);
Serial.println(" !");
nDevices++; }
else if (error==4){
Serial.print("Unknow error at address 0x");
if (address<16)
Serial.print("0");
Serial.println(address,HEX);
} }
if (nDevices == 0){
Serial.println("No I2C devices found\n");}
else {
Serial.println("done");}
}
*/
void screen_refresh(int count,byte szoveg[]) {
for(int i=0;i<count;i++){
for(int i=0;i<3;i++)
{
/*************************** FIRST FRAME ***************************/
digitalWrite(latchPin, LOW);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[0]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[8]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[16]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[24]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[32]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[40]);
digitalWrite(latchPin, HIGH);
ledmatrix.Shift_Register_Emulator(254,LedPort); }
ledmatrix.Shift_Register_Emulator(255,LedPort); //Turn off all the LEDs
/******************************* SECOND FRAME ********************************/
for(int i=0;i<3;i++)
{ digitalWrite(latchPin, LOW);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[1]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[9]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[17]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[25]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[33]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[41]);
digitalWrite(latchPin, HIGH);
ledmatrix.Shift_Register_Emulator(253,LedPort);}
ledmatrix.Shift_Register_Emulator(255,LedPort); //Turn off all the LEDs
/**************************** THIRD FRAME *******************************/
for(int i=0;i<3;i++)
{
digitalWrite(latchPin, LOW);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[2]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[10]);
//Serial.println(szoveg[11]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[18]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[26]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[34]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[42]);
digitalWrite(latchPin, HIGH);
ledmatrix.Shift_Register_Emulator(251,LedPort); }
ledmatrix.Shift_Register_Emulator(255,LedPort); //Turn off all the LEDs
/************************* FOURTH FRAME *******************************/
for(int i=0;i<3;i++)
{ digitalWrite(latchPin, LOW);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[3]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[11]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[19]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[27]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[35]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[43]);
digitalWrite(latchPin, HIGH);
ledmatrix.Shift_Register_Emulator(247,LedPort);}
ledmatrix.Shift_Register_Emulator(255,LedPort); //Turn off all the LEDs
/***************************** FIFTH FRAME ******************************/
for(int i=0;i<3;i++)
{ digitalWrite(latchPin, LOW);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[4]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[12]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[20]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[28]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[36]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[44]);
digitalWrite(latchPin, HIGH);
ledmatrix.Shift_Register_Emulator(239,LedPort); }
ledmatrix.Shift_Register_Emulator(255,LedPort);
/**************************** SIXTH FRAME *****************************/
for(int i=0;i<3;i++)
{ digitalWrite(latchPin, LOW);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[5]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[13]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[21]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[29]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[37]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[45]);
digitalWrite(latchPin, HIGH);
ledmatrix.Shift_Register_Emulator(223,LedPort);
}
ledmatrix.Shift_Register_Emulator(255,LedPort); //Turn off all the LEDs
/*************************** SEVENTH FRAME **************************/
for(int i=0;i<3;i++)
{ digitalWrite(latchPin, LOW);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[6]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[14]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[22]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[30]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[38]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[46]);
digitalWrite(latchPin, HIGH);
ledmatrix.Shift_Register_Emulator(191,LedPort);
}
ledmatrix.Shift_Register_Emulator(255,LedPort); //Turn off all the LEDs
/**************************** EIGHTH FRAME ***************************/
for(int i=0;i<3;i++)
{ digitalWrite(latchPin, LOW);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[7]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[15]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[23]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[31]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[39]);
shiftOut(dataPin, clockPin, MSBFIRST, szoveg[47]);
digitalWrite(latchPin, HIGH);
ledmatrix.Shift_Register_Emulator(127,LedPort);}
ledmatrix.Shift_Register_Emulator(255,LedPort); //Turn off all the LEDs
}}
void printarray(byte inarray[]){
for (int g=0; g<47; g++){
if (inarray[g]<16){
Serial.print("0");
}
Serial.print(inarray[g],HEX);
//Serial.println(inarray[g],HEX);
}
}
/*
void load(){
for (int i = 0; i < 47; i++) {
//szoveg[i]=i2c_eeprom_read_byte(0x51, i);
//Serial.print(i);
//Serial.print(":");
//Serial.print(i2c_eeprom_read_byte(0x51, i));
}
}
void screen_update(){
//Serial.println(2);
screen_refresh(25,data);
}
void displaz(unsigned char c){
//screen_refresh(25,error1);
//scr_rotate_left(25,szoveg);
//displayDHT(25);
//temp[i]
//display_text();
for(int i=0; i<5; i++)
{
screen_refresh(25, &Font5x7[((c - 0x20) * 5) + i]);
}
}
void loop(){
for (int ff=0;ff<254;ff++)
displaz(ff);
}
void scr_rotate_left(int count, byte data[]){ //A teljes kijelzõt srollozza önmagával
for (int i = 0; i < count; i++) {
screen_refresh(25,data);
}
for (int i = 0; i < 47; i++) {
data[i]=data[i]>>1;
}}
void scr_rotate_left_funny(int count, byte data[]){ //A teljes kijelzõt srollozza önmagával
for (int i = 0; i < 47; i++) {
data[i]=data[i]>>1;
screen_refresh(25,data);
}}
void copyFromArrayToArray48(byte in[], byte out[]){
for (int i = 0; i < 47; i++) {
out[i]=in[i]; }
Serial.println();
}
void displayDHT(int count){
unsigned long currentMillis = millis();
if (currentMillis - previousMillis >= interval) {
previousMillis = currentMillis;
Serial.println(millis());
int chk = DHT.read22(DHT22_PIN);
switch (chk){
case DHTLIB_OK:
Serial.print("OK,\t");
error=0;
break;
case DHTLIB_ERROR_CHECKSUM:
Serial.print("Checksum error,\t");
break;
case DHTLIB_ERROR_TIMEOUT:
Serial.print("Time out error,\t");
error=1;
break;
default:
Serial.print("Unknown error,\t");
error=1;
break;
}
if (error==0){
Serial.print(DHT.humidity, 1);
Serial.print(",\t");
Serial.println(DHT.temperature, 1);
}
else{
Serial.println("hiba");
for (int i = 0; i < count; i++) {
screen_refresh(25,error1);
}
for (int i = 0; i < 47; i++) {
data[i]=data[i]>>1;
}
}
}
}
*/
byte temp[48];
//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]};
void display(){
//String input="Hello";
//char karaktere[]={"e"};
//char karakterrCsillag[]={0x08, 0x2A, 0x00,0x2A,0x08,0};
//input.replace("H",&ledmap[0][6]);
//input.replace("e",&ledmap[1][5]);
// for(int j = 0; j < 5; j++){
// temp[j]=ledmap[1][j];
// }//close for j
//for(int j = 0; j < 47; j++){
// temp[j]=input[j];
//}
//screen_refresh(25, temp);
}
byte ledmap[52][6]= // A 40 az persze csak hasraütés, ahány betűt akarsz (meg számot)
{
{0x7E, 0x11, 0x11, 0x11, 0x7E,0x00},// A
{0x7F, 0x49, 0x49, 0x49, 0x36,0x00},// B
{0x3E, 0x41, 0x41, 0x41, 0x22,0x00},// C
{0x7F, 0x41, 0x41, 0x22, 0x1C,0x00},// D
{0x7F, 0x49, 0x49, 0x49, 0x41,0x00},// E
{0x7F, 0x09, 0x09, 0x01, 0x01,0x00},// F
{0x3E, 0x41, 0x41, 0x51, 0x32,0x00},// G
{0x7F, 0x08, 0x08, 0x08, 0x7F,0x00},// H
{0x00, 0x41, 0x7F, 0x41, 0x00,0x00},// I
{0x20, 0x40, 0x41, 0x3F, 0x01,0x00},// J
{0x7F, 0x08, 0x14, 0x22, 0x41,0x00},// K
{0x7F, 0x40, 0x40, 0x40, 0x40,0x00},// L
{0x7F, 0x02, 0x04, 0x02, 0x7F,0x00},// M
{0x7F, 0x04, 0x08, 0x10, 0x7F,0x00},// N
{0x3E, 0x41, 0x41, 0x41, 0x3E,0x00},// O
{0x7F, 0x09, 0x09, 0x09, 0x06,0x00},// P
{0x3E, 0x41, 0x51, 0x21, 0x5E,0x00},// Q
{0x7F, 0x09, 0x19, 0x29, 0x46,0x00},// R
{0x46, 0x49, 0x49, 0x49, 0x31,0x00},// S
{0x01, 0x01, 0x7F, 0x01, 0x01,0x00},// T
{0x3F, 0x40, 0x40, 0x40, 0x3F,0x00},// U
{0x1F, 0x20, 0x40, 0x20, 0x1F,0x00},// V
{0x7F, 0x20, 0x18, 0x20, 0x7F,0x00},// W
{0x63, 0x14, 0x08, 0x14, 0x63,0x00},// X
{0x03, 0x04, 0x78, 0x04, 0x03,0x00},// Y
{0x61, 0x51, 0x49, 0x45, 0x43,0x00},// Z
{0x20, 0x54, 0x54, 0x54, 0x78,0x00},// a
{0x7F, 0x48, 0x44, 0x44, 0x38,0x00},// b
{0x38, 0x44, 0x44, 0x44, 0x20,0x00},// c
{0x38, 0x44, 0x44, 0x48, 0x7F,0x00},// d
{0x38, 0x54, 0x54, 0x54, 0x18,0x00},// e
{0x08, 0x7E, 0x09, 0x01, 0x02,0x00},// f
{0x08, 0x14, 0x54, 0x54, 0x3C,0x00},// g
{0x7F, 0x08, 0x04, 0x04, 0x78,0x00},// h
{0x00, 0x44, 0x7D, 0x40, 0x00,0x00},// i
{0x20, 0x40, 0x44, 0x3D, 0x00,0x00},// j
{0x00, 0x7F, 0x10, 0x28, 0x44,0x00},// k
{0x00, 0x41, 0x7F, 0x40, 0x00,0x00},// l
{0x7C, 0x04, 0x18, 0x04, 0x78,0x00},// m
{0x7C, 0x08, 0x04, 0x04, 0x78,0x00},// n
{0x38, 0x44, 0x44, 0x44, 0x38,0x00},// o
{0x7C, 0x14, 0x14, 0x14, 0x08,0x00},// p
{0x08, 0x14, 0x14, 0x18, 0x7C,0x00},// q
{0x7C, 0x08, 0x04, 0x04, 0x08,0x00},// r
{0x48, 0x54, 0x54, 0x54, 0x20,0x00},// s
{0x04, 0x3F, 0x44, 0x40, 0x20,0x00},// t
{0x3C, 0x40, 0x40, 0x20, 0x7C,0x00},// u
{0x1C, 0x20, 0x40, 0x20, 0x1C,0x00},// v
{0x3C, 0x40, 0x30, 0x40, 0x3C,0x00},// w
{0x44, 0x28, 0x10, 0x28, 0x44,0x00},// x
{0x0C, 0x50, 0x50, 0x50, 0x3C,0x00},// y
{0x44, 0x64, 0x54, 0x4C, 0x44,0x00}// z
};
void printString(char *s){
char *t = s;
int size = strlen(s)*6;
if(size<6*8) size = 6*8;
byte * b = (byte *) malloc(size);
memset(b, 0, size);
int i = 0;
while(*t) {
for(int j=0;j<6;j++){
b[i] = ledmap[*t-'A'][j];
i++;
}
t++;
}
// for(int i = 0;i<size;i++) Serial.print(b[i], HEX);
// Serial.println("");
screen_refresh(25,b);
free(b);
}
void loop(){
//screen_refresh(25,data);
//scr_rotate_left(25,szoveg);
//displayDHT(25);
printString("HELLO");
}
Örülök, hogy sikerült!
Én örülök a legjobban neki...
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!
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...
|
|