OK Mégsem
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   45 / 839
(#) nexudes hozzászólása Aug 31, 2014 /
 
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?
  1. //fokozat kijelző gs500E-hez
  2.  
  3. byte FokozatBe = 0;
  4. byte i = 0;
  5. byte Fokozatok[] = {2,3,4,5,6,7,8}; // tömb, fokozat bementek 2-es üres, 8-as a 6.
  6.  
  7. const byte dig2 = 2;
  8. const byte dig3 = 3;
  9. const byte dig4 = 4;
  10. const byte dig5 = 5;
  11. const byte dig6 = 6;
  12. const byte dig7 = 7;
  13. const byte dig8 = 8;
  14. const byte dig9 = 9;
  15. const byte dig10 = 10;
  16. const byte dig11 = 11;
  17. // byte dig12 = 12; 7 segmenst hajtja meg
  18. const byte dig13 = 13;
  19.  
  20. // 7 szegmenses bemenetei összepárosítva
  21. const byte a = A3;
  22. const byte b = A2;
  23. const byte c = A1;
  24. const byte d = A0;
  25. const byte e = 12;
  26. const byte f = A5;
  27. const byte g = A4;
  28.  
  29. // ----------------------------------
  30.  
  31. void FokozatLCD(int n)
  32. {
  33. switch(n)
  34. {
  35. // kiirandó fokozatok
  36. case 0:
  37. digitalWrite(a, HIGH);
  38. digitalWrite(b, HIGH);
  39. digitalWrite(c, HIGH);
  40. digitalWrite(d, HIGH);
  41. digitalWrite(e, HIGH);
  42. digitalWrite(f, HIGH);
  43. digitalWrite(g, LOW);
  44. break;
  45. case 1:
  46. digitalWrite(a, LOW);
  47. digitalWrite(b, HIGH);
  48. digitalWrite(c, HIGH);
  49. digitalWrite(d, LOW);
  50. digitalWrite(e, LOW);
  51. digitalWrite(f, LOW);
  52. digitalWrite(g, LOW);
  53. break;
  54. case 2:
  55. digitalWrite(a, HIGH);
  56. digitalWrite(b, HIGH);
  57. digitalWrite(c, LOW);
  58. digitalWrite(d, HIGH);
  59. digitalWrite(e, HIGH);
  60. digitalWrite(f, LOW);
  61. digitalWrite(g, HIGH);
  62. break;
  63. case 3:
  64. digitalWrite(a, HIGH);
  65. digitalWrite(b, HIGH);
  66. digitalWrite(c, HIGH);
  67. digitalWrite(d, HIGH);
  68. digitalWrite(e, LOW);
  69. digitalWrite(f, LOW);
  70. digitalWrite(g, HIGH);
  71. break;
  72. case 4:
  73. digitalWrite(a, LOW);
  74. digitalWrite(b, HIGH);
  75. digitalWrite(c, HIGH);
  76. digitalWrite(d, LOW);
  77. digitalWrite(e, LOW);
  78. digitalWrite(f, HIGH);
  79. digitalWrite(g, HIGH);
  80. break;
  81. case 5:
  82. digitalWrite(a, HIGH);
  83. digitalWrite(b, LOW);
  84. digitalWrite(c, HIGH);
  85. digitalWrite(d, HIGH);
  86. digitalWrite(e, LOW);
  87. digitalWrite(f, HIGH);
  88. digitalWrite(g, HIGH);
  89. break;
  90. case 6:
  91. digitalWrite(a, HIGH);
  92. digitalWrite(b, LOW);
  93. digitalWrite(c, HIGH);
  94. digitalWrite(d, HIGH);
  95. digitalWrite(e, HIGH);
  96. digitalWrite(f, HIGH);
  97. digitalWrite(g, HIGH);
  98. break;
  99. case 7:
  100. digitalWrite(a, HIGH);
  101. digitalWrite(b, HIGH);
  102. digitalWrite(c, HIGH);
  103. digitalWrite(d, LOW);
  104. digitalWrite(e, LOW);
  105. digitalWrite(f, LOW);
  106. digitalWrite(g, LOW);
  107. break;
  108. case 8:
  109. digitalWrite(a, HIGH);
  110. digitalWrite(b, HIGH);
  111. digitalWrite(c, HIGH);
  112. digitalWrite(d, HIGH);
  113. digitalWrite(e, HIGH);
  114. digitalWrite(f, HIGH);
  115. digitalWrite(g, HIGH);
  116. break;
  117. case 9:
  118. digitalWrite(a, HIGH);
  119. digitalWrite(b, HIGH);
  120. digitalWrite(c, HIGH);
  121. digitalWrite(d, HIGH);
  122. digitalWrite(e, LOW);
  123. digitalWrite(f, HIGH);
  124. digitalWrite(g, HIGH);
  125. break;
  126. case 'ErrorF':
  127. digitalWrite(a, HIGH);
  128. digitalWrite(b, LOW);
  129. digitalWrite(c, LOW);
  130. digitalWrite(d, HIGH);
  131. digitalWrite(e, HIGH);
  132. digitalWrite(f, HIGH);
  133. digitalWrite(g, HIGH);
  134. break;
  135. case 'ErrorX':
  136. digitalWrite(a, LOW);
  137. digitalWrite(b, LOW);
  138. digitalWrite(c, LOW);
  139. digitalWrite(d, LOW);
  140. digitalWrite(e, LOW);
  141. digitalWrite(f, LOW);
  142. digitalWrite(g, LOW);
  143. break;
  144. }
  145. };
  146.  
  147. //------------------------------------------
  148. void setup() {    
  149.  
  150.   Serial.begin(9600);
  151.  
  152. // bejövő jelek a fokazokhoz  
  153.   pinMode(2, INPUT);  
  154.   pinMode(3, INPUT);
  155.   pinMode(4, INPUT);
  156.   pinMode(5, INPUT);
  157.   pinMode(6, INPUT);
  158.   pinMode(7, INPUT);
  159.   pinMode(8, INPUT);
  160. // eddig
  161.  
  162.   pinMode(9, OUTPUT);
  163.  
  164. // 7 szegmenses kihajtáshoz kimenetre állítás  
  165.   pinMode(12, OUTPUT);
  166.   pinMode(A0, OUTPUT);
  167.   pinMode(A1, OUTPUT);
  168.   pinMode(A2, OUTPUT);
  169.   pinMode(A3, OUTPUT);
  170.   pinMode(A4, OUTPUT);
  171.   pinMode(A5, OUTPUT);
  172.  
  173.  
  174. }  
  175. void loop()
  176. {
  177.   i = 0;
  178. /*
  179. // kijelző teszt
  180. for ( i=0; i < 10; i++)  
  181.   {
  182.   FokozatLCD(i);
  183.   delay(500);
  184.   }
  185.  FokozatLCD('ErrorF');
  186.  delay(500);
  187. */
  188.  
  189. // kijező üresre állítás
  190. digitalWrite(a, LOW);
  191. digitalWrite(b, LOW);
  192. digitalWrite(c, LOW);
  193. digitalWrite(d, LOW);
  194. digitalWrite(e, LOW);
  195. digitalWrite(f, LOW);
  196. digitalWrite(g, LOW);
  197.  
  198. // fokozatok kinullázása a tömben
  199. for ( i=0; i < 6; i++)
  200.  {
  201.    Fokozatok[i] = 0;
  202.   }
  203. // fokozatok beolvasása a tömbe
  204. for ( i=0; i < 6; i++)
  205.  {
  206.    Fokozatok[i] = digitalRead(i + 2);
  207.   }
  208. for ( i=0; i < 6; i++)  
  209.    {
  210.      if (Fokozatok[i] == HIGH) // bemenet vizsgálata van e jel, és ha igen, akkor a fokozat kiiratása
  211.    {
  212.   FokozatLCD(i);
  213.   }
  214.  }
  215.  
  216. // delay(1000);
  217. };

fokozat kije...png		    
(#) kapu48 válasza andykaaa hozzászólására (») Aug 31, 2014 /
 
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.
  1. void LcdCharacter(char character, int charx)    // Bővítsük a rutint karakter szélesség átadásával
  2. {
  3.   LcdWrite(LCD_D, 0x00);
  4.   for (int index = 0; index < charx; index++)
  5.   {
  6.     LcdWrite(LCD_D, ASCII[character - 0x20][index]);
  7.   }
  8.   LcdWrite(LCD_D, 0x00);
  9. }
  10. ….
  11. void LcdString(char *characters, int charx)     // Bővítsük a rutint karakter szélesség átadásával
  12. {
  13.  
  14.   while (*characters)
  15.   {
  16.     LcdCharacter(*characters++,  charx);        // Bővítsük a rutint karakter szélesség átadásával
  17.   }
  18. }
  19. ….
  20.  
  21. Aztán a ki írás:
  22. 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!)
(#) holex válasza nexudes hozzászólására (») Aug 31, 2014 /
 
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
  1. for ( i=0; i < 6; i++)
  2.    {
  3.      if (Fokozatok[i] == HIGH) // bemenet vizsgálata van e jel, és ha igen, akkor a fokozat kiiratása
  4.    {
  5.   FokozatLCD(i);
  6.   }
  7.  }



ciklus, akkor mivel több HIGH állapot is lehet, ezért egymásra írja azokat a számokat, amiknél HIGH az állapot.
(#) kapu48 válasza nexudes hozzászólására (») Aug 31, 2014 /
 
Ha itt int-et deklaráltál!
void FokozatLCD(int n)
...
Akkor, hogyan adsz át itt stringet?
FokozatLCD('ErrorF');
(#) holex válasza kapu48 hozzászólására (») Aug 31, 2014 /
 
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.
(#) Kovidivi hozzászólása Aug 31, 2014 /
 
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!

  1. #include <SPI.h>
  2.  
  3. #define chipselect 10
  4. #define drby 9
  5. #define reset 8
  6.  
  7.  
  8. void setup(){
  9.   pinMode(chipselect,OUTPUT);
  10.   pinMode(drby,INPUT);  //alacsony lesz, ha kész a konverzió, ezután magas lesz, ha átment minden adat, és
  11.                         //addig magas marad, amíg a következő konverzió nincs kész.
  12.   pinMode(chipselect,OUTPUT);
  13.   SPI.begin();
  14.   SPI.setBitOrder(MSBFIRST);
  15.   Serial.begin(9600);
  16.   digitalWrite(chipselect,LOW);  //engedélyezve van az IC
  17.   digitalWrite(reset,LOW);
  18.   delay(500);
  19.   digitalWrite(chipselect,HIGH);
  20.   digitalWrite(reset,HIGH);
  21.   delay(100);
  22.   digitalWrite(chipselect,LOW);
  23.   delay(1);
  24.   SPI.transfer(0x20);
  25.   SPI.transfer(0xa5);
  26.   SPI.transfer(0x10);
  27.   SPI.transfer(0x44);
  28.   delay(1);
  29.   digitalWrite(chipselect,HIGH);
  30. }
  31.  
  32. void loop()
  33. {
  34.  
  35.   while(1)
  36.   {
  37.     meres();
  38.     delay(500);
  39.   }
  40. }
  41.  
  42. void meres()
  43. {
  44.  //dataready();
  45.   digitalWrite(chipselect,LOW);
  46.   delay(10);
  47.   SPI.transfer(0x38);  //++++++++++ következő lépés: olvasás a data reg-ből
  48.   char data=SPI.transfer(0x00);
  49.   char data2=SPI.transfer(0x00);
  50.   delay(1);
  51.   digitalWrite(chipselect,HIGH);  //átvitel lezárása (drby láb magas, ha minden bit átment!)
  52.   Serial.print(data,HEX);
  53.   Serial.print("   ");
  54.   Serial.println(data2,HEX);
  55. }
  56.  
  57. void dataready()
  58. {
  59.   while (1)
  60.  {
  61.     Serial.println(" adat nincs kesz");
  62.     delay(1);
  63.     int drby_=digitalRead(drby);  
  64.     if (drby_==0)
  65.     {
  66.       Serial.println("Kesz az adat!");
  67.       delay(1000);
  68.       break;     //++++++++++ // alacsony lesz, ha kész a konverzió
  69.     }
  70.  }
  71. }
(#) Kovidivi válasza holex hozzászólására (») Aug 31, 2014 /
 
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
(#) Kovidivi válasza Kovidivi hozzászólására (») Aug 31, 2014 /
 
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.
  1. byte ezkell= 0x80;  // 10000000 bináris (=DBRY bit 1-es)
  2.       byte DataNotReady=0x00; // 00000000
  3.       int kesz=1;  //kilépés flag
  4.       while(kesz) // wait for end of conversion
  5.         {
  6.           SPI.transfer(0x08);//command for comm reg to read  (dec   8)
  7.         // comm. register olvasása, alap esetben 00000000, de ha kész a konverzió,
  8.         // akkor 10000000
  9.           DataNotReady =SPI.transfer(0x00); // Read comm register
  10.           Serial.print("drby: ");
  11.           Serial.print(DataNotReady,BIN);
  12.           Serial.print(" ezvan<- ->ezkell ");
  13.           Serial.println(ezkell,BIN);
  14.           if (DataNotReady==ezkell) kesz=0;
  15.         }

Amit kapok:
  1. drby: 11111111 ezvan<- ->ezkell 10000000
  2. drby: 0 ezvan<- ->ezkell 10000000
  3. drby: 11111111 ezvan<- ->ezkell 10000000
  4. drby: 0 ezvan<- ->ezkell 10000000
  5. drby: 11111111 ezvan<- ->ezkell 10000000
  6. drby: 0 ezvan<- ->ezkell 10000000
  7. drby: 0 ezvan<- ->ezkell 10000000
  8. drby: 11111111 ezvan<- ->ezkell 10000000
  9. drby: 0 ezvan<- ->ezkell 10000000
  10. drby: 11111111 ezvan<- ->ezkell 10000000
  11. drby: 0 ezvan<- ->ezkell 10000000
  12. drby: 0 ezvan<- ->ezkell 10000000
  13. drby: 0 ezvan<- ->ezkell 10000000
  14. drby: 0 ezvan<- ->ezkell 10000000
  15. drby: 0 ezvan<- ->ezkell 10000000
  16. drby: 0 ezvan<- ->ezkell 10000000
  17. drby: 0 ezvan<- ->ezkell 10000000
  18. drby: 1111111 ezvan<- ->ezkell 10000000
  19. drby: 11111111 ezvan<- ->ezkell 10000000
  20. drby: 0 ezvan<- ->ezkell 10000000
  21. drby: 11111111 ezvan<- ->ezkell 10000000
  22. drby: 0 ezvan<- ->ezkell 10000000
  23. drby: 11111111 ezvan<- ->ezkell 10000000
  24. drby: 0 ezvan<- ->ezkell 10000000
  25. drby: 11111111 ezvan<- ->ezkell 10000000
  26. 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
(#) Kovidivi válasza Kovidivi hozzászólására (») 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.
(#) nexudes válasza kapu48 hozzászólására (») Szept 1, 2014 /
 
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.
(#) nexudes válasza holex hozzászólására (») Szept 1, 2014 /
 
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
(#) nexudes válasza Kovidivi hozzászólására (») Szept 1, 2014 /
 
Köszi ezen az irányon megyek majd tovább.
(#) holex válasza nexudes hozzászólására (») Szept 1, 2014 /
 
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.
(#) andykaaa válasza kapu48 hozzászólására (») Szept 1, 2014 /
 
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 ...
(#) andykaaa válasza kapu48 hozzászólására (») Szept 1, 2014 /
 
Valahogy igy ?
  1. ............
  2. void LcdCharacter(char character, int charx) {
  3.   LcdWrite(LCD_D, 0x00);
  4.   for (int index = 0; index < charx; index++)   {
  5.     LcdWrite(LCD_D, ASCII[character - 0x20][index]);   }
  6.     LcdWrite(LCD_D, 0x00); }
  7.  
  8. void LcdString(char *characters, int charx) {
  9.   while (*characters) {
  10.     LcdCharacter(*characters++, charx);  } }
  11. ..........
  12.   int charx;
  13. gotoXY(4,1);
  14.   LcdString ("TestDisplay", 7)
  15. gotoXY(4,2);
  16.   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
(#) Kovidivi válasza Kovidivi hozzászólására (») Szept 1, 2014 /
 
Egy alap próbálkozást próbáltam tenni.
  1. #define din 12
  2. #define dout 11
  3. #define drdy 5
  4. #define reset 8
  5. #define cs 10
  6. #define sclk 13 //with LED
  7. #define speed 100 //ms-ban a parancsok közti idő
  8. #include "SPI.h"
  9.  
  10. char data=0;
  11.  
  12. void setup()
  13. {
  14.   SPI.begin();
  15.   //SPI.setBitOrder(MSBFIRST);
  16.   /*
  17.   pinMode(dout, INPUT); //bejovo adat
  18.   pinMode(din, OUTPUT); //kimenő adat
  19.   pinMode(sclk, OUTPUT); //órajel
  20.   */
  21.   pinMode(drdy, INPUT); //ha alacsony, akkor kész a konverzió
  22.   pinMode(reset, OUTPUT); //ha magas, akkor engedélyezve van az IC
  23.   pinMode(cs, OUTPUT);  //alacsony, akkor engedélyezve van az IC
  24.   Serial.begin(9600);
  25.   //*****************
  26.   delay(500);
  27.   digitalWrite(cs,HIGH);
  28.   digitalWrite(reset,LOW);
  29.   delay(500);
  30.   digitalWrite(reset,HIGH);
  31.   digitalWrite(cs,LOW);
  32.   delay(100);
  33.   //****************** IC bekapcsolva
  34. }
  35.  
  36. void loop()
  37. {
  38.   digitalWrite(cs,LOW);
  39.   data=SPI.transfer(0x28);
  40.   digitalWrite(cs,HIGH);
  41.   Serial.print(data,BIN); Serial.print(" = ");
  42.   Serial.print(data,HEX); Serial.print("      ");
  43.   digitalWrite(cs,LOW);
  44.   data=SPI.transfer(0x28);  
  45.   digitalWrite(cs,HIGH);
  46.   Serial.print(data,BIN); Serial.print(" = ");
  47.   Serial.println(data,HEX);  
  48.   delay(1000);
  49. }


Amire ezt kapom eredményül:
  1. = 0      0 = 0
  2. 0 = 0      0 = 0
  3. 0 = 0      0 = 0
  4. 101000 = 28      101000 = 28
  5. 11111111111111111111111111111110 = FFFFFFFE      11111111111111111111111111111111 = FFFFFFFF
  6. 0 = 0      0 = 0
  7. 0 = 0      0 = 0
  8. 0 = 0      0 = 0
  9. 0 = 0      0 = 0
  10. 0 = 0      0 = 0
  11. 101000 = 28      101000 = 28
  12. 11111111111111111111111111111111 = FFFFFFFF      11111111111111111111111111111111 = FFFFFFFF
  13. 0 = 0      0 = 0
  14. 0 = 0      0 = 0
  15. 0 = 0      0 = 0
  16. 0 = 0      0 = 0
  17. 101000 = 28      101000 = 28
  18. 101000 = 28      11111111111111111111111111111111 = FFFFFFFF
  19. 11111111111111111111111111111111 = FFFFFFFF      11111111111111111111111111111111 = FFFFFFFF
  20. 0 = 0      0 = 0
  21. 0 = 0      0 = 0
  22. 101000 = 28      101000 = 28
  23. 11111111111111111111111111111111 = FFFFFFFF      11111111111111111111111111111111 = FFFFFFFF
  24. 0 = 0      0 = 0
  25. 0 = 0      0 = 0
  26. 0 = 0      0 = 0
  27. 0 = 0      0 = 0
  28. 101000 = 28      101000 = 28
  29. 101000 = 28      101000 = 28
  30. 11111111111111111111111111111111 = FFFFFFFF      11111111111111111111111111111111 = FFFFFFFF
  31. 0 = 0      0 = 0
  32. 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

01.jpg
02.jpg
03.jpg
04.jpg
     
(#) kapu48 válasza andykaaa hozzászólására (») 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
(#) TavIR-AVR válasza rmis hozzászólására (») Szept 1, 2014 /
 
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.
(#) rmis válasza TavIR-AVR hozzászólására (») Szept 1, 2014 /
 
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.
(#) kapu48 válasza kapu48 hozzászólására (») Szept 1, 2014 /
 
Itt találtam neked hasonló felépítésű karakter táblát készen: font_6x8.h
Ezt be másolod a programodba.

Természetesen, ha másik karaktereket akarsz használni az tudatnod kel a programoddal is!
Az alábbi ASCII tömb átadása helyet:
LcdWrite(LCD_D, ASCII[character - 0x20][index]);

Most font6_8 adod meg
LcdWrite(LCD_D, font6_8 [character - 0x20][index]);
(#) andykaaa válasza kapu48 hozzászólására (») Szept 2, 2014 /
 
Koszonom,
Ez tenyleg jol jon mert nincs ilyesmire mar sem kedvem, sem idom. Koszonom.
(#) Kovidivi hozzászólása Szept 2, 2014 /
 
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.
  1. #define din 12
  2. #define dout 11
  3. #define drdy 5
  4. #define reset 8
  5. #define cs 10
  6. #define sclk 13 //with LED
  7. #include "SPI.h"
  8.  
  9. char data;
  10.  
  11. void setup()
  12. {
  13.   SPI.begin();
  14.   SPI.setBitOrder(MSBFIRST);
  15.   Serial.begin(9600);
  16. }
  17.  
  18. void loop()
  19. {
  20. delay(100);
  21.   SPI.transfer(0x20); //írni akarok a clock regiszterbe 00100000 0x20
  22.    delay(1);
  23.   SPI.transfer(0xA5);  //ezt írom bele: 10100101 0xa5
  24.    delay(1);
  25.   SPI.transfer(0x10);  //írni akarom a setup regisztert. 00010000 0x10
  26.   delay(1);
  27.   SPI.transfer(0x44);  //01000100 0x44
  28.   delay(1);
  29.  
  30.   while(1)
  31.   {
  32.   ///visszaolvasás:
  33.   Serial.println("\nKezdek visszaolvasni.");
  34.   SPI.transfer(0x28);  //olvasni akarom clock reg-t. 00101000 0x28
  35.   delay(1);
  36.   data=SPI.transfer(0);  
  37.   delay(1);
  38.   Serial.print(data,BIN); Serial.print(" bin<- 10100101 a5 ->hex ");Serial.println(data,HEX);
  39.  
  40.   SPI.transfer(0x18);  //olvasni akarom setup reg-t. 00011000 0x18
  41.   delay(1);
  42.   data=SPI.transfer(0);  
  43.   delay(1);
  44.   Serial.print(data,BIN); Serial.print(" bin<- 01000100 44 ->hex ");Serial.println(data,HEX);
  45.   delay(1000);
  46.   }
  47. }

Erre ezt kapom soros monitoron:
  1. Kezdek visszaolvasni.
  2. 11111111111111111111111110100101 bin<- 10100101 a5 ->hex FFFFFFA5
  3. 1000100 bin<- 01000100 44 ->hex 44
  4.  
  5. Kezdek visszaolvasni.
  6. 11111111111111111111111110100101 bin<- 10100101 a5 ->hex FFFFFFA5
  7. 100 bin<- 01000100 44 ->hex 4
  8.  
  9. Kezdek visszaolvasni.
  10. 11111111111111111111111110100101 bin<- 10100101 a5 ->hex FFFFFFA5
  11. 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.
(#) kapu48 válasza andykaaa hozzászólására (») Szept 2, 2014 /
 
É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!)
(#) kapu48 válasza kapu48 hozzászólására (») Szept 2, 2014 /
 
Ú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!:
  1. // font_8x16.h
  2. // big font
  3. unsigned char const font8_16[][16]={
  4.         {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
  5.         {0x00,0x00,0x00,0xFC,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x19,0x18,0x00,0x00,0x00},
  6.         {0x00,0x10,0x0C,0x12,0x0C,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
  7.         {0x00,0x20,0x20,0xF8,0x20,0xF8,0x20,0x00,0x00,0x02,0x1F,0x02,0x1F,0x02,0x02,0x00},
  8.         {0x00,0x70,0x88,0xFC,0x08,0x30,0x00,0x00,0x00,0x0C,0x10,0x7F,0x11,0x0E,0x00,0x00},
  9.         {0x70,0x88,0x70,0x80,0x60,0x18,0x00,0x00,0x00,0x18,0x06,0x01,0x0E,0x11,0x0E,0x00},
  10.         {0x00,0xF0,0x88,0xF0,0x80,0x80,0x00,0x00,0x0F,0x10,0x13,0x14,0x0F,0x10,0x10,0x00},
  11.         {0x10,0x16,0x0E,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
  12.         {0x00,0x00,0x00,0xE0,0x18,0x04,0x02,0x00,0x00,0x00,0x00,0x03,0x0C,0x10,0x20,0x00},
  13.         {0x00,0x02,0x04,0x18,0xE0,0x00,0x00,0x00,0x00,0x20,0x10,0x0C,0x03,0x00,0x00,0x00},
  14.         {0x40,0x40,0x80,0xF0,0x80,0x40,0x40,0x00,0x02,0x02,0x01,0x0F,0x01,0x02,0x02,0x00},
  15.         {0x80,0x80,0x80,0xF0,0x80,0x80,0x80,0x00,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x00},
  16.         {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x40,0x58,0x38,0x00,0x00,0x00,0x00,0x00},
  17.         {0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
  18.         {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x18,0x00,0x00,0x00,0x00,0x00},
  19.         {0x00,0x00,0x00,0x80,0x60,0x1C,0x02,0x00,0x00,0x30,0x0C,0x03,0x00,0x00,0x00,0x00},
  20.         {0x00,0xE0,0x10,0x08,0x08,0x10,0xE0,0x00,0x00,0x07,0x08,0x10,0x10,0x08,0x07,0x00},
  21.         {0x00,0x10,0x10,0xF8,0x00,0x00,0x00,0x00,0x00,0x10,0x10,0x1F,0x10,0x10,0x00,0x00},
  22.         {0x00,0x30,0x08,0x08,0x08,0x88,0x70,0x00,0x00,0x18,0x14,0x12,0x11,0x10,0x18,0x00},
  23.         {0x00,0x30,0x08,0x88,0x88,0x48,0x30,0x00,0x00,0x0C,0x10,0x10,0x10,0x11,0x0E,0x00},
  24.         {0x00,0x80,0x40,0x20,0xF8,0x00,0x00,0x00,0x00,0x03,0x02,0x12,0x1F,0x12,0x12,0x00},
  25.         {0x00,0xF8,0x88,0x48,0x48,0x48,0x88,0x00,0x00,0x0C,0x10,0x10,0x10,0x10,0x0F,0x00},
  26.         {0x00,0xE0,0x10,0x88,0x88,0x98,0x00,0x00,0x00,0x0F,0x11,0x10,0x10,0x10,0x0F,0x00},
  27.         {0x00,0x38,0x08,0x08,0xC8,0x38,0x08,0x00,0x00,0x00,0x00,0x1F,0x00,0x00,0x00,0x00},
  28.         {0x00,0x70,0x88,0x88,0x88,0x88,0x70,0x00,0x00,0x0E,0x11,0x10,0x10,0x11,0x0E,0x00},
  29.         {0x00,0xF0,0x08,0x08,0x08,0x90,0xE0,0x00,0x00,0x00,0x19,0x11,0x11,0x08,0x07,0x00},
  30.         {0x00,0x00,0x00,0xC0,0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x18,0x00,0x00,0x00},
  31.         {0x00,0x00,0x00,0x40,0x00,0x00,0x00,0x00,0x00,0x00,0x40,0x30,0x00,0x00,0x00,0x00},
  32.         {0x00,0x80,0x40,0x20,0x10,0x08,0x04,0x00,0x00,0x00,0x01,0x02,0x04,0x08,0x10,0x00},
  33.         {0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x00,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x00},
  34.         {0x00,0x04,0x08,0x10,0x20,0x40,0x80,0x00,0x00,0x10,0x08,0x04,0x02,0x01,0x00,0x00},
  35.         {0x00,0x38,0x04,0x04,0x04,0x84,0x78,0x00,0x00,0x00,0x00,0x18,0x1B,0x00,0x00,0x00},
  36.         {0xE0,0x10,0xC8,0x28,0xE8,0x10,0xE0,0x00,0x07,0x08,0x17,0x14,0x13,0x14,0x0B,0x00},
  37.         {0x00,0x00,0xE0,0x18,0xE0,0x00,0x00,0x00,0x10,0x1E,0x13,0x02,0x13,0x1E,0x10,0x00},
  38.         {0x08,0xF8,0x88,0x88,0x88,0x48,0x30,0x00,0x10,0x1F,0x10,0x10,0x10,0x11,0x0E,0x00},
  39.         {0xE0,0x10,0x08,0x08,0x08,0x08,0x38,0x00,0x07,0x08,0x10,0x10,0x10,0x08,0x04,0x00},
  40.         {0x08,0xF8,0x08,0x08,0x08,0x10,0xE0,0x00,0x10,0x1F,0x10,0x10,0x10,0x08,0x07,0x00},
  41.         {0x08,0xF8,0x88,0x88,0xE8,0x08,0x10,0x00,0x10,0x1F,0x10,0x10,0x13,0x10,0x08,0x00},
  42.         {0x08,0xF8,0x88,0x88,0xE8,0x08,0x10,0x00,0x10,0x1F,0x10,0x00,0x03,0x00,0x00,0x00},
  43.         {0xE0,0x10,0x08,0x08,0x08,0x38,0x00,0x00,0x07,0x08,0x10,0x10,0x12,0x0E,0x02,0x00},
  44.         {0x08,0xF8,0x88,0x80,0x88,0xF8,0x08,0x00,0x10,0x1F,0x10,0x00,0x10,0x1F,0x10,0x00},
  45.         {0x00,0x08,0x08,0xF8,0x08,0x08,0x00,0x00,0x00,0x10,0x10,0x1F,0x10,0x10,0x00,0x00},
  46.         {0x00,0x00,0x08,0x08,0xF8,0x08,0x08,0x00,0x60,0x40,0x40,0x40,0x3F,0x00,0x00,0x00},
  47.         {0x08,0xF8,0x88,0xC0,0x28,0x18,0x08,0x00,0x10,0x1F,0x10,0x01,0x16,0x18,0x10,0x00},
  48.         {0x08,0xF8,0x08,0x00,0x00,0x00,0x00,0x00,0x10,0x1F,0x10,0x10,0x10,0x10,0x18,0x00},
  49.         {0x08,0xF8,0x78,0x80,0x78,0xF8,0x08,0x00,0x10,0x1F,0x00,0x1F,0x00,0x1F,0x10,0x00},
  50.         {0x08,0xF8,0x38,0xC0,0x08,0xF8,0x08,0x00,0x10,0x1F,0x10,0x01,0x0E,0x1F,0x00,0x00},
  51.         {0xE0,0x10,0x08,0x08,0x08,0x10,0xE0,0x00,0x07,0x08,0x10,0x10,0x10,0x08,0x07,0x00},
  52.         {0x08,0xF8,0x88,0x88,0x88,0x88,0x70,0x00,0x10,0x1F,0x10,0x00,0x00,0x00,0x00,0x00},
  53.         {0xE0,0x10,0x08,0x08,0x08,0x10,0xE0,0x00,0x07,0x08,0x14,0x14,0x18,0x28,0x27,0x00},
  54.         {0x08,0xF8,0x88,0x88,0x88,0x70,0x00,0x00,0x10,0x1F,0x10,0x01,0x06,0x18,0x10,0x00},
  55.         {0x00,0x70,0x88,0x88,0x08,0x08,0x38,0x00,0x00,0x1C,0x10,0x10,0x11,0x11,0x0E,0x00},
  56.         {0x18,0x08,0x08,0xF8,0x08,0x08,0x18,0x00,0x00,0x00,0x10,0x1F,0x10,0x00,0x00,0x00},
  57.         {0x08,0xF8,0x08,0x00,0x08,0xF8,0x08,0x00,0x00,0x0F,0x10,0x10,0x10,0x0F,0x00,0x00},
  58.         {0x08,0x78,0x88,0x00,0x88,0x78,0x08,0x00,0x00,0x00,0x07,0x18,0x07,0x00,0x00,0x00},
  59.         {0x08,0xF8,0x00,0xF8,0x00,0xF8,0x08,0x00,0x00,0x01,0x1F,0x00,0x1F,0x01,0x00,0x00},
  60.         {0x08,0x18,0x68,0x80,0x68,0x18,0x08,0x00,0x10,0x18,0x16,0x01,0x16,0x18,0x10,0x00},
  61.         {0x08,0x38,0xC8,0x00,0xC8,0x38,0x08,0x00,0x00,0x00,0x10,0x1F,0x10,0x00,0x00,0x00},
  62.         {0x00,0x10,0x08,0x08,0xC8,0x38,0x08,0x00,0x00,0x10,0x1C,0x13,0x10,0x10,0x18,0x00},
  63.         {0x00,0x00,0x00,0xFE,0x02,0x02,0x02,0x00,0x00,0x00,0x00,0x3F,0x20,0x20,0x20,0x00},
  64.         {0x00,0x00,0x00,0x80,0x60,0x1C,0x02,0x00,0x00,0x30,0x0C,0x03,0x00,0x00,0x00,0x00},
  65.         {0x00,0x02,0x02,0x02,0xFE,0x00,0x00,0x00,0x00,0x20,0x20,0x20,0x3F,0x00,0x00,0x00},
  66.         {0x00,0x00,0x04,0x02,0x02,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
  67.         {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x00},
  68.         {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x0C,0x18,0x00,0x00},
  69.         {0x00,0x80,0x40,0x40,0x40,0x80,0x00,0x00,0x00,0x0C,0x12,0x11,0x11,0x1F,0x10,0x00},
  70.         {0x08,0xF8,0x80,0x40,0x40,0x40,0x80,0x00,0x00,0x1F,0x10,0x10,0x10,0x10,0x0F,0x00},
  71.         {0x00,0x00,0x80,0x40,0x40,0x40,0x80,0x00,0x00,0x07,0x08,0x10,0x10,0x10,0x08,0x00},
  72.         {0x00,0x80,0x40,0x40,0x40,0x48,0xF8,0x00,0x00,0x0F,0x10,0x10,0x10,0x08,0x1F,0x10},
  73.         {0x00,0x80,0x40,0x40,0x40,0x40,0x80,0x00,0x00,0x0F,0x11,0x11,0x11,0x11,0x09,0x00},
  74.         {0x00,0x40,0x40,0xF0,0x48,0x48,0x18,0x00,0x00,0x10,0x10,0x1F,0x10,0x10,0x00,0x00},
  75.         {0x00,0x80,0x40,0x40,0x40,0xC0,0x40,0x00,0x00,0x35,0x4A,0x4A,0x4A,0x49,0x30,0x00},
  76.         {0x08,0xF8,0x80,0x40,0x40,0x40,0x80,0x00,0x10,0x1F,0x10,0x00,0x00,0x10,0x1F,0x10},
  77.         {0x00,0x40,0x58,0xD8,0x00,0x00,0x00,0x00,0x00,0x10,0x10,0x1F,0x10,0x10,0x00,0x00},
  78.         {0x00,0x00,0x00,0x40,0x58,0xD8,0x00,0x00,0x00,0x60,0x40,0x40,0x40,0x3F,0x00,0x00},
  79.         {0x08,0xF8,0x00,0x00,0xC0,0x40,0x40,0x00,0x10,0x1F,0x12,0x01,0x16,0x18,0x10,0x00},
  80.         {0x00,0x08,0x08,0xF8,0x00,0x00,0x00,0x00,0x00,0x10,0x10,0x1F,0x10,0x10,0x00,0x00},
  81.         {0x40,0xC0,0x40,0xC0,0x40,0x80,0x00,0x00,0x10,0x1F,0x00,0x1F,0x00,0x1F,0x10,0x00},
  82.         {0x40,0xC0,0x80,0x40,0x40,0x40,0x80,0x00,0x10,0x1F,0x10,0x00,0x00,0x10,0x1F,0x10},
  83.         {0x00,0x00,0x80,0x40,0x40,0x80,0x00,0x00,0x00,0x07,0x08,0x10,0x10,0x08,0x07,0x00},
  84.         {0x40,0xC0,0x80,0x40,0x40,0x40,0x80,0x00,0x40,0x7F,0x50,0x10,0x10,0x10,0x0F,0x00},
  85.         {0x00,0x80,0x40,0x40,0x40,0x40,0xC0,0x00,0x00,0x0F,0x10,0x10,0x10,0x48,0x7F,0x40},
  86.         {0x40,0x40,0xC0,0x80,0x40,0x40,0xC0,0x00,0x10,0x10,0x1F,0x10,0x10,0x00,0x00,0x00},
  87.         {0x00,0x80,0x40,0x40,0x40,0xC0,0x00,0x00,0x00,0x19,0x12,0x12,0x12,0x0C,0x00,0x00},
  88.         {0x00,0x40,0x40,0xF0,0x40,0x40,0x00,0x00,0x00,0x00,0x00,0x0F,0x10,0x10,0x00,0x00},
  89.         {0x40,0xC0,0x00,0x00,0x00,0x40,0xC0,0x00,0x00,0x0F,0x10,0x10,0x10,0x08,0x1F,0x10},
  90.         {0x40,0xC0,0x40,0x00,0x00,0x40,0xC0,0x40,0x00,0x00,0x07,0x18,0x04,0x03,0x00,0x00},
  91.         {0x40,0xC0,0x00,0xC0,0x00,0xC0,0x40,0x00,0x00,0x03,0x1C,0x03,0x1C,0x03,0x00,0x00},
  92.         {0x00,0x40,0xC0,0x00,0x40,0xC0,0x40,0x00,0x00,0x10,0x18,0x17,0x07,0x18,0x10,0x00},
  93.         {0x40,0xC0,0x40,0x00,0x00,0x40,0xC0,0x40,0x40,0x40,0x47,0x38,0x0C,0x03,0x00,0x00},
  94.         {0x00,0xC0,0x40,0x40,0x40,0xC0,0x40,0x00,0x00,0x10,0x18,0x16,0x11,0x10,0x18,0x00},
  95.         {0x00,0x00,0x00,0x80,0x7E,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x3F,0x20,0x00,0x00},
  96.         {0x00,0x00,0x00,0xFF,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x7F,0x00,0x00,0x00,0x00},
  97.         {0x00,0x00,0x02,0x7E,0x80,0x00,0x00,0x00,0x00,0x00,0x20,0x3F,0x00,0x00,0x00,0x00},
  98.         {0x00,0x06,0x01,0x01,0x02,0x04,0x04,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}
  99. };


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
(#) Kovidivi válasza Kovidivi hozzászólására (») Szept 3, 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.

  1. #define din 12
  2. #define dout 11
  3. #define drdy 5
  4. #define reset 8 //fixen +3.3V
  5. #define cs 10
  6. #define sclk 13
  7. #define ido 04 //ms-ban a parancsok közti idő
  8. #include "SPI.h"
  9.  
  10. byte data1;
  11. byte data2;
  12. byte data;
  13.  
  14. void setup()
  15. {
  16.   SPI.begin();
  17.   SPI.setBitOrder(MSBFIRST);
  18.   SPI.setDataMode(SPI_MODE0) ;
  19.   SPI.setClockDivider(SPI_CLOCK_DIV128);
  20.   /*
  21.   pinMode(dout, INPUT); //bejovo adat
  22.   pinMode(din, OUTPUT); //kimenő adat
  23.   pinMode(sclk, OUTPUT); //órajel
  24.   */
  25.   pinMode(drdy, INPUT); //ha alacsony, akkor kész a konverzió
  26.   pinMode(reset, OUTPUT); //ha magas, akkor engedélyezve van az IC
  27.   pinMode(cs, OUTPUT);  //alacsony, akkor engedélyezve van az IC
  28.   Serial.begin(9600);
  29.   //*****************
  30.   delay(500);
  31.   digitalWrite(cs,HIGH);
  32.   digitalWrite(reset,LOW);
  33.   delay(500);
  34.   digitalWrite(reset,HIGH);
  35.   digitalWrite(cs,LOW);
  36.   delay(1);
  37.   //****************** IC bekapcsolva
  38.  
  39.   SPI.transfer(0x20);
  40.     delay(ido);
  41.   SPI.transfer(0xa5);  
  42.     delay(ido);
  43.  SPI.transfer(0x10);
  44.  delay(ido);
  45.   SPI.transfer(0B11000101);
  46. delay(ido);
  47. digitalWrite(cs,HIGH);
  48. }
  49.  
  50. void loop()
  51. {
  52.   //while((digitalRead(drdy))==HIGH)  //ezzel ellenőrizhető, ha a konverzió kész!
  53.   //{;}
  54.  
  55.   //Serial.print("drdy alacsony!\n");
  56.   SPI.transfer(0x28);  //olvasni akarom clock reg-t. 00101000 0x28
  57.   delay(10);
  58.   data=SPI.transfer(0B00000000);  
  59.   Serial.print(data,BIN); Serial.print(" bin<- clock reg ->hex ");Serial.println(data,HEX);
  60.   delay(10);
  61.  
  62.   SPI.transfer(0B00001000);  //olvasni akarom comm. reg-t. 00001000 0x08
  63.   delay(10);
  64.   data=SPI.transfer(0x00);  
  65.   Serial.print(data,BIN); Serial.print(" bin<- comm reg ->hex ");Serial.println(data,HEX);
  66.   delay(10);
  67.  
  68.   SPI.transfer(0xFF);SPI.transfer(0xFF); SPI.transfer(0xFF); SPI.transfer(0xFF);
  69.   SPI.transfer(0B00011000);  //olvasni akarom setup reg-t. 00011000 0x18
  70.   //delay(10);
  71.   data=SPI.transfer(0xA1);  
  72.   Serial.print(data,BIN); Serial.print(" bin<- setup reg ->hex ");Serial.println(data,HEX);
  73.   delay(10);
  74.  
  75.   SPI.transfer(0x38);  //olvasni akarom data reg-t. 00111000 0x38
  76.   delay(10);
  77.   data=SPI.transfer(0xFF);  
  78.   Serial.print(data,BIN); Serial.print(" bin<- data1 reg ->hex ");Serial.println(data,HEX);
  79.   delay(10);
  80.   data=SPI.transfer(0x00);  
  81.   Serial.print(data,BIN); Serial.print(" bin<- data2 reg ->hex ");Serial.println(data,HEX);
  82.   delay(10);
  83.   Serial.println("\n\n");
  84.  SPI.transfer(0xFF); SPI.transfer(0xFF); SPI.transfer(0xFF); SPI.transfer(0xFF);
  85.   delay(100);
  86.     digitalWrite(cs,LOW);
  87.   SPI.transfer(0x38);
  88.   data1=SPI.transfer(0);
  89.   data2=SPI.transfer(0);
  90.     delay(10);
  91.       digitalWrite(cs,HIGH);
  92.  
  93.   Serial.print(data1,BIN); Serial.print(" bin<- data1 ->hex ");Serial.println(data1,HEX);
  94.   Serial.print(data2,BIN); Serial.print(" bin<- data2 ->hex ");Serial.println(data2,HEX);
  95.   delay(1000);
  96.  
  97.   //Serial.println("\n\n");
  98.  //SPI.transfer(0xFF); SPI.transfer(0xFF); SPI.transfer(0xFF); SPI.transfer(0xFF);
  99.  //a 32db 1-essel lehet a soros kommunikációt újraindítani, regiszter értékek
  100.  // nem változnak!
  101.  
  102. }
(#) Kovidivi válasza Kovidivi hozzászólására (») Szept 3, 2014 /
 
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á.
(#) Kovidivi válasza Kovidivi hozzászólására (») Szept 3, 2014 /
 
Max1415 Arduino működő kód. Bekötés az előző hozzászólásban.
  1. #define din 12
  2. #define dout 11
  3. #define drdy 5
  4. #define reset 8 //fixen +3.3V
  5. #define cs 10
  6. #define sclk 13
  7. #define ido 04 //ms-ban a parancsok közti idő
  8. #include "SPI.h"
  9.  
  10. byte data1;
  11. byte data2;
  12. byte data;
  13. unsigned int adcValue=0;
  14. float ertek=0;
  15.  
  16. void setup()
  17. {
  18.   SPI.begin();
  19.   SPI.setBitOrder(MSBFIRST);
  20.   SPI.setDataMode(SPI_MODE0) ;
  21.   SPI.setClockDivider(SPI_CLOCK_DIV128);
  22.   pinMode(drdy, INPUT); //ha alacsony, akkor kész a konverzió
  23.   pinMode(reset, OUTPUT); //ha magas, akkor engedélyezve van az IC
  24.   pinMode(cs, OUTPUT);  //alacsony, akkor engedélyezve van az IC
  25.   Serial.begin(9600);
  26.   digitalWrite(cs,LOW);
  27.   delay(1);
  28.   SPI.transfer(0x20);
  29.   delay(ido);
  30.   SPI.transfer(0xa5);  
  31.   delay(ido);
  32.   SPI.transfer(0x10);
  33.   delay(ido);
  34.   SPI.transfer(0x44); //fsync start
  35.   delay(ido*10);
  36.   SPI.transfer(0x45); //fsync stop
  37.   SPI.transfer(0B00111000); //data kiolvas
  38.   data=SPI.transfer(0);  //eldob
  39.   data=SPI.transfer(0);
  40.   digitalWrite(cs,HIGH);
  41. }
  42.  
  43. void loop()
  44. {
  45.   while((digitalRead(drdy))==HIGH)  //ezzel ellenőrizhető, ha a konverzió kész!
  46.      {;}
  47.   digitalWrite(cs,LOW);
  48.   SPI.transfer(0x38);
  49.   data1=SPI.transfer(0);
  50.   data2=SPI.transfer(0);
  51.   delay(10);
  52.   adcValue = data1 << 8;
  53.   adcValue = adcValue | data2;
  54.   ertek=(float(adcValue)*3.607)/65535;
  55.   Serial.print("Adc value: "); Serial.print(adcValue);Serial.print(" feszko: "); Serial.println(ertek,6);
  56.   SPI.transfer(0xFF); SPI.transfer(0xFF); SPI.transfer(0xFF); SPI.transfer(0xFF);
  57.   digitalWrite(cs,HIGH);
  58.   delay(500);  
  59.  
  60. }

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...)
(#) kapu48 válasza Kovidivi hozzászólására (») Szept 3, 2014 /
 
É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.
(#) Kovidivi válasza kapu48 hozzászólására (») Szept 3, 2014 /
 
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
Ezekre szükség lehet! - HESTORE.HU

BIT3193-SO
W5100-M
LIYV-1x0.14-OR-HELU
DN-701200
PLS 3112
Következő: »»   45 / 839
Bejelentkezés

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