1
2
3
4
5
6
7
8
9
void setup() {
  // Diese Funktion setup() wird nur einmal aufgerufen.
  // Hier kommt die Initialisierung rein.
}

void loop() {
  // Diese Funktion wird kontinuierlich hintereinander aufgerufen.
  // Hier kommt die gesamte Regelungslogik/das Ausführungsprogramm rein.
}

1
2
3
4
5
6
7
8
9
10
11
int main() {

	setup(); // einmal aufrufen

	// unendliche Schleife
	while (true) {
		loop(); // immer wieder neu die loop()-Funktion aufrufen
	}

	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
void setup() {
  // PIN 9 als Spannungsausgang konfigurieren
  pinMode(9, OUTPUT);
}

void loop() {
  digitalWrite(9, HIGH);  // Spannung auf +5V setzen (LED geht an)
  delay(1000);            // eine Sekunde warten
  digitalWrite(9, LOW);   // Spannung auf 0 setzen, Verbindung mit Ground (LED geht aus)
  delay(1000);            // eine Sekunde warten
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
// Variable hält Zeitpunkt, an dem als nächstes was gemacht werden soll
unsigned long nextActiveMillis;

// Variable hält aktuellen Zustand der LEDs (aktuellen Schritt in der Schrittkette)
bool LEDsOn;

void setup() {
  pinMode(8, OUTPUT);
  pinMode(9, OUTPUT);
  nextActiveMillis = millis(); // wir beginnen sofort mit der ersten Aktion
  LEDsOn = false; // anfänglich sind die LEDs aus
}

void loop() {
  // prüfen, ob wir aktiv werden müssen
  if (millis() >= nextActiveMillis) {

    // welchen Schritt führen wir als nächstes aus
    if (LEDsOn) {
      // LEDs sind an, schalte sie aus
      digitalWrite(8, LOW);
      digitalWrite(9, LOW);
      LEDsOn = false;
      // warte 300 ms bis zur nächsten Aktion
      nextActiveMillis = millis() + 300;
    }
    else {
      // LEDs sind aus, schalte sie an
      digitalWrite(8, HIGH);
      digitalWrite(9, HIGH);
      LEDsOn = true;
      // warte 1000 ms bis zur nächsten Aktion
      nextActiveMillis = millis() + 1000;
    }
  }

  // hier könnten wir jetzt noch anderes Zeug machen, während wir auf das Eintreten des
  // nächsten Schaltzustandes warten
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
int brightness = 0;  // aktuelle Helligkeit (0..255)
int stepSize = 5;    // Wieviele Helligkeitsschritte pro Anpassung verändern

void loop() {
  // Helligkeit/PWM-Spannung am PIN 9 setzen 
  analogWrite(9, brightness);

  // Helligkeit stufenweise ändern
  brightness = brightness + stepSize;

  // Beim Unterschreiten oder Überschreiten der Grenzen die Richtung tauschen
  if (brightness <= 0 || brightness >= 255) {
    stepSize = -stepSize;
  }
  // 30 Millisekunden warten
  delay(30);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
// Variable hält Zeitpunkt, an dem als nächstes was gemacht werden soll
unsigned long nextActiveMillis_ROT;
unsigned long nextActiveMillis_BLAU;

// Aktualisierungsinterval in ms
int delay_ROT = 50;
int delay_BLAU = 500;

// aktuelle Helligkeit (0..255)
int brightness_ROT = 0;  
int brightness_BLAU = 0;

// Wieviele Helligkeitsschritte pro Anpassung verändern
int stepSize_ROT = 5;
int stepSize_BLAU = 25; // größere Schritte als bei ROT machen

void setup() {
  pinMode(9, OUTPUT);
  pinMode(10, OUTPUT);

  // Anfangszustand herstellen: beide aus
  digitalWrite(9, LOW);
  digitalWrite(10, LOW);

  nextActiveMillis_ROT = millis(); // wir beginnen sofort mit der ersten Aktion
  nextActiveMillis_BLAU = millis(); // wir beginnen sofort mit der ersten Aktion
}


void loop() {
  // prüfen, ob wir ROT ändern
  if (millis() >= nextActiveMillis_ROT) {

    // Helligkeit stufenweise ändern
    brightness_ROT = brightness_ROT + stepSize_ROT;
    // auf Wertebereich beschränken
    if (brightness_ROT > 255)
      brightness_ROT = 255;
    if (brightness_ROT < 0)
      brightness_ROT = 0;

    // neue Helligkeit (Spannungswert) setzen
    analogWrite(9, brightness_ROT);

    // Beim Unterschreiten oder Überschreiten der Grenzen die Richtung tauschen
    if (brightness_ROT <= 0 || brightness_ROT >= 255) 
      stepSize_ROT = -stepSize_ROT;

    nextActiveMillis_ROT = millis() + delay_ROT;
  }

  // prüfen, ob wir BLAU ändern
  if (millis() >= nextActiveMillis_BLAU) {

    // Helligkeit stufenweise ändern
    brightness_BLAU = brightness_BLAU + stepSize_BLAU;
    // auf Wertebereich beschränken
    if (brightness_BLAU > 255)
      brightness_BLAU = 255;
    if (brightness_BLAU < 0)
      brightness_BLAU = 0;

    // neue Helligkeit (Spannungswert) setzen
    analogWrite(10, brightness_BLAU);

    // Beim Unterschreiten oder Überschreiten der Grenzen die Richtung tauschen
    if (brightness_BLAU <= 0 || brightness_BLAU >= 255) 
      stepSize_BLAU = -stepSize_BLAU;

    nextActiveMillis_BLAU = millis() + delay_BLAU;
  }

  // hier könnten wir jetzt noch anderes Zeug machen, während wir auf das Eintreten des
  // nächsten Schaltzustandes warten
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// Klasse, welche die "bin ich jetzt dran" Funktion kapselt
class TimedAction {
public:
  void init(int delay) {
    m_delay = delay;
    m_nextActiveMillis = millis();
  }
  
  void reset() {
    m_nextActiveMillis = millis();
  }

  bool isActive() {
    if (millis() < m_nextActiveMillis) 
      return false; // Aktiv-Zeitpunkt noch nicht erreicht

    // nächsten Zeitpunkt festlegen
    m_nextActiveMillis = millis() + m_delay;

    return true; // Jetzt sind wir aktiv
  }

private:
  unsigned long m_nextActiveMillis   = 0;   // Nächster Aktualisierungszeitpunkt
  int           m_delay              = 50;  // Wartezeit zwischen Anpassungen in ms
};

1
m_nextActiveMillis = millis() + m_delay;

1
2
3
4
5
6
void loop() {
   leds.set(5); // schalte nur LED 1 und 3 an
   delay(30);
   leds.set(2); // schalte nur LED 2 an
   delay(30);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
// Die zu schreibende Klasse LEDstates
class LEDstates {
  // TODO : GTA Teilnehmer
};


// Klassename LEDstates, wir erstellen eine Klassenvariable LEDs
LEDstates LEDs;

const int NUM_PINS = 5;
int PINS[NUM_PINS] = {3, 4, 5, 6, 7};

void setup() {
  // Klassenobjekt LEDs konfigurieren -> Anzahl der PINS/LEDS wird übergeben
  // und der C-Array mit den PIN IDs
  LEDs.setup(NUM_PINS, PINS);
  // alle LEDs ausschalten (quasi wie die Funktion setLEDs() oben programmiert)
  LEDs.set(0);
}


void loop() {
   int permutations = 1 << LEDs.count(); // = 2^NUM_LEDS
   for (int i=0; i<permutations; ++i) {
     LEDs.set(i);
     delay(30);
   }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
// Einbinden unserer Hilfsklassen
#include "LEDstates.h"
#include "LEDFade.h"
#include "TimedAction.h"

class Charge {
public:
  Charge(LEDFade * fade1, LEDFade * fade2, LEDFade * fade3) : 
    m_fade1(fade1),
    m_fade2(fade2),
    m_fade3(fade3)
  {
  }


  void reset() {
    m_timer.reset();
    m_counter = 1; 
    // 1 heißt "Charge hat begonnen" - wenn wir auf 0 
    // zurückfallen, ist Charge-Modus wieder aus
  }


  void updateLEDBrightness() {
    // fade 1 - wenn counter zwischen 0 ... 255
    // fade 2 - wenn counter zwischen 256 ... 511
    // fade 3 - wenn counter zwischen 512 ... 767

    if (m_counter > 255) {
      m_fade1->setValue(255); // komplett an
    }
    else {
      m_fade1->setValue(m_counter);
    }
    if (m_counter > 511) {
      m_fade2->setValue(255); // komplett an
    }
    else {
      int value = m_counter - 256;
      if (value < 0)
        value = 0; // falls counter < 256 ist
      m_fade2->setValue(value);
    }

    int value = m_counter - 512;
    if (value < 0)
      value = 0; // falls counter < 512 ist
    m_fade3->setValue(value);
  }


  void updateCharge(bool lightIsOn) {
    // sind wir dran mit aktualisieren?
    if (!m_timer.isActive())
      return;

    if (lightIsOn) {
      // maxvalue = 3*256 - 1
      if (++m_counter > 767) {
        m_counter = 767;  // Counter bei Maximalwert stoppen
        m_hasReachedMaximum = true;
      }
    }
    else {
      if (--m_counter < 0) {
        m_counter = 0;  // Counter bei Maximalwert stoppen
        m_hasReachedMaximum = true;
      }
    }
    updateLEDBrightness();
  }

  bool isFullyCharged() const {
    return m_hasReachedMaximum && m_counter > 0;
  }

  int m_counter = 0;

private:
  TimedAction   m_timer;
  // Zeiger auf fade-Klassenobjekte (werden extern erzeugt und hier nur benutzt)
  LEDFade      *m_fade1; 
  LEDFade      *m_fade2;
  LEDFade      *m_fade3;
  bool          m_hasReachedMaximum = false;
};



// Zustände unserer Steuerung
enum {
  S_IDLE,    // In diesem Modus wird nur eine LED gefaded
  S_CHARGE,  // In diesem Zustand werden die Charge-LEDs auf-/abgeblendet
  S_ON_MODE1 // Schaltung läuft im Modus 1 los (Willkommen im LCD Display)

  // TODO : weitere Zustände hinzubauen
};


// ** KONSTANTEN/PIN MAPPING **

// Inputs
int BRIGHTNESS_PIN = A0;

// Outputs

// PWM Pins
int CHARGE_PIN1 = 9;
int CHARGE_PIN2 = 10;
int CHARGE_PIN3 = 11;

// Pins für die LEDs
int LED_PINS[8] = { 2, 4, 7, A1, A2, A3, A4, A5};

// ** VARIABLEN **

// Zur Ansteuerung der dimmbaren Charge-LEDs
LEDFade fade1;
LEDFade fade2;
LEDFade fade3;

// Controller für die ganze Charge-Logik
Charge charge(&fade1, &fade2, &fade3);

// Klasse für die 8 LEDs
LEDstates leds;

// Aktueller Zustand der Schaltung
int state = S_IDLE;

// Variablen für verschiedene Modi
TimedAction onModeTimer;
int onModeCounter;
int ledNumberCounter = 0;

// Timer für Debug-Ausgaben durch die serielle Schnittstelle
TimedAction serialTimer;


void setup() {
  fade1.init(CHARGE_PIN1, true, 0, 25, 5); // Konfiguriert zum langsam pulsieren
  fade2.init(CHARGE_PIN2, true, 0, 10, 5);
  fade3.init(CHARGE_PIN3, true, 0, 10, 5);

  pinMode(BRIGHTNESS_PIN, INPUT);

  leds.setup(8, LED_PINS);
  leds.set(0);

  serialTimer.init(500); // alle 500 ms eine Meldung über USB
  Serial.begin(115200);
}



// ** Hauptschleife, wird ständig durchlaufen **
void loop() {

  // Den Helligkeitssensor lesen wir immer aus.
  int brightnessValue = analogRead(BRIGHTNESS_PIN);
  // wenn Helligkeit größer als 900, dann ist das Licht an
  bool lightIsOn = (brightnessValue > 900); 

  // Je nachdem in welchem Modus die Schaltung ist, machen wir verschiedene Sachen.
  switch (state) {
    case S_IDLE: // Rote LED pulsieren lassen und auf Licht-An warten
      fade1.fade();
      if (lightIsOn) {
        state = S_CHARGE; // Licht ist an - wir wechseln in den Zustand 'Charge'
        charge.reset();
      }
    break;

    case S_CHARGE: // Charge-LEDs werden heller (oder ohne Licht wieder dunkel)
      charge.updateCharge(lightIsOn);
      // sind wir zurück auf 0 gefallen, gehen wir wieder in den Modus IDLE
      if (charge.m_counter == 0)
        state = S_IDLE;
      // sind wir vollkommen aufgeladen, gehen wir in den Modus ON_MODE1
      if (charge.isFullyCharged()) {
        state = S_ON_MODE1;
        onModeCounter = 0; // wir beginnen mit LED-Stufe 0
        onModeTimer.init(100);
      }
    break;

    case S_ON_MODE1: // in diesem Modus schalten wir alle LEDs schnell 
                     // hintereinander ein und aus und dann das LCD-Display an
      if (onModeTimer.isActive()) {
        ++onModeCounter;
        if (onModeCounter % 2) {  // ungerade Zahl?
          leds.set(255);
        }
        else {
          leds.set(0);
        }
        if (onModeCounter == 20) {
          // for now fall back to idle mode
          state = S_IDLE;
        }
      }
    break;
  }

  // Debug-Feedback
  if (serialTimer.isActive()) {
    Serial.print(brightnessValue);
    Serial.print(",");
    Serial.print(state);
    Serial.print(",");
    Serial.println(charge.m_counter);
  }
}