|
A klónok CH340 Soros-USB illesztőjének drivere ( Letöltés)
Sziasztok!
Egy kis segítséget szeretnék kérni, mert elakadtam.
Fokozat kijelzőt akarok építeni a motoromhoz, 7 szegmenses kijelzővel.
Ami már szépen működik is, ha csak ki kell íratni a számokat 0-9-ig.
Viszont, ha bemeneteken (D2-8-ig) szeretnék beolvasni állapotot (LOW,HIGH) az is sikerül, de nagyon lassan fut le. több mp. mire átáll egyik fokozatról a másikra.(Arduino nano v3)
tehát pld 4-es-ről átdugom 3-asra, akkor marad rajta a 4-es, de ráírja a 3-ast.
Itt van a kis program amit írtam, hol lehet benne a hiba?
//fokozat kijelző gs500E-hez byte FokozatBe = 0; byte i = 0; byte Fokozatok[] = {2,3,4,5,6,7,8}; // tömb, fokozat bementek 2-es üres, 8-as a 6. const byte dig2 = 2; const byte dig3 = 3; const byte dig4 = 4; const byte dig5 = 5; const byte dig6 = 6; const byte dig7 = 7; const byte dig8 = 8; const byte dig9 = 9; const byte dig10 = 10; const byte dig11 = 11; // byte dig12 = 12; 7 segmenst hajtja meg const byte dig13 = 13; // 7 szegmenses bemenetei összepárosítva const byte a = A3; const byte b = A2; const byte c = A1; const byte d = A0; const byte e = 12; const byte f = A5; const byte g = A4; // ---------------------------------- void FokozatLCD(int n) { switch(n) { // kiirandó fokozatok case 0: digitalWrite(a, HIGH); digitalWrite(b, HIGH); digitalWrite(c, HIGH); digitalWrite(d, HIGH); digitalWrite(e, HIGH); digitalWrite(f, HIGH); digitalWrite(g, LOW); break; case 1: digitalWrite(a, LOW); digitalWrite(b, HIGH); digitalWrite(c, HIGH); digitalWrite(d, LOW); digitalWrite(e, LOW); digitalWrite(f, LOW); digitalWrite(g, LOW); break; case 2: digitalWrite(a, HIGH); digitalWrite(b, HIGH); digitalWrite(c, LOW); digitalWrite(d, HIGH); digitalWrite(e, HIGH); digitalWrite(f, LOW); digitalWrite(g, HIGH); break; case 3: digitalWrite(a, HIGH); digitalWrite(b, HIGH); digitalWrite(c, HIGH); digitalWrite(d, HIGH); digitalWrite(e, LOW); digitalWrite(f, LOW); digitalWrite(g, HIGH); break; case 4: digitalWrite(a, LOW); digitalWrite(b, HIGH); digitalWrite(c, HIGH); digitalWrite(d, LOW); digitalWrite(e, LOW); digitalWrite(f, HIGH); digitalWrite(g, HIGH); break; case 5: digitalWrite(a, HIGH); digitalWrite(b, LOW); digitalWrite(c, HIGH); digitalWrite(d, HIGH); digitalWrite(e, LOW); digitalWrite(f, HIGH); digitalWrite(g, HIGH); break; case 6: digitalWrite(a, HIGH); digitalWrite(b, LOW); digitalWrite(c, HIGH); digitalWrite(d, HIGH); digitalWrite(e, HIGH); digitalWrite(f, HIGH); digitalWrite(g, HIGH); break; case 7: digitalWrite(a, HIGH); digitalWrite(b, HIGH); digitalWrite(c, HIGH); digitalWrite(d, LOW); digitalWrite(e, LOW); digitalWrite(f, LOW); digitalWrite(g, LOW); break; case 8: digitalWrite(a, HIGH); digitalWrite(b, HIGH); digitalWrite(c, HIGH); digitalWrite(d, HIGH); digitalWrite(e, HIGH); digitalWrite(f, HIGH); digitalWrite(g, HIGH); break; case 9: digitalWrite(a, HIGH); digitalWrite(b, HIGH); digitalWrite(c, HIGH); digitalWrite(d, HIGH); digitalWrite(e, LOW); digitalWrite(f, HIGH); digitalWrite(g, HIGH); break; case 'ErrorF': digitalWrite(a, HIGH); digitalWrite(b, LOW); digitalWrite(c, LOW); digitalWrite(d, HIGH); digitalWrite(e, HIGH); digitalWrite(f, HIGH); digitalWrite(g, HIGH); break; case 'ErrorX': digitalWrite(a, LOW); digitalWrite(b, LOW); digitalWrite(c, LOW); digitalWrite(d, LOW); digitalWrite(e, LOW); digitalWrite(f, LOW); digitalWrite(g, LOW); break; } }; //------------------------------------------ void setup() { Serial.begin(9600); // bejövő jelek a fokazokhoz pinMode(2, INPUT); pinMode(3, INPUT); pinMode(4, INPUT); pinMode(5, INPUT); pinMode(6, INPUT); pinMode(7, INPUT); pinMode(8, INPUT); // eddig pinMode(9, OUTPUT); // 7 szegmenses kihajtáshoz kimenetre állítás pinMode(12, OUTPUT); pinMode(A0, OUTPUT); pinMode(A1, OUTPUT); pinMode(A2, OUTPUT); pinMode(A3, OUTPUT); pinMode(A4, OUTPUT); pinMode(A5, OUTPUT); } void loop() { i = 0; /* // kijelző teszt for ( i=0; i < 10; i++) { FokozatLCD(i); delay(500); } FokozatLCD('ErrorF'); delay(500); */ // kijező üresre állítás digitalWrite(a, LOW); digitalWrite(b, LOW); digitalWrite(c, LOW); digitalWrite(d, LOW); digitalWrite(e, LOW); digitalWrite(f, LOW); digitalWrite(g, LOW); // fokozatok kinullázása a tömben for ( i=0; i < 6; i++) { Fokozatok[i] = 0; } // fokozatok beolvasása a tömbe for ( i=0; i < 6; i++) { Fokozatok[i] = digitalRead(i + 2); } for ( i=0; i < 6; i++) { if (Fokozatok[i] == HIGH) // bemenet vizsgálata van e jel, és ha igen, akkor a fokozat kiiratása { FokozatLCD(i); } } // delay(1000); };
Ha 1 kicsit értesz a programozáshoz?
Össze lehet ollózni kicsi idő ráfordítással!
Pl.:
Innen másolhatsz megfelelő font készletet!
Arduino-Libs / GraphicsLib /
És kicsit tovább fejleszted a meglevő rutinokat, hogy kezelni is tudjad.
void LcdCharacter(char character, int charx) // Bővítsük a rutint karakter szélesség átadásával { LcdWrite(LCD_D, 0x00); for (int index = 0; index < charx; index++) { LcdWrite(LCD_D, ASCII[character - 0x20][index]); } LcdWrite(LCD_D, 0x00); } …. void LcdString(char *characters, int charx) // Bővítsük a rutint karakter szélesség átadásával { while (*characters) { LcdCharacter(*characters++, charx); // Bővítsük a rutint karakter szélesség átadásával } } …. Aztán a ki írás: LcdString("Hello World!", charx); // Bővítsük a rutint karakter szélesség átadásával
(Csak gondolat ébresztőnek szántam ezt a pár sort neked! A kidolgozása már rád vár!)
Szerintem az az oka, hogy a bemenetek amikbe épp nincs bedugva semmi, azok lebegnek, azaz nem tudhatod biztosra hogy LOW vagy HIGH állapotot olvas be róluk, és amikor lefut a
for ( i=0; i < 6; i++) { if (Fokozatok[i] == HIGH) // bemenet vizsgálata van e jel, és ha igen, akkor a fokozat kiiratása { FokozatLCD(i); } }
ciklus, akkor mivel több HIGH állapot is lehet, ezért egymásra írja azokat a számokat, amiknél HIGH az állapot.
Ha itt int-et deklaráltál!
void FokozatLCD(int n)
...
Akkor, hogyan adsz át itt stringet?
FokozatLCD('ErrorF');
Nem adott át neki sehol, mert egyrészt az a rész ki van kommentezve, másrészt a sztring " jelek között van, nem pedig ' jelek között, így a fordító karakterként értelmezi, ami ugye valamilyen kódtábla szerint egy egész szám. Bár érdekes megoldás, az tény  De mivel ki van kommentezve biztos nem azzal van a gond.
Sziasztok!
MAX1415 16bit-es ADC-t szeretnék életre kelteni Arduino UNO-val.
adatlap. A 29. oldalon levő folyamatábrát próbáltam leprogramozni. Ez volt a példa, amiből kiindultam, ez ugyanaz, csak C-ben: Bővebben: Link.
Van az IC-nek egy lába (DRBY), ami alacsony lesz, ha kész az ADC konverzió. Ezután lehet kiolvasni soros interfészen az 2x8bit-et egymás után.
Az IC lábainak bekötése a következő (kezdem az 1-es lábtól):
SCLK -> PIN13
CLKIN-> GND (a belső oszcillátor megy ilyenkor)
CLKOUT ->lebeg
CS (chipselect) -> pin10
reset-> pin8
ain2+ lebeg
ain1+ poti középső kivetése (kb. 0.6V-ra állítva)
ain1- gnd
ref+ 3.3V
fer- gnd
ain2- lebeg
drby -> pin9
dout -> pin11
din -> pin12
vdd -> 3.3V
gnd -> gnd
Csak 0 0-t, vagy FFFFFF FFFFFF-t kapok soros monitoron.
ha használom a dataready() függvényt, aminek csak annyi a dolga, hogy várakozik, amíg a DRBY alacsony nem lesz, azt látom, hogy nem vált át az a láb alacsonyra. Ha kézzel rakom át GND-re a kábelt, akkor szépen jelez a függvény.
Nem gond az, hogy a kimenetek 5V-ot adnak ki, miközben az IC kb. 3.6V-ig tolerálja a feszültséget?
Köszönöm!
#include <SPI.h> #define chipselect 10 #define drby 9 #define reset 8 void setup(){ pinMode(chipselect,OUTPUT); pinMode(drby,INPUT); //alacsony lesz, ha kész a konverzió, ezután magas lesz, ha átment minden adat, és //addig magas marad, amíg a következő konverzió nincs kész. pinMode(chipselect,OUTPUT); SPI.begin(); SPI.setBitOrder(MSBFIRST); Serial.begin(9600); digitalWrite(chipselect,LOW); //engedélyezve van az IC digitalWrite(reset,LOW); delay(500); digitalWrite(chipselect,HIGH); digitalWrite(reset,HIGH); delay(100); digitalWrite(chipselect,LOW); delay(1); SPI.transfer(0x20); SPI.transfer(0xa5); SPI.transfer(0x10); SPI.transfer(0x44); delay(1); digitalWrite(chipselect,HIGH); } void loop() { while(1) { meres(); delay(500); } } void meres() { //dataready(); digitalWrite(chipselect,LOW); delay(10); SPI.transfer(0x38); //++++++++++ következő lépés: olvasás a data reg-ből char data=SPI.transfer(0x00); char data2=SPI.transfer(0x00); delay(1); digitalWrite(chipselect,HIGH); //átvitel lezárása (drby láb magas, ha minden bit átment!) Serial.print(data,HEX); Serial.print(" "); Serial.println(data2,HEX); } void dataready() { while (1) { Serial.println(" adat nincs kesz"); delay(1); int drby_=digitalRead(drby); if (drby_==0) { Serial.println("Kesz az adat!"); delay(1000); break; //++++++++++ // alacsony lesz, ha kész a konverzió } } }
Helló!
Jó az ötleted! Ha a felhúzó ellenállást bekapcsolja a kérdező, nem lesz lebegő bemenet, viszont akkor a soros ellenállást le kell csökkenteni kis méretűre, vagy el kell hagyni, nem a pozitív feszültségre kell kapcsolni, hanem a GND-re, plusz invertálni kell minden bemenetet.
Bővebben: Link
Bővebben: Link Ezt az oldalt is néztem, kódot kipróbáltam. Nem tudom már értelmezni, hogy miért nem megy.
Itt egy kód, amivel lekérem sorosan a comm. register értékét, és megvizsgálom, hogy a DRBY bit értéke 1, vagy sem.
byte ezkell= 0x80; // 10000000 bináris (=DBRY bit 1-es) byte DataNotReady=0x00; // 00000000 int kesz=1; //kilépés flag while(kesz) // wait for end of conversion { SPI.transfer(0x08);//command for comm reg to read (dec 8) // comm. register olvasása, alap esetben 00000000, de ha kész a konverzió, // akkor 10000000 DataNotReady =SPI.transfer(0x00); // Read comm register Serial.print("drby: "); Serial.print(DataNotReady,BIN); Serial.print(" ezvan<- ->ezkell "); Serial.println(ezkell,BIN); if (DataNotReady==ezkell) kesz=0; }
Amit kapok:
drby: 11111111 ezvan<- ->ezkell 10000000 drby: 0 ezvan<- ->ezkell 10000000 drby: 11111111 ezvan<- ->ezkell 10000000 drby: 0 ezvan<- ->ezkell 10000000 drby: 11111111 ezvan<- ->ezkell 10000000 drby: 0 ezvan<- ->ezkell 10000000 drby: 0 ezvan<- ->ezkell 10000000 drby: 11111111 ezvan<- ->ezkell 10000000 drby: 0 ezvan<- ->ezkell 10000000 drby: 11111111 ezvan<- ->ezkell 10000000 drby: 0 ezvan<- ->ezkell 10000000 drby: 0 ezvan<- ->ezkell 10000000 drby: 0 ezvan<- ->ezkell 10000000 drby: 0 ezvan<- ->ezkell 10000000 drby: 0 ezvan<- ->ezkell 10000000 drby: 0 ezvan<- ->ezkell 10000000 drby: 0 ezvan<- ->ezkell 10000000 drby: 1111111 ezvan<- ->ezkell 10000000 drby: 11111111 ezvan<- ->ezkell 10000000 drby: 0 ezvan<- ->ezkell 10000000 drby: 11111111 ezvan<- ->ezkell 10000000 drby: 0 ezvan<- ->ezkell 10000000 drby: 11111111 ezvan<- ->ezkell 10000000 drby: 0 ezvan<- ->ezkell 10000000 drby: 11111111 ezvan<- ->ezkell 10000000 drby: 0 ezvan<- ->ezkell 10000000
A kezem közelsége változtatja az értékeket... Másik csere IC-vel ugyanez. A hozzászólás módosítva: Aug 31, 2014
Bocsi, hogy ilyen sűrűn írok. A 13-as LED-nek minimum hunyorognia kellene, hiszen ott jön a CLOCK, nem? Na ez a LED nálam egyáltalán nem világít, viszont ha a pin13-at multiméterrel nézem az SCK-hoz képest, akkor ott sípol a multi, a miso és a mosi is csatlakozik. Még egy lehetőség van, hogy szoftverből adok órajelet. Megpróbálom a setup és a clock regisztert kiolvasni, ezeknek megvan az alap értéke, 0x01 és 0x85, ha eddig eljutok, akkor legalább már működik valami.
Köszönöm a segítségeket.
Ne kérdezd ,nekem is fura volt, de így működik a rutin tökéletesen.
'ErrorF' egyébként egy E lenne a 7 szegmensesen, csak szeretem a beszédesebb dolgokat.
hmm, köszi, ezen elgondolkoztam, ezek szerint valahogy "terminálni" kellene a nem használt bemeneteket?
Tettem bele delay()-t és olyankor olyan érzésem volt, mintha fel lenne töltődve egy "kondi" és amíg kisül van a bemeneten jel, ami pár mp, és addig ugrál több a kijelző a számok közt.
Szóval nagyon valószínű, hogy az van amit mondtál.
(Buta mókusok megtekerik a chipben a mókuskereket )
Nagyon amatőr vagyok ez nekem tényleg csak hobbi 
Köszi ezen az irányon megyek majd tovább.
Nem delay kell bele, hanem minden bemenetedet húz földre egy 10k-s ellenállással, arra vezetékre ami felül a rajzodon szerepel meg vagy ne tegyél ellenállást, vagy nagyon kis értékűt, és akkor jó lesz. Másik lehetőség, hogy a belső felhúzóellenállásokat bekapcsolod és inverz logikát használsz. De az első varíációnál nem kell bele se nyúlnod a programba, csak 8 db 10k-s ellenállásra lesz szükséged.
Hello,
Koszi a gondolatebresztot, de ha ertenem hozza tenyleg nem kerdeznem.
Olvasgattam erre meg arra valamiket rola, de panaszkodtak a karakter magassagara, a szelesseg ment ahogy ment.
Nem igazan ertek hozza. A nyaron osszeszedett tudasommal orulok hogy tudtam irni egy mukodo logokai reszt es hogy csak ugy siman kiirja egy Nokia 3410 -es LCD -re.
Mindemellett nekifogok es probalkozom,   amig ...
Valahogy igy ?
............ void LcdCharacter(char character, int charx) { LcdWrite(LCD_D, 0x00); for (int index = 0; index < charx; index++) { LcdWrite(LCD_D, ASCII[character - 0x20][index]); } LcdWrite(LCD_D, 0x00); } void LcdString(char *characters, int charx) { while (*characters) { LcdCharacter(*characters++, charx); } } .......... int charx; gotoXY(4,1); LcdString ("TestDisplay", 7) gotoXY(4,2); LcdString ("TestDisplay", 5);
Kellene mukodjon a sajat karakterkeszlettel, vagy kell vallasszak masikat hozza.
Kiprobalni csak delutan-este lessz lehetosegem ... A hozzászólás módosítva: Szept 1, 2014
Egy alap próbálkozást próbáltam tenni.
#define din 12 #define dout 11 #define drdy 5 #define reset 8 #define cs 10 #define sclk 13 //with LED #define speed 100 //ms-ban a parancsok közti idő #include "SPI.h" char data=0; void setup() { SPI.begin(); //SPI.setBitOrder(MSBFIRST); /* pinMode(dout, INPUT); //bejovo adat pinMode(din, OUTPUT); //kimenő adat pinMode(sclk, OUTPUT); //órajel */ pinMode(drdy, INPUT); //ha alacsony, akkor kész a konverzió pinMode(reset, OUTPUT); //ha magas, akkor engedélyezve van az IC pinMode(cs, OUTPUT); //alacsony, akkor engedélyezve van az IC Serial.begin(9600); //***************** delay(500); digitalWrite(cs,HIGH); digitalWrite(reset,LOW); delay(500); digitalWrite(reset,HIGH); digitalWrite(cs,LOW); delay(100); //****************** IC bekapcsolva } void loop() { digitalWrite(cs,LOW); data=SPI.transfer(0x28); digitalWrite(cs,HIGH); Serial.print(data,BIN); Serial.print(" = "); Serial.print(data,HEX); Serial.print(" "); digitalWrite(cs,LOW); data=SPI.transfer(0x28); digitalWrite(cs,HIGH); Serial.print(data,BIN); Serial.print(" = "); Serial.println(data,HEX); delay(1000); }
Amire ezt kapom eredményül:
= 0 0 = 0 0 = 0 0 = 0 0 = 0 0 = 0 101000 = 28 101000 = 28 11111111111111111111111111111110 = FFFFFFFE 11111111111111111111111111111111 = FFFFFFFF 0 = 0 0 = 0 0 = 0 0 = 0 0 = 0 0 = 0 0 = 0 0 = 0 0 = 0 0 = 0 101000 = 28 101000 = 28 11111111111111111111111111111111 = FFFFFFFF 11111111111111111111111111111111 = FFFFFFFF 0 = 0 0 = 0 0 = 0 0 = 0 0 = 0 0 = 0 0 = 0 0 = 0 101000 = 28 101000 = 28 101000 = 28 11111111111111111111111111111111 = FFFFFFFF 11111111111111111111111111111111 = FFFFFFFF 11111111111111111111111111111111 = FFFFFFFF 0 = 0 0 = 0 0 = 0 0 = 0 101000 = 28 101000 = 28 11111111111111111111111111111111 = FFFFFFFF 11111111111111111111111111111111 = FFFFFFFF 0 = 0 0 = 0 0 = 0 0 = 0 0 = 0 0 = 0 0 = 0 0 = 0 101000 = 28 101000 = 28 101000 = 28 101000 = 28 11111111111111111111111111111111 = FFFFFFFF 11111111111111111111111111111111 = FFFFFFFF 0 = 0 0 = 0 0 = 0 0 = 0
Amit csinálok:
Reset-et magasra húzom, Cs-et alacsonyra, ezzel aktív az IC. Elküldöm az IC-nek a 0x28-at, ami 00101000, vagyis első nulla: jelzem, hogy kommunikálok az IC-vel. Reg. select: 010 - ez a clock register, következő 1-es jelzi hogy olvasni akarom, többi nulla, nem lényeges. Az első data küldésnél elküldöm az IC-nek a parancsot, a következőnek küldhetnék bármit, mert olyankor csak adatot fogadok. Amit vissza kellene kapnom, az a csatolmányban is látszik, 10000101, vagyis 0x85.
Amiben nem vagyok biztos: CLKIN-t földre húzom, ilyenkor a belső oszcillátor megy. Drby-nal nem foglalkozok, hiszen nem konverziós eredményt szeretnék olvasni.
"Drive RESET low to reset the MAX1415/MAX1416 to
power-on reset status. DRDY goes high and all communication
to the MAX1415/MAX1416 is ignored while RESET
is low. Upon releasing RESET, the device must be reconfigured
to begin a conversion." - tehát ha alacsony a reset, akkor ingorálva van minden kommunikáció. Ezért én magasra húzom. Több láb nincs is az IC-n, amivel foglalkozni kellene. A CS-re van ábra. De írja is az adatlap, hogy: "CS selects the active device in systems with more than one device on
the serial bus. Drive CS low to clock data in on DIN and to clock data out on DOUT. When CS is high,
DOUT is high impedance. Connect CS to GND for 3-wire operation." Tehát én fixen lerakom GND-re a lábat. Van valami mód, amivel tudnám a kommunikációt ellenőrizni?
Köszönöm. A hozzászólás módosítva: Szept 1, 2014
Mint jeleztem a válaszom csak gondolatébresztő volt, hogy merre induljál el.
(A részleteket neked kellene megoldani. Feltéve, hogy van ilyen irányú érdeklődésed?
Mert ha csak szeretnél valami gyors megoldást? Akkor keresgélj inkább a NET-en példát rá.)
A jelenlegi karakter készleted magassága 1 Byte = 8 pont, szélessége 5 Byte = 5 pont.
static const byte ASCII[][5] =
{
{0x00, 0x00, 0x00, 0x00, 0x00} // 20
,{0x00, 0x00, 0x5f, 0x00, 0x00} // 21 !
Le rajzolva a !:
0 0 1 0 0
0 0 1 0 0
0 0 1 0 0
0 0 1 0 0 (F)
0 0 1 0 0
0 0 0 0 0
0 0 0 0 0
0 0 1 0 0 (5)
….
A programod mostani állapotában csak ezt tudja kirajzolni.
Első lépésként növeljük a karakterek szélességét.
Kel hozzá megfelelő karakter készlet, magassága 1 Byte = 8 pont, szélessége 6 Byte = 6 pont.
static const byte ASCII8x6[][6] =
{
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00} // 20
,{0x00, 0x00, 0x5f, 0x5f, 0x00, 0x00} // 21 !
Le rajzolva a !:
0 0 1 1 0 0
0 0 1 1 0 0
0 0 1 1 0 0
0 0 1 1 0 0 (F)
0 0 1 1 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 1 1 0 0 (5)
….
Kérdés, hogy bele vágsz a megoldásba? A hozzászólás módosítva: Szept 1, 2014
| (#) |
rmis hozzászólása |
Szept 1, 2014 |
 |
/ |
 |
|
Sziasztok!
Lenne egy kérdésem, az ethernet shielddel kapcsolatban, hátha járt már így valaki.
Van egy működő kapcsolásom (ethernet szerver, de talán ez nem lényeges), melyet 5V-os dugasztáppal üzemeltetek (bár min 7V kellene neki, de ezzel is elketyeg). A lényeg, hogy ezzel megy tökéletesen. Ha viszont egy 12V-os dugasztápot teszek rá az 5 voltos helyett, akkor az arduino ugyan megy rendesen, viszont az ethernet shield meg sem nyikkan... (nem "official arduino" shield...)
Találkozott már valaki ilyen problémával?
A válaszokat előre is köszönném
Melyik Eth Shield?
Tippek:
-3.3V os táp elmelegszik és lekapcsol
- az 5V stab nem 5V-os.
- A külső 5V-ról (ha a VInben jön be), az Arduino nem indulhat el, mert a BOD 4.2V (ez alatt a chip resetben és a 7805-n ~1V esik). Azaz itt valami nem odavaló van.
Köszi a gyors választ!
HA 5V megy a Vinre (5V = kb. 3,6V a panelon), akkor műkszik rendesen
Akkor van a baj, ha 12V megy a Vinre. Az ethernet shield pedig a W5100 chippel szerelt micro SD-s típus.
Koszonom,
Ez tenyleg jol jon mert nincs ilyesmire mar sem kedvem, sem idom. Koszonom.
Helló!
Annyira sikerült rájönnöm, hogy a miso és mosi kábelek meg voltak cserélve.
Már tudok valamennyire kommunikálni az IC-vel, de nem tökéletes. Még csak regisztereket állítok be, és olvasom vissza, de a második visszaolvasásnál elveszik az érték, vagy elcsúszik az adatbusz szinkronja, vagy ilyesmi.
#define din 12 #define dout 11 #define drdy 5 #define reset 8 #define cs 10 #define sclk 13 //with LED #include "SPI.h" char data; void setup() { SPI.begin(); SPI.setBitOrder(MSBFIRST); Serial.begin(9600); } void loop() { delay(100); SPI.transfer(0x20); //írni akarok a clock regiszterbe 00100000 0x20 delay(1); SPI.transfer(0xA5); //ezt írom bele: 10100101 0xa5 delay(1); SPI.transfer(0x10); //írni akarom a setup regisztert. 00010000 0x10 delay(1); SPI.transfer(0x44); //01000100 0x44 delay(1); while(1) { ///visszaolvasás: Serial.println("\nKezdek visszaolvasni."); SPI.transfer(0x28); //olvasni akarom clock reg-t. 00101000 0x28 delay(1); data=SPI.transfer(0); delay(1); Serial.print(data,BIN); Serial.print(" bin<- 10100101 a5 ->hex ");Serial.println(data,HEX); SPI.transfer(0x18); //olvasni akarom setup reg-t. 00011000 0x18 delay(1); data=SPI.transfer(0); delay(1); Serial.print(data,BIN); Serial.print(" bin<- 01000100 44 ->hex ");Serial.println(data,HEX); delay(1000); } }
Erre ezt kapom soros monitoron:
Kezdek visszaolvasni. 11111111111111111111111110100101 bin<- 10100101 a5 ->hex FFFFFFA5 1000100 bin<- 01000100 44 ->hex 44 Kezdek visszaolvasni. 11111111111111111111111110100101 bin<- 10100101 a5 ->hex FFFFFFA5 100 bin<- 01000100 44 ->hex 4 Kezdek visszaolvasni. 11111111111111111111111110100101 bin<- 10100101 a5 ->hex FFFFFFA5 100 bin<- 01000100 44 ->hex 4
Az első sorba pont beállítás után kiolvasom a regisztert, megfelelő értéket kapok, viszont már csak 7bit-et, másodiknál már csak 3bit marad, ha jól látom, az utolsó három bit. Azt sem nagyon értem, hogy miért kapom 32biten vissza egy 8bites regiszter tartalmát: 1111111111111111111111111010010 , a vége rendben van, de az eleje felesleges.
Annyi a haladás, hogy ezeket az értékeket már stabilan tartja az IC.
Valakinek van valami ötlete? Köszönöm.
Éppen ettől féltem, hogy hamar feladod!
Pedig még csak az alapoknál tartunk, a cél legalább Félkövér betűk rajzolása lett volna.
(Sajnos olyat még nem találta készen! Hátha valaki tud majd neked ajánlani?)
A lényeg, hogy a kirajzolás a bal felső sarokból kezdődik a 0 bit-től lefele.
1.Byte, 2.Byte …
Bit0
Bit1
Bit2
Bit3
Bit4
Bit5
Bit6
Bit7
Már tudsz 8 pont magas tetszőleges szélességű karaktereket rajzolni?
A magasabb karakterek rajzolásának trükkje, hogy a felső 8 sor kirajzolása után alá rajzolod a további részeket.
Lenne is itt hozzá font_8x16.h készlet.
(A kínai megjegyzéseket törölni kellene belőle!)
Úgy döntöttem, hogy kel nekem is ez a font készlet, ezért ki javítgattam.
És itt van a köz javára!:
// font_8x16.h // big font unsigned char const font8_16[][16]={ {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}, {0x00,0x00,0x00,0xFC,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x19,0x18,0x00,0x00,0x00}, {0x00,0x10,0x0C,0x12,0x0C,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}, {0x00,0x20,0x20,0xF8,0x20,0xF8,0x20,0x00,0x00,0x02,0x1F,0x02,0x1F,0x02,0x02,0x00}, {0x00,0x70,0x88,0xFC,0x08,0x30,0x00,0x00,0x00,0x0C,0x10,0x7F,0x11,0x0E,0x00,0x00}, {0x70,0x88,0x70,0x80,0x60,0x18,0x00,0x00,0x00,0x18,0x06,0x01,0x0E,0x11,0x0E,0x00}, {0x00,0xF0,0x88,0xF0,0x80,0x80,0x00,0x00,0x0F,0x10,0x13,0x14,0x0F,0x10,0x10,0x00}, {0x10,0x16,0x0E,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}, {0x00,0x00,0x00,0xE0,0x18,0x04,0x02,0x00,0x00,0x00,0x00,0x03,0x0C,0x10,0x20,0x00}, {0x00,0x02,0x04,0x18,0xE0,0x00,0x00,0x00,0x00,0x20,0x10,0x0C,0x03,0x00,0x00,0x00}, {0x40,0x40,0x80,0xF0,0x80,0x40,0x40,0x00,0x02,0x02,0x01,0x0F,0x01,0x02,0x02,0x00}, {0x80,0x80,0x80,0xF0,0x80,0x80,0x80,0x00,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x00}, {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x40,0x58,0x38,0x00,0x00,0x00,0x00,0x00}, {0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}, {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x18,0x00,0x00,0x00,0x00,0x00}, {0x00,0x00,0x00,0x80,0x60,0x1C,0x02,0x00,0x00,0x30,0x0C,0x03,0x00,0x00,0x00,0x00}, {0x00,0xE0,0x10,0x08,0x08,0x10,0xE0,0x00,0x00,0x07,0x08,0x10,0x10,0x08,0x07,0x00}, {0x00,0x10,0x10,0xF8,0x00,0x00,0x00,0x00,0x00,0x10,0x10,0x1F,0x10,0x10,0x00,0x00}, {0x00,0x30,0x08,0x08,0x08,0x88,0x70,0x00,0x00,0x18,0x14,0x12,0x11,0x10,0x18,0x00}, {0x00,0x30,0x08,0x88,0x88,0x48,0x30,0x00,0x00,0x0C,0x10,0x10,0x10,0x11,0x0E,0x00}, {0x00,0x80,0x40,0x20,0xF8,0x00,0x00,0x00,0x00,0x03,0x02,0x12,0x1F,0x12,0x12,0x00}, {0x00,0xF8,0x88,0x48,0x48,0x48,0x88,0x00,0x00,0x0C,0x10,0x10,0x10,0x10,0x0F,0x00}, {0x00,0xE0,0x10,0x88,0x88,0x98,0x00,0x00,0x00,0x0F,0x11,0x10,0x10,0x10,0x0F,0x00}, {0x00,0x38,0x08,0x08,0xC8,0x38,0x08,0x00,0x00,0x00,0x00,0x1F,0x00,0x00,0x00,0x00}, {0x00,0x70,0x88,0x88,0x88,0x88,0x70,0x00,0x00,0x0E,0x11,0x10,0x10,0x11,0x0E,0x00}, {0x00,0xF0,0x08,0x08,0x08,0x90,0xE0,0x00,0x00,0x00,0x19,0x11,0x11,0x08,0x07,0x00}, {0x00,0x00,0x00,0xC0,0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x18,0x00,0x00,0x00}, {0x00,0x00,0x00,0x40,0x00,0x00,0x00,0x00,0x00,0x00,0x40,0x30,0x00,0x00,0x00,0x00}, {0x00,0x80,0x40,0x20,0x10,0x08,0x04,0x00,0x00,0x00,0x01,0x02,0x04,0x08,0x10,0x00}, {0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x00,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x00}, {0x00,0x04,0x08,0x10,0x20,0x40,0x80,0x00,0x00,0x10,0x08,0x04,0x02,0x01,0x00,0x00}, {0x00,0x38,0x04,0x04,0x04,0x84,0x78,0x00,0x00,0x00,0x00,0x18,0x1B,0x00,0x00,0x00}, {0xE0,0x10,0xC8,0x28,0xE8,0x10,0xE0,0x00,0x07,0x08,0x17,0x14,0x13,0x14,0x0B,0x00}, {0x00,0x00,0xE0,0x18,0xE0,0x00,0x00,0x00,0x10,0x1E,0x13,0x02,0x13,0x1E,0x10,0x00}, {0x08,0xF8,0x88,0x88,0x88,0x48,0x30,0x00,0x10,0x1F,0x10,0x10,0x10,0x11,0x0E,0x00}, {0xE0,0x10,0x08,0x08,0x08,0x08,0x38,0x00,0x07,0x08,0x10,0x10,0x10,0x08,0x04,0x00}, {0x08,0xF8,0x08,0x08,0x08,0x10,0xE0,0x00,0x10,0x1F,0x10,0x10,0x10,0x08,0x07,0x00}, {0x08,0xF8,0x88,0x88,0xE8,0x08,0x10,0x00,0x10,0x1F,0x10,0x10,0x13,0x10,0x08,0x00}, {0x08,0xF8,0x88,0x88,0xE8,0x08,0x10,0x00,0x10,0x1F,0x10,0x00,0x03,0x00,0x00,0x00}, {0xE0,0x10,0x08,0x08,0x08,0x38,0x00,0x00,0x07,0x08,0x10,0x10,0x12,0x0E,0x02,0x00}, {0x08,0xF8,0x88,0x80,0x88,0xF8,0x08,0x00,0x10,0x1F,0x10,0x00,0x10,0x1F,0x10,0x00}, {0x00,0x08,0x08,0xF8,0x08,0x08,0x00,0x00,0x00,0x10,0x10,0x1F,0x10,0x10,0x00,0x00}, {0x00,0x00,0x08,0x08,0xF8,0x08,0x08,0x00,0x60,0x40,0x40,0x40,0x3F,0x00,0x00,0x00}, {0x08,0xF8,0x88,0xC0,0x28,0x18,0x08,0x00,0x10,0x1F,0x10,0x01,0x16,0x18,0x10,0x00}, {0x08,0xF8,0x08,0x00,0x00,0x00,0x00,0x00,0x10,0x1F,0x10,0x10,0x10,0x10,0x18,0x00}, {0x08,0xF8,0x78,0x80,0x78,0xF8,0x08,0x00,0x10,0x1F,0x00,0x1F,0x00,0x1F,0x10,0x00}, {0x08,0xF8,0x38,0xC0,0x08,0xF8,0x08,0x00,0x10,0x1F,0x10,0x01,0x0E,0x1F,0x00,0x00}, {0xE0,0x10,0x08,0x08,0x08,0x10,0xE0,0x00,0x07,0x08,0x10,0x10,0x10,0x08,0x07,0x00}, {0x08,0xF8,0x88,0x88,0x88,0x88,0x70,0x00,0x10,0x1F,0x10,0x00,0x00,0x00,0x00,0x00}, {0xE0,0x10,0x08,0x08,0x08,0x10,0xE0,0x00,0x07,0x08,0x14,0x14,0x18,0x28,0x27,0x00}, {0x08,0xF8,0x88,0x88,0x88,0x70,0x00,0x00,0x10,0x1F,0x10,0x01,0x06,0x18,0x10,0x00}, {0x00,0x70,0x88,0x88,0x08,0x08,0x38,0x00,0x00,0x1C,0x10,0x10,0x11,0x11,0x0E,0x00}, {0x18,0x08,0x08,0xF8,0x08,0x08,0x18,0x00,0x00,0x00,0x10,0x1F,0x10,0x00,0x00,0x00}, {0x08,0xF8,0x08,0x00,0x08,0xF8,0x08,0x00,0x00,0x0F,0x10,0x10,0x10,0x0F,0x00,0x00}, {0x08,0x78,0x88,0x00,0x88,0x78,0x08,0x00,0x00,0x00,0x07,0x18,0x07,0x00,0x00,0x00}, {0x08,0xF8,0x00,0xF8,0x00,0xF8,0x08,0x00,0x00,0x01,0x1F,0x00,0x1F,0x01,0x00,0x00}, {0x08,0x18,0x68,0x80,0x68,0x18,0x08,0x00,0x10,0x18,0x16,0x01,0x16,0x18,0x10,0x00}, {0x08,0x38,0xC8,0x00,0xC8,0x38,0x08,0x00,0x00,0x00,0x10,0x1F,0x10,0x00,0x00,0x00}, {0x00,0x10,0x08,0x08,0xC8,0x38,0x08,0x00,0x00,0x10,0x1C,0x13,0x10,0x10,0x18,0x00}, {0x00,0x00,0x00,0xFE,0x02,0x02,0x02,0x00,0x00,0x00,0x00,0x3F,0x20,0x20,0x20,0x00}, {0x00,0x00,0x00,0x80,0x60,0x1C,0x02,0x00,0x00,0x30,0x0C,0x03,0x00,0x00,0x00,0x00}, {0x00,0x02,0x02,0x02,0xFE,0x00,0x00,0x00,0x00,0x20,0x20,0x20,0x3F,0x00,0x00,0x00}, {0x00,0x00,0x04,0x02,0x02,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}, {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x00}, {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x0C,0x18,0x00,0x00}, {0x00,0x80,0x40,0x40,0x40,0x80,0x00,0x00,0x00,0x0C,0x12,0x11,0x11,0x1F,0x10,0x00}, {0x08,0xF8,0x80,0x40,0x40,0x40,0x80,0x00,0x00,0x1F,0x10,0x10,0x10,0x10,0x0F,0x00}, {0x00,0x00,0x80,0x40,0x40,0x40,0x80,0x00,0x00,0x07,0x08,0x10,0x10,0x10,0x08,0x00}, {0x00,0x80,0x40,0x40,0x40,0x48,0xF8,0x00,0x00,0x0F,0x10,0x10,0x10,0x08,0x1F,0x10}, {0x00,0x80,0x40,0x40,0x40,0x40,0x80,0x00,0x00,0x0F,0x11,0x11,0x11,0x11,0x09,0x00}, {0x00,0x40,0x40,0xF0,0x48,0x48,0x18,0x00,0x00,0x10,0x10,0x1F,0x10,0x10,0x00,0x00}, {0x00,0x80,0x40,0x40,0x40,0xC0,0x40,0x00,0x00,0x35,0x4A,0x4A,0x4A,0x49,0x30,0x00}, {0x08,0xF8,0x80,0x40,0x40,0x40,0x80,0x00,0x10,0x1F,0x10,0x00,0x00,0x10,0x1F,0x10}, {0x00,0x40,0x58,0xD8,0x00,0x00,0x00,0x00,0x00,0x10,0x10,0x1F,0x10,0x10,0x00,0x00}, {0x00,0x00,0x00,0x40,0x58,0xD8,0x00,0x00,0x00,0x60,0x40,0x40,0x40,0x3F,0x00,0x00}, {0x08,0xF8,0x00,0x00,0xC0,0x40,0x40,0x00,0x10,0x1F,0x12,0x01,0x16,0x18,0x10,0x00}, {0x00,0x08,0x08,0xF8,0x00,0x00,0x00,0x00,0x00,0x10,0x10,0x1F,0x10,0x10,0x00,0x00}, {0x40,0xC0,0x40,0xC0,0x40,0x80,0x00,0x00,0x10,0x1F,0x00,0x1F,0x00,0x1F,0x10,0x00}, {0x40,0xC0,0x80,0x40,0x40,0x40,0x80,0x00,0x10,0x1F,0x10,0x00,0x00,0x10,0x1F,0x10}, {0x00,0x00,0x80,0x40,0x40,0x80,0x00,0x00,0x00,0x07,0x08,0x10,0x10,0x08,0x07,0x00}, {0x40,0xC0,0x80,0x40,0x40,0x40,0x80,0x00,0x40,0x7F,0x50,0x10,0x10,0x10,0x0F,0x00}, {0x00,0x80,0x40,0x40,0x40,0x40,0xC0,0x00,0x00,0x0F,0x10,0x10,0x10,0x48,0x7F,0x40}, {0x40,0x40,0xC0,0x80,0x40,0x40,0xC0,0x00,0x10,0x10,0x1F,0x10,0x10,0x00,0x00,0x00}, {0x00,0x80,0x40,0x40,0x40,0xC0,0x00,0x00,0x00,0x19,0x12,0x12,0x12,0x0C,0x00,0x00}, {0x00,0x40,0x40,0xF0,0x40,0x40,0x00,0x00,0x00,0x00,0x00,0x0F,0x10,0x10,0x00,0x00}, {0x40,0xC0,0x00,0x00,0x00,0x40,0xC0,0x00,0x00,0x0F,0x10,0x10,0x10,0x08,0x1F,0x10}, {0x40,0xC0,0x40,0x00,0x00,0x40,0xC0,0x40,0x00,0x00,0x07,0x18,0x04,0x03,0x00,0x00}, {0x40,0xC0,0x00,0xC0,0x00,0xC0,0x40,0x00,0x00,0x03,0x1C,0x03,0x1C,0x03,0x00,0x00}, {0x00,0x40,0xC0,0x00,0x40,0xC0,0x40,0x00,0x00,0x10,0x18,0x17,0x07,0x18,0x10,0x00}, {0x40,0xC0,0x40,0x00,0x00,0x40,0xC0,0x40,0x40,0x40,0x47,0x38,0x0C,0x03,0x00,0x00}, {0x00,0xC0,0x40,0x40,0x40,0xC0,0x40,0x00,0x00,0x10,0x18,0x16,0x11,0x10,0x18,0x00}, {0x00,0x00,0x00,0x80,0x7E,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x3F,0x20,0x00,0x00}, {0x00,0x00,0x00,0xFF,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x7F,0x00,0x00,0x00,0x00}, {0x00,0x00,0x02,0x7E,0x80,0x00,0x00,0x00,0x00,0x00,0x20,0x3F,0x00,0x00,0x00,0x00}, {0x00,0x06,0x01,0x01,0x02,0x04,0x04,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00} };
A karakterenkénti első 8 Byte a felső 8*8-as pont mátrixot képviseli, miután ezt már ki tudod rajzolni.
Az első oszlop alá mozgatod a kurzort és folytatod a második 8 Byte 8*8 pont mátrix ki rajzolásával.
Végül a kiszámolod következő karakter kezdetének helyét és oda teszed a kurzort.
Fr@ncba ez is feleslegesen be sórszámozta!  A hozzászólás módosítva: Szept 2, 2014
Helló.
Átállítottam a változó típusát byte-ra, így szuperül a 8bit-et kapom csak, ami kell. Más is észrevette már, hogy soros monitor az első nullákat levágja, ha BIN-módban küldesz ár adatot? Tehát amikor 7bit-et kaptam, az csak annyit jelentett, hogy az első bit 0.
Már van egy programrészletem, ami kilistázza az összes regiszter tartalmát
Többször sikerült már valahogy kisakkoznom, hogy a poti tekerésével változtak a HEX számok, a tekeréssel arányosan, tehát ebből lesz valami, az biztos. Azt sejtem, hogy a setup regiszter Mode control, és Fsync részét kell megértenem. Itt van olyan, nulla kalibrálás, és full scale kalibrálás. Gondolom ezzel a kettővel kellene az alsó és felső tartományt beállítani, és ezután mehetne csak a mérés. Amikor össze is hoztam a tekerés hatására változó számokat, nem teljes tartományban tudtam tekerni, mert gyorsan FF-t, vagy 00-t kaptam, pedig a Vref+ a 3.3V-on van, a Vref- pedig a GND-n. Felrakom a jelenlegi progit, hátha próbálkozik még valaki ezzel az IC-vel az idő folyamán . Jól elszenvedek itt magamban. Kis lépésekben azért haladok valahova, az a lényeg.
lábkiosztás: IC->Arduino: 1-pin13, 2-gnd, 4-gnd, 5-3.3V, 7-poti középső, 8-gnd, 9-3.3V, 10-gnd, 12-pin5 (drdy), 13-pin12, 14-pin11, 15-3.3V, 16-gnd.
#define din 12 #define dout 11 #define drdy 5 #define reset 8 //fixen +3.3V #define cs 10 #define sclk 13 #define ido 04 //ms-ban a parancsok közti idő #include "SPI.h" byte data1; byte data2; byte data; void setup() { SPI.begin(); SPI.setBitOrder(MSBFIRST); SPI.setDataMode(SPI_MODE0) ; SPI.setClockDivider(SPI_CLOCK_DIV128); /* pinMode(dout, INPUT); //bejovo adat pinMode(din, OUTPUT); //kimenő adat pinMode(sclk, OUTPUT); //órajel */ pinMode(drdy, INPUT); //ha alacsony, akkor kész a konverzió pinMode(reset, OUTPUT); //ha magas, akkor engedélyezve van az IC pinMode(cs, OUTPUT); //alacsony, akkor engedélyezve van az IC Serial.begin(9600); //***************** delay(500); digitalWrite(cs,HIGH); digitalWrite(reset,LOW); delay(500); digitalWrite(reset,HIGH); digitalWrite(cs,LOW); delay(1); //****************** IC bekapcsolva SPI.transfer(0x20); delay(ido); SPI.transfer(0xa5); delay(ido); SPI.transfer(0x10); delay(ido); SPI.transfer(0B11000101); delay(ido); digitalWrite(cs,HIGH); } void loop() { //while((digitalRead(drdy))==HIGH) //ezzel ellenőrizhető, ha a konverzió kész! //{;} //Serial.print("drdy alacsony!\n"); SPI.transfer(0x28); //olvasni akarom clock reg-t. 00101000 0x28 delay(10); data=SPI.transfer(0B00000000); Serial.print(data,BIN); Serial.print(" bin<- clock reg ->hex ");Serial.println(data,HEX); delay(10); SPI.transfer(0B00001000); //olvasni akarom comm. reg-t. 00001000 0x08 delay(10); data=SPI.transfer(0x00); Serial.print(data,BIN); Serial.print(" bin<- comm reg ->hex ");Serial.println(data,HEX); delay(10); SPI.transfer(0xFF);SPI.transfer(0xFF); SPI.transfer(0xFF); SPI.transfer(0xFF); SPI.transfer(0B00011000); //olvasni akarom setup reg-t. 00011000 0x18 //delay(10); data=SPI.transfer(0xA1); Serial.print(data,BIN); Serial.print(" bin<- setup reg ->hex ");Serial.println(data,HEX); delay(10); SPI.transfer(0x38); //olvasni akarom data reg-t. 00111000 0x38 delay(10); data=SPI.transfer(0xFF); Serial.print(data,BIN); Serial.print(" bin<- data1 reg ->hex ");Serial.println(data,HEX); delay(10); data=SPI.transfer(0x00); Serial.print(data,BIN); Serial.print(" bin<- data2 reg ->hex ");Serial.println(data,HEX); delay(10); Serial.println("\n\n"); SPI.transfer(0xFF); SPI.transfer(0xFF); SPI.transfer(0xFF); SPI.transfer(0xFF); delay(100); digitalWrite(cs,LOW); SPI.transfer(0x38); data1=SPI.transfer(0); data2=SPI.transfer(0); delay(10); digitalWrite(cs,HIGH); Serial.print(data1,BIN); Serial.print(" bin<- data1 ->hex ");Serial.println(data1,HEX); Serial.print(data2,BIN); Serial.print(" bin<- data2 ->hex ");Serial.println(data2,HEX); delay(1000); //Serial.println("\n\n"); //SPI.transfer(0xFF); SPI.transfer(0xFF); SPI.transfer(0xFF); SPI.transfer(0xFF); //a 32db 1-essel lehet a soros kommunikációt újraindítani, regiszter értékek // nem változnak! }
Annyi érdekesség történt, hogy a gyári folyamatábrás példát kipróbáltam, az mindig beakadt ott, hogy a drdy nem ment le alacsony szintre, tehát várakoztam végtelenségig. Megfogtam a kábelt, szimplán átdugtam GND-re, ekkor tovább futott a program, és elkezdett mérni is az IC. kb. 36000-től 65000-ig kaptam számokat (persze HEX-ben), volt tartomány, ahol nem változtak a számok. Két lehetőség van, kell valami, amitől a DRDY magától lemegy alacsony szintre (kalibrálással kapcsolatos dolog lehet), vagy pedig nekem kell DRDY-ra elküldeni valamit, hiszen most lebegve azt szedett össze, amit akart. Most már legalább elő tudom állítani ezt a véletlen eseményt. Ez a folyamatábra az adatlap 29. oldalán van: Bővebben: Link, előtte 0X44-et küldünk el, amivel törli az Fsync-et, amivel free running konverzió fog futni. Erre írja, hogy a DRDY magas marad, amíg ki nem olvasom a data registert. Na ezt kipróbálom, mit szól hozzá.
Max1415 Arduino működő kód. Bekötés az előző hozzászólásban.
#define din 12 #define dout 11 #define drdy 5 #define reset 8 //fixen +3.3V #define cs 10 #define sclk 13 #define ido 04 //ms-ban a parancsok közti idő #include "SPI.h" byte data1; byte data2; byte data; unsigned int adcValue=0; float ertek=0; void setup() { SPI.begin(); SPI.setBitOrder(MSBFIRST); SPI.setDataMode(SPI_MODE0) ; SPI.setClockDivider(SPI_CLOCK_DIV128); pinMode(drdy, INPUT); //ha alacsony, akkor kész a konverzió pinMode(reset, OUTPUT); //ha magas, akkor engedélyezve van az IC pinMode(cs, OUTPUT); //alacsony, akkor engedélyezve van az IC Serial.begin(9600); digitalWrite(cs,LOW); delay(1); SPI.transfer(0x20); delay(ido); SPI.transfer(0xa5); delay(ido); SPI.transfer(0x10); delay(ido); SPI.transfer(0x44); //fsync start delay(ido*10); SPI.transfer(0x45); //fsync stop SPI.transfer(0B00111000); //data kiolvas data=SPI.transfer(0); //eldob data=SPI.transfer(0); digitalWrite(cs,HIGH); } void loop() { while((digitalRead(drdy))==HIGH) //ezzel ellenőrizhető, ha a konverzió kész! {;} digitalWrite(cs,LOW); SPI.transfer(0x38); data1=SPI.transfer(0); data2=SPI.transfer(0); delay(10); adcValue = data1 << 8; adcValue = adcValue | data2; ertek=(float(adcValue)*3.607)/65535; Serial.print("Adc value: "); Serial.print(adcValue);Serial.print(" feszko: "); Serial.println(ertek,6); SPI.transfer(0xFF); SPI.transfer(0xFF); SPI.transfer(0xFF); SPI.transfer(0xFF); digitalWrite(cs,HIGH); delay(500); }
Ez már egy működőképes kód. És tényleg ki kellett olvasni a data regisztert, el is dobom. A program végén ha nem küldök 32db egyest, hibás, köztes adatokat is kapok, amik általában nullák. Nem tudom, kell-e kalibrálni, de elég pontos, ahogy próbálgattam (persze mihez képest pontos...)
Én úgy értelmezem az adatlap 23. oldal diagram szerint, hogy minden írás és olvasás művelet után a CS-t H-ba húzza! A DRDY is csak ez után aktiválódik.
Nálad viszont az összes művelet egyetlen digitalWrite(cs,LOW); engedélyezés alatt történik?
Szerintem CS- billegtetni kellene szerintem ez jelzi, hogy 1 művelet véget ért.
Szia. Köszi, hogy ránéztél az adatlapra!
Az adatlapban azt olvastam, hogy ha háromvezetékes módban szeretnénk kommunikálni, elég a CS-t GND-re kötni direktben.
"Active-Low Chip-Select Input. CS selects the active device in systems with more than one device on the serial bus. Drive CS low to clock data in on DIN and to clock data out on DOUT. When CS is high, DOUT is high impedance. Connect CS to GND for 3-wire operation.".
200mS alatt csináltam 100 mérést, ezeket átlagoltam, jók lettek az eredmények így, hogy mindig alacsony volt a CS. Raktam még 32db 1-est a setup részbe, mert volt olyan, hogy 3-4. resetre indult el a konverzió. Így azonnal megy az IC. A hozzászólás módosítva: Szept 3, 2014
|
|
