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   254 / 863
(#) Daszkalosz válasza kapu48 hozzászólására (») Aug 18, 2016 /
 
Akkor tudsz egy egyszerűbb megoldást a menüre?
(#) kapu48 válasza Daszkalosz hozzászólására (») Aug 18, 2016 1 /
 
Ez a rész jó!

  1. /* @file Idokapcsolo.ino
  2.         || @version 1.0
  3.         || @author kapu48
  4.         || @contact
  5.         ||
  6.         || @description
  7.         || | Demonstrates changing the keypad size and key values.
  8.         || #
  9.         */
  10.  
  11.  #include <LiquidCrystal_I2C.h> //this library is included in the Arduino IDE
  12.  #include <Wire.h>
  13.  #include <Keypad.h>
  14.  #include "RTClib.h"
  15.  
  16.   LiquidCrystal_I2C lcd(0x27, 20, 4);
  17.  
  18.   RTC_DS1307 RTC;
  19.        
  20.   const int REL1 =  7;
  21.   const int REL2 =  8;
  22.   const int REL3 =  9;
  23.   const int REL4 = 10;
  24.  
  25.   int hour;
  26.   int minute;
  27.   int second;
  28.                  
  29.   const byte ROWS = 4; //four rows
  30.   const byte COLS = 1; //four columns
  31.  //define the cymbols on the buttons of the keypads
  32.    char hexaKeys[ROWS] = {'0','1','2','3'};
  33.              
  34.    byte rowPins[ROWS] = {5, 4, 3, 2}; //connect to the row pinouts of the keypad
  35.    byte colPins[1] = {8}; //connect to the column pinouts of the keypad
  36.          
  37.  //initialize an instance of class NewKeypad
  38.    Keypad customKeypad = Keypad( makeKeymap(hexaKeys), rowPins, colPins, ROWS, COLS);
  39.    DateTime now;
  40.        
  41.                       //relays adat structure
  42.   struct relays {
  43.  // bekapcsolás
  44.     uint16_t Rbe_year;
  45.     uint8_t Rbe_mon;
  46.     uint8_t Rbe_day;                        
  47.     uint8_t Rbe_hour;
  48.     uint8_t Rbe_min;
  49.     uint8_t Rbe_sec;
  50.            
  51.  // kikapcsolás
  52.     uint16_t Rki_year;
  53.     uint8_t Rki_mon;
  54.     uint8_t Rki_day;          
  55.     uint8_t Rki_hour;
  56.     uint8_t Rki_min;
  57.     uint8_t Rki_sec;          
  58.   };
  59.          
  60.  // Relay flags
  61.     #define Rbe1  0
  62.     #define Rbe2  1
  63.     #define Rbe3  2
  64.     #define Rbe4  3
  65.  
  66.     relays relaysT[4];                 // Tömböd 4 relének
  67.      
  68.     uint8_t relayF = 0;                // Relék állapotjelző bitek
  69.      
  70.     uint8_t relayNum;
  71.    char customKey;
  72.  
  73.    
  74. /*
  75.  
  76. //Menu variables
  77.   MenuBackend menu = MenuBackend(menuUsed,menuChanged);
  78. //initialize menuitems
  79.   MenuItem menu1Item1 = MenuItem("1. Dugalj 1");
  80.   MenuItem menuItem1SubItem1 = MenuItem("1.1 BE");
  81.   MenuItem menuItem1SubItem2 = MenuItem("1.2 KI");
  82.   MenuItem menu1Item2 = MenuItem("2. Dugalj 2");
  83.   MenuItem menuItem2SubItem1 = MenuItem("2.1 BE");
  84.   MenuItem menuItem2SubItem2 = MenuItem("2.2 KI");
  85.   MenuItem menu1Item3 = MenuItem("3. Dugalj 3");
  86.   MenuItem menuItem3SubItem1 = MenuItem("3.1 BE");
  87.   MenuItem menuItem3SubItem2 = MenuItem("3.2 KI");
  88.   MenuItem menu1Item4 = MenuItem("4. Dugalj 4");
  89.   MenuItem menuItem4SubItem1 = MenuItem("4.1 BE");
  90.   MenuItem menuItem4SubItem2 = MenuItem("4.2 KI");
  91.   MenuItem menu1Item5 = MenuItem(" Vissza ");
  92. */
  93.  
  94. void setup()
  95. {
  96.  
  97.   Serial.begin(9600);
  98.   lcd.begin(20, 4);
  99.   lcd.backlight();
  100.   Wire.begin();
  101.   lcd.clear();
  102.   RTC.begin();
  103.  
  104.   digitalWrite(REL1, HIGH);
  105.   digitalWrite(REL2, HIGH);
  106.   digitalWrite(REL3, HIGH);
  107.   digitalWrite(REL4, HIGH);
  108.                  
  109.   pinMode(REL1, OUTPUT);
  110.   pinMode(REL2, OUTPUT);
  111.   pinMode(REL3, OUTPUT);
  112.   pinMode(REL4, OUTPUT);
  113.  
  114.   if (! RTC.isrunning()) {
  115.      Serial.println("RTC is NOT running!");
  116.   // Beállítja az RTC dáum és idő vázlatát
  117.      RTC.adjust(DateTime(__DATE__, __TIME__));
  118.        }
  119.        
  120.   // Valahol feltöltöd az  relay tömböt
  121.   // bekapcsolás
  122.                      
  123.      relaysT[0].Rbe_hour = 10;
  124.      relaysT[0].Rbe_min = 30;
  125.      relaysT[0].Rbe_sec = 0;
  126.      
  127.      // kikapcsolás
  128.                      
  129.       relaysT[0].Rki_hour = 10;
  130.       relaysT[0].Rki_min = 50;
  131.       relaysT[0].Rki_sec = 0;
  132.            
  133.    // bekapcsolás
  134.                      
  135.       relaysT[1].Rbe_hour = 10;
  136.       relaysT[1].Rbe_min = 30;
  137.       relaysT[1].Rbe_sec = 0;
  138.            
  139.    // kikapcsolás
  140.                      
  141.       relaysT[1].Rki_hour = 10;
  142.       relaysT[1].Rki_min = 50;
  143.       relaysT[1].Rki_sec = 0;
  144.            
  145.    // bekapcsolás
  146.                    
  147.       relaysT[2].Rbe_hour = 10;
  148.       relaysT[2].Rbe_min = 30;
  149.       relaysT[2].Rbe_sec = 0;
  150.            
  151.    // kikapcsolás
  152.                      
  153.       relaysT[2].Rki_hour = 10;
  154.       relaysT[2].Rki_min = 50;
  155.       relaysT[2].Rki_sec = 0;
  156.            
  157.    // bekapcsolás
  158.                    
  159.       relaysT[3].Rbe_hour = 10;
  160.       relaysT[3].Rbe_min = 30;
  161.       relaysT[3].Rbe_sec = 0;
  162.            
  163.    // kikapcsolás
  164.                      
  165.       relaysT[3].Rki_hour = 10;
  166.       relaysT[3].Rki_min = 50;
  167.       relaysT[3].Rki_sec = 0;
  168.    /*        
  169.     // Példa flag használatára
  170.        relayF |= (1 << Rbe1);           // Jelző set
  171.        relayF &= ~(1 << Rbe1);          // Jelző reset
  172.      if(relayF &(~(1 << Rbe1))){};      // flag vizsgálat bekapcsoltra
  173.      if(!(relayF &(~(1 << Rbe1)))){};   // flag vizsgálat kikapcsoltra
  174.      
  175.        relayF |= (1 << Rbe2);           // Jelző set
  176.        relayF &= ~(1 << Rbe2);          // Jelző reset
  177.      if(relayF &(~(1 << Rbe2))){};      // flag vizsgálat bekapcsoltra
  178.      if(!(relayF &(~(1 << Rbe2)))){};   // flag vizsgálat kikapcsoltra
  179.      
  180.        relayF |= (1 << Rbe3);           // Jelző set
  181.        relayF &= ~(1 << Rbe3);          // Jelző reset
  182.      if(relayF &(~(1 << Rbe3))){};      // flag vizsgálat bekapcsoltra
  183.      if(!(relayF &(~(1 << Rbe3)))){};   // flag vizsgálat kikapcsoltra
  184.      
  185.        relayF |= (1 << Rbe4);           // Jelző set
  186.        relayF &= ~(1 << Rbe4);          // Jelző reset
  187.      if(relayF &(~(1 << Rbe4))){};      // flag vizsgálat bekapcsoltra
  188.      if(!(relayF &(~(1 << Rbe4)))){};   // flag vizsgálat kikapcsoltra
  189.      */
  190.      
  191.    
  192.          
  193.  
  194.  
  195.   lcd.setCursor(0,0);
  196.   lcd.print("Idokapcsolo menu");
  197.  
  198.  
  199.  }
  200.  
  201.  
  202.  
  203.  
  204.  
  205.  
  206.  
  207.  
  208.  
  209.  
  210. void loop()
  211. {
  212.     DateTime now = RTC.now();
  213.          
  214.     lcd.setCursor(0, 0);
  215.     lcd.print(now.year(), DEC);
  216.     lcd.print('.');
  217.     lcd.print(now.month(), DEC);
  218.     lcd.print('.');
  219.     lcd.print(now.day(), DEC);
  220.     lcd.print(' ');
  221.     lcd.setCursor(10, 0);
  222.      if (now.hour()<10)
  223.     lcd.print('0');
  224.     lcd.print(now.hour(), DEC);
  225.     lcd.print(':');
  226.      if (now.minute()<10)
  227.     lcd.print('0');
  228.     lcd.print(now.minute(), DEC);
  229.     lcd.print(':');
  230.      if (now.second()<10)
  231.     lcd.print('0');
  232.     lcd.print(now.second(), DEC);
  233.     lcd.setCursor(6, 1);
  234.          
  235.          
  236.          
  237.     for(uint8_t i = 0; i < 4; i++){
  238.            
  239.     // relé bekapcsol
  240.  
  241.     if(!(relayF &(~(1 << i)))){   // Ha flag = 0
  242.      if((relaysT[i].Rbe_hour == now.hour()) && (relaysT[i].Rbe_min == now.minute()) && (relaysT[i].Rbe_sec == now.second())){
  243.          digitalWrite(REL1 + i, HIGH);
  244.          relayF |= (1 << i);   // Jelző set      
  245.         }
  246.        }
  247.      // relé kikapcsol
  248.      
  249.      if(relayF &(~(1 << i))){   // Ha flag = 1
  250.        if((relaysT[i].Rki_hour == now.hour()) && (relaysT[i].Rki_min == now.minute()) &&(relaysT[i].Rki_sec == now.second()) ){
  251.            digitalWrite(REL1 + i, LOW);
  252.            relayF &= ~(1 << i);   // Jelző reset      
  253.           }
  254.          }  
  255.       }  
  256.          
  257.    
  258.    customKey = customKeypad.getKey();
  259.          
  260.    if (customKey){
  261.    Serial.println(customKey);  
  262.      }
  263.      /*
  264.    if (customKey == '0'){
  265.        relayhour_setting();
  266.      } else if (customKey == '1'){
  267.        relayminute_setting();
  268.      } else if (customKey == '2'){
  269.        relaysec_setting();
  270.  
  271.      }else{}
  272.    */  
  273.  
  274.  
  275.  
  276.  
  277. } //loop()...
  278.  
  279.  
  280.  
  281.  
  282.  
  283. //............................................................secBe_settting()................................................    
  284.         void relaysecBe_settting(uint8_t relay)
  285.          {
  286.             char keypressed;
  287.            
  288.            relaysT[relay].Rbe_sec =  now.second();
  289.            
  290.             lcd.setCursor(0,1);
  291.             lcd.print("Set second: ");
  292.             lcd.print(relay);  
  293.             lcd.setCursor(0,2);
  294.             lcd.print("mPerc = ");
  295.             if(relaysT[relay].Rbe_sec < 10) lcd.print(" ");
  296.             lcd.print(relaysT[relay].Rbe_sec);        
  297.         do {                                                    //
  298.             lcd.setCursor(8,1);
  299.             if(relaysT[relay].Rbe_sec < 10) lcd.print(" ");
  300.             lcd.print(relaysT[relay].Rbe_sec);
  301.             delay(100);
  302.             keypressed =customKeypad.getKey();                  //
  303.             if (keypressed=='1')                                //
  304.                 {
  305.                   if(relaysT[relay].Rbe_sec< 60){
  306.                       relaysT[relay].Rbe_sec ++;                        
  307.                    }else{
  308.                       relaysT[relay].Rbe_sec = 0;
  309.                    }
  310.                    
  311.                  }
  312.              if (keypressed=='2')                              //
  313.                 {
  314.                   if(relaysT[relay].Rbe_sec > 0){
  315.                       relaysT[relay].Rbe_sec --;                                
  316.                    }else{
  317.                       relaysT[relay].Rbe_sec = 59;
  318.                    }                              
  319.                  }
  320.                //delay(100);
  321.               } while(keypressed != '3');                      //
  322.           if (! RTC.isrunning()) {
  323.         Serial.println("RTC is NOT running!");
  324.         // Beállítja az RTC dáum és idő vázlatát
  325.         RTC.adjust(DateTime(__DATE__, __TIME__));
  326.        }    
  327.            
  328.       }
  329.      
  330.       //............................................................secKi_settting()................................................    
  331.         void relaysecKi_settting(uint8_t relay)
  332.          {
  333.             char keypressed;
  334.                        
  335.            relaysT[relay].Rki_sec =  now.second();
  336.            
  337.             lcd.setCursor(0,1);
  338.             lcd.print("Set second: ");
  339.             lcd.print(relay);  
  340.             lcd.setCursor(0,2);
  341.             lcd.print("mPerc = ");
  342.             if(relaysT[relay].Rki_sec < 10) lcd.print(" ");
  343.             lcd.print(relaysT[relay].Rki_sec);        
  344.         do {                                                    
  345.             lcd.setCursor(8,1);
  346.             if(relaysT[relay].Rki_sec < 10) lcd.print(" ");
  347.             lcd.print(relaysT[relay].Rki_sec);
  348.             delay(100);
  349.             keypressed =customKeypad.getKey();                   //
  350.             if (keypressed=='1')                                 //
  351.                 {
  352.                   if(relaysT[relay].Rki_sec< 60){
  353.                       relaysT[relay].Rki_sec ++;                    
  354.                    }else{
  355.                       relaysT[relay].Rki_sec = 0;
  356.                    }
  357.                    
  358.                  }
  359.              if (keypressed=='2')                               //
  360.                 {
  361.                   if(relaysT[relay].Rki_sec > 0){
  362.                       relaysT[relay].Rki_sec --;                //
  363.                    }else{
  364.                       relaysT[relay].Rki_sec = 59;
  365.                    }                                          
  366.                  }
  367.                //delay(100);
  368.               } while(keypressed != '3');                       //
  369.           if (! RTC.isrunning()) {
  370.         Serial.println("RTC is NOT running!");
  371.         // Beállítja az RTC dáum és idő vázlatát
  372.         RTC.adjust(DateTime(__DATE__, __TIME__));
  373.        }    
  374.            
  375.       }
  376. //.....................................................hourBe_setting().......................................................    
  377.          void relayhourBe_settting(uint8_t relay)
  378.          {
  379.             char keypressed;
  380.      
  381.             relaysT[relay].Rbe_hour = now.hour();
  382.        
  383.             lcd.setCursor(0,1);
  384.             lcd.print("Set hour:         ");  
  385.             lcd.setCursor(0,2);
  386.             lcd.print("Ora =               ");
  387.             if(relaysT[relay].Rbe_hour< 10) lcd.print(" ");
  388.             lcd.print(relaysT[relay].Rbe_hour);      
  389.          do {                                                      //
  390.                
  391.               lcd.setCursor(6,1);
  392.               if(relaysT[relay].Rbe_hour < 10) lcd.print(" ");
  393.               lcd.print(relaysT[relay].Rbe_hour);
  394.               delay(100);
  395.               keypressed =customKeypad.getKey();                   //
  396.               if (keypressed=='1')                                 //
  397.                 {
  398.                   if(relaysT[relay].Rbe_hour < 24){
  399.                       relaysT[relay].Rbe_hour ++;                                
  400.                    }else{
  401.                       relaysT[relay].Rbe_hour = 0;
  402.                    }
  403.                    
  404.                  }
  405.                 if (keypressed=='2')                              //
  406.                 {
  407.                   if(relaysT[relay].Rbe_hour> 0){
  408.                       relaysT[relay].Rbe_hour --;                 //
  409.                    }else{
  410.                       relaysT[relay].Rbe_hour = 23;
  411.                    }                                
  412.                  }
  413.                //delay(100);
  414.               } while(keypressed != '3');                         //
  415.              
  416.               if (! RTC.isrunning()) {
  417.         Serial.println("RTC is NOT running!");
  418.         // Beállítja az RTC dáum és idő vázlatát
  419.         RTC.adjust(DateTime(__DATE__, __TIME__));
  420.        }
  421.          
  422.            
  423.            
  424.          }  
  425.          //.....................................................hourKi_setting().......................................................    
  426.          void relayhourKi_settting(uint8_t relay)
  427.          {
  428.             char keypressed;
  429.      
  430.             relaysT[relay].Rki_hour = now.hour();
  431.        
  432.             lcd.setCursor(0,1);
  433.             lcd.print("Set hour:         ");  
  434.             lcd.setCursor(0,2);
  435.             lcd.print("Ora =               ");
  436.             if(relaysT[relay].Rki_hour< 10) lcd.print(" ");
  437.             lcd.print(relaysT[relay].Rki_hour);      
  438.          do {                                                      //
  439.                
  440.               lcd.setCursor(6,1);
  441.               if(relaysT[relay].Rki_hour < 10) lcd.print(" ");
  442.               lcd.print(relaysT[relay].Rki_hour);
  443.               delay(100);
  444.               keypressed =customKeypad.getKey();                   //
  445.               if (keypressed=='1')                                 //
  446.                 {
  447.                   if(relaysT[relay].Rki_hour < 24){
  448.                       relaysT[relay].Rki_hour ++;                                
  449.                    }else{
  450.                       relaysT[relay].Rki_hour = 0;
  451.                    }
  452.                    
  453.                  }
  454.                 if (keypressed=='2')                              //
  455.                 {
  456.                   if(relaysT[relay].Rki_hour> 0){
  457.                       relaysT[relay].Rki_hour --;                                
  458.                    }else{
  459.                       relaysT[relay].Rki_hour = 23;
  460.                    }                                
  461.                  }
  462.                //delay(100);
  463.               } while(keypressed != '3');                         //
  464.              
  465.               if (! RTC.isrunning()) {
  466.         Serial.println("RTC is NOT running!");
  467.         // Beállítja az RTC dáum és idő vázlatát
  468.         RTC.adjust(DateTime(__DATE__, __TIME__));
  469.        }
  470.          
  471.            
  472.            
  473.          }
  474.        //...........................................................minuteBe_setting().................................................        
  475.          void relayminuteBe_settting(uint8_t relay)
  476.          {
  477.             char keypressed;
  478.            
  479.             relaysT[relay].Rbe_min = now.minute();
  480.            
  481.             lcd.setCursor(0,1);
  482.             lcd.print("Set Minute:          ");  
  483.             lcd.setCursor(0,2);
  484.             lcd.print("Perc = ");
  485.             if(relaysT[relay].Rbe_min < 10) lcd.print(" ");
  486.             lcd.print(relaysT[relay].Rbe_min);      
  487.          do {                                                      //
  488.                
  489.               lcd.setCursor(7,1);
  490.               if(relaysT[relay].Rbe_min< 10) lcd.print(" ");
  491.               lcd.print(relaysT[relay].Rbe_min);
  492.               delay(100);
  493.               keypressed =customKeypad.getKey();                   //
  494.               if (keypressed=='1')                                 //
  495.                 {
  496.                   if(relaysT[relay].Rbe_min < 60){
  497.                       relaysT[relay].Rbe_min ++;                                 //
  498.                    }else{
  499.                       relaysT[relay].Rbe_min = 0;
  500.                    }
  501.                    
  502.                  }
  503.                 if (keypressed=='2')                               //
  504.                 {
  505.                   if(relaysT[relay].Rbe_min > 0){
  506.                       relaysT[relay].Rbe_min --;                  
  507.                    }else{
  508.                       relaysT[relay].Rbe_min = 59;
  509.                    }                                
  510.                  }
  511.                //delay(100);
  512.               } while(keypressed != '3');                          //
  513.          
  514.           if (! RTC.isrunning()) {
  515.         Serial.println("RTC is NOT running!");
  516.         // Beállítja az RTC dáum és idő vázlatát
  517.         RTC.adjust(DateTime(__DATE__, __TIME__));
  518.        }    
  519.        
  520.          }
  521.          
  522.          //...........................................................minuteKi_setting().................................................
  523. void relayminuteKi_settting(uint8_t relay)
  524.          {
  525.             char keypressed;
  526.      
  527.             relaysT[relay].Rki_hour = now.minute();
  528.        
  529.             lcd.setCursor(0,1);
  530.             lcd.print("Set Minute:         ");  
  531.             lcd.setCursor(0,2);
  532.             lcd.print("Perc =               ");
  533.             if(relaysT[relay].Rki_hour< 10) lcd.print(" ");
  534.             lcd.print(relaysT[relay].Rki_hour);      
  535.          do {                                                      //
  536.                
  537.               lcd.setCursor(6,1);
  538.               if(relaysT[relay].Rki_hour < 10) lcd.print(" ");
  539.               lcd.print(relaysT[relay].Rki_hour);
  540.               delay(100);
  541.               keypressed =customKeypad.getKey();                   //
  542.               if (keypressed=='1')                                 //
  543.                 {
  544.                   if(relaysT[relay].Rki_hour < 60){
  545.                       relaysT[relay].Rki_hour ++;                                
  546.                    }else{
  547.                       relaysT[relay].Rki_hour = 0;
  548.                    }
  549.                    
  550.                  }
  551.                 if (keypressed=='2')                              //
  552.                 {
  553.                   if(relaysT[relay].Rki_hour> 0){
  554.                       relaysT[relay].Rki_hour --;                                
  555.                    }else{
  556.                       relaysT[relay].Rki_hour = 59;
  557.                    }                                
  558.                  }
  559.                //delay(100);
  560.               } while(keypressed != '3');                         //
  561.              
  562.               if (! RTC.isrunning()) {
  563.         Serial.println("RTC is NOT running!");
  564.         // Beállítja az RTC dáum és idő vázlatát
  565.         RTC.adjust(DateTime(__DATE__, __TIME__));
  566.        }
  567.          
  568.            
  569.            
  570.  }

Kivéve az void relayminuteKi_settting(uint8_t relay) rutint!
relaysT[relay].Rki_hour = 59; hour Helyet!!
relaysT[relay].Rki_min = 59; min kellenek
A hozzászólás módosítva: Aug 18, 2016
(#) Daszkalosz válasza kapu48 hozzászólására (») Aug 18, 2016 /
 
Igen, a copy-paste. Azt szerintem elfelejtettem átírni.
Akkor a.jelenlegi menürendszert törlöm
(#) kapu48 válasza Daszkalosz hozzászólására (») Aug 18, 2016 1 /
 
Amit vissza adtam azt javitsad ki!

Ne már mindent én csináljak helyted?

Ot a menü hivás példa, csak átkel keresztelni a neveket és meg irnio a rutinokat!:
  1. customKey = customKeypad.getKey();
  2.              
  3.  
  4.    if (customKey == '0'){
  5.        relayhour_setting();
  6.      } else if (customKey == '1'){
  7.        relayminute_setting();
  8.      } else if (customKey == '2'){
  9.        relaysec_setting();
  10.      }else {
  11.        relaysec_setting();
  12.       }


Gondold át, hogy mit is akarsz csinálni?
És irdle kodban.
A hozzászólás módosítva: Aug 18, 2016
(#) Daszkalosz válasza kapu48 hozzászólására (») Aug 18, 2016 /
 
Köszönöm a türelmed és segítségedet ismét
(#) kapu48 válasza kapu48 hozzászólására (») Aug 18, 2016 1 /
 
Irányadónak csináltam neked!
Igy képzelem:
  1. ....
  2.   customKey = customKeypad.getKey();
  3.  
  4.    if (customKey == '0'){
  5.        menu1();
  6.      } else if (customKey == '1'){
  7.        menu2();
  8.      } else if (customKey == '2'){
  9.        menu3();
  10.      }else  menu4();
  11.      
  12. } //loop()...
  13.  
  14. void menu1(){
  15.  
  16.     lcd.setCursor(0,0);
  17.     lcd.print("1. Dugalj 1");
  18.     lcd.setCursor(0,1);
  19.   do{
  20.     delay(100);
  21.     customKey = customKeypad.getKey();
  22.        
  23.     if (customKey == '1'){      
  24.       lcd.print("1.1 BE");
  25.       relaysecBe_settting(0);
  26.     }  
  27.     if (customKey == '2'){    
  28.       lcd.print("1.2 KI");
  29.       relaysecKi_settting(0);
  30.     }
  31.   } while(customKey != '3');
  32. }
  33. folytasd:
  34.  
  35. void menu2(){
  36.  
  37.  
  38.   lcd.setCursor(0,0);
  39.   lcd.print("2. Dugalj 2");
  40.  
  41.   lcd.setCursor(0,0);
  42.   lcd.print("2.1 BE");
  43.  
  44.   lcd.setCursor(0,0);
  45.   lcd.print ("2.2 KI");
  46. }
  47.  
  48.  void menu3(){
  49.  
  50.   lcd.setCursor(0,0);
  51.   lcd.print("3. Dugalj 3");
  52.  
  53.   lcd.setCursor(0,0);
  54.   lcd.print("3.1 BE");
  55.  
  56.   lcd.setCursor(0,0);
  57.   lcd.print("3.2 KI");
  58.  }
  59.  
  60.  void menu4(){
  61.   lcd.setCursor(0,0);
  62.   lcd.print("4. Dugalj 4");
  63.  
  64.   lcd.setCursor(0,0);
  65.   lcd.print("4.1 BE");
  66.  
  67.   lcd.setCursor(0,0);
  68.   lcd.print("4.2 KI");
  69.  
  70.   lcd.setCursor(0,0);
  71.   lcd.print(" Vissza ");
  72.  }
  73.  ...

Ez lenne az elv!
4 gombból ennyire telt! Ezért kellenek még további almenüket létrehoznod.
A hozzászólás módosítva: Aug 18, 2016
(#) Daszkalosz válasza kapu48 hozzászólására (») Aug 19, 2016 /
 
Köszönöm szépen,folytatom
(#) kapu48 válasza kapu48 hozzászólására (») Aug 19, 2016 /
 
Látom még nem érted mire valók a jelzők!

Láttál már vasútállomáson váltót?
A tetejére van építve 1 jelző tábla, mindig együtt forog a váltóval!!!
Az jelzi, hogy a váltó éppen merre van állítva.

Tehát kezdésnél minden relé ki van kapcsolva, minden jelző 0-án áll.
Mikor a relét bekapcsolod, a hozzá tartozó jelzőt is 1-esre állítod.
Kikapcsoláskor vissza állítod 0-ára.

Így mindig tudod a jelzők állásából, hogyan álnak a reléid.
És ha pl. már bevan kapcsolva? Ne próbálja a programod még 1000 * újra bekapcsolni!

Te ellentétben a setup részben jól meg kavartad a jelzők állását!
Feleslegesen! Így aztán nem is működhetett neked jól a programod!
(#) Daszkalosz válasza kapu48 hozzászólására (») Aug 19, 2016 /
 
Értem. Igyekszem tanulni
(#) morgo hozzászólása Aug 19, 2016 /
 
Sziasztok!
Programon belül van egy várakozási idő, ami "delay (2000);". Hogy a várakozás alatt is figyelje egy nyomógomb állapotát, úgy sejtem, hogy a "millis" használata kéne.
Hogyan kell ezt használni, hogy ne hibát adjon az ellenőrzés? Olvasgatom, a netes leírásokat, de valami fölött valószínűleg elsiklok, mert nem igazán jön össze.
A hozzászólás módosítva: Aug 19, 2016
(#) kapu48 válasza morgo hozzászólására (») Aug 19, 2016 /
 
És, hogyan próbáltad?
Mi a hiba jelzés?
(#) morgo válasza kapu48 hozzászólására (») Aug 19, 2016 /
 
unsigned int time = millis() + 6000; - ez van a kód elején,
if (millis() < time) - ez meg a loopba ahol a delay működik.

Viszont így nem csinál semmit.
(#) kapu48 válasza morgo hozzászólására (») Aug 19, 2016 /
 
  1. unsigned long delayTime;
  2. // Beállítod a várakozás hosszát
  3. delayTime  = millis() + 2000;
  4.  
  5. do{
  6. // itt valamit csinálsz
  7.  
  8.  } while(delayTime  >  millis()); // ismételődik amíg delayTime nagyobb mint millis()
(#) morgo válasza kapu48 hozzászólására (») Aug 19, 2016 /
 
Köszi, megnézem.
(#) Gránátalma hozzászólása Aug 20, 2016 /
 
Sziasztok!
Kezdő kérdés lesz.

Volt egy UNO-m amit remekül tudtam programozni az aktuális legújabb arduino szoftverrel. Viszont ismerősét nem tudtam vele, csak egy régebbivel.
Most vettem egy Mega2560-at, amit már nem tdok programozni a legújabbal, konkrétan látja a COM porton, get board infoval kiolvassa a dolgait, de az uploading erre a hibára áll ki:
  1. Arduino: 1.6.11 (Windows 10), Board: "Arduino/Genuino Uno"
  2.  
  3. Sketch uses 928 bytes (2%) of program storage space. Maximum is 32,256 bytes.
  4. Global variables use 9 bytes (0%) of dynamic memory, leaving 2,039 bytes for local variables. Maximum is 2,048 bytes.
  5. avrdude: stk500_recv(): programmer is not responding
  6. avrdude: stk500_getsync() attempt 1 of 10: not in sync: resp=0x75
  7. avrdude: stk500_getsync() attempt 2 of 10: not in sync: resp=0x00
  8. avrdude: stk500_getsync() attempt 3 of 10: not in sync: resp=0x00
  9. avrdude: stk500_getsync() attempt 4 of 10: not in sync: resp=0x00
  10. avrdude: stk500_getsync() attempt 5 of 10: not in sync: resp=0x00
  11. avrdude: stk500_getsync() attempt 6 of 10: not in sync: resp=0x00
  12. avrdude: stk500_getsync() attempt 7 of 10: not in sync: resp=0x00
  13. avrdude: stk500_getsync() attempt 8 of 10: not in sync: resp=0x00
  14. Problem uploading to board.  See http://www.arduino.cc/en/Guide/Troubleshooting#upload for suggestions.
  15. avrdude: stk500_getsync() attempt 9 of 10: not in sync: resp=0x00
  16. avrdude: stk500_getsync() attempt 10 of 10: not in sync: resp=0x00
  17.  
  18. This report would have more information with
  19. "Show verbose output during compilation"
  20. option enabled in File -> Preferences.


Próbáltam régebbit, azzal is ez a helyzet. Ötletetek esetleg van rá?
(#) Daszkalosz válasza kapu48 hozzászólására (») Aug 20, 2016 /
 
Szia!
Az almenüket,hogy tudom létrehozni?
Eddig megcsináltam

Idokapcsolo_...zip		    
(#) Gránátalma válasza Gránátalma hozzászólására (») Aug 20, 2016 /
 
Megoldódott kábelcserével. A gyárival hol megy, hol nem.

Másik dolog:
A megával tudok új AVR csipre égetni programot kivezetékeléssel?
Azt tudom, hogy a bootloadert rá tudom égetni, de az UNO-m cserélhető IC-s volt, abba beledugtam a bootloaderrel felégetett IC-t és rátoltam a programot.
Ez viszont SMD IC-s.
(#) kapu48 válasza Daszkalosz hozzászólására (») Aug 20, 2016 /
 
Egy férfinek mernie kellene kezdeményeznie!
Új ötlettel előjönni, nem csak a máséra hagyatkozni!

Gondoltam, hogy megcsinálod ezen a sémán a perc és óra hívó rutinkat is!

Mivel a loop-bol azokat kellene hívni, és onnan elágazni az egyes relék felé.
A menükben még nem használod a ’0’-ás gombot, pl. azzal lépkedhetnél tovább a relé tömbök feltöltésénél.
(#) Daszkalosz válasza kapu48 hozzászólására (») Aug 20, 2016 /
 
Férfiként merek kezdeményezni!És nem célozgatni! Hidd el én is tudok!!!
De mivel írtam anno,hogy kezdő vagyok benne,már beláthatnád,hogy nekem ez még nehéz!
Amit most írtál azt sem értem teljesen. Mindegy,valahogy megoldom!
(#) Kovidivi válasza Daszkalosz hozzászólására (») Aug 20, 2016 /
 
Ha valamit nem tudsz, az nem gond, de ha más oldja meg helyetted a problémát, akkor sosem fogod megérteni, hogy mi miért történik, és mindig segítségre fogsz szorulni. Én sem kezdek bele egy routert leprogramozni, mert túl sok információ hiányzik hozzá. Sőt, linux-szal is ezért nem foglalkozok. Az alapokat kellene megértened, a 60napos tanfolyamot kellene lekezdened, és egyszerű programokat kellene először írnod, hogy rájöjj, mi miért van. Nem lehet kihagyni lépéseket, olyan, mint az ABC. Minden betűt ismerned kell, hogy tudj olvasni/írni.
(#) Daszkalosz válasza Kovidivi hozzászólására (») Aug 20, 2016 /
 
Igen tudom. A 60- napos tanfolyamon is részt veszek és külön még van pár könyvem is. egyszerű kapcsolások mennek. Csináltam már keltetővezérlést is. Sikeresen. Azért ugrottam bele ebbe a projektbe,de belátom,hogy korai volt!
(#) (Felhasználó 120038) válasza Daszkalosz hozzászólására (») Aug 20, 2016 /
 
Szia!

Nem tuti megoldás, lehet nem is ezt szeretnéd. Ha almenuket is szeretnél, akkor ehhez hasonlóan is lehet:

  1. void menu1(){                      // Csak a sec van deklarálva a hour és a minut nincs. Az is kellene,de nem tudom hogyan
  2.  
  3.     lcd.setCursor(0,0);
  4.     lcd.print("1. Dugalj 1");
  5.     lcd.setCursor(0,1);
  6.   do{
  7.     delay(100);
  8.     customKey = customKeypad.getKey();
  9.     lcd.setCursor(1,1);
  10.     lcd.print("Almenu: '0'-as gomb");
  11.       if (customKey == '0'){    
  12.      
  13.       menu1Almenuje();
  14.     }    
  15.     if (customKey == '1'){    
  16.       lcd.print("1.1 BE");
  17.       relaysecBe_setting(0);
  18.     }
  19.     if (customKey == '2'){    
  20.       lcd.print("1.2 KI");
  21.       relaysecKi_setting(0);
  22.     }
  23.   } while(customKey != '3');
  24. }
  25.  
  26. //Csak tipp:
  27.  
  28. void menu1Almenuje(){
  29. //Ezt fogod meghíni, mikor a menu1-ben 0-s gombot nyomsz.
  30. //Ez a rutin is addig megy, amíg a felhasználó 3-ast nem nyom.
  31. //Ha ezt megteszi akkor a menu1() kódba ugrik vissza, onnan folytatja majd.
  32. //Persze lehetne sokkal-sokkal komolyabbat is írni, pl innen is ugorjon ki, illetve a menu1ből is, de azt rádbízom (globális változókkal lehet)
  33.   do{
  34.         delay(100);
  35.         customKey = customKeypad.getKey();
  36.        
  37.         if (customKey == '1'){
  38.             //Csináljon valamit.
  39.          }
  40.        if (customKey == '2'){  
  41.            //Csináljon valami mást  
  42.          }
  43.    } while(customKey != '3');
  44. }



A kódrészlet NEM 100%, csak gondolatébresztő.


Nem a tutoriálokkal van szerintem a gond, hanem azzal, hogy a programozás igényel egyfajta gondolkodás módot, azt meg kell szerezni, nem adják ingyen. Hiába írjuk, írják meg helyetted, azzal nem leszel előbbre. Sajnos ez ilyen, meg kell érte szenvedni, de utána minden menni fog, mint a karikacsapás.
A hozzászólás módosítva: Aug 20, 2016
(#) Daszkalosz válasza (Felhasználó 120038) hozzászólására (») Aug 20, 2016 /
 
Igen ezt szerettem volna,hogy van két almenü a "BE" és"KI" És akkor A Menü1 ben folytathatom tovább a hour,és minute beírását?
Igazad van,nem fogom megtanulni,ha megírjátok helyettem,de nem találtam ilyen kapcsolást a neten,amiből tanulhattam volna!
A tanfolyamok ,meg csak alapokat tanítanak.
A gondolatmenet meg van,csak a kivitelezéssel van problémám.
A hozzászólás módosítva: Aug 20, 2016
(#) kapu48 válasza (Felhasználó 120038) hozzászólására (») Aug 20, 2016 /
 
Az igazság, hogy nem szoktam 4 gombos menüvel kínlódni, ilyen bonyolult feladatnál.

Nem éri meg!
Olyan sok elágazást kel bele rakni, hogy végül a felhasználó nem tud rajta eligazodni, és vissza dobja a munkát.

Inkább beleteszem a 4*4-es mátrix billentyűt! Egyszerűbb kezelni, a menü is érthetőbb!
Programozni is könnyebb.

Ha meg nincsen rá +1000Ft.-ja? Akkor eltanácsolom a kínaiakhoz!
(#) (Felhasználó 120038) válasza Daszkalosz hozzászólására (») Aug 20, 2016 /
 
Nem értem a kérdésed. Ha van "Be" és "KI" akkor szeretnél beállítani még valamit? Azaz ha a menu1-ben 1-est nyom, akkor a korábbi kód :

  1. if (customKey == '1'){    
  2.        lcd.print("1.1 BE");
  3.        relaysecBe_setting(0);
  4.  
  5.   }


csak a sec-et állítja be, pontosabban a relé bekapcsolási idejének a másodpercét. Gondolom ez neked nem elég, mert szeretnéd az órát, percet is nem? Ott van az elküldött, gyönyörűen megírt kódban! Csak meg kell hívni őket! Az én belepiszkálásomat el is felejtheted!
  1. if (customKey == '1'){    
  2.        lcd.print("1.1 BE");
  3.        relaysecBe_setting(0);
  4.        delay(5);
  5.        relayminuteBe_setting(0);
  6.        delay(5);
  7.        relayhourBe_setting(0);
  8.   }
  9.  
  10.  if (customKey == '2'){    
  11.  
  12.          lcd.print("1.2 KI");
  13.  
  14.         relaysecKi_setting(0);
  15.         delay(5);
  16.         relayminuteKi_setting(0);
  17.         delay(5);
  18.         relayhourKi_setting(0);
  19.  
  20.     }


A ...._setting(0) ban a zárójelben lévő adat adja meg, hogy melyik relét kapcsolja ki, be. Pontosabban a tömb indexe, már ha jól tévedek. Mindenhol ez kell neked, ha jól gondolom, csak a megfelelő indexxel!
(#) (Felhasználó 120038) válasza kapu48 hozzászólására (») Aug 20, 2016 /
 
Így van! Én is ezért használok kínai 220 ft-os keymatrixot. Most azzal játszok, hogy i2C-vel kötöm össze ezt a mátrixot, ne zabáljon annyi lábat.
(#) Daszkalosz válasza (Felhasználó 120038) hozzászólására (») Aug 20, 2016 /
 
Igen, inkább így lesz a jobb.köszönöm
A hozzászólás módosítva: Aug 20, 2016
(#) kapu48 válasza (Felhasználó 120038) hozzászólására (») Aug 20, 2016 /
 
Esetünkben, állítólag Mega az alaplap?
Annyi lába van, mint a 100 lábúnak!
(#) (Felhasználó 120038) válasza kapu48 hozzászólására (») Aug 20, 2016 /
 
Lehet, de én csak Nanóval operálok! Annak az az előnye, kis káromkodás után (mikor elfogynak a lábak), hogy keres az ember más megoldást, így találtam i2C illesztőt hozzá. Még be is lehet lőni a címét, kis kapcsolókkal!
Persze nem minden bitet, de na....
(#) kapu48 válasza Daszkalosz hozzászólására (») Aug 21, 2016 /
 
Azt vettem észre, hogy nagy butaság volt a részemről ebben a formában segíteni neked!

Hiszen így nem érted az egészet!

Első körben meg írtuk az RTC beállító rutinokat!
Utána kelet volna azok mintájára létrehozni a relé kapcsolások időpont tárolását, és beállítását.
Erre föl mit csinálsz?
Legyalulod a már késznek tűnő RTC rutinokat, és átalakítod, relé tömb feltöltő rutinokká!
Most akkor hogyan fogod az RTC-t beállítani, ha szükséges?

Szóval tényleg le kellene írnod, hogy mit, milyen sorrendben kellene megvalósítani.
(Nem csak mondogatni, hogy már megvan fejben!)

Mert most abszolút nem érted, hogy mit, miért csinálsz éppen!
Ezekre szükség lehet! - HESTORE.HU

DS1307
REL485-2CH-12V
MEGA2560-R3
SN74LS138N
N20-12-35
Következő: »»   254 / 863
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