Verkehrsampel V2

// Two traffic lights, using the standard pattern (R,R+Y,G,Y).

// version 2

#include <Adafruit_NeoPixel.h>

// we use a single strip of 14 LEDs, two LEDs per lamp
// traffic light A with three lamps:  RED( 1, 2), YELLOW( 3, 4), GREEN( 5, 6)
// traffic light B with three lamps:  RED(11,12), YELLOW( 9,10), GREEN( 7, 8)
Adafruit_NeoPixel strip = Adafruit_NeoPixel(14,26);

 // position of the first LED of each LAMP for each TL
int ledPos[2][3] = { 
    {1,3,5},            // tlA
    {11,9,7}            // tlB
};

#define PIX_PER_LAMP 2                      // number of led pixels per lamp

int tlA=0, tlB=1;                           // the two Traffic Lights


// switching times; note that "red time" is only the overlap between the traffic lights
// id addition a TL will always be red when its opposing TL shows yellow or green

// standard times per STATE (durations in msec)
int stdTimes[4] = { 500, 1000, 10000, 2000 };

// specific times for each TL
int times[2][4];                    // specific durations for each traffic light

// symbolic constants for the different STATES of a TL
#define STOP                0       // red lamp on
#define ALERT               1       // simultaneously red and yellow on
#define GO                  2       // green lamp on
#define HALT                3       // yellow lamp on

// the three base colors; note that brightness will be adjusted separately
uint32_t colors[3] = {
    strip.Color( 255,   0,   0 ),       // RED
    strip.Color( 128, 128,   0 ),       // YELLOW
    strip.Color(   0, 255,   0 )        // GREEN
};
// symbolic constants for the lamp color index
#define RED_LAMP     0
#define YELLOW_LAMP  1
#define GREEN_LAMP   2


/*
 * We have several layers of functions, from TOP to BOTTOM:
 *   (7) setGreenTime       : configure switching times
 *   (6) peformCycle        : walk through all states in the correct sequence
 *   (5) stop,alert,go,halt : change state of TrafficLight switching appropriate lamp(s)
 *   (4) xOff               : switch a certain lamp (x) OFF
 *   (3) on, off            : switch a lamp on/off using its fixed color
 *   (2) setColor           : assign a color to an arbitrary lamp, changing all of its LEDs
 *   (1) showFor            : transfer LED settings to the strip and wait  for the appropriate time
 */

// Layer (1) : transfer LED states to the strip and wait for the specified time
void showFor(int msec) {
    strip.show();
    delay(msec);
}

// Layer (2) : set a single lamp to an arbitrary color
void setColor(int tlNr, int lampNr, uint32_t color) {
    strip.fill(color,ledPos[tlNr][lampNr],PIX_PER_LAMP);    
}

// Layer (3) : switch a single lamp ON or OFF using its fixed color
void on(int tlNr, int lampNr) {
    setColor(tlNr,lampNr,colors[lampNr]);    // each lamp has its fixed color
}
void off(int tlNr, int lampNr) {
    setColor(tlNr,lampNr,0);    // color 0 == BLACK == OFF
}

// Layer (4) : switch OFF a certain lamp
void RedOff(int tlNr) {
    off(tlNr,RED_LAMP);
}
void YellowOff(int tlNr) {
    off(tlNr,YELLOW_LAMP);
}
void GreenOff(int tlNr) {
    off(tlNr,GREEN_LAMP);
}

// Layer (5) : change state of TL switching the necessary lamps ON or OFF
void stop(int tlNr) {
    YellowOff(tlNr);
    on(tlNr,RED_LAMP);
    showFor(times[tlNr][STOP]);
}
void alert(int tlNr) {
    on(tlNr,YELLOW_LAMP);
    showFor(times[tlNr][ALERT]);
}
void go(int tlNr) {
    RedOff(tlNr);
    YellowOff(tlNr);
    on(tlNr,GREEN_LAMP);
    showFor(times[tlNr][GO]);
}
void halt(int tlNr) {
    GreenOff(tlNr);
    on(tlNr,YELLOW_LAMP);
    showFor(times[tlNr][HALT]);
}

// Layer (6) : walk through all states in the correct sequence
void performCycle(int tlNr) {
    stop        (tlNr);
    alert       (tlNr);
    go          (tlNr);
    halt        (tlNr);
    stop        (tlNr);   
}

// Layer (7) : configure switching times (adjust duration of GREEN_TIME)
void setGreenTime(int tlNr, int greenTime) {
    for (int d=STOP;d<=HALT;d++) {
        times[tlNr][d] = stdTimes[d];
    }    
    times[tlNr][GO] = greenTime;
}


void setup() {
    Serial.begin(115200);
    delay(100);

    Serial.println("Traffic Lights starting ..");
    strip.fill();
    strip.setBrightness(20);

    setGreenTime(tlA,  5000);
    setGreenTime(tlB, 10000);

    stop(tlA);
    stop(tlB);
}

void loop() {

    performCycle(tlA);
    performCycle(tlB);
}

// This little program demonstrates the idea of OBJECT ORIENTATION.
// version 1

// message logging to the serial port with time stamp
void debug(String message) {
    Serial.println(message);
}

// ============== INTERFACE of class DOG

class Dog {
    // a dog can sleep, eat and play.
    
    public:
        Dog(String name);
        void sleep(); 
        void eat();
        void play();
    private:
        String name;
};

// ============= IMPLEMENTATION of class DOG

Dog::Dog(String name) {
    this->name=name;
}

void Dog::sleep() {
    debug(name+": I am sleeping");
}
void Dog::eat() {
    debug(name+": I am eating");
}
void Dog::play() {
    debug(name+": I am playing");
}


// ================ USING class DOG

void setup() {
    // setup serial port
    Serial.begin(115200);
    delay(1000);

    Dog fluffy = Dog("Fluffy");
    Dog bobby = Dog("Bobby");

    fluffy.sleep();
    fluffy.eat();
    bobby.eat();
    fluffy.play();
}

void loop() {}

Fluffy: I am sleeping
Fluffy: I am eating
Bobby: I am eating
Fluffy: I am playing

// This little program demonstrates the idea of OBJECT ORIENTATION.
// version 2

// message logging to the serial port with time stamp
void debug(String message) {
    Serial.println(message);
}

// INTERFACE

class Dog {
    // a dog can sleep, eat and play.
    // It gets tired by playing and will be hungry after sleeping
    
    public:
        Dog(String name);
        void sleep(); 
        void eat();
        void play();
        boolean isHungry();
    private:
        bool hungry;
        bool tired;
        String name;
};

// IMPLEMENTATION

Dog::Dog(String name) {
    this->name=name;
    hungry=false;
    tired=false;
}

void Dog::sleep() {
    if (hungry) {
        debug(name+": cannot sleep. Give me a bone, please!");
    }
    else if (tired) {
        debug(name+": sleeping ..");
        tired=false;
        hungry=true;
    }
    else {
        debug(name+": I am not tired");
    }
}
void Dog::eat() {
    if (hungry) {
        debug(name+": yes, time for eating -- tastes good!");
        hungry=false;
    }
    else {
        debug(name+": I am not hungry");
    }
}
void Dog::play() {
    if (!hungry && !tired)  {
        debug(name+": yes, playing is great fun!");
        tired=true;
        hungry=true;
    }
    else {
        debug(name+": I do not want to play now.");
    }
}

boolean Dog::isHungry() {
    return hungry;
}

// USAGE

void setup() {
    // setup serial port
    Serial.begin(115200);
    delay(1000);

    Dog fluffy = Dog("Fluffy");
    
    fluffy.sleep();
    fluffy.play();
    fluffy.sleep();
    debug("Fluffy might be hungry? : "+String(fluffy.isHungry()));
    fluffy.eat();
    debug("still hungry, Fluffy? "+String(fluffy.isHungry()));
    fluffy.sleep();
    fluffy.play();
    fluffy.sleep();
    fluffy.eat();
}

void loop() {}

Fluffy: I am not tired
Fluffy: yes, playing is great fun!
Fluffy: cannot sleep. Give me a bone, please!
Fluffy might be hungry? : 1
Fluffy: yes, time for eating -- tastes good!
still hungry, Fluffy? 0
Fluffy: sleeping ..
Fluffy: I do not want to play now.
Fluffy: cannot sleep. Give me a bone, please!
Fluffy: yes, time for eating -- tastes good!