makerClock_zum_Anpassen.ino

#include <Wire.h>                 // "Wire" Library für die Kommunikation zum Real Time Clock Chip
#include <Adafruit_NeoPixel.h>    // "Adafruit NeoPixel" Library für die LEDs
// https://github.com/adafruit/Adafruit_NeoPixel
#include "TimerOne.h"             // "TimerOne" Library für den Drehencoder
// https://playground.arduino.cc/Code/Timer1

#ifdef __AVR__
#include <avr/power.h>
#endif

#define PIN_LED 6  // LEDs sind am Pin D6 angeschlossen
#define NUM_PIXELS 60  // Anzahl LEDs = 60
#define LED_OFFSET 41  // Anpassung der 12 Uhr Ausrichtung

// Encoder Pins
#define PIN_ENCODER_A 3         // Interrupt Pin
#define PIN_ENCODER_B 4
#define PIN_BUTTON 5
#define PIN_LIGHT_SENSOR 3

// Real Time Clock (RTC) DS1307
#define DS1307_I2C_ADDRESS 0b1101000

// Button States
#define IS_PRESSED LOW
#define IS_RELEASED HIGH

// Color definitions
#define RED pixels.Color(225,0,0)
#define GREEN pixels.Color(0,255,0)
#define BLUE pixels.Color(0,0,255)
#define PURPLE pixels.Color(255,5,255)
#define LIGHT_RED pixels.Color(150,0,0)
#define LIGHT_WHITE pixels.Color(205,205,65)
#define LIGHT_BLUE pixels.Color(0,58,238)
#define DARK_BLUE pixels.Color(0, 71, 186)
#define MEINE_FARBE 0x50AB00

// Hier können die Farben eingestellt werden
#define HCOLOR DARK_BLUE  // color for hours
#define MCOLOR LIGHT_WHITE   // color for minutes
#define SCOLOR RED    // color for seconds

//Die zwei LEDs auf der Frontseite:
#define LED1 A1
#define LED2 A2
//digitalWrite(LED1,1);

#define COUNTER_BUTTON_PRESSED 10
#define TIME_TO_SWITCH_TO_NEXT_STATE 5

volatile signed int ec_pos = 0;
volatile bool encoder_en = true;
int sekunden = 0;
int second_ds = 0;
signed int stonde = 0;
unsigned  int clock_state = 0;
unsigned int time_h = 0;
unsigned int time_m = 0;
unsigned int time_s = 0;

unsigned int counter = 0;

float brightnessFilter = 0;

Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUM_PIXELS, PIN_LED, NEO_GRB + NEO_KHZ800);

/*
   Setup
   -> the setup function runs once when you press reset or power the board
*/
void setup() {
  pinMode(PIN_ENCODER_A, INPUT_PULLUP);
  pinMode(PIN_ENCODER_B, INPUT_PULLUP);
  pinMode(PIN_BUTTON, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(PIN_ENCODER_A), doEncoderA, CHANGE);

  Wire.begin();                             //i2c (serielle Schnittstelle) starten

  Timer1.initialize(50000);                 // initialize timer1 to 50ms
  Timer1.attachInterrupt(timer1callback);   // attaches callback() as a timer overflow interrupt

  pixels.begin();                           //LED Starten
  // rtcset(30,3);           //(fkt setzt stunden und Minuten des RTC--> integer)

  Serial.begin(9600);
  int brightness = analogRead(PIN_LIGHT_SENSOR);
  //  Serial.print("Brightness Test: ");
  //  Serial.print(brightness);
  //  Serial.print("\n");
  Serial.print("Started...\n");
}

/*
   Main Loop as endless loop
*/
void loop() {
  // Clear LEDs
  pixels.clear();

  // Check if button is pressed
  boolean button_state = checkButtonState();

  // Check for clock state transition based upon button state
  clock_state = recalculateClockState(clock_state, button_state);

  // Move the hour, minute and second hand if necessary
  setClock();

  // Wait for 50ms
  delay(50);
}

boolean checkButtonState() {
  return digitalRead(PIN_BUTTON);
}

int recalculateClockState(int old_state, boolean button) {
  int new_state = old_state;
  switch (old_state) {
    case 0:
      time_h = rtchours();
      time_m = rtcminutes();
      time_s = rtcseconds();

      if (button == IS_PRESSED) {
        // Switch to clock setting
        new_state = 1;
      }
      break;
    case 1:
      counter++;
      if ((button == IS_PRESSED) && (counter > COUNTER_BUTTON_PRESSED)) {
        // Show animation to the user
        animation(1);

        ec_pos = 60 + time_h;
        new_state = 2;
        counter = 0;
      } else if (button == IS_RELEASED) {
        new_state = 0;
        counter = 0;
      }
      break;
    case 2:
      time_m = ec_pos % 60;
      if ((button == IS_PRESSED) && (counter > TIME_TO_SWITCH_TO_NEXT_STATE)) {
        ec_pos = 120 + time_m;
        animation(2);
        new_state = 3;
        counter = 0;
      } else if (button == IS_RELEASED) {
        counter++;
      }
      break;
    case 3:
      time_h = ec_pos % 12;
      if ((button == IS_PRESSED) && (counter > TIME_TO_SWITCH_TO_NEXT_STATE)) {
        rtcset(time_m, time_h);
        animation(3);
        new_state = 0;
        counter = 0;
      } else if (button == IS_RELEASED) {
        counter++;
      }
      break;
    default:
      new_state = 0;
  }
  return new_state;
}

void setClock() {
  // set hour clockhand moving every 5 minutes
  pixels.setPixelColor(((time_h + NUM_PIXELS) * 5 + LED_OFFSET-2 + (time_m / 12)) % NUM_PIXELS, HCOLOR);
  pixels.setPixelColor(((time_h + NUM_PIXELS) * 5 + LED_OFFSET-1 + (time_m / 12)) % NUM_PIXELS, HCOLOR);
  pixels.setPixelColor(((time_h + NUM_PIXELS) * 5 + LED_OFFSET   + (time_m / 12)) % NUM_PIXELS, HCOLOR);
  pixels.setPixelColor(((time_h + NUM_PIXELS) * 5 + LED_OFFSET+1 + (time_m / 12)) % NUM_PIXELS, HCOLOR);
  pixels.setPixelColor(((time_h + NUM_PIXELS) * 5 + LED_OFFSET+2 + (time_m / 12)) % NUM_PIXELS, HCOLOR);
  // set minute clockhand
  pixels.setPixelColor((time_m + LED_OFFSET) % NUM_PIXELS, MCOLOR);
  // set second clockhand
  pixels.setPixelColor((time_s + LED_OFFSET) % NUM_PIXELS, SCOLOR);

  // check brightness
  brightnessFilter = (29 * brightnessFilter + getBright()) / 30; // Moving Average Filter
  pixels.setBrightness(brightnessFilter);

  pixels.show();
}

/*
   Encoder Interrupt Routine
*/
void doEncoderA() {
  // look for a low-to-high on channel A
  if (encoder_en) {
    encoder_en = false;
    if (digitalRead(PIN_ENCODER_A) == HIGH) {
      // check channel B to see which way encoder is turning
      if (digitalRead(PIN_ENCODER_B) == LOW) {
        ec_pos = ec_pos + 1;         // CW
      }
      else {
        ec_pos = ec_pos - 1;         // CCW
       
      }
    } else {
      // must be a high-to-low edge on channel A
      // check channel B to see which way encoder is turning
      if (digitalRead(PIN_ENCODER_B) == HIGH) {
        ec_pos = ec_pos + 1;          // CW
      } else {
        ec_pos = ec_pos - 1;          // CCW
      }
    }
    Timer1.start();
  }
}

/*
   Timer1 Interrupt Routine (Used for encoder debouncing)
*/

void timer1callback() {
  encoder_en = true;
  Timer1.stop();
}

/*
   Sekunden von RTC Abfragen
   Input: --
   Output: Integer Sekunden (0-59)
*/
unsigned int rtcseconds(void) {
  Wire.beginTransmission(DS1307_I2C_ADDRESS);      // Get the slave's attention, tell it we're sending a command byte
  Wire.write(0x00);                       //  The command byte, sets pointer to register with address of 0x32
  Wire.endTransmission();
  Wire.requestFrom(DS1307_I2C_ADDRESS, 1);         // Tell slave we need to read 1byte from the current register
  int sec = Wire.read();                      // read that byte into variable
  Wire.endTransmission();                 // "Hang up the line" so others can use it (can have multiple slaves & masters connected)
  return sec % 16 + (10 * (sec >> 4));    //BCD zu dezimal umrechen
}

/*
   Minuten von RTC Abfragen
   Input: --
   Output: Integer Minuten (0-59)
*/
unsigned int rtcminutes(void) {
  Wire.beginTransmission(DS1307_I2C_ADDRESS);      // Get the slave's attention, tell it we're sending a command byte
  Wire.write(0x01);                       //  The command byte, sets pointer to register with address of 0x32
  Wire.endTransmission();
  Wire.requestFrom(DS1307_I2C_ADDRESS, 1);         // Tell slave we need to read 1byte from the current register
  int m = Wire.read();                    // read that byte into variable
  Wire.endTransmission();                 // "Hang up the line" so others can use it (can have multiple slaves & masters connected)
  return m % 16 + (10 * (m >> 4));        //BCD zu dezimal umrechen
}

/*
   Stunden von RTC Abfragen
   Input: --
   Output: Integer Stunden
*/
unsigned int rtchours(void) {
  Wire.beginTransmission(DS1307_I2C_ADDRESS);      // Get the slave's attention, tell it we're sending a command byte
  Wire.write(0x02);                       // Set the address to the hour register
  Wire.endTransmission();
  Wire.requestFrom(DS1307_I2C_ADDRESS, 1);         // Tell slave we need to read 1byte from the current register
  int h = Wire.read();                    // read that byte into variable
  Wire.endTransmission();                 // "Hang up the line" so others can use it (can have multiple slaves & masters connected)
  return h % 16 + (10 * (h >> 4));        // BCD zu dezimal umrechen
}

/*
   RTC Zeit einstellen                     TODO:Erwartet BCD Werte (--> noch anpassen)
   Input: Integer Minuten
          Integer Stunden
   Output: --
*/
void rtcset(int m, int h) {
  Wire.beginTransmission(DS1307_I2C_ADDRESS);
  Wire.write(0x00);                       // set next input to start at the seconds register
  Wire.write(0);                          // set seconds

  m = m % 10 + ((m / 10) << 4);
  Wire.write(m);
  // set min
  h = h % 10 + ((h / 10) << 4);
  Wire.write(h);                         // set hours
  Wire.endTransmission();
}

/*
  Helligkeit abfragen
  Input: --
  Output: Integer mit Helligkeitswert. Gefiltert und skaliert 0-255 (dunkel-hell)
*/
int getBright(void) {
  signed int brt = 0;
  brt = analogRead(PIN_LIGHT_SENSOR);
  if (brt >= 512) {
    brt = (234 - (brt - 512) / 2);
  }
  else {
    brt = 255;
  }
  if (brt < 3) {
    brt = 3;
  }
  return brt;
}

/*
  Animation für den Uebergang zum Zeit-Programmiermodus
*/
void animation(int sel) {
  switch (sel) {
    case 1:
      for (int i = 0; i < NUM_PIXELS; i++) {
        int red = 0 + i * 4;
        pixels.setPixelColor(59 - i, pixels.Color(red, 0, 0));
        // from 0 (off) to 255 (max brightness)
        pixels.setBrightness(i*4);
        pixels.show();
        delay(20);
      }
      break;
    case 2:
      for (int loop = 0; loop < 22; loop++) {
        int green = loop * 10;
        for (int i = 0; i < NUM_PIXELS; i++) {
          pixels.setPixelColor(i, pixels.Color(0, green, 0));
        }
        // from 0 (off) to 255 (max brightness)
        pixels.setBrightness(loop*10);
        pixels.show();
        delay(30);
      }
      break;
    case 3:
      for (int i = 0; i < NUM_PIXELS; i++) {
        pixels.clear();
        int green = 240 - i * 4;
        pixels.setPixelColor(i, pixels.Color(0, green, 0));
        // from 0 (off) to 255 (max brightness)
        pixels.setBrightness(255 - i*4);
        pixels.show();
        delay(20);
      }
  }
}