INFO: Dieses Forum nutzt Cookies...
Cookies sind für den Betrieb des Forums unverzichtbar. Mit der Nutzung des Forums erklärst Du dich damit einverstanden, dass wir Cookies verwenden.

Es wird in jedem Fall ein Cookie gesetzt um diesen Hinweis nicht mehr zu erhalten. Desweiteren setzen wir Google Adsense und Google Analytics ein.

Antwort schreiben 
 
Themabewertung:
  • 0 Bewertungen - 0 im Durchschnitt
  • 1
  • 2
  • 3
  • 4
  • 5
Grundprogramm Arduino
19.03.2015, 16:47 (Dieser Beitrag wurde zuletzt bearbeitet: 19.03.2015 17:44 von Home38.)
Beitrag #9
Verarbeitungsschleife LOOP
Code:
void loop() {

  /****************************************************************************
  Wenn die Eingabe erfolgt ist, dann Eingabezeile und alles andere löschen !
  ***************************************************************************​**/
  DeleteInString() ;

  /* Schleife zur Eingabe des Zeichens / Abfrage der Pins */
  do
  {

      // *** Abfragen, ob etwas über UDP-Angekommen ist !

      UDP_packetSize = Udp.parsePacket();
      UDP_recvIP = Udp.remoteIP() ;              // IP des Senders
      
      if(UDP_packetSize)              // *** Entspricht den empfangenen Zeichen !
        {
          
          // Löschen des Puffers ! Wichtig !!!
          for(int i=0;i<UDP_TX_PACKET_MAX_SIZE;i++) { UDP_packetBuffer[i] = 0; }

/*     ------------------------------------ (1) ------------------------------------ */

UDP-Päckchen verarbeiten

/*     ------------------------------------ (1) ------------------------------------ */

        
          Udp.read(UDP_packetBuffer,UDP_TX_PACKET_MAX_SIZE);
          DebugPrint("UDP RECV:"+String(UDP_packetSize)+" from " + GetStringIPFrom_IPAddress(UDP_recvIP),"1");
          DebugPrint("UDP RECV:"+String(UDP_packetBuffer),"1") ;
    
/*     ------------------------------------ (2) ------------------------------------ */

Hier wird der Inhalt des Päckchens verarbeitet !

/*     ------------------------------------ (2) ------------------------------------ */

      
          JumpToStartActionCode(String(UDP_packetBuffer),"UDP") ;
          
        }
        
    
      /* Am Ende wird ermittelt, ob eine Taste gedrückt wurde */
      
      PressCounter_Old = PressCounter ;
    
      /****************************************************************************
      Hier werden die einzelnen Pins auslesen
      ***************************************************************************​**/
  
      // **********************************              
      // *** OHNE Relais-Taster
      // **********************************
      DebugValue=digitalRead(pin_Debug);          
      if (DebugValue == 0 )
        {
          DebugText = "Pin_Debug = " + String(pin_Debug) + " " + String(DebugValue) ;
          
          DebugValue2 = digitalRead(pin_Debug) ;
          
          while(DebugValue2 == 0)
            {
            delay(prellDelay) ;
            DebugValue2 = digitalRead(pin_Debug) ;
            } ;
          
          DebugPrint(DebugText,"0") ;
          
          DebugPress++;
          BlinkLed(DebugLed,stdLedDelay1,stdLedDelay2,1) ;
          PressCounter++;
          
        }

      // **********************************              
      // *** OHNE Relais-Taster
      // **********************************
      FunctionValue=digitalRead(pin_Function);          
      if (FunctionValue == 0 )
        {
          FunctionText = "Pin_Function = " + String(pin_Function) + " " + String(FunctionValue) ;
          
          FunctionValue2 = digitalRead(pin_Function) ;
          
          while(FunctionValue2 == 0)
            {
            delay(prellDelay) ;
            FunctionValue2 = digitalRead(pin_Function) ;
            } ;
          
          DebugPrint(FunctionText,"0") ;
          
          FunctionPress++;
          BlinkLed(FunctionLed,stdLedDelay1,stdLedDelay2,1) ;
          PressCounter++;
          
        }

      // **********************************              
      // *** OHNE Relais-Taster
      // **********************************
      ModusValue=digitalRead(pin_Modus);          
      if (ModusValue == 0 )
        {
          DebugText = "Pin_Modus = " + String(pin_Modus) + " " + String(ModusValue) ;
          
          ModusValue2 = digitalRead(pin_Modus) ;
          
          /* TIP - Nachfolgend : while(digitalRead(pin_Modus))  
              hat den gleichen Effekt, nur mit dem Unterschied, daß die Tasten-Eingabe langsam
              mitläuft und den Zähler langsam weiterzählt, kann auch sinnvoll sein .
              Testen mit höherem prellDelay !!
              Jedenfalls mit >  while(ModusValue2 == 0)  < muss man die Taste wieder
              loslassen, damit das Programm weiterläuft.
          */
          while(ModusValue2 == 0)
            {
            delay(prellDelay) ;
            ModusValue2 = digitalRead(pin_Modus) ;
            } ;
          
          DebugPrint(DebugText,"0") ;
          
          ModusPress++;
          BlinkLed(ModusLed,stdLedDelay1,stdLedDelay2,1) ;
          PressCounter++;
          
      }

Das mit dem Entprellen muss man ein bischen tunen und ausprobieren. Ich habe etliche Tage gesessen und auch nachgelesen, wieder probiert und nachgelesen.

Ich habe es so hinbekommen, daß bei Dauerdrücken der Taste nur ein Tastendruck registriert wird.

Ein Tip an alle, die gerade erst anfangen (so wie ich). An bestimmte Sachen
muss man sich langsam herantasten. Wenn man so wie ich am Anfang zuviel will,
wenn man weiß was gehen könnte, kann man sich sehr leicht verzetteln.

Das ganze Timing und Handling im Zusammenhang mit einem Microcontroller kann man mit einem normalen PC bzw. PC-Programm nicht vergleichen.

Code:
// **********************************              
      // *** Eingabetaster abfragen !
      // **********************************
      InputValue=digitalRead(pin_Input);
      if (InputValue == 0)
        {
          
          DebugText = "Pin_Input = " + String(pin_Input) + " " + String(InputValue) ;

          InputValue2 = digitalRead(pin_Input) ;
          
          while(InputValue2 == 0)
          {
            delay(prellDelay) ;
            InputValue2 = digitalRead(pin_Input) ;
          }  ;

          DebugPrint(DebugText,"0") ;
          
          InputPress++;
          PressCounter++;
          
          // Wenn Input nur einmal gedrückt wurde , müssen Modus und Debug-Press gelöscht werden, falls
          // die Tasten bereits vorher gedrückt wurden
          if (InputPress == 1)
            {
              SetOnLed(InputLed) ;      // Anzeigen, daß sich das Programm im Eingabemodus befindet !
              ResetPress("MODUS") ;
              ResetPress("DEBUG") ;
              ResetPress("FUNCTION") ;
            }
          
          //
          //
          //
          if (InputPress == 2)
            {
              
            // Auswerten, was eigegeben wurde !
            if (ModusPress > 0)
              {
              Modus = ModusPress ;                                          // Modus abspeichern !
              BlinkLed(ModusLed,stdLedDelay1,stdLedDelay2,ModusPress) ;
              ResetPress("*ALL") ;                                          // Alle Tasten wieder zurüchsetzen !
              PrintCurrentConfig(0) ;  
              }
          
            if (DebugPress > 0)
              {
              Debug = DebugPress ;
              BlinkLed(DebugLed,stdLedDelay1,stdLedDelay2,DebugPress) ;
              ResetPress("*ALL") ;
              PrintCurrentConfig(0) ;
              }          

            if (FunctionPress > 0)
              {
              Function = FunctionPress ;
              BlinkLed(FunctionLed,stdLedDelay1,stdLedDelay2,FunctionPress) ;
              ResetPress("*ALL") ;
              PrintCurrentConfig(0) ;
              }          

            SetOffLed(InputLed) ;

            // *************************************************************************
            // *** Hier werden die Aktionen für FUNCTION ausgeführt, Input abgeschlossen
            // *************************************************************************
            
            if (Function > 0) {
            
              StartActionCode("FUNCTION",Function,"BOARD_F") ;              

              Function = 0 ;
            
              // Debug über Funktion ein und ausschalten !
            
              }
  
            if (Debug > 1) {
              
              // Sonderfall, bei Debug = 1 wird nur mitprotokolliert !              
              StartActionCode("DEBUG",Function,"BOARD_D") ;              
            
              Function = 0 ;
              
              }          
                              
            }
          
            
                      
          }
          
          //
          //
          //
          if (InputPress > 2)
            {
            ResetPress("*ALL") ;
            PrintCurrentConfig(0) ;
            }

// **********************************              
      // *** Eingabetaster abfragen !
      // **********************************
      InputValue=digitalRead(pin_Input);
      if (InputValue == 0)
        {
          
          DebugText = "Pin_Input = " + String(pin_Input) + " " + String(InputValue) ;

          InputValue2 = digitalRead(pin_Input) ;
          
          while(InputValue2 == 0)
          {
            delay(prellDelay) ;
            InputValue2 = digitalRead(pin_Input) ;
          }  ;

          DebugPrint(DebugText,"0") ;
          
          InputPress++;
          PressCounter++;
          
          // Wenn Input nur einmal gedrückt wurde , müssen Modus und Debug-Press gelöscht werden, falls
          // die Tasten bereits vorher gedrückt wurden
          if (InputPress == 1)
            {
              SetOnLed(InputLed) ;      // Anzeigen, daß sich das Programm im Eingabemodus befindet !
              ResetPress("MODUS") ;
              ResetPress("DEBUG") ;
              ResetPress("FUNCTION") ;
            }
          
          //
          //
          //
          if (InputPress == 2)
            {
              
            // Auswerten, was eigegeben wurde !
            if (ModusPress > 0)
              {
              Modus = ModusPress ;                                          // Modus abspeichern !
              BlinkLed(ModusLed,stdLedDelay1,stdLedDelay2,ModusPress) ;
              ResetPress("*ALL") ;                                          // Alle Tasten wieder zurüchsetzen !
              PrintCurrentConfig(0) ;  
              }
          
            if (DebugPress > 0)
              {
              Debug = DebugPress ;
              BlinkLed(DebugLed,stdLedDelay1,stdLedDelay2,DebugPress) ;
              ResetPress("*ALL") ;
              PrintCurrentConfig(0) ;
              }          

            if (FunctionPress > 0)
              {
              Function = FunctionPress ;
              BlinkLed(FunctionLed,stdLedDelay1,stdLedDelay2,FunctionPress) ;
              ResetPress("*ALL") ;
              PrintCurrentConfig(0) ;
              }          

            SetOffLed(InputLed) ;

            // *************************************************************************
            // *** Hier werden die Aktionen für FUNCTION ausgeführt, Input abgeschlossen
            // *************************************************************************
            
            if (Function > 0) {
            
              [color=#FF0000]StartActionCode("FUNCTION",Function,"BOARD_F") ;[/color]              

              Function = 0 ;
            
              // Debug über Funktion ein und ausschalten !
            
              }
  
            if (Debug > 1) {
              
              // Sonderfall, bei Debug = 1 wird nur mitprotokolliert !              
              StartActionCode("DEBUG",Function,"BOARD_D") ;              
            
              Function = 0 ;
              
              }          
                              
            }
          
            
                      
          }
          
          //
          //
          //
          if (InputPress > 2)
            {
            ResetPress("*ALL") ;
            PrintCurrentConfig(0) ;
            }

In diesem Teil wird die I-Taste geprüft.

Wenn man die I-Taste das erste mal drückt, wird die Input-Led geschaltet, damit man sehen kann, daß sich das Board im Eingabemodus befindet.

Danach drückt man die anderen Tasten sooft, wie man möchte, um beim Beispiel zu bleiben Funktion. Man drückt jetzt Funktion einmal.

Drückt man jetzt wieder die I-Taste, wird in Functio der Wert 1 gespeichert.

Interessant wird es erst, wenn (rot markiert) die Funktion ausgeführt werden soll !

Code:
// **********************************              
      // *** Taster1 !
      // **********************************
      Switch1Value=digitalRead(pin_Switch1);
      if (Switch1Value == 0)
        {
          DebugText = "Pin_Switch1 = " + String(pin_Switch1) + " " + String(Switch1Value) ;

          Switch1Value2 = digitalRead(pin_Switch1) ;
          
          while(Switch1Value2 == 0)
            {
            delay(prellDelay) ;
            Switch1Value2 = digitalRead(pin_Switch1) ;
            }  ;
            
          DebugPrint(DebugText,"0") ;
          
          Switch1Press++;
          BlinkLed(Switch1Led,stdLedDelay1,stdLedDelay2,1) ;
          PressCounter++;
          
          // Zurücksetzen
          
          if (InputPress == 1 && DebugPress == 1 && Switch1Press == 1 && ModusPress == 1)
            {
              JumpToStartActionCode("!SWITCH99","BOARD_S1") ;
            }
          
          ResetPress("*ALL") ;                                          // Alle Tasten wieder zurüchsetzen !
          PrintCurrentConfig(0) ;  
          
          // Je nach dem Was für ein Modus eingestellt wurde, erfolgen jetzt die Aktionen !
          BlinkLed(ModusLed,stdLedDelay1,stdLedDelay2,Modus) ;          // Anzeigen des Modus
          
          JumpToStartActionCode("!SWITCH01","BOARD_S2") ;
          
          DebugText = "Modus = " + String(Modus) + " Switch1 ...PRESSED..." ;
          DebugPrint(DebugText,"1") ;
            
        }

      // **********************************              
      // *** Taster2 !
      // **********************************
      Switch2Value=digitalRead(pin_Switch2);
      if (Switch2Value == 0)
        {
          DebugText = "Pin_Switch2 = " + String(pin_Switch2) + " " + String(Switch2Value) ;

          Switch2Value2 = digitalRead(pin_Switch2) ;
          
          while(Switch2Value2 == 0)
            {
            delay(prellDelay) ;
            Switch2Value2 = digitalRead(pin_Switch2) ;
            }  ;
            
          DebugPrint(DebugText,"0") ;
          
          Switch2Press++;
          BlinkLed(Switch2Led,stdLedDelay1,stdLedDelay2,1) ;
          PressCounter++;
          
          // Zurücksetzen
          
          if (InputPress == 1 && DebugPress == 1 && ModusPress == 1 && Switch2Press == 1)
            {
              JumpToStartActionCode("!SWITCH99","BOARD_S2") ;
            }
          
          ResetPress("*ALL") ;                                          // Alle Tasten wieder zurüchsetzen !
          PrintCurrentConfig(0) ;  
          
          // Je nach dem Was für ein Modus eingestellt wurde, erfolgen jetzt die Aktionen !
          // Je nach dem Was für ein Modus eingestellt wurde, erfolgen jetzt die Aktionen !
          BlinkLed(ModusLed,stdLedDelay1,stdLedDelay2,Modus) ;          // Anzeigen des Modus
          
          [color=#FF4500]JumpToStartActionCode("!SWITCH02","BOARD_S2") ;[/color]
          
          DebugText = "Modus = " + String(Modus) + " Switch2 ...PRESSED..." ;
          DebugPrint(DebugText,"1") ;
            
        }

In diesem Abschnitt werden die beiden Taster S1 und S2 abgefragt.

Die Zeile in Rot ist hier auch wichtig.

Ups, das mit dem ROT klappt nicht, da muss ich noch mal nachbessern !

Code:
/****************************************************************************
      Serielle Schnittstelle auslesen , wird durch externen Puffer/UART befüllt
      ***************************************************************************​**/
    
      inReadChar = Serial.read();      /* Hinweis Wenn nichts gelesen wurde, ist inReadChar = -1 */
      
      /* Wenn ein Zeichen gelesen werden konnte , dann String befüllen             */
      if (inReadChar > -1)
        {
          
        ++inTermCount;                                                        
      // if (Debug == 1 ) { Serial.print("Termcount= ");Serial.print(inTermCount) ; Serial.println(" ") ; }  
          
        inString[inCount] = inReadChar ;                                          /* Es wurde etwas gelesen , String befüllen                                   */

      
      
        /* *** Endekennzeichen erkannt !                      */
        if (inReadChar == INTERMINATOR) {
          DebugPrint("INTERMINATOR erkannt !","1") ;
          inTerminated = INTERMINATOR ;
          hString1 = String(inString);                        // String übernehmen
          DeleteInString ;                                   // Alles löschen
          }
          else {
            
            /* normales Zeichen oder Eingabepuffer bei '#' löschen ??    */
            if (inReadChar != CHARDELETE) {
              inString[inCount] = inReadChar ;
              ++inCount;
              
              // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
              // !!! Nur für Extra-Debugging !!!
              // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
              
              //  DebugText = "Zeichen gelesen : " + String(inReadChar) ;
              //  DebugPrint(DebugText,"1") ;
              //  PrintInString() ;
                        
              
              }
              else {
                DebugPrint("xxxxxxxxx inString gelöscht !","1") ;
                DeleteInString() ;
                
                // PrintInString() ;
                
                }
              
            
          }          
        
        
        
        }
        
      if (inTerminated == INTERMINATOR) {
        
        hString1 = String(inString) ;
        
        /* DEBUG-Modus einschalten , wenn Zeichenkette !DEBUG1! erkannt wird    */
        
          /* WICHTIG !!!! \r = CR auch mit abfragen , das wird so von der seriellen Schnittstelle gelesen !     */
          DebugText = "SERIAL INPUT: >" + hString1 + "<" ;
          DebugPrint(DebugText ,"1") ;
          
          // Eingabe über Seriell
          JumpToStartActionCode(hString1,"SERIAL") ;
          
          hString1 = "" ;
        
        }
  
      if (PressCounter != PressCounter_Old) { PrintPressCounter() ; }
            
  } while (inTermCount <= INLENGTH & inTerminated != INTERMINATOR);  /* Beenden, wenn Trennzeichen kommt oder Anzahl Zeichen zu groß ! */
  
// An diese Position kommt der Arduino nur, wenn eine falsche Eingabe erzeugt wurde

if (inTermCount > INLENGTH) { DebugText = "Eingabeläge überschritten " ; }
if (inTerminated == INTERMINATOR) { DebugText = "Endekennzeichen gefunden !" ; }

DebugPrint(DebugText,"1") ;

}

Hier wird die serielle Schnittstelle abgefragt und wenn mehr als INLENGTH Zeichen da sind oder das Zeichen CHARDELETE erscheint, kann man wieder etwas eingeben.

Erkennt das Programm das Zeilenende mit INTERMINATOR, wird die gesamte Teile an den "echten" Steuerungsteil übergeben.

JumpToStartActionCode(hString1,"SERIAL") ;

Die Funktionen, die ich hier nicht aufgeführt habe, erklären sich (hoffe ich) schon auf Grund Ihres Namens.

Jetzt komme ich zu den beiden Kernfunktionen des Programms.

1.JumpStartToActionCode

Hier wird der erhaltene String (Seriell/UDP) aufgespalten und für das "richtige" Programm vorbereitet.

Code:
void JumpToStartActionCode(String pActionString, String pSource) {

  /* WICHTIG SERIELL !!!! \r = CR auch mit abfragen , das wird so von der seriellen Schnittstelle gelesen !     */
  String pActionCode ;
  int pActionValue ;
  String hActionValue ;
  
  if (pActionString.substring(1,9) == "FUNCTION") {
        pActionCode = "FUNCTION" ;
        hActionValue = pActionString.substring(9,11) ;
        pActionValue = hActionValue.toInt() ;
      }
      
  if (pActionString.substring(1,6) == "DEBUG") {
        pActionCode = "DEBUG" ;
        hActionValue = pActionString.substring(6,8) ;
        pActionValue = hActionValue.toInt() ;
      }
      
  if (pActionString.substring(1,7) == "SWITCH") {
        pActionCode = "SWITCH" ;
        hActionValue = pActionString.substring(7,9) ;
        pActionValue = hActionValue.toInt() ;
      }
  
  if (pActionString.substring(1,6) == "MODUS") {
        pActionCode = "MODUS" ;
        hActionValue = pActionString.substring(6,8) ;
        pActionValue = hActionValue.toInt() ;
      }
      
  DebugText = "ActionCode = " + pActionCode + " ActionValue " + hActionValue +" / Code = " + String(pActionValue) + " / Source = " + pSource ;
  DebugPrint(DebugText,"1") ;  
  
  StartActionCode(pActionCode,pActionValue,pSource) ;
    
    
}

2. StartActionCode

In diesem Teil erfolgt die Ansteuerung der einzelnen Aktionen. Mit diesem Kontrukt kann ich alle drei Eingabearten realisieren. Das Programm reagiert immer gleich, egal, auf welche Art ich die Eingabe tätige.

Um beim Beispiel der Klingelanlage zu bleiben, kann ich hier einstellen, wie das Programm reagieren soll, wenn bestimmte Parameter eingestellt sind.

Die Anlage reagiert bei Tastendruck S1 und Modus=1 anders als bei S1 und Modus=2.

Mit dem Befehl !MODUS01 kann man zum Beispiel auch den Modus vom Netzwerk aus ändern.

Code:
void StartActionCode(String pAction, int pCode, String pSource) {

       DebugText = "StartActionCode Action = " + pAction + " / Code = " + String(pCode) + " / Source = " + pSource ;
       DebugPrint(DebugText,"1") ;
  
       if (pAction == "SWITCH") {
      
             switch(pCode)
               {
            
                 case 1 : DebugText = "Switch 01" + String(pCode) + " : Soft Press " ;
                          DebugPrint(DebugText,"1") ;
                          
                          if (Modus == 1) { CircleLow(circle1,500,2000) ; }
                          
                          break ;
                
                 case 2 : DebugText = "Switch 02" + String(pCode) + " : Soft Press " ;
                          DebugPrint(DebugText,"1") ;
                          
                          if (Modus == 1) { CircleLow(circle2,500,2000) ; }
                          
                          break ;
                          
                  case 99 :  SetOnLed(Switch1Led) ;
                             SetOnLed(InputLed) ;
                             SetOnLed(DebugLed) ;
                             SetOnLed(ModusLed) ;
                             SetOnLed(FunctionLed) ;
              
                             // Serial.print("RESET IN 20 Sekunden ..........................") ;
                             delay(5000) ;
                             pinMode(resetPin, OUTPUT) ;
                             break ;
                          
                             { Serial.print("...") ; } while(1) ;  
                          
                 default :   DebugText = "Funktion " + String(pCode) + " : not exist ... " ;
                             DebugPrint(DebugText,"1") ;
                             break ;
                
               }
       }
  
      
       if (pAction == "MODUS") {
      
          DebugText = "Modus " + String(pCode) + " : Set " ;
          DebugPrint(DebugText,"1") ;
          
          Modus = pCode ;                
                          
       }
      
      
       if (pAction == "DEBUG") {
      
             switch(pCode)
               {
            
                 case 0 : DebugText = "Funktion " + String(pCode) + " : Set Debug = 0 " ;
                          DebugPrint(DebugText,"1") ;
                          Debug = 0 ;
                          break ;
                
                 case 1 : Debug = 1 ;
                          DebugText = "Funktion " + String(pCode) + " : Set Debug = 1 " ;
                          DebugPrint(DebugText,"1") ;
                          PrintDebugInfo() ;
                          break ;
                
                 default :   DebugText = "Funktion " + String(pCode) + " : not exist ... " ;
                             DebugPrint(DebugText,"1") ;
                             break ;
                
               }
       }
  
       if (pAction == "FUNCTION") {
      
            
            switch(pCode)
                {
                  case 1 : DebugText = "Funktion " + String(pCode) + " : Test Circle / LED / Other" ;
                           DebugPrint(DebugText,"1") ;
                          
                           // Relais angeschlossen

                           CircleLow(circle1,500,2000) ;
                           CircleLow(circle2,500,2000) ;
                           CircleLow(circle3,500,2000) ;
                           CircleLow(circle4,500,2000) ;
                           CircleLow(circle5,500,2000) ;
                           CircleLow(circle6,500,2000) ;
                           CircleLow(circle7,500,2000) ;
                           CircleLow(circle8,500,2000) ;
                          
                           CircleLow(circle1,0,1000) ;
                           CircleLow(circle2,0,1000) ;
                           CircleLow(circle3,0,1000) ;
                           CircleLow(circle4,0,1000) ;
                           CircleLow(circle5,0,1000) ;
                           CircleLow(circle6,0,1000) ;
                           CircleLow(circle7,0,1000) ;
                           CircleLow(circle8,0,1000) ;
                          
                           CircleHigh(circle8,0,1000) ;
                           CircleHigh(circle7,0,1000) ;
                           CircleHigh(circle6,0,1000) ;
                           CircleHigh(circle5,0,1000) ;
                           CircleHigh(circle4,0,1000) ;
                           CircleHigh(circle3,0,1000) ;
                           CircleHigh(circle2,0,1000) ;
                           CircleHigh(circle1,0,1000) ;
                          
                          
                           // Andere Schließer (Ohne Relais
                          
                           CircleLow(circle9,2000,2000) ;
                           CircleLow(circle10,2000,2000) ;
                                                    
                           // LED's

                           BlinkLed(Switch1Led,stdLedDelay1,stdLedDelay2,3) ;
                           BlinkLed(Switch2Led,stdLedDelay1,stdLedDelay2,3) ;
                           BlinkLed(FunctionLed,stdLedDelay1,stdLedDelay2,3) ;
                           BlinkLed(DebugLed,stdLedDelay1,stdLedDelay2,3) ;
                           BlinkLed(ModusLed,stdLedDelay1,stdLedDelay2,3) ;
                           BlinkLed(InputLed,stdLedDelay1,stdLedDelay2,3) ;
                           break ;
                  
                  case 7 : BlinkLed(Switch1Led,stdLedDelay1,stdLedDelay2,3) ;
                           BlinkLed(Switch2Led,stdLedDelay1,stdLedDelay2,3) ;
                           BlinkLed(FunctionLed,stdLedDelay1,stdLedDelay2,3) ;
                           BlinkLed(DebugLed,stdLedDelay1,stdLedDelay2,3) ;
                           BlinkLed(ModusLed,stdLedDelay1,stdLedDelay2,3) ;
                           BlinkLed(InputLed,stdLedDelay1,stdLedDelay2,3) ;
                           break ;
                  
                  // Mit Hilfe der Lampen den Status anzeigen
                  case 8 : DebugText = "Funktion " + String(pCode) + " : Show Modus / Debug / other on LED" ;
                           DebugPrint(DebugText,"1") ;
                           PrintCurrentConfig(1) ;
                           break ;
                          
                  // Debug ausschalten
                  case 9 : Debug = 0 ;
                           DebugText = "Funktion " + String(pCode) + " : Set Debug = 0" ;
                           DebugPrint(DebugText,"1") ;
                           SetDebug(0) ;
                           break ;
                
                  // Ausschalten der Relais-Kreise      
                  case 71: CircleHigh(circle1,0,0) ;
                           break ;
                  case 72: CircleHigh(circle2,0,0) ;
                           break ;
                  case 73: CircleHigh(circle3,0,0) ;
                           break ;
                  case 74: CircleHigh(circle4,0,0) ;
                           break ;
                  case 75: CircleHigh(circle5,0,0) ;
                           break ;
                  case 76: CircleHigh(circle6,0,0) ;
                           break ;
                  case 77: CircleHigh(circle7,0,0) ;
                           break ;
                  case 78: CircleHigh(circle8,0,0) ;
                           break ;
                  
                  // Einschalten der Relais-Kreise
                  case 81: CircleLow(circle1,0,0) ;
                           break ;
                  case 82: CircleLow(circle2,0,0) ;
                           break ;
                  case 83: CircleLow(circle3,0,0) ;
                           break ;
                  case 84: CircleLow(circle4,0,0) ;
                           break ;
                  case 85: CircleLow(circle5,0,0) ;
                           break ;
                  case 86: CircleLow(circle6,0,0) ;
                           break ;
                  case 87: CircleLow(circle7,0,0) ;
                           break ;
                  case 88: CircleLow(circle8,0,0) ;
                           break ;
                          
                  default :   DebugText = "Funktion " + String(pCode) + " : not exist ... " ;
                              DebugPrint(DebugText,"1") ;
                              break ;        
                }  
      
       }    
      
}

So weit so gut. Ich werde das Programm noch einmal überarbeiten (vorerst nur die Kommentare) und wenn ich richtig Zeit habe, werde ich noch andere Funktionen einbauen und den Code hier einstellen.

Die Teileliste und der Schaltplan folgen noch, die hätte ich beinahe ganz vergessen !!!
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
24.03.2015, 22:39
Beitrag #10
RE: Grundprogramm Arduino
    Hallo ,

ich hätte nicht gedacht , daß ich es heute fertig bekomme, aber ich glaube so gehts.

Mit dem Fritzing habe ich die Schaltung nachgebaut.

Wäre dankbar, wenn mal jemand rüberschauen würde.

Kann mir jemand sagen, warum ich die fzz-Datei nicht anhängen kann ??
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
24.06.2015, 19:17
Beitrag #11
Mein Leben hat wieder einen Sinn.
Danke, Danke, Danke !!!

An den Gelegenheitsbastler UND GROSSES LOB an die Jungs, die eine APP Namens "Haussteuerung Pro" (Kategorie Sonstiges !!!) herausgebracht haben. Der Gelegenheitsbastler hatte gesagt, es ist eine geniale Kombination. Ich bin gerade dabei, diese Kombination noch ein wenig zu verfeinern.
Das Grundprogramm wird jetzt so erweitert, daß auch noch der TCP-Server integriert werden kann. Dann kann ich über die App ENDLICH meine Klingelanlage fertigstellen.

Tja, manchmal lohnt es sich, zu warten und etwas auszusitzen.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
26.06.2015, 17:13
Beitrag #12
RE: Grundprogramm Arduino
Hallo,

nach dem Kauf der App habe ich mich gleich in meinen Bastelkeller verzogen und meinen Sketch für den Arduino so angepasst, daß ich auch noch den EthernetServer mit eingebaut habe. (Der Ethernet Grund-Code ist auch nicht von mir, sondern vom Hersteller der App !!!)

Neben UDP, Seriell und Tastensteuerung kann das Grundprogramm jetzt auch die App-Befehle entgegennehmen. Das Board kann unabhängig von der App gesteuert werden. Dank der Statusinformationen, die das Board zurückgibt, werden Änderungen am Status (wenn möglich) mit angezeigt. Es ist also theoretisch möglich, das Board von mehreren Seiten aus anzusteuern.

Hier erst einmal die Bilder von der App, bzw. der angepassten Oberfläche.

   

Licht 41 / 42 / 43 sind einfache Relaiskreise, die den Nummern im Grundprogramm entsprechen.

Gartentor ist der Kreis für den Elektrischen Summer, den ich ansteuern möchte.

Mit Gartentor Partymodus ist gemeint, daß der Gast den Klingelknopf betätigt und nach 5 Sekunden der Summer am Gartentor das Tor öffnet , damit ich mich nicht so viel bewegen muss. :-)

Standardmodus ist der Normale Modus, es klingelt nur , oder gongt , oder ...

Müsste mal über eine Kamera nachdenken ...

   

Taster 1 simuliert (bzw. drückt den Klingelknopf) , Taster 2 hat noch keine Bedeutung.

Stumschaltung (erklärt sich von selbst)

Mit Debug kann ich den UDP-Debugger anschmeißen, der schon im Grundprogramm eingebaut war. Damit konnte ich die Logik der App nachvollziehen und war daher eine sehr große Hilfe für mich.

Und Reset setzt das Board zurück ..

Hier noch eine kleine Demo (Leider sind im Keller keine optimalen Lichtverhältnisse vorhanden, mann kann aber alles erkennen !)





Ich werde jetzt noch den Code etwas aufhübschen und die Fritzingschaltung
optisch noch ein bischen ändern und dann stell ich das auch noch rein !
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
15.07.2015, 19:27 (Dieser Beitrag wurde zuletzt bearbeitet: 15.07.2015 19:31 von Home38.)
Beitrag #13
RE: Grundprogramm Arduino
Hi,

anbei der Sketch (Prototyp-noch nicht optimiert !) für die Steuerung der APP.

Bei der Einstellung der Netzwerkkarte die IP-Adresse / Mac-Adresse ändern , wenn nötig !!


.ino  GrundProgrammMEGA2560_V41_PLUS_APP.ino (Größe: 59,06 KB / Downloads: 87)


Hier das Bild. Habe festgestellt, daß man ein paar Widerstände für die Taster eindampfen kann !

   



Die Relaiskarte ist eine RB-8/5V (Pollin - Bestellnummer 810 273)
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
Antwort schreiben 


Möglicherweise verwandte Themen...
Thema: Verfasser Antworten: Ansichten: Letzter Beitrag
  Arduino Neuling: Zugeklappten Laptop mit Arduino aufwecken + Kiste aufklappen? Ikearegal 2 2.527 02.02.2014 07:59
Letzter Beitrag: Ikearegal

Gehe zu:


Benutzer, die gerade dieses Thema anschauen: 1 Gast/Gäste