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   242 / 849
(#) Bakman válasza Tibicsek hozzászólására (») Júl 11, 2016 /
 
Első lépésként megnézed, hogy az 1-es DIP kapcsoló hogyan áll. Ha kell öntözni, akkor az öntözés idejéig kinyitod az 1-es szelepet. Ha lejárt az időzítés, megnézed a 2-es kapcsolót. Ha ott nem kell öntözni, ugrasz a 3-as kapcsoló vizsgálatára, tehát a másodiknál megadott időzítést figyelembe sem kell venni. Ha kell öntözni a hármas pozícióban, akkor a beállított ideig ezt megteszed, majd elzárod a vizet és mész a negyedik kapcsolóhoz stb. Már ha jól értem a kérdést.
(#) Tibicsek válasza Bakman hozzászólására (») Júl 11, 2016 /
 
ez a kód ami működik és ebbe kellene beletenni ezt a dip kapcsolós történetet
  1. #include <LiquidCrystal.h>
  2.  
  3. const int szelep1 = 22;
  4. const int szelep2 = 23;
  5. const int szelep3 = 24;
  6. const int szelep4 = 25;
  7. const int szelep5 = 26;
  8. const int szelep6 = 27;
  9. const int szelep7 = 28;
  10. const int szelep8 = 29;
  11. const int szelep9 = 30;
  12. const int szelep10 = 31;
  13. const int szelep11 = 32;
  14. const int szelep12 = 33;
  15. const int szelep13 = 34;
  16. const int szelep14 = 35;
  17.  
  18. const byte interpin = 2;
  19. const byte interpin2 = 3;
  20.  
  21. unsigned long currentMillis;
  22. unsigned long previousMillis;
  23. unsigned long beintervall;
  24. unsigned long time;
  25. unsigned long elozoido = 0;
  26. unsigned long startmillis;
  27.  
  28. unsigned int jelenlegiido = 0;
  29. unsigned int felfele;
  30.  
  31. volatile unsigned long interval = 300000;
  32.  
  33. int ertek = 15000;
  34. int stat;
  35. int perc;
  36. int masodperc;
  37. int hours;
  38. int mp;
  39. int aperc;
  40. int amasodperc;
  41. int ahours;
  42. int amp;
  43. int buttonstate = 0;
  44. int buttonstate2 = 0;
  45. int lastbuttonstate = LOW;
  46. int lastbuttonstate2 = LOW;
  47.  
  48. long intervall = 120000;
  49. long lastdebounce = 0;
  50. long debouncedelay = 50;
  51.  
  52. byte szamoca[8] = {
  53.   0b00010,
  54.   0b00100,
  55.   0b00100,
  56.   0b11111,
  57.   0b11111,
  58.   0b11111,
  59.   0b01110,
  60.   0b00100
  61. };
  62.  
  63. LiquidCrystal lcd(9,8,7,6,5,4);
  64.  
  65. void setup(){
  66.   lcd.begin(16,2);
  67.   pinMode(szelep1, OUTPUT);
  68.   pinMode(szelep2, OUTPUT);
  69.   pinMode(szelep3, OUTPUT);
  70.   pinMode(szelep4, OUTPUT);
  71.   pinMode(szelep5, OUTPUT);
  72.   pinMode(szelep6, OUTPUT);
  73.   pinMode(szelep7, OUTPUT);
  74.   pinMode(szelep8, OUTPUT);
  75.   pinMode(szelep9, OUTPUT);
  76.   pinMode(szelep10, OUTPUT);
  77.   pinMode(szelep11, OUTPUT);
  78.   pinMode(szelep12, OUTPUT);
  79.   pinMode(szelep13, OUTPUT);
  80.   pinMode(szelep14, OUTPUT);
  81.   pinMode(interpin,INPUT_PULLUP);
  82.   pinMode(interpin2,INPUT_PULLUP);
  83.   attachInterrupt(digitalPinToInterrupt(interpin), minfel, FALLING);
  84.   attachInterrupt(digitalPinToInterrupt(interpin2), minle, FALLING);
  85.   lcd.createChar(0, szamoca);
  86.   lcd.setCursor(1,0);
  87.   lcd.print("Boda & Veszka");
  88.   lcd.setCursor(6,1);
  89.   lcd.write((byte)0);
  90.   delay(5000);
  91.   lcd.clear();
  92. }
  93.  
  94. void loop(){
  95. beintervall = interval;
  96. currentMillis=millis();
  97. if(currentMillis-previousMillis<interval){
  98. time= interval-(currentMillis-previousMillis);
  99. }else{
  100.   stat++;
  101. previousMillis=millis();
  102. }
  103.  
  104. if (stat == 0){
  105.   digitalWrite(szelep1, HIGH);
  106.   digitalWrite(szelep2, LOW);
  107.   digitalWrite(szelep3, LOW);
  108.   digitalWrite(szelep4, LOW);
  109.   digitalWrite(szelep5, LOW);
  110.   digitalWrite(szelep6, LOW);
  111.   digitalWrite(szelep7, LOW);
  112.   digitalWrite(szelep8, LOW);
  113.   digitalWrite(szelep9, LOW);
  114.   digitalWrite(szelep10, LOW);
  115.   digitalWrite(szelep11, LOW);
  116.   digitalWrite(szelep12, LOW);
  117.   digitalWrite(szelep13, LOW);
  118.   digitalWrite(szelep14, LOW);
  119. }
  120. if (stat == 1){
  121.   digitalWrite(szelep1, LOW);
  122.   digitalWrite(szelep2, HIGH);
  123.   digitalWrite(szelep3, LOW);
  124.   digitalWrite(szelep4, LOW);
  125.   digitalWrite(szelep5, LOW);
  126.   digitalWrite(szelep6, LOW);
  127.   digitalWrite(szelep7, LOW);
  128.   digitalWrite(szelep8, LOW);
  129.   digitalWrite(szelep9, LOW);
  130.   digitalWrite(szelep10, LOW);
  131.   digitalWrite(szelep11, LOW);
  132.   digitalWrite(szelep12, LOW);
  133.   digitalWrite(szelep13, LOW);
  134.   digitalWrite(szelep14, LOW);
  135. }
  136. if (stat ==2){
  137.   digitalWrite(szelep1, LOW);
  138.   digitalWrite(szelep2, LOW);
  139.   digitalWrite(szelep3, HIGH);
  140.   digitalWrite(szelep4, LOW);
  141.   digitalWrite(szelep5, LOW);
  142.   digitalWrite(szelep6, LOW);
  143.   digitalWrite(szelep7, LOW);
  144.   digitalWrite(szelep8, LOW);
  145.   digitalWrite(szelep9, LOW);
  146.   digitalWrite(szelep10, LOW);
  147.   digitalWrite(szelep11, LOW);
  148.   digitalWrite(szelep12, LOW);
  149.   digitalWrite(szelep13, LOW);
  150.   digitalWrite(szelep14, LOW);
  151. }
  152. if (stat ==3){
  153.   digitalWrite(szelep1, LOW);
  154.   digitalWrite(szelep2, LOW);
  155.   digitalWrite(szelep3, LOW);
  156.   digitalWrite(szelep4, HIGH);
  157.   digitalWrite(szelep5, LOW);
  158.   digitalWrite(szelep6, LOW);
  159.   digitalWrite(szelep7, LOW);
  160.   digitalWrite(szelep8, LOW);
  161.   digitalWrite(szelep9, LOW);
  162.   digitalWrite(szelep10, LOW);
  163.   digitalWrite(szelep11, LOW);
  164.   digitalWrite(szelep12, LOW);
  165.   digitalWrite(szelep13, LOW);
  166.   digitalWrite(szelep14, LOW);
  167. }
  168. if (stat ==4){
  169.   digitalWrite(szelep1, LOW);
  170.   digitalWrite(szelep2, LOW);
  171.   digitalWrite(szelep3, LOW);
  172.   digitalWrite(szelep4, LOW);
  173.   digitalWrite(szelep5, HIGH);
  174.   digitalWrite(szelep6, LOW);
  175.   digitalWrite(szelep7, LOW);
  176.   digitalWrite(szelep8, LOW);
  177.   digitalWrite(szelep9, LOW);
  178.   digitalWrite(szelep10, LOW);
  179.   digitalWrite(szelep11, LOW);
  180.   digitalWrite(szelep12, LOW);
  181.   digitalWrite(szelep13, LOW);
  182.   digitalWrite(szelep14, LOW);
  183. }
  184. if (stat ==5){
  185.   digitalWrite(szelep1, LOW);
  186.   digitalWrite(szelep2, LOW);
  187.   digitalWrite(szelep3, LOW);
  188.   digitalWrite(szelep4, LOW);
  189.   digitalWrite(szelep5, LOW);
  190.   digitalWrite(szelep6, HIGH);
  191.   digitalWrite(szelep7, LOW);
  192.   digitalWrite(szelep8, LOW);
  193.   digitalWrite(szelep9, LOW);
  194.   digitalWrite(szelep10, LOW);
  195.   digitalWrite(szelep11, LOW);
  196.   digitalWrite(szelep12, LOW);
  197.   digitalWrite(szelep13, LOW);
  198.   digitalWrite(szelep14, LOW);
  199. }
  200. if (stat ==6){
  201.   digitalWrite(szelep1, LOW);
  202.   digitalWrite(szelep2, LOW);
  203.   digitalWrite(szelep3, LOW);
  204.   digitalWrite(szelep4, LOW);
  205.   digitalWrite(szelep5, LOW);
  206.   digitalWrite(szelep6, LOW);
  207.   digitalWrite(szelep7, HIGH);
  208.   digitalWrite(szelep8, LOW);
  209.   digitalWrite(szelep9, LOW);
  210.   digitalWrite(szelep10, LOW);
  211.   digitalWrite(szelep11, LOW);
  212.   digitalWrite(szelep12, LOW);
  213.   digitalWrite(szelep13, LOW);
  214.   digitalWrite(szelep14, LOW);
  215. }
  216. if (stat ==7){
  217.   digitalWrite(szelep1, LOW);
  218.   digitalWrite(szelep2, LOW);
  219.   digitalWrite(szelep3, LOW);
  220.   digitalWrite(szelep4, LOW);
  221.   digitalWrite(szelep5, LOW);
  222.   digitalWrite(szelep6, LOW);
  223.   digitalWrite(szelep7, LOW);
  224.   digitalWrite(szelep8, HIGH);
  225.   digitalWrite(szelep9, LOW);
  226.   digitalWrite(szelep10, LOW);
  227.   digitalWrite(szelep11, LOW);
  228.   digitalWrite(szelep12, LOW);
  229.   digitalWrite(szelep13, LOW);
  230.   digitalWrite(szelep14, LOW);
  231. }
  232. if (stat ==8){
  233.   digitalWrite(szelep1, LOW);
  234.   digitalWrite(szelep2, LOW);
  235.   digitalWrite(szelep3, LOW);
  236.   digitalWrite(szelep4, LOW);
  237.   digitalWrite(szelep5, LOW);
  238.   digitalWrite(szelep6, LOW);
  239.   digitalWrite(szelep7, LOW);
  240.   digitalWrite(szelep8, LOW);
  241.   digitalWrite(szelep9, HIGH);
  242.   digitalWrite(szelep10, LOW);
  243.   digitalWrite(szelep11, LOW);
  244.   digitalWrite(szelep12, LOW);
  245.   digitalWrite(szelep13, LOW);
  246.   digitalWrite(szelep14, LOW);
  247. }
  248. if (stat ==9){
  249.   digitalWrite(szelep1, LOW);
  250.   digitalWrite(szelep2, LOW);
  251.   digitalWrite(szelep3, LOW);
  252.   digitalWrite(szelep4, LOW);
  253.   digitalWrite(szelep5, LOW);
  254.   digitalWrite(szelep6, LOW);
  255.   digitalWrite(szelep7, LOW);
  256.   digitalWrite(szelep8, LOW);
  257.   digitalWrite(szelep9, LOW);
  258.   digitalWrite(szelep10, HIGH);
  259.   digitalWrite(szelep11, LOW);
  260.   digitalWrite(szelep12, LOW);
  261.   digitalWrite(szelep13, LOW);
  262.   digitalWrite(szelep14, LOW);
  263. }
  264. if (stat ==10){
  265.   digitalWrite(szelep1, LOW);
  266.   digitalWrite(szelep2, LOW);
  267.   digitalWrite(szelep3, LOW);
  268.   digitalWrite(szelep4, LOW);
  269.   digitalWrite(szelep5, LOW);
  270.   digitalWrite(szelep6, LOW);
  271.   digitalWrite(szelep7, LOW);
  272.   digitalWrite(szelep8, LOW);
  273.   digitalWrite(szelep9, LOW);
  274.   digitalWrite(szelep10, LOW);
  275.   digitalWrite(szelep11, HIGH);
  276.   digitalWrite(szelep12, LOW);
  277.   digitalWrite(szelep13, LOW);
  278.   digitalWrite(szelep14, LOW);
  279. }
  280. if (stat ==11){
  281.   digitalWrite(szelep1, LOW);
  282.   digitalWrite(szelep2, LOW);
  283.   digitalWrite(szelep3, LOW);
  284.   digitalWrite(szelep4, LOW);
  285.   digitalWrite(szelep5, LOW);
  286.   digitalWrite(szelep6, LOW);
  287.   digitalWrite(szelep7, LOW);
  288.   digitalWrite(szelep8, LOW);
  289.   digitalWrite(szelep9, LOW);
  290.   digitalWrite(szelep10, LOW);
  291.   digitalWrite(szelep11, LOW);
  292.   digitalWrite(szelep12, HIGH);
  293.   digitalWrite(szelep13, LOW);
  294.   digitalWrite(szelep14, LOW);
  295. }
  296. if (stat ==12){
  297.   digitalWrite(szelep1, LOW);
  298.   digitalWrite(szelep2, LOW);
  299.   digitalWrite(szelep3, LOW);
  300.   digitalWrite(szelep4, LOW);
  301.   digitalWrite(szelep5, LOW);
  302.   digitalWrite(szelep6, LOW);
  303.   digitalWrite(szelep7, LOW);
  304.   digitalWrite(szelep8, LOW);
  305.   digitalWrite(szelep9, LOW);
  306.   digitalWrite(szelep10, LOW);
  307.   digitalWrite(szelep11, LOW);
  308.   digitalWrite(szelep12, LOW);
  309.   digitalWrite(szelep13, HIGH);
  310.   digitalWrite(szelep14, LOW);
  311. }
  312. if (stat ==13){
  313.   digitalWrite(szelep1, LOW);
  314.   digitalWrite(szelep2, LOW);
  315.   digitalWrite(szelep3, LOW);
  316.   digitalWrite(szelep4, LOW);
  317.   digitalWrite(szelep5, LOW);
  318.   digitalWrite(szelep6, LOW);
  319.   digitalWrite(szelep7, LOW);
  320.   digitalWrite(szelep8, LOW);
  321.   digitalWrite(szelep9, LOW);
  322.   digitalWrite(szelep10, LOW);
  323.   digitalWrite(szelep11, LOW);
  324.   digitalWrite(szelep12, LOW);
  325.   digitalWrite(szelep13, LOW);
  326.   digitalWrite(szelep14, HIGH);
  327. }
  328. if (stat ==14){
  329.   stat=0;
  330. }
  331.  
  332. mp = time/1000;   // eltelt másodpercek összesen
  333. masodperc = mp%60; // másodperc 0..59
  334. perc = (mp/60)%60;  // perc 0..59
  335. hours = (mp/3600)%24;  // óra 0..23
  336.  
  337. amp = interval/1000;   // eltelt másodpercek összesen
  338. amasodperc = amp%60; // másodperc 0..59
  339. aperc = (amp/60)%60;  // perc 0..59
  340. ahours = (amp/3600)%24;  // óra 0..23
  341.  
  342. lcd.setCursor(0,1);
  343. lcd.print("Akt.:");
  344. lcd.setCursor(6,1);
  345. lcd.print(hours);
  346. lcd.setCursor(7,1);
  347. lcd.print(":");
  348. lcd.setCursor(8,1);
  349. if (perc < 10){lcd.print(' ');}
  350. lcd.print(perc);
  351. lcd.setCursor(10,1);
  352. lcd.print(":");
  353. lcd.setCursor(11,1);
  354. if (masodperc < 10){lcd.print(' ');}
  355. lcd.print(masodperc);
  356.  
  357. lcd.setCursor(0,0);
  358. lcd.print("Beal.:");
  359. lcd.setCursor(7,0);
  360. lcd.print(ahours);
  361. lcd.setCursor(8,0);
  362. lcd.print(":");
  363. lcd.setCursor(9,0);
  364. if(aperc < 10){lcd.print(' ');}
  365. lcd.print(aperc);
  366. lcd.setCursor(11,0);
  367. lcd.print(":");
  368. lcd.setCursor(12,0);
  369. if (amasodperc < 10){lcd.print(' ');}
  370. lcd.print(amasodperc);
  371. }
  372. void minfel(){
  373.   int reading = digitalRead(interpin);
  374.     if (reading != lastbuttonstate) {
  375.     lastdebounce = millis();
  376.   }
  377.  
  378.   if ((millis() - lastdebounce) > debouncedelay) {
  379.     if (reading != buttonstate) {
  380.       buttonstate = reading;
  381.       if (buttonstate == LOW) {
  382.       }
  383.     }
  384.   }
  385.   interval += ertek;
  386.   lastbuttonstate = reading;
  387. }
  388. void minle(){
  389.   int reading2 = digitalRead(interpin2);
  390.     if (reading2 != lastbuttonstate2) {
  391.     lastdebounce = millis();
  392.   }
  393.  
  394.   if ((millis() - lastdebounce) > debouncedelay) {
  395.     if (reading2 != buttonstate2) {
  396.       buttonstate2 = reading2;
  397.       if (buttonstate2 == LOW) {
  398.       }
  399.     }
  400.   }
  401.   interval -= ertek;
  402.   lastbuttonstate2 = reading2;
  403. }
(#) (Felhasználó 120038) válasza Bakman hozzászólására (») Júl 11, 2016 /
 
Megoldható amit szeretnél, nem annyira bonyulult.

Értem. Szóval az a gond a sorbakötéssel, hogy ha kikapcsolod a kört, attól még vár öt percet, mire ráfutna a következőre, addig nem csinálna semmit. Ez ok.

Akkor már csak programozni kell. Amint írtam az is simán megoldható. Az időzítéssél úgy csinálnám, hogy csak akkor várjon öt percet, ha az aktuálisat be kell kapcsolni, különben keresse a többit.

Akkor nem is kell for ciklus, mert ezt a fő loop maga megoldja. Szóval:

Loop-on belül:
Definiálj egy változót, ami i=1 től indul. Ez a változó fog növekedni 14-ig.


ha digitalread(i)==high akkor: 'Ez a kapcsoló digitális lába
kapcsolja be az i+14-lábat, relét
várjon öt percet, ami egy do while ciklusban kell legyen így a fő loop nem megy tovább. (remélem ez Arduino-ban is így lesz)

A fentebbi while után letellik az öt perc, ezért kell egy i=i+1, növeljük azt a lábat, amit kapcsolni kell. A fentebbi ha digitalread(i)==high feltétel megoldja neked, hogy ha a kapcsoló értéke 0, akkor az if-en belüli rész nem fog lefutni, nem is fog várni ÖT percet, mert az a rész átugródik, kihaggya.

Namost a fő loop végére kell még, hogy ha eljut az i==15 ig, akkor i=1, hogy necsak 1x fusson minden.

Így, ha minden ok, akkor tömb sem kell bele. Nincs itthon összerakva Arduino-m, a kódokat inkább ferjből nyomom, ha bemásolod a kódod, könyebb lesz.
(#) Tibicsek válasza (Felhasználó 120038) hozzászólására (») Júl 11, 2016 /
 
Az előző hozzászólásban bemásoltam az egész kódot
A hozzászólás módosítva: Júl 11, 2016
(#) (Felhasználó 120038) válasza Tibicsek hozzászólására (») Júl 11, 2016 /
 
Ok, még valami!

Annyit azért tudnom kellene még, hogy egyszerre csak 1 kör mehet? Mert a fenti példám csak arra jó. Szóval 1 kör 5 perc, pl második kimarad, harmadik bekapcsol 5 percre (rögtön az első lekapcsolása után), utána 4 kör megint öt percre, 5. kimarad, hatodik bekapcsol 5 percre, utána hetedik öt percre és így tovább?
(#) Elektro.on válasza Tibicsek hozzászólására (») Júl 11, 2016 /
 
Uhh de hosszú kód.
Én mindenképpen rövidebb ciklusokba helyezném az egészet.
Agent…Z hozzászólását értelmezd.
Egyébként ha bonyolultabb feladatnak állsz neki, javaslom, hogy elöbb jól köröljárva a fealadatot fogalmazd meg azt és írd le.
Utána készítessz egy folyamat ábrát, és meglepődsz mennyivel egyszerűbb, átláthatóbb és módosíthatóbb kódot tudsz majd írni.
(#) Tibicsek válasza (Felhasználó 120038) hozzászólására (») Júl 11, 2016 /
 
igen! így hirtelen ez elég bonyolult nekem tudom, hogy így is elég szájbarágós a dolog, de nemtudnád esetleg konkrét kód formájában is kifejteni nekem?
A hozzászólás módosítva: Júl 11, 2016
(#) Elektro.on válasza Tibicsek hozzászólására (») Júl 11, 2016 /
 
Annak idelyén Delphiben én is így kezdtem . Eszeme jutott valami, nekiállta és írtam a kódot. Persze a végén már nem tudtam , hogy az elején mi micsoda.
Ja és a kódon belül vizuálisan tagolni, és bőven lehet kommentelni.
A hozzászólás módosítva: Júl 11, 2016
(#) Elektro.on válasza Tibicsek hozzászólására (») Júl 11, 2016 /
 
Nem vagyok egy C guru. Mint írtam inkább Delphi -zek. Meg volt egy kis PHP régebben.
Amúgy én PIC el foglalkozgatok és Paskal-ban. Félek, hogy konkrét kóddal csak félre vezetnélek.
Ha volna 1-2 órám megoldanám, de már biztos nem ma este. Addigra meg rutinos Arduino-sok többet segítenek. Én csak általánosságban írtam, hogy a kód ne egy végtelen hosszú regény legyen. Tagolni kell, ha lehet fügvényekre bontani, és azokat meghívni.
A hozzászólás módosítva: Júl 11, 2016
(#) (Felhasználó 120038) válasza Tibicsek hozzászólására (») Júl 11, 2016 /
 
Dolgozom rajta, de azt látni, hogy SOKKAL rövidebb lesz a kód!

(#) Elektro.on válasza Tibicsek hozzászólására (») Júl 11, 2016 /
 
Egy kicsit Off ezért bocs mindenkitől, de valami hasonló módon kéne. Még ez is messze nem tökéletes.:
Bővebben: Link

De látom Agent_Z már dolgozik rajta!
A hozzászólás módosítva: Júl 11, 2016
(#) (Felhasználó 120038) válasza (Felhasználó 120038) hozzászólására (») Júl 11, 2016 /
 
  1. 94.void loop(){
  2.  
  3.  
  4. 95.beintervall = interval;
  5.  
  6.  
  7.  
  8.  
  9. 96.currentMillis=millis();
  10.  
  11.  
  12.  
  13. //Ez fog növekedni 1 től 14 ig, ezek lesznek a kapcsolók. (Fizikailag is ezeken a lábakon kell lenniük)
  14. stat=1;
  15. //Csak ennyi kell bele, nem kell az a rengeteg sor!
  16. //Ha jól láttam, akkor a stat lépked végig a pin kapcsolólábain.
  17.   if digitalRead(stat) == HIGH
  18.   {
  19.     //Itt kellene megoldanod, hogy 5 percet várjon:
  20.     Start_time= millis(); //Ezt majd definiálod valahol, mármint a start time-ot. Azért raktam bele, mert nem értettem teljesen a tiédet
  21.     delay(5); //Tuti ami fix alapon...
  22.     while currentMillis-Start_time<=300000 //Azaz Öt percig ez fog menni!!!
  23.       {
  24.         digital.write(stat+21,HIGH);//Ez kapcsolja be ha minden igaz az 1-es kapcsolóhoz tartozó relét!!!
  25.         delay 500;
  26.  
  27. //Itt szebb lenne, ha nem kapcsolná mindig be, csak 1x. Azt úgy lehetne, hogy egy változót definiálnál a while elött pl kapcsolhat=1. Így az egész digital.write sort egy if-be kellene tenni.
  28. ha kapcolhat=1 akkor digital.write....
  29. és rögtön utána az if-en belül kapcsolhat=0.
  30. Így csak egyszer kapcsolná be az 5 perc alatt. AAz újabb lábnál meg úgyis felveszi az 1-et.
  31.  
  32.         // Csakhogy így a kijelzésekre NEM FUT RÁ, azt is meg kell hívnod majd innen.
  33.       }
  34.    
  35.     //Ha megvan az öt perc, akkor ki kell kapcsolni!!!!
  36.     digital.write(stat+21,LOW);
  37.     delay(100);
  38.     //Akkor léphetünk a másik kapcsoló lábra:
  39.     stat=stat+1;
  40.    
  41.     //Figyelni kell, hogy ha ez 15, akkor legyen újra 1.
  42.         if stat==15
  43.         {
  44.           stat=1;
  45.         }
  46.        
  47.   }  
  48.  
  49.  
  50.  
  51.  
  52.  //Az a baj, hogy idáig nem is ér el a programod, mert először 5 percig dekkol a while ciklusban.
  53. //Ki kell szervezned mindent, vagy a fenti ciklusom lezáró karakterét a megfelelő helyre kell tenned.
  54. //Ez már a te gondod lesz, mert nem látom át teljesen a kódod.
  55. //Este van, meg sörözök is...
  56.  
  57. Láthatod, hogy kitöröltem eddig mindent!!!
  58. Persze lehet kicsit többet is a kelleténél, de nem is az volt a lényeg.
  59.  
  60. 332.mp = time/1000;   // eltelt másodpercek összesen


Láthatod, hogy rengeteg sort kitöröltem. A kód sajnos nem biztos, inkább csak tájékoztató, gondolatindító.

Sajnos nem láttam át teljesen a programod, ezért csak fejből írtam bele, plusz mint mondtam nincs itthon összerakva arduino. Szerintem érteni fogod, hogy mit is akartam vele kezdeni.
(#) Tibicsek válasza (Felhasználó 120038) hozzászólására (») Júl 11, 2016 /
 
a visszaszámlálás idejét nekem válztoztatnom kell és csak így tudtam megoldani, hogy lefelé számoljon ezt tudjam változtatni az egésznek ez lényege
A hozzászólás módosítva: Júl 11, 2016
(#) (Felhasználó 120038) válasza (Felhasználó 120038) hozzászólására (») Júl 11, 2016 /
 
Igen, csak nem jó teljesen..

A stat=1 sort ki kell venni belőle, mert a fő loop mindig felülírja! Szóval a setup-ban kell neki kezdőértéket adni.
(#) (Felhasználó 120038) válasza Tibicsek hozzászólására (») Júl 11, 2016 /
 
Semmi, gond!

Az úgy ok, csak annyi kell, hogy egy külső függvénybe teszed a kiíratást stb, majd a while ciklusomból hívogatod azokat. Ekkor minden ok lesz, kapcsolis, meg ki is ír mindent.
(#) Tibicsek válasza (Felhasználó 120038) hozzászólására (») Júl 11, 2016 /
 
Én most adom fel az egészet teljesen bekavarodtam Ez a stat változó honnan látja nekem a kapcsolókat?
(#) (Felhasználó 120038) válasza Tibicsek hozzászólására (») Júl 11, 2016 /
 
Ne add fel!

Egyelőre sehol sem. Írtam korábban, hogy ilyenkor az kell, hogy a kapcsolók lábai az 1-14 ig legyenek bekötve az ARDUINO-ba. Ha nem tudod fizikailag bekötni 1 től, hanem pl 2-15-ig, akkor a stat nem 1 től indul, hanem 2-től. Ennek a megoldásnak az a kikötése hogy egyesével növekedve legyen a lábkiosztás fizikailag. Ha össze vissza van (Úgy kötötted), akkor kicsit neccesebb, mert akkor kell tömböket is használni.

A megoldásom minden 5 perc után növeli 1-el az értékét, azaz FIZIKAILAG is úgy kell bekötni, hogy a 2 jelentése a kódban az az ARDUINO 2-es lábát is jelenti.

Ha ez nem megoldható, akkor kell a tömbös megoldás, mert akkor 5 percenként növelem a TÖMB INDEXÉT (ami majd a stat lesz), és az adott indexű elem meg tartalmazza majd a láb számát, amire fizikailag kötve lett.

Minden megoldható, csak akarni kell szerintem.

A lényeg, hogy amit írtam az megszakítja öt percre a loop futását, és addig azt teszi ami benne van.
(#) (Felhasználó 120038) válasza (Felhasználó 120038) hozzászólására (») Júl 11, 2016 /
 
Ezért kérdeztem, hogy mennyi digitális láb van. Ha van 28 minimum akkor ok.

Azért nem kell definiálni sokmindent, csak a setup-ban kell belőni, hogy a kapcsolókhoz kötött arduino lábak, például 1-14 ig mindegyik INPUT!! Sejtésem szerint a kapcsoló 0 állása lehuzza egy ellenálláson keresztül 0V-ra a lábat, 1-es állásban meg felhúzza 5v-ra. (Te raktad össze... )

A kódban meg olvasgatok róla, semmi egyéb.
(#) Tibicsek válasza (Felhasználó 120038) hozzászólására (») Júl 12, 2016 /
 
belső felhúzó ellenállást használok
(#) (Felhasználó 120038) válasza Tibicsek hozzászólására (») Júl 12, 2016 /
 
Akkor ok minden.

Szerintem a setup-ban kell beállítani a dip kapcsolókhoz kötött Arduino lábait, hogy azok inputok legyenek, megfelelő kezdőértékkel.

A többit meg megírtad már, nem lesz ez olyan vészes, mint ahogy elsőnek látszik.
(#) Panhard válasza Tibicsek hozzászólására (») Júl 12, 2016 /
 
Nézd meg ezt: Ez annyit csinál, hogy ahol léptetted a stat változódat az ELSE után, ugye az a rész csak egyszer fut le mindig, ha letelik az idő. Itt vannak vezérelve a kimenetek.
A többi programrészhez nem nyúltam. Elméletben ennek működnie kell.

  1. #include <LiquidCrystal.h>
  2.  
  3. const int szelep[]= {22,23,24,25,26,27,28,29,30,31,32,33,34,35}; //nem kell sorban lenniük
  4. const int dipbemenet[] = {4,5,6,7,8,9,10,11,12,13,14,15,16,17};     //ezeknek sem
  5. bool mindendipNull;
  6.  
  7. const byte interpin = 2;
  8. const byte interpin2 = 3;
  9.  
  10. unsigned long currentMillis;
  11. unsigned long previousMillis;
  12. unsigned long beintervall;
  13. unsigned long time;
  14. unsigned long elozoido = 0;
  15. unsigned long startmillis;
  16.  
  17. unsigned int jelenlegiido = 0;
  18. unsigned int felfele;
  19.  
  20. volatile unsigned long interval = 300000;
  21.  
  22. int ertek = 15000;
  23. int stat;
  24. int perc;
  25. int masodperc;
  26. int hours;
  27. int mp;
  28. int aperc;
  29. int amasodperc;
  30. int ahours;
  31. int amp;
  32. int buttonstate = 0;
  33. int buttonstate2 = 0;
  34. int lastbuttonstate = LOW;
  35. int lastbuttonstate2 = LOW;
  36.  
  37. long intervall = 12000;
  38. long lastdebounce = 0;
  39. long debouncedelay = 50;
  40.  
  41. byte szamoca[8] = {
  42.   0b00010,
  43.   0b00100,
  44.   0b00100,
  45.   0b11111,
  46.   0b11111,
  47.   0b11111,
  48.   0b01110,
  49.   0b00100
  50. };
  51.  
  52. LiquidCrystal lcd(9,8,7,6,5,4);
  53.  
  54. //******************************************************************
  55. void setup(){
  56.   lcd.begin(16,2);
  57.  
  58.   for(int i=0;i<14;i++){pinMode(szelep[i], OUTPUT);}
  59.  
  60.   pinMode(interpin,INPUT_PULLUP);
  61.   pinMode(interpin2,INPUT_PULLUP);
  62.   attachInterrupt(digitalPinToInterrupt(interpin), minfel, FALLING);
  63.   attachInterrupt(digitalPinToInterrupt(interpin2), minle, FALLING);
  64.   lcd.createChar(0, szamoca);
  65.   lcd.setCursor(1,0);
  66.   lcd.print("Boda & Veszka");
  67.   lcd.setCursor(6,1);
  68.   lcd.write((byte)0);
  69.   delay(5000);
  70.   lcd.clear();
  71. }
  72. //******************************************************************  
  73. void loop(){
  74. beintervall = interval;
  75. currentMillis=millis();
  76. if(currentMillis-previousMillis<interval){
  77. time= interval-(currentMillis-previousMillis);
  78. }else{
  79.   previousMillis=millis();
  80.  
  81.   mindendipNull = true; //beállítok egy bool-t, hogy minden kapcsoló 0-ban van.
  82.  
  83.   for(int temp=0;temp<14;temp++){   //utána lekérdezem õket. Ha csak egy is 1-es, akkor törlöm a bool-t, amit korábban beállítottam.
  84.     if(digitalRead(dipbemenet[temp])){mindendipNull = false;} //Ez azért kell, mert késõbb ez a feltétele, hogy a while ciklus lefusson.
  85.     }                                                                                                           //mert ha minden kapcsoló 0, akkor soha nem lép ki a ciklusból. Mert keresi az 1-et.
  86.  
  87.   if(!mindendipNull){    //Itt a while ciklus feltétele.
  88.   while(!digitalRead(dipbemenet[stat])){stat++;} //lekérdezi az aktuális bemenetet addig, amíg 1-est nem talál. 0-nál növeli a stat-ot.
  89.                                            
  90.    for(int a=0;a<14;a++){      //beállítja a kimeneteket.
  91.     if(stat == a){                              //a stat értékének megfelelõ kimenet lesz 1-es, a többi 0.
  92.       for(int b=1;b<15;b++){
  93.         if(b == a+1){digitalWrite(szelep[b],HIGH);}else{digitalWrite(szelep[b],LOW);}
  94.             }
  95.       } } }
  96.        
  97.      
  98.    stat++;              // itt növeli a stat-ot, a következõ ciklusban ezzel az értékkel kezdi a bemenetek vizsgálatát.
  99.    if (stat >=14){stat=0;}
  100.  
  101. }
  102.  
  103.  
  104.  
  105. mp = time/1000;   // eltelt másodpercek összesen
  106. masodperc = mp%60; // másodperc 0..59
  107. perc = (mp/60)%60;  // perc 0..59
  108. hours = (mp/3600)%24;  // óra 0..23
  109.  
  110. amp = interval/1000;   // eltelt másodpercek összesen
  111. amasodperc = amp%60; // másodperc 0..59
  112. aperc = (amp/60)%60;  // perc 0..59
  113. ahours = (amp/3600)%24;  // óra 0..23
  114.  
  115. lcd.setCursor(0,1);
  116. lcd.print("Akt.:");
  117. lcd.setCursor(6,1);
  118. lcd.print(hours);
  119. lcd.setCursor(7,1);
  120. lcd.print(":");
  121. lcd.setCursor(8,1);
  122. if (perc < 10){lcd.print(' ');}
  123. lcd.print(perc);
  124. lcd.setCursor(10,1);
  125. lcd.print(":");
  126. lcd.setCursor(11,1);
  127. if (masodperc < 10){lcd.print(' ');}
  128. lcd.print(masodperc);
  129.  
  130. lcd.setCursor(0,0);
  131. lcd.print("Beal.:");
  132. lcd.setCursor(7,0);
  133. lcd.print(ahours);
  134. lcd.setCursor(8,0);
  135. lcd.print(":");
  136. lcd.setCursor(9,0);
  137. if(aperc < 10){lcd.print(' ');}
  138. lcd.print(aperc);
  139. lcd.setCursor(11,0);
  140. lcd.print(":");
  141. lcd.setCursor(12,0);
  142. if (amasodperc < 10){lcd.print(' ');}
  143. lcd.print(amasodperc);
  144. }
  145. //******************************************************************  
  146. void minfel(){
  147.   int reading = digitalRead(interpin);
  148.     if (reading != lastbuttonstate) {
  149.     lastdebounce = millis();
  150.   }
  151.  
  152.   if ((millis() - lastdebounce) > debouncedelay) {
  153.     if (reading != buttonstate) {
  154.       buttonstate = reading;
  155.       if (buttonstate == LOW) {
  156.       }
  157.     }
  158.   }
  159.   interval += ertek;
  160.   lastbuttonstate = reading;
  161. }
  162. //******************************************************************  
  163. void minle(){
  164.   int reading2 = digitalRead(interpin2);
  165.     if (reading2 != lastbuttonstate2) {
  166.     lastdebounce = millis();
  167.   }
  168.  
  169.   if ((millis() - lastdebounce) > debouncedelay) {
  170.     if (reading2 != buttonstate2) {
  171.       buttonstate2 = reading2;
  172.       if (buttonstate2 == LOW) {
  173.       }
  174.     }
  175.   }
  176.   interval -= ertek;
  177.   lastbuttonstate2 = reading2;
  178. }
(#) (Felhasználó 120038) válasza Panhard hozzászólására (») Júl 12, 2016 /
 
Szia!

Na így kell a tömböket definiálni!

A kódod nem értem teljesen, ezért ha valótlant állítok, akkor elnézést!

1. Nem értem pontosan, hogy a setup-ban miért kell 14*5 másodpercet várni.
2. Ha jól értem a kódot, akkor a loop rögtön egy 5 perces várakozásal kezd, de mit kapcsol be? (Ha kell egyáltalán, mert mi van, ha minden dip 0-n áll?)
3. A while ciklus végetlen lesz, ha minden dip 0. Így sem lesz akkor kijelzés.

Annyi kellene a kódomba, hogy az adott tömb elemét kell betenni a read-ba, és a hozzátartozó relét meg kapcsolni, ami szintén a másik tömbben van. Elég a while előtt bekapcsolni rögtön az if után, így csak egyszer futna le. Letellik az öt perc, keresi a következő, bekapcsolandó lábat.

Nem lenne jobb, ha csak akkor várna, ha kell? A while ciklusban ami az időt nézi, kell egy delay(100), valamint az egész kiíratást egy függvénybe, amit innen hív meg. Plusz persze lehetne egy olyan láb, ami kikapcsol mindent, azt is kellene itt figyelni, akkor nem menne még 5 percet, kiugrasztaná a while-ból, illetve a loop következő feldolgozásánál nem futna bele.

Ez csak a véleményem, legalábbis én így állnék neki.
(#) andykaaa válasza proba hozzászólására (») Júl 12, 2016 /
 
Koszi, megoldottam. Hat azert kellet volna ket if hogy kiszurjem az egyenloseget is.
(#) Panhard válasza (Felhasználó 120038) hozzászólására (») Júl 12, 2016 /
 
1. A setup-ban nincs 14*5 mp várakozás, csaz 5mp. Azt nem én tettem bele, de attól nem lesz rosszabb a program, csak kicsit később indul be. Ha erre gondolsz:
for(int i=0;i<14;i++){pinMode(szelep[i], OUTPUT);}
Ez a ciklus 14-szer fut le, itt állítja be a lábakat kimenetté. Amíg ez fut, innen nem lép ki, tehát nem adódik hozzá az 5000ms késleltetés.
2. Az 5 perces várakozással kezdés az igaz, erre nem figyeltem.
3. Az igaz, hogy a while ciklus végtelen lenne, ha minden dip 0 , de azért van előtte egy for ciklus is, ami megvizsgálja a bemeneteket, és ha mind 0, akkor a while ciklus le sem fut.

Ezt csak hamar éjszakás műszakban csináltam, nem kell véglegesnek venni. Nyilván lehet rajta még szépíteni, de a lényeg, hogy így működne. Ez csak olyan segítő, tájékoztató jellegű dolog.
(#) proba válasza (Felhasználó 120038) hozzászólására (») Júl 12, 2016 /
 
Szerintem lehet olyat is, a kimenetekre soros kapcsoló a jelfogó vezérlése felé, és egy ellenállás ami a kapcsoló utáni logikai állapottal ellentétes állapotba húzza a bemenetet. ( lehetőleg jó nagy, hogy ezen keresztül ne induljon a relé, és a szintet se rontsa el) A lábat bemenetnek programozva , meg lehet állapítani be van e kapcsolva, ha be van, akkor egyértelmű melyik kimenetet kell kapcsolni. Így minden bemenet vizsgálható, ha meg ki van kapcsolva, még szoftverhiba sem kapcsolja be.
A hozzászólás módosítva: Júl 12, 2016
(#) (Felhasználó 120038) válasza Panhard hozzászólására (») Júl 12, 2016 /
 
Szia!

Nem láttam, átnézem jobban!

Hoppá! Tényleg! Nem vettem észre a } karaktert! Bocsánat! Kicsit idegen tőlem ez a nyelv, bele kell rázódnom.

A while-nál sem vágom a {} karakterláncokat. Lehet tényleg jó, nem látom át!

Amúgy elsőre én is hasonlót javasoltam neki, de rájöttem, hogy nincs feltétlenül szüksége rá. A tömbös megoldás sokkal de sokkal jobb lesz neki szerintem, mert akkor kötögetheti a lábakat szabadon.

Éjszakás? Szinte nem is aludtam, bébicsőszködöm, illetve nincs légkondi. Holnaptól lehűlés!
(#) (Felhasználó 120038) válasza proba hozzászólására (») Júl 12, 2016 /
 
Üdv!

Igen. Erre nem gondoltam, megmondom őszintén nem vágom ennyire a dolgod, de igazad lehet.

Felvetettem egy hasonló lehetőséget, de nem gondoltam át rendesen, ezért el is vetettem.
(#) Tibicsek hozzászólása Júl 12, 2016 /
 
Nagyon szépen köszönöm ezt a sok-sok segítséget! lehet, hogy hülyeségek lesznek, de van 1-2 kérdésem ugye van a szelep[] tömb és a dipbemenet[] tömb ennek egyes elemeire hogyan tudok rákérdezni? vagy ilyet nemlehet? ez nekem még annyira nemtiszta, de próbálom megtanulni ezt is Ha esetleg Kecskemét felé jártok szóljatok! Vendégeim vagytok egy sörre!
(#) Daszkalosz hozzászólása Júl 12, 2016 /
 
Sziasztok!
A segítségeteket szeretném kérni!
Kezdőként szerkesztettem egy kódot,ami szépen működött eddig,de most valamiért hibát ír ki!
Sajnos annyira még nem értek hozzá,még kezdő szinten vagyok.
Ezt a hibát írja ki


Arduino: 1.6.4 (Windows 8.1), Board: "Arduino Mega or Mega 2560, ATmega2560 (Mega 2560)"

DS1307_AND_DHT22_LCD.ino: In function 'void loop()':
DS1307_AND_DHT22_LCD:83: error: 'class DateTime' has no member named 'dayOfWeek'
'class DateTime' has no member named 'dayOfWeek'

This report would have more information with
"Show verbose output during compilation"
enabled in File > Preferences.

  1. //Ds1307  RTC és DHT22 szenzor LCD-re kiírva
  2.  
  3. #include <Wire.h>
  4. #include "RTClib.h"      //Óra könyvtár
  5. #include "DHT.h"         //Hőmérséklet és páratartalom könyvtár
  6. #include <LiquidCrystal_I2C.h>
  7. #define DHTPIN 7         //Hőmérséklet szenzor a 7-es pinre kötve
  8. #define DHTTYPE DHT22
  9.  DHT dht(DHTPIN, DHTTYPE);
  10.  int ledPin = 13;
  11.  LiquidCrystal_I2C lcd(0x27, 20, 4);
  12.  RTC_DS1307 RTC;
  13.  byte e1[8] = {B10,B100,B1110,B10001,B11111,B10000,B1110};     // Ez az é betű
  14.  byte o1[8] = {B100,B100,B0,B1110,B10001,B10001,B1110};        // Ez a hosszú ó betű
  15.  byte o2[8] = {B1010,B0,B1110,B10001,B10001,B10001,B1110};     // Ez a rövid ö betű
  16.  byte o3[8] = {B1010,B1010,B0,B1110,B10001,B10001,B1110};      // Ez a hosszú ő betű
  17.  byte a1[8] = {B10,B100,B1110,B1,B1111,B10001,B1111};          // Ez az á betű
  18.  byte u1[8] = {B10,B100,B10001,B10001,B10001,B10011,B1101};    // Ez a hosszú ú betű
  19.  byte u2[8] = {B1010,B0,B0,B10001,B10001,B10011,B1101};        // Ez a rövid ü betű
  20.  byte u3[8] = {B1010,B1010,B0,B10001,B10001,B10011,B1101};     // Ez a hosszú ű betű
  21.  
  22.  
  23.  
  24.  
  25.  
  26. void setup () {
  27.     Serial.begin(9600);
  28.     Wire.begin();
  29.     Serial.println("DHT22");
  30.     dht.begin();
  31.     RTC.begin();
  32.     lcd.begin(20, 4);
  33.     lcd.backlight();
  34.     lcd.createChar(1, e1);       // Ez az é betű
  35.     lcd.createChar(2, o2);       // Ez a rövid ö betű
  36.     lcd.createChar(3, o1);       // Ez a hosszú ó betű
  37.     lcd.createChar(4, o3);       // Ez a hosszú ő betű
  38.     lcd.createChar(8, a1);       // Ez az á betű
  39.     lcd.createChar(5, u1);       // Ez a hosszú ú betű
  40.     lcd.createChar(6, u2);       // Ez a rövid ü betű
  41.     lcd.createChar(7, u3);       // Ez a hosszú ű betű
  42.    
  43.  
  44.    
  45.  
  46.    
  47.    pinMode(8,OUTPUT);
  48.  
  49.   if (! RTC.isrunning()) {
  50.    Serial.println("RTC is NOT running!");
  51.     // Beállítja az RTC dáum és idő vázlatát
  52.    RTC.adjust(DateTime(__DATE__, __TIME__));
  53.     }
  54. }
  55.  
  56. void loop () {
  57.     DateTime now = RTC.now();
  58.     // Év,hónap,nap megjelenítése a kijelzőn
  59.    
  60.     lcd.setCursor(0, 0);
  61.     lcd.print(now.year(), DEC);
  62.     lcd.print('.');
  63.     lcd.print(now.month(), DEC);
  64.     lcd.print('.');
  65.     lcd.print(now.day(), DEC);
  66.     lcd.print(' ');
  67.     lcd.setCursor(10, 0);
  68.      if (now.hour()<10)
  69.     lcd.print('0');
  70.     lcd.print(now.hour(), DEC);
  71.     lcd.print(':');
  72.      if (now.minute()<10)
  73.     lcd.print('0');
  74.     lcd.print(now.minute(), DEC);
  75.     lcd.print(':');
  76.     if (now.second()<10)
  77.     lcd.print('0');
  78.     lcd.print(now.second(), DEC);
  79.     lcd.setCursor(6, 1);
  80.      
  81.  
  82.     int dayofweek = now.dayOfWeek();
  83.     switch(dayofweek){
  84.      case 1:
  85.      lcd.print("Hetfo");
  86.      lcd.setCursor(7, 1);
  87.      lcd.write(1);
  88.      lcd.setCursor(10, 1);
  89.      lcd.write(4);
  90.      break;
  91.      case 2:
  92.      lcd.print("Kedd");
  93.      break;
  94.      case 3:
  95.      lcd.print("Szerda");
  96.      break;
  97.      case 4:
  98.      lcd.print("Csutortok");
  99.      lcd.setCursor(8, 1);
  100.      lcd.write(6);
  101.      lcd.setCursor(10, 1);
  102.      lcd.write(2);
  103.      lcd.setCursor(13, 1);
  104.      lcd.write(2);
  105.      break;
  106.      case 5:
  107.      lcd.print("Pentek");
  108.      lcd.setCursor(7, 1);
  109.      lcd.write(1);
  110.      break;
  111.      case 6:
  112.      lcd.print("Szombat");
  113.      break;
  114.      case 0:
  115.      lcd.print("Vasarnap");
  116.      lcd.setCursor(9, 1);
  117.      lcd.write(0);
  118.      break;
  119.     delay(1000);
  120.     }
  121.     {
  122.  
  123. // DHT22 szenzor paraméterei megjelenítése LCD kijelző
  124.  
  125.  
  126.   float h = dht.readHumidity();
  127.  
  128.   float t = dht.readTemperature();
  129.  
  130. // set the cursor to (0,0):
  131.   lcd.setCursor(0, 2);
  132. // print from 0 to 9:
  133.   lcd.setCursor(0, 2);
  134.   lcd.print("Homerseklet: ");
  135.   lcd.setCursor(1, 2);         //Kurzor 3. sor 2. karakternél
  136.   lcd.write(4);                //Átírjuk az o betüt ő-re
  137.   lcd.setCursor(3, 2);         //Kurzor 3. sor 4-es karakternél
  138.   lcd.write(1);                //Átírjuk az e betüt é-re
  139.   lcd.setCursor(6, 2);         //Kurzor 3. sor 7-es karakternél
  140.   lcd.write(1);                //Átírjuk az e betüt é-re
  141.   lcd.setCursor(13, 2);        //Kurzor 3. sor 14-es karakternél
  142.   lcd.print(t);                //Hőmérséklet érték kiírása
  143.   lcd.print((char)223);        //Fokjel előhívása memoriából
  144.   lcd.print("C");
  145.  
  146.  
  147. // set the cursor to (16,1):
  148.   lcd.setCursor(0, 3);
  149.   lcd.print("Paratartalom: ");
  150.   lcd.setCursor(1, 3);
  151.   lcd.write(8);                 //Átírjuk az a betüt á-re
  152.   lcd.setCursor(14, 3);         // A páratartalom kijelzés a 14.sortól kezdődik
  153.   lcd.print(h);
  154.   lcd.print("%");
  155.   delay(200);
  156.  
  157. }
  158.  
  159. }


Nagyon köszönöm a segítséget
(#) (Felhasználó 120038) válasza Daszkalosz hozzászólására (») Júl 12, 2016 /
 
Cseréltél oprendszert a legutóbbi jó futás óta?
Következő: »»   242 / 849
Bejelentkezés

Belépés

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