Revision 0:34f429428d45, committed 2017-03-28

Comitter:

SimonLie

Date:

Tue Mar 28 09:07:49 2017 +0000

Commit message:

inital version

Changed in this revision

diff -r 000000000000 -r 34f429428d45 RTC.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/RTC.cpp	Tue Mar 28 09:07:49 2017 +0000
@@ -0,0 +1,72 @@
+#include "mbed.h"
+#include "RTC.h"
+
+/* Pinfunktionen */
+I2C i2cRTC(PB_9,PB_8);
+
+/* Funktionen */
+void vfStopRTCOszi(){
+    char data[2];
+    data[0] = 0x00;
+    data[1] = 0x80;
+    i2cRTC.write(nRTCADRESS_W, data, 2);
+    }
+    
+void vfStartAndInitRTC(unsigned char bSeconds, 
+                       unsigned char bMinutes, 
+                       unsigned char bHours, 
+                       unsigned char bDay, 
+                       unsigned char bDate,
+                       unsigned char bMonth,
+                       unsigned char bYear,
+                       unsigned char bControl){
+    char acCalendar[9];
+    acCalendar[0] = 0x00;
+    acCalendar[1] = cfDezToBcd(bSeconds);
+    acCalendar[2] = cfDezToBcd(bMinutes);
+    acCalendar[3] = cfDezToBcd(bHours);
+    acCalendar[4] = cfDezToBcd(bDay);
+    acCalendar[5] = cfDezToBcd(bDate);
+    acCalendar[6] = cfDezToBcd(bMonth);
+    acCalendar[7] = cfDezToBcd(bYear);
+    acCalendar[8] = cfDezToBcd(bControl);    
+    i2cRTC.write(nRTCADRESS_W, acCalendar, 9);                           
+    }
+void vfSetTime(unsigned char bSeconds,
+               unsigned char bMinutes,
+               unsigned char bHours){
+    char acTime[4];
+    acTime[0] = 0x00;
+    acTime[1] = cfDezToBcd(bSeconds);               
+    acTime[2] = cfDezToBcd(bMinutes);
+    acTime[3] = cfDezToBcd(bHours);
+    i2cRTC.write(nRTCADRESS_W, acTime, 4);
+    }    
+
+    
+void vfGetTime(unsigned char *bSeconds,
+               unsigned char *bMinutes,
+               unsigned char *bHours){
+    char time[1];
+    char data[3];
+    time[0] = 0x00;     //Adresse des Sekunden-Registers
+    i2cRTC.write(nRTCADRESS_W, time, 1);
+    i2cRTC.read(nRTCADRESS_R, data, 3);
+    *bSeconds = bfBcdToDez((unsigned char)data[0]);
+    *bMinutes = bfBcdToDez((unsigned char)data[1]);
+    *bHours = bfBcdToDez((unsigned char)data[2]);                   
+    }
+    
+unsigned char bfBcdToDez(unsigned char bBcdValue){
+    unsigned char bDezValue = 0;
+    bDezValue = bBcdValue & 0x0F;
+    bDezValue = bDezValue + ((bBcdValue >> 4) * 10);
+    return bDezValue;
+    }
+    
+char cfDezToBcd(unsigned char bDezValue){
+    char cBcdValue = 0;
+    cBcdValue = bDezValue % 10;
+    cBcdValue = cBcdValue | (((bDezValue - (bDezValue%10)) / 10) << 4);
+    return cBcdValue;
+    }
\ No newline at end of file

diff -r 000000000000 -r 34f429428d45 RTC.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/RTC.h	Tue Mar 28 09:07:49 2017 +0000
@@ -0,0 +1,31 @@
+#ifndef _RTC_H_
+#define _RTC_H_
+
+#include "mbed.h"
+
+/* Defines */
+#define nRTCADRESS_W    0xD0
+#define nRTCADRESS_R    0xD1
+
+/* Funktionen */
+void vfStopRTCOszi();
+void vfStartAndInitRTC(unsigned char bSeconds, 
+                       unsigned char bMinutes, 
+                       unsigned char bHours, 
+                       unsigned char bDay, 
+                       unsigned char bDate,
+                       unsigned char bMonth,
+                       unsigned char bYear,
+                       unsigned char bControl);
+void vfSetTime(unsigned char bSeconds,
+               unsigned char bMinutes,
+               unsigned char bHours);
+void vfGetTime(unsigned char *bSeconds,
+               unsigned char *bMinutes,
+               unsigned char *bHours);
+unsigned char bfBcdToDez(unsigned char bBcdValue);
+char cfDezToBcd(unsigned char bDezValue);
+
+
+
+#endif
\ No newline at end of file

diff -r 000000000000 -r 34f429428d45 main.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/main.cpp	Tue Mar 28 09:07:49 2017 +0000
@@ -0,0 +1,849 @@
+/* Includes */
+#include "mbed.h"
+#include "RTC.h"
+
+/* Defines */
+#define nWATERINGDURATIONDAY            180 //Sekunden = 3 Minuten
+#define nWATERINGDURATIONNIGHT          600 //Sekunden = 10 Minuten
+#define nCHECKBTTNINTERVAL              0.025
+#define nCHECKROTARYSWITCHINTERVAL      1   
+#define nCHECKNIGHTWATERINGINTERVAL     1
+
+/* Funktionsstrukturen */
+void vfInit();
+void vfQueueCourt(unsigned char bCourtNumber);
+void vfBttnOnP3();
+void vfBttnOnP4();
+void vfBttnOnP5();
+void vfBttnOnP6();
+void vfBttnOnP7();
+void vfBttnOnP8();
+void vfEndWateringP3();
+void vfEndWateringP4();
+void vfEndWateringP5();
+void vfEndWateringP6();
+void vfEndWateringP7();
+void vfEndWateringP8();
+void vfWaterNextCourt();
+void vfShiftCourtQueue(unsigned char bCourtNumber);
+void vfWateringAllCourts();
+void vfResetFlag();
+unsigned char bfGetRotarySwitchValue();
+void vfCheckBttns();
+void vfCheckRotarySwitch();
+void vfCheckNightWatering();
+
+/* Pinfunktionen */
+/* Button Ein */
+DigitalIn diBttnOnP3(PB_15);        //Button-Ein für Platz 3
+DigitalIn diBttnOnP4(PC_2);         //Button-Ein für Platz 4
+DigitalIn diBttnOnP5(PC_3);         //Button-Ein für Platz 5
+DigitalIn diBttnOnP6(PB_12);        //Button-Ein für Platz 6
+DigitalIn diBttnOnP7(PB_2);         //Button-Ein für Platz 7
+DigitalIn diBttnOnP8(PB_1);         //Button-Ein für Platz 8
+/* Button Aus */
+DigitalIn diBttnOffP3(PA_11);       //Button-Aus für Platz 3
+DigitalIn diBttnOffP4(PC_6);        //Button-Aus für Platz 4
+DigitalIn diBttnOffP5(PC_12);       //Button-Aus für Platz 5
+DigitalIn diBttnOffP6(PC_5);        //Button-Aus für Platz 6
+DigitalIn diBttnOffP7(PB_7);        //Button-Aus für Platz 7
+DigitalIn diBttnOffP8(PC_8);        //Button-Aus für Platz 8
+/* Relais für LEDs */
+DigitalOut doRelaisLEDP3(PA_5);     //LED für Platz 3, 
+DigitalOut doRelaisLEDP4(PC_11);     //LED für Platz 4, 
+DigitalOut doRelaisLEDP5(PC_9);     //LED für Platz 5
+DigitalOut doRelaisLEDP6(PC_7);     //LED für Platz 6
+DigitalOut doRelaisLEDP7(PB_6);     //LED für Platz 7
+DigitalOut doRelaisLEDP8(PA_7);     //LED für Platz 8
+/* Relais für Ventile */
+DigitalOut doRelaisVentP3(PB_13);   //Ventil für Platz 3
+DigitalOut doRelaisVentP4(PB_14);   //Ventil für Platz 4
+DigitalOut doRelaisVentP5(PB_4);    //Ventil für Platz 5
+DigitalOut doRelaisVentP6(PB_5);    //Ventil für Platz 6
+DigitalOut doRelaisVentP7(PB_10);   //Ventil für Platz 7
+DigitalOut doRelaisVentP8(PA_9);    //Ventil für Platz 8
+/* Schlüsselschalter */
+DigitalIn diNightWatering(PC_10);   //Schlüsselschalter 
+/* Drehschalter */
+DigitalIn diRotarySwitchPin1(PA_1); //Drehschalter Wert 1
+DigitalIn diRotarySwitchPin4(PA_4); //Drehschalter Wert 4
+DigitalIn diRotarySwitchPin8(PA_0); //Drehschalter Wert 8
+DigitalIn diRotarySwitchPin2(PA_10); //Drehschalter Wert 2
+
+Serial pc(USBTX,USBRX);
+
+
+/* Nutzfunktionen */
+Timeout toEndWateringP3;
+Timeout toEndWateringP4;
+Timeout toEndWateringP5;
+Timeout toEndWateringP6;
+Timeout toEndWateringP7;
+Timeout toEndWateringP8;
+Timeout toResetFlag;
+Ticker tkCheckBttns;
+Ticker tkCheckRotarySwitch;
+Ticker tkCheckNightWatering;
+
+
+/* Globale Variablen */
+unsigned char abCourtQueue[6]={0};      //Warteschlange Bewässerung (immer nur ein Platz wird gewässert)
+unsigned char bValveState;
+int i32WateringDurationNight;    //Dauer der Bewässerung eines Platzes während der Nacht
+int i32WateringDurationDay;
+int i32NightWateringMinute[10];
+int i32NightWateringHour[10];
+unsigned int abFlagSetzen[6]={0};
+unsigned int abFlagZaehler[7]={0};
+unsigned int bKeySwitch;
+unsigned int bNightWateringIsRunning;
+
+enum enValveState{
+    enValveInUse,
+    enValveUnused
+    };
+
+/* Funktionen */
+void vfCheckNightWatering(){
+    unsigned char bSeconds, bMinutes, bHours;
+    int i;    
+    if( bKeySwitch == 1 ){
+        vfGetTime(&bSeconds, &bMinutes, &bHours);
+        for(i = 0; i < 10; i++){
+            if(i32NightWateringHour[i] == bHours && i32NightWateringMinute[i] == bMinutes && bNightWateringIsRunning == 0){
+                    vfWateringAllCourts();
+                    bNightWateringIsRunning = 1;
+                    toResetFlag.attach(&vfResetFlag, 90); //Nach 90 Sekunden wird die Flag resetet
+                }
+            } 
+        }
+    }
+
+void vfCheckRotarySwitch(){
+    int i;
+    switch(bfGetRotarySwitchValue()){
+        default:
+            i32WateringDurationDay = 180;
+            i32WateringDurationNight = 180;       //3 Minuten
+            i32NightWateringHour[0] = 23;
+            i32NightWateringMinute[0] = 0;
+            i32NightWateringHour[1] = 4;
+            i32NightWateringMinute[1] = 30;
+            i32NightWateringHour[2] = 7;
+            i32NightWateringMinute[2] = 0;
+            for(i = 3; i < 10; i++){
+                i32NightWateringMinute[i] = 65;   //65 ist unerreichbar
+                i32NightWateringHour[i] = 25;      //25 ist unerreichbar
+                }  
+            break;
+        case 0:
+            i32WateringDurationDay = 180;
+            i32WateringDurationNight = 180;       //3 Minuten
+            i32NightWateringHour[0] = 23;
+            i32NightWateringMinute[0] = 0;
+            i32NightWateringHour[1] = 4;
+            i32NightWateringMinute[1] = 30;
+            i32NightWateringHour[2] = 7;
+            i32NightWateringMinute[2] = 0;
+            for(i = 3; i < 10; i++){
+                i32NightWateringMinute[i] = 65;   //65 ist unerreichbar
+                i32NightWateringHour[i] = 25;      //25 ist unerreichbar
+                }            
+            break;
+        case 1:
+            i32WateringDurationDay = 180;
+            i32WateringDurationNight = 240;       //4 Minuten
+            i32NightWateringHour[0] = 23;
+            i32NightWateringMinute[0] = 0;
+            i32NightWateringHour[1] = 4;
+            i32NightWateringMinute[1] = 30;
+            i32NightWateringHour[2] = 7;
+            i32NightWateringMinute[2] = 0;
+            for(i = 3; i < 10; i++){
+                i32NightWateringMinute[i] = 65;   //65 ist unerreichbar
+                i32NightWateringHour[i] = 25;      //25 ist unerreichbar
+                } 
+            break;
+        case 2:
+            i32WateringDurationDay = 180;
+            i32WateringDurationNight = 300;       //5 Minuten
+            i32NightWateringHour[0] = 23;
+            i32NightWateringMinute[0] = 0;
+            i32NightWateringHour[1] = 4;
+            i32NightWateringMinute[1] = 30;
+            i32NightWateringHour[2] = 7;
+            i32NightWateringMinute[2] = 0;
+            for(i = 3; i < 10; i++){
+                i32NightWateringMinute[i] = 65;   //65 ist unerreichbar
+                i32NightWateringHour[i] = 25;      //25 ist unerreichbar
+                } 
+            break;
+        case 3:
+            i32WateringDurationDay = 180;
+            i32WateringDurationNight = 180;       //3 Minuten
+            i32NightWateringHour[0] = 23;
+            i32NightWateringMinute[0] = 0;
+            i32NightWateringHour[1] = 4;
+            i32NightWateringMinute[1] = 30;
+            for(i = 2; i < 10; i++){
+                i32NightWateringMinute[i] = 65;   //65 ist unerreichbar
+                i32NightWateringHour[i] = 25;      //25 ist unerreichbar
+                } 
+            break;
+        case 4:
+            i32WateringDurationDay = 180;
+            i32WateringDurationNight = 240;       //4 Minuten
+            i32NightWateringHour[0] = 23;
+            i32NightWateringMinute[0] = 0;
+            i32NightWateringHour[1] = 4;
+            i32NightWateringMinute[1] = 30;
+            for(i = 2; i < 10; i++){
+                i32NightWateringMinute[i] = 65;   //65 ist unerreichbar
+                i32NightWateringHour[i] = 25;      //25 ist unerreichbar
+                } 
+            break;
+        case 5:
+            i32WateringDurationDay = 180;
+            i32WateringDurationNight = 300;       //5 Minuten
+            i32NightWateringHour[0] = 23;
+            i32NightWateringMinute[0] = 0;
+            i32NightWateringHour[1] = 4;
+            i32NightWateringMinute[1] = 30;
+            for(i = 2; i < 10; i++){
+                i32NightWateringMinute[i] = 65;   //65 ist unerreichbar
+                i32NightWateringHour[i] = 25;      //25 ist unerreichbar
+                } 
+            break;
+        case 6:
+            i32WateringDurationDay = 180;
+            i32WateringDurationNight = 360;     //6 Minuten
+            i32NightWateringHour[0] = 23;
+            i32NightWateringMinute[0] = 0;
+            i32NightWateringHour[1] = 4;
+            i32NightWateringMinute[1] = 30;
+            for(i = 2; i < 10; i++){
+                i32NightWateringMinute[i] = 65;   //65 ist unerreichbar
+                i32NightWateringHour[i] = 25;      //25 ist unerreichbar
+                } 
+            break;
+        case 7:
+            i32WateringDurationDay = 180;
+            i32WateringDurationNight = 420;       //7 Minuten
+            i32NightWateringHour[0] = 23;
+            i32NightWateringMinute[0] = 0;
+            i32NightWateringHour[1] = 4;
+            i32NightWateringMinute[1] = 30;
+            for(i = 2; i < 10; i++){
+                i32NightWateringMinute[i] = 65;   //65 ist unerreichbar
+                i32NightWateringHour[i] = 25;      //25 ist unerreichbar
+                } 
+            break;
+        case 8:
+            i32WateringDurationDay = 180;
+            i32WateringDurationNight = 480;       //8 Minuten
+            i32NightWateringHour[0] = 23;
+            i32NightWateringMinute[0] = 0;
+            i32NightWateringHour[1] = 4;
+            i32NightWateringMinute[1] = 30;
+            for(i = 2; i < 10; i++){
+                i32NightWateringMinute[i] = 65;   //65 ist unerreichbar
+                i32NightWateringHour[i] = 25;      //25 ist unerreichbar
+                } 
+            break;
+        case 9:
+            i32WateringDurationDay = 180;
+            i32WateringDurationNight = 540;       //9 Minuten
+            i32NightWateringHour[0] = 23;
+            i32NightWateringMinute[0] = 0;
+            i32NightWateringHour[1] = 4;
+            i32NightWateringMinute[1] = 30;
+            for(i = 2; i < 10; i++){
+                i32NightWateringMinute[i] = 65;   //65 ist unerreichbar
+                i32NightWateringHour[i] = 25;      //25 ist unerreichbar
+                } 
+            break;
+        case 10:
+            i32WateringDurationDay = 180;
+            i32WateringDurationNight = 600;       //10 Minuten
+            i32NightWateringHour[0] = 23;
+            i32NightWateringMinute[0] = 0;
+            i32NightWateringHour[1] = 4;
+            i32NightWateringMinute[1] = 30;
+            for(i = 2; i < 10; i++){
+                i32NightWateringMinute[i] = 65;   //65 ist unerreichbar
+                i32NightWateringHour[i] = 25;      //25 ist unerreichbar
+                } 
+            break;
+        case 11:
+            i32WateringDurationDay = 180;
+            i32WateringDurationNight = 660;       //11 Minuten
+            i32NightWateringHour[0] = 23;
+            i32NightWateringMinute[0] = 0;
+            i32NightWateringHour[1] = 4;
+            i32NightWateringMinute[1] = 30;
+            for(i = 2; i < 10; i++){
+                i32NightWateringMinute[i] = 65;   //65 ist unerreichbar
+                i32NightWateringHour[i] = 25;      //25 ist unerreichbar
+                } 
+            break;
+         case 12:
+            i32WateringDurationDay = 180;
+            i32WateringDurationNight = 720;       //12 Minuten
+            i32NightWateringHour[0] = 23;
+            i32NightWateringMinute[0] = 0;
+            i32NightWateringHour[1] = 4;
+            i32NightWateringMinute[1] = 30;
+            for(i = 2; i < 10; i++){
+                i32NightWateringMinute[i] = 65;   //65 ist unerreichbar
+                i32NightWateringHour[i] = 25;      //25 ist unerreichbar
+                } 
+            break;
+        case 13:
+            i32WateringDurationDay = 180;
+            i32WateringDurationNight = 780;       //13 Minuten
+            i32NightWateringHour[0] = 23;
+            i32NightWateringMinute[0] = 0;
+            i32NightWateringHour[1] = 4;
+            i32NightWateringMinute[1] = 30;
+            for(i = 2; i < 10; i++){
+                i32NightWateringMinute[i] = 65;   //65 ist unerreichbar
+                i32NightWateringHour[i] = 25;      //25 ist unerreichbar
+                } 
+            break;
+        case 14:
+            i32WateringDurationDay = 180;
+            i32WateringDurationNight = 840;       //14 Minuten
+            i32NightWateringHour[0] = 23;
+            i32NightWateringMinute[0] = 0;
+            i32NightWateringHour[1] = 4;
+            i32NightWateringMinute[1] = 30;
+            for(i = 2; i < 10; i++){
+                i32NightWateringMinute[i] = 65;   //65 ist unerreichbar
+                i32NightWateringHour[i] = 25;      //25 ist unerreichbar
+                } 
+            break;
+        case 15:
+            i32WateringDurationDay = 15;
+            i32WateringDurationNight = 15;
+            for(i = 0; i < 10; i++){
+                i32NightWateringHour[i] = 10+i;       //10 Uhr bis 19 Uhr
+                }
+            for(i = 0; i < 10; i++){
+                i32NightWateringMinute[i] = i * 6;    //Alle 6 Minuten
+                }     
+            break;
+        }            
+    }
+
+void vfCheckBttns(){
+  //  static int abFlagZaehler[7];
+    
+    if(diBttnOnP3.read() == 1)
+    {
+        abFlagZaehler[0]++;
+        if(abFlagZaehler[0] >= 10)
+            {
+                vfBttnOnP3();
+                abFlagZaehler[0] = 10;
+            }
+    }
+    else
+                abFlagZaehler[0] = 0;                
+    
+    if(diBttnOnP4.read() == 1)
+    {
+        abFlagZaehler[1]++;
+        if(abFlagZaehler[1] >= 10)
+            {
+                vfBttnOnP4();
+                abFlagZaehler[1] = 10;
+            }
+    }
+    else
+                abFlagZaehler[1] = 0;                
+    
+    if(diBttnOnP5.read() == 1)
+    {
+        abFlagZaehler[2]++;
+        if(abFlagZaehler[2] >= 10)
+            {
+                vfBttnOnP5();
+                abFlagZaehler[2] = 10;
+            }
+    }
+    else
+                abFlagZaehler[2] = 0;                
+    
+    if(diBttnOnP6.read() == 1)
+    {
+        abFlagZaehler[3]++;
+        if(abFlagZaehler[3] >= 10)
+            {
+                vfBttnOnP6();
+                abFlagZaehler[3] = 10;
+            }
+    }
+    else
+                abFlagZaehler[3] = 0;                
+    
+    if(diBttnOnP7.read() == 1)
+    {
+        abFlagZaehler[4]++;
+        if(abFlagZaehler[4] >= 10)
+            {
+                vfBttnOnP7();
+                abFlagZaehler[4] = 10;
+            }
+    }
+    else
+                abFlagZaehler[4] = 0;                
+
+    if(diBttnOnP8.read() == 1)
+    {
+        abFlagZaehler[5]++;
+        if(abFlagZaehler[5] >= 10)
+            {
+                vfBttnOnP8();
+                abFlagZaehler[5] = 10;
+            }
+    }
+    else
+                abFlagZaehler[5] = 0;                
+           
+    if(diBttnOffP3.read() == 0){
+        vfEndWateringP3();
+        }
+    else if(diBttnOffP4.read() == 0){
+        vfEndWateringP4();
+        }
+    else if(diBttnOffP5.read() == 0){
+        vfEndWateringP5();
+        }
+    else if(diBttnOffP6.read() == 0){
+        vfEndWateringP6();
+        }
+    else if(diBttnOffP7.read() == 0){
+        vfEndWateringP7();
+        }
+    else if(diBttnOffP8.read() == 0){
+        vfEndWateringP8();
+        }
+        
+    if(diNightWatering.read() == 1)
+    {
+        abFlagZaehler[6]++;
+        if(abFlagZaehler[6] >= 50)
+            {
+                bKeySwitch = 1;
+                abFlagZaehler[6] = 50;
+            }
+    }
+    else
+    {
+                bKeySwitch = 0;
+                abFlagZaehler[6] = 0;                
+    }
+}
+
+
+void vfBttnOnP3(){
+    if(abFlagSetzen[0] == 0)
+        {
+        doRelaisLEDP3 = 0;              //Relais schaltet bei ziehen auf GND
+        abFlagSetzen[0] = 1;
+        vfQueueCourt((unsigned char)3);
+        }
+    }
+    
+void vfBttnOnP4(){
+    if(abFlagSetzen[1] == 0)
+        {
+        doRelaisLEDP4 = 0;
+        abFlagSetzen[1] = 1;
+        vfQueueCourt((unsigned char)4);
+        }
+    
+    }
+    
+void vfBttnOnP5(){
+    if(abFlagSetzen[2] == 0)
+        {
+        doRelaisLEDP5 = 0;
+        abFlagSetzen[2] = 1;
+        vfQueueCourt((unsigned char)5);
+        }    
+    }
+    
+void vfBttnOnP6(){
+    if(abFlagSetzen[3] == 0)
+        {
+        doRelaisLEDP6 = 0;
+        abFlagSetzen[3] = 1;
+        vfQueueCourt((unsigned char)6);
+        }
+    }
+    
+void vfBttnOnP7(){
+    if(abFlagSetzen[4] == 0)
+        {
+        doRelaisLEDP7 = 0;
+        abFlagSetzen[4] = 1;
+        vfQueueCourt((unsigned char)7);
+        }
+    }
+    
+void vfBttnOnP8(){
+    if(abFlagSetzen[5] == 0)
+        {
+        doRelaisLEDP8 = 0;
+        abFlagSetzen[5] = 1;
+        vfQueueCourt((unsigned char)8);
+        }
+    
+    }
+    
+
+void vfQueueCourt(unsigned char bCourtNumber){
+    int i;
+    for( i = 0; i < 6; i++){
+        if( abCourtQueue[i] == 0 || abCourtQueue[i] == bCourtNumber){
+            abCourtQueue[i] = bCourtNumber;
+            i = 7;      //Abbruch der for-Schleife
+            }
+        }
+    }
+
+void vfShiftCourtQueue(unsigned char bCourtNumberDay, unsigned char bCourtNumberNight){
+    int i,j;
+    for( i = 0; i < 6; i++){
+        if( abCourtQueue[i] == bCourtNumberDay || abCourtQueue[i] == bCourtNumberNight){
+            abCourtQueue[i] = 0;
+            }
+        }
+    for( j = 0; j < 5; j++){    
+        for( i = 0; i < 5; i++){
+            if( abCourtQueue[i] == 0){
+                abCourtQueue[i] = abCourtQueue[i+1];
+                abCourtQueue[i+1] = 0;
+                }
+            }
+        }
+    }
+    
+    
+void vfEndWateringP3(){
+        doRelaisVentP3 = 1;     //Relais wird ausgeschaltet
+        doRelaisLEDP3 = 1;
+        toEndWateringP3.detach();
+        vfShiftCourtQueue(3,13);
+        bValveState = enValveUnused;        
+        abFlagSetzen[0] = 0;
+}
+
+void vfEndWateringP4(){
+        doRelaisVentP4 = 1;    
+        doRelaisLEDP4 = 1;
+        toEndWateringP4.detach();
+        vfShiftCourtQueue(4,14); 
+        bValveState = enValveUnused;
+        abFlagSetzen[1] = 0;
+} 
+  
+void vfEndWateringP5(){
+        abFlagSetzen[2] = 0;
+        doRelaisVentP5 = 1;   
+        doRelaisLEDP5 = 1;
+        toEndWateringP5.detach();
+        vfShiftCourtQueue(5,15); 
+        bValveState = enValveUnused;
+        abFlagSetzen[2] = 0;
+}
+    
+void vfEndWateringP6(){
+        doRelaisVentP6 = 1;    
+        doRelaisLEDP6 = 1;
+        toEndWateringP6.detach();
+        vfShiftCourtQueue(6,16); 
+        bValveState = enValveUnused;
+        abFlagSetzen[3] = 0;
+}
+    
+void vfEndWateringP7(){
+        doRelaisVentP7 = 1;    
+        doRelaisLEDP7 = 1;
+        toEndWateringP7.detach();
+        vfShiftCourtQueue(7,17); 
+        bValveState = enValveUnused;
+        abFlagSetzen[4] = 0;
+}
+    
+void vfEndWateringP8(){
+        doRelaisVentP8 = 1;    
+        doRelaisLEDP8 = 1;
+        toEndWateringP8.detach();
+        vfShiftCourtQueue(8,18); 
+        bValveState = enValveUnused;
+        abFlagSetzen[5] = 0;
+}
+    
+void vfWateringAllCourts(){
+    unsigned char i;
+    for( i = 18; i >= 13; i-- ){
+        abFlagSetzen[i-13] = 1;
+        vfQueueCourt(i);
+        }    
+    doRelaisLEDP3 = 0;
+    doRelaisLEDP4 = 0;
+    doRelaisLEDP5 = 0;
+    doRelaisLEDP6 = 0;
+    doRelaisLEDP7 = 0;
+    doRelaisLEDP8 = 0;
+    }
+    
+void vfWaterNextCourt(){
+    switch(abCourtQueue[0]){
+        default:
+            break;
+        case 0:
+            bValveState = enValveUnused;
+            break;
+        case 3:
+            doRelaisVentP3 = 0;
+            toEndWateringP3.attach(&vfEndWateringP3, i32WateringDurationDay);
+            bValveState = enValveInUse;
+            break;
+        case 4:
+            doRelaisVentP4 = 0;
+            toEndWateringP4.attach(&vfEndWateringP4, i32WateringDurationDay);
+            bValveState = enValveInUse;
+            break;
+        case 5:
+            doRelaisVentP5 = 0;
+            toEndWateringP5.attach(&vfEndWateringP5, i32WateringDurationDay);
+            bValveState = enValveInUse;
+            break;
+        case 6:
+            doRelaisVentP6 = 0;
+            toEndWateringP6.attach(&vfEndWateringP6, i32WateringDurationDay);
+            bValveState = enValveInUse;
+            break;
+        case 7:
+            doRelaisVentP7 = 0;
+            toEndWateringP7.attach(&vfEndWateringP7, i32WateringDurationDay);
+            bValveState = enValveInUse;
+            break;
+        case 8:
+            doRelaisVentP8 = 0;
+            toEndWateringP8.attach(&vfEndWateringP8, i32WateringDurationDay);
+            bValveState = enValveInUse;
+            break;
+        case 13:
+            if(bKeySwitch == 1){
+                doRelaisVentP3 = 0;
+                bValveState = enValveInUse;
+                toEndWateringP3.attach(&vfEndWateringP3, i32WateringDurationNight);
+                }
+            else
+                doRelaisVentP3 = 1;
+            break;
+        case 14:
+            if(bKeySwitch == 1){
+                doRelaisVentP4 = 0;            
+                toEndWateringP4.attach(&vfEndWateringP4, i32WateringDurationNight);
+                bValveState = enValveInUse;
+                }
+            else
+                doRelaisVentP4 = 1;
+            break;
+        case 15:
+            if(bKeySwitch == 1){
+                doRelaisVentP5 = 0;                                
+                toEndWateringP5.attach(&vfEndWateringP5, i32WateringDurationNight);
+                bValveState = enValveInUse;
+                }
+            else
+                doRelaisVentP5 = 1;
+            break;
+        case 16:
+            if(bKeySwitch == 1){
+                doRelaisVentP6 = 0;
+                toEndWateringP6.attach(&vfEndWateringP6, i32WateringDurationNight);
+                bValveState = enValveInUse;
+                }
+            else
+                doRelaisVentP6 = 1;
+            break;
+        case 17:
+            if(bKeySwitch == 1){
+                doRelaisVentP7 = 0;
+                toEndWateringP7.attach(&vfEndWateringP7, i32WateringDurationNight);
+                bValveState = enValveInUse;
+                }
+            else
+                doRelaisVentP7 = 1;
+            break;
+        case 18:
+            if(bKeySwitch == 1){
+                doRelaisVentP8 = 0;
+                toEndWateringP8.attach(&vfEndWateringP8, i32WateringDurationNight);
+                bValveState = enValveInUse;
+                }
+            else
+                doRelaisVentP8 = 1;
+            break;
+        }
+            
+    }
+    
+unsigned char bfGetRotarySwitchValue(){
+    unsigned char bRotarySwitchPin1 = 0;
+    unsigned char bRotarySwitchPin2 = 0;
+    unsigned char bRotarySwitchPin4 = 0;
+    unsigned char bRotarySwitchPin8 = 0;
+    if(diRotarySwitchPin1.read() > (float)0.5)
+        bRotarySwitchPin1 = 1;
+    if(diRotarySwitchPin2.read() > (float)0.5)
+        bRotarySwitchPin2 = 1;
+    if(diRotarySwitchPin4.read() > (float)0.5)
+        bRotarySwitchPin4 = 1;            
+    if(diRotarySwitchPin8.read() > (float)0.5)
+        bRotarySwitchPin8 = 1;    
+    return ( (bRotarySwitchPin1 * 1) +
+             (bRotarySwitchPin2 * 2) +
+             (bRotarySwitchPin4 * 4) +
+             (bRotarySwitchPin8 * 8) );
+    }
+    
+void vfResetFlag(){
+    bNightWateringIsRunning = 0;
+    }
+    
+void vfInit(){
+    /* Initialisierung der Knöpfe und derer Interruptfunktionen */
+    
+    /* Alle Relais ausschalten */
+    doRelaisVentP3 = 1;
+    doRelaisVentP4 = 1;
+    doRelaisVentP5 = 1;
+    doRelaisVentP6 = 1;
+    doRelaisVentP7 = 1;
+    doRelaisVentP8 = 1;
+
+    doRelaisLEDP3 = 1;   
+    doRelaisLEDP4 = 1;   
+    doRelaisLEDP5 = 1;   
+    doRelaisLEDP6 = 1;   
+    doRelaisLEDP7 = 1;   
+    doRelaisLEDP8 = 1;  
+    
+    abFlagSetzen[0] = 0;
+    abFlagSetzen[1] = 0;
+    abFlagSetzen[2] = 0;
+    abFlagSetzen[3] = 0;
+    abFlagSetzen[4] = 0;
+    abFlagSetzen[5] = 0;
+    
+    abFlagZaehler[0] = 0;
+    abFlagZaehler[1] = 0;
+    abFlagZaehler[2] = 0;
+    abFlagZaehler[3] = 0;
+    abFlagZaehler[4] = 0;
+    abFlagZaehler[5] = 0;
+    abFlagZaehler[6] = 0;
+    
+    diBttnOnP3.mode(PullDown);
+    diBttnOnP4.mode(PullDown);
+    diBttnOnP5.mode(PullDown);
+    diBttnOnP6.mode(PullDown);
+    diBttnOnP7.mode(PullDown);
+    diBttnOnP8.mode(PullDown);
+    
+    diBttnOffP3.mode(PullDown);
+    diBttnOffP4.mode(PullDown);
+    diBttnOffP5.mode(PullDown);
+    diBttnOffP6.mode(PullDown);
+    diBttnOffP7.mode(PullDown);
+    diBttnOffP8.mode(PullDown);
+    
+    diRotarySwitchPin1.mode(PullDown);
+    diRotarySwitchPin2.mode(PullDown);
+    diRotarySwitchPin4.mode(PullDown);
+    diRotarySwitchPin8.mode(PullDown);
+    
+    diNightWatering.mode(PullDown);    
+    bNightWateringIsRunning = 0;
+    bKeySwitch = 0;
+    
+    tkCheckBttns.attach(&vfCheckBttns, nCHECKBTTNINTERVAL);                 
+    tkCheckRotarySwitch.attach(&vfCheckRotarySwitch,nCHECKROTARYSWITCHINTERVAL);     
+    tkCheckNightWatering.attach(&vfCheckNightWatering,nCHECKNIGHTWATERINGINTERVAL);  
+           
+    i32WateringDurationDay = nWATERINGDURATIONDAY;
+    i32WateringDurationNight = nWATERINGDURATIONNIGHT;
+        
+    bValveState = enValveUnused;
+    }
+
+int main() {
+    char acTime[6];
+    unsigned char bcTime[6];
+    char cBuffer;
+    unsigned char bSeconds, bMinutes, bHours;
+    int i=-1;
+    int j;
+    vfInit();
+        
+    /*
+        Möglichen Befehle:
+        "z":
+            Gibt die akutelle Uhrzeit in der Konsole aus.
+        "d":
+            Gibt die aktuelle Drehschalterstellung in der Konsole aus.
+        "t":
+            Initialisiert die Zeitsetzung.
+            Beispiel:
+                Es soll die Uhrzeit 22:35:59 eingestellt werden.
+                Befehl: "t223559"
+    */
+    while(1) {  
+        if(pc.readable()){
+            cBuffer = pc.getc();
+            if(i >= 0 && i <= 5){
+                acTime[i] = cBuffer;
+                i++;
+                }
+            if(cBuffer == 't'){
+                i = 0;
+                }
+            if(cBuffer == 'z'){
+                vfGetTime(&bSeconds, &bMinutes, &bHours);
+                pc.printf("\n\rAktuelle Zeit:\n\r");
+                pc.printf("%2u:%2u:%2u\n\r", bHours, bMinutes, bSeconds);
+                }
+            if(cBuffer == 'd'){
+                pc.printf("\n\rDrehschalterstellung: %u \n\r",bfGetRotarySwitchValue());
+                }
+            if(i >= 6){
+                for(j = 0; j<6; j++){
+                    bcTime[j] = acTime[j] - 48;
+                    }
+                vfStopRTCOszi();
+                wait(0.3);
+                vfSetTime((bcTime[4]*10)+bcTime[5],(bcTime[2]*10)+bcTime[3],(bcTime[0]*10)+bcTime[1]);
+                i = -1;                
+                vfGetTime(&bSeconds, &bMinutes, &bHours);
+                pc.printf("\n\rAktuelle Zeit:\n\r");
+                pc.printf("%2u:%2u:%2u\n\r", bHours, bMinutes, bSeconds);
+                }
+            }      
+        switch(bValveState){
+            default:
+                break;
+            case enValveUnused:
+                vfWaterNextCourt();                
+                break;
+            case enValveInUse:
+                break;
+            }
+        }
+    }

diff -r 000000000000 -r 34f429428d45 mbed.bld
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mbed.bld	Tue Mar 28 09:07:49 2017 +0000
@@ -0,0 +1,1 @@
+http://mbed.org/users/mbed_official/code/mbed/builds/c0f6e94411f5
\ No newline at end of file