Ich habe einiges weitergefrickelt hier. Für den zweiten Wecker, den ja meine Schwester bekommt hab ich mir Stereosound vorgenommen, der soll von einem PAM 8403 verstärkt werden.
Ich habe mich versucht im Aufbau schönerer Platinen.
Dann kam heraus, dass der dfPlayer ne kleine Drecksau ist, und Entstörungsmaßnahmen braucht. Obligatorisch ist die spannungreduzierte Versorgung @4,2V und die serielle Verbindung mit 1k inline für RX UND TX. Im Netz findet man Anleitungen, dass nur in einem Pfad(vergessen welcher) der Widerstand nötig wäre, aber das führt zu deutlich hörbaren Einstreuungen. Dann sollte es ja eigentlich reichen, die DAC-Ausgänge des dfPlayers über nen Spannungsteiler am Verstärker anzuschließen, nur leider wird da das Vergnügen durch ein brummähnliches Geräusch gestört. Nach etwas googeln hab ich ein Datenblatt zum yx5200 genannten Chip
, und siehe da, es gibt einen Pin, der für "decoupling" verwendet werden soll. Da hab ich mal nen Elko mit 100µF drangehängt und mit dem Kopfhörer als einzige am DAC angeschlossene Last gekuckt, wie sich das verhält. Wenn ich den Elko direkt an der Masse vom Kopfhörer kontaktiert hab, ging das Geräusch weg, bei anderen Massepunkten nicht. Gleiches Prinzip am PAM8403 probiert: funzt.
Durch Labornetzteil-Fehlbedienung hab ich ne µSD-Karte gehimmelt und war am grübeln, ob das an meiner Entkopplungslösung gelegen haben könnte, die Neue zeigt aber keinerlei Ausfallserscheinungen, hoffentlich bleibt das so.
Da ich den integrierten Amp nicht nutze, hab ich den direkt von der Platine runtergelötet und einen der dadurch freiwerdenden Pins für die Entkopplungsleitung zum Verstärker genutzt. Hier ist der aktuelle Schaltplan:
Der Spannungsteiler am Helligkeitssensor verträgt auch mehr als 20k, der Sensor, den ich da jetzt habe kommt von Maxens und hat ne etwas andere Kennlinie als der im ersten Wecker. Den höheren Vorwiderstand für die LED hab ich durch leicht unterdimensionierte Zuleitung erreicht, die lässt sich auch leichter verlegen.
Der Spannungsteiler vor den Eingängen am Verstärker verträgt wahrscheinlich auch 8-10k statt der 4,7. Mir ist das laut genug und man bekommt ne bessere SNR-Ratio, weil man den DAC voll(er) aussteuert. Die Platine die ich hier hab führt den Enable-Pin nicht heraus und hat dafür 2x GND, das fand ich unnötig und hab einen der beiden GND-Pins umgewidmet. Leider macht Pam Knackser, wenn sie über enable an- und ausgeschaltet wird, da hatte ich mir besseres erhofft.
kleine Anprobe, wird mal wieder knapp. Der Entkopplungselko kommt beim nächsten Mal auf die Lochrasterplatine, die Heißkleber-Huckepack Lösung ist nicht so schön...
So sieht das jetzt aus. Die Verdunklungsfolie auf dem Display verbessert die Lesbarkeit enorm, weil man die inaktiven Segmente quasi nicht mehr sieht. Vorher war da der LED-Phosphor zu sehen, der natürlich auch auf blaues Licht aus anderen Quellen anspricht.
Bei Gehäuse n°2 hab ich es geschafft, nicht bis ganz hinten durchzufräsen, der KüKö hat dadurch bessere Konvektion. Beim Bauhaus hatten sie wg Corona nurnoch Reststücke an Plexiglas, das größte hatte 6mm, nehm ich halt das. Ist jetzt auch ne andere Mattierungsfolie ohne Streifen und mit recht grober Textur. Gefällt mir besser.
Am Code gings auch weiter, ich hatte zwischenzeitlich mit ner race-condition eine Beschleunigungsfunktion für den Encoder zusammengepfuscht, die bei schnellem Drehen statt Minuten halbe Stunden addiert/subtrahiert hat. Das war dann aber doch etwas fummelig und wurde wieder auf die Umschaltlösung zurückgebaut. Hab mal Quellen angegeben und hier und da etwas aufgeräumt. Die v1.0 kommt nah, ich muss mich zusammenreißen nicht neue features zu proggen, während noch ungeliebter Kleinkruscht abgearbeitet werden will.
Code: Alles auswählen
Edit: Aktualisierter Code vom Post drunter
//Lichtwecker v1.0
//Dieser Sketch ist getestet auf Nano V3 (ATmega 168:Button2Pin@#13, nur <80 Plätze für shuffle wg wenig Speicherplatz; Bedarf wahrscheinlich weiterer Optimierungen
// AtMega 328T, Button2Pin@#12, Kann 255 Plätze für shuffle, Displayhelligkeit anderer Sensor und Spannungsteiler)
//done: Encoderbeschleunigung wieder rauswerfen, ist doof wg Undosierbarkeit.
//Done! beleuchteter Taster für Anzeige Alarm Scharfgestellt, LED soll auch gedimmt werden. Ungenutzten tm1637 Pin rausführen?
//done: Shuffle anstelle von Random für Songs abspielen. (Speicherbedarf! Ò_ó)
//done: neue Funktion für Fading: averaging vor Ausgabe an PWM, ersetzt jetzt nicht mehr notwendige for-loops.
//done: einstellbarer Sleep-Timer für Leselicht, nach x Minuten schaltet die Lampe von alleine ab.
//todo:
//
//neues Feature: Sleep Timer bekommt nach Wahl einen langsamen "Sonnenuntergang in den letzten x Minuten.
// ^Mangel an Bedienelementen?^
//
/* Beschreibung:
*
Kann: Wecken mit 16bit Sonnenaufgang, dazu MP3 Abspielen(no1). Es gibt 4 Weckzustande:
1. Sonnenaufgang, MP3 aus Ordner1 wird abgespielt. dauert 30 Minuten
2. nach Ablauf von 1. ohne Interaktion kommt MP3 aus Ordner2 (lauteres, invasiveres Audio),
weiterhin volle Helligkeit
3. Wenn während 1. oder 2. der Ausknopf (Button2) gedrückt wird, wird ein angenehmer H-Wert gesetzt und angenehme leise Musik(Ordner3) gespielt.
4. Wenn der Ausknopf erneut gedrückt wird, wird das Licht ausgefadet und abgeschaltet.
MP3 aus Ordner4 wird abgespielt (soll nur n kurzer Sound sein, unter 10s. Zu lang wird abgeschnitten wg ende des Fadeouts)
Weckzeit wird angezeigt bei gedrücktem Ausknopf(Button2) Eingestellt mittels Encoder,
Druck auf Encoder Pushbutton (Button0) wechselt Stunden/Minuten. Was gerade eingestellt wird,
kann im Moment noch nicht angezeigt werden.(todo, benötigt andere library)
Neue Uhrzeit wird eingestellt indem man die Uhrzeit als Weckzeit einstellt und dann den Alarm an/aus
Button (Button1) 5Sekunden oder länger hält. die Zeit wird on Button release geschrieben, man kann
also die nächste Minute einstellen, den Knopf gedrückt halten und im richtigen Moment loslassen und
hat eine sehr genau eingestellte Zeit.
Mit Doppelklick auf den Arcade Button (Button2) kann man die LED zu Beleuchtungszwecken verwenden, Über die Einstellung der Weckstunden
kann man die Intensität einstellen. Stufe 0 ist besonders Dunkel, zur Verwendendung als Nachtlicht.
Die Helligkeit des Displays wird automatisch der Umgebungshelligkeit angepasst. Zum Einlesen wird ein
Spannungsteiler zwischen 5v-Fotoresistor-20K_Ohm-GND Auf A7 eingelesen und nach Beschränkung auf
setBrightness gemappt.
Folgende Bibliotheken werden benötigt:
bereits in Arduino IDE integriert:
-wire.h
-SoftwareSerial.h
Separat zu installieren:
-DFPlayerMini_Fast by PowerBroker2
-TM1637 by Avishay Orpaz
-encoder.h by Paul Stoffregen
Die Codeschnipsel um den ds3231 einzulesen stammen von:
https://tronixstuff.com/2014/12/01/tutorial-using-ds1307-and-ds3231-real-time-clock-modules-with-arduino/
Die 16Bit-PWM Codeschnipsel stammen von:
https://github.com/RoboUlbricht/arduinoslovakia/blob/master/timer/timer1_pwm_16bit/timer1_pwm_16bit.ino
getestet auf: Arduino Nano v3 (AtMega168, AtMega328P) (bei 168 ist der Speicherplatz ist knapp, serial-> PC könnte Probleme verursachen, wenn es aktiviert wird)
*/
//DFPlayer mini
#include <SoftwareSerial.h>
#include <DFPlayerMini_Fast.h>
SoftwareSerial mySerial(A2, A1); // RX, TX
DFPlayerMini_Fast myMP3;
#include "Wire.h"
#define DS3231_I2C_ADDRESS 0x68 //DS3231 Zeitgeber
//Tm1637
//#include <Arduino.h>
#include <TM1637Display.h>
// Module connection pins (Digital Pins)
#define CLK 5
#define DIO 4
TM1637Display display(CLK, DIO);
//Encoder
#include <Encoder.h>
Encoder myEnc(2, 3);
//Eingänge
#define button0Pin 6 // Encoder pushbutton pin
#define button1Pin 7 // Alarm an/aus & Zeit setzen Knopf
byte button2Pin = 12; // Arcade Button auf der Oberseite - Neue Rev:D12 alte Revision: Pin D13
const byte HellPin = A7; //Einlesen der aktuellen Helligkeit im Raum über Fotowiderstand*Spannungsteiler
//Ausgänge
const byte ledPin = 10; //(10)LED/Mosfet - Treiber angeschlossen an Pin9 oder 10 (16Bit PWM)
const byte disPin = 9; //(9)Display Stromversorgung an armeleute DAC//Spannung soll auch für Tasterbeleuchtung in V2 herhalten!
const byte AmpEnPin = 8; //Amp Enable, brauchts nicht mehr
const byte PampEnPin = A3; //ist A3, verschoben wg debug dfPlayer
//Variablen
unsigned long schedulT = 0; //Aufrufe der Uhrzeit /DS3231 begrenzen auf 1x pro Sekunde
unsigned long fadePointer = 0; //wird bei Alarmauslösung gesetzt und dient zur Berechnung der Helligkeit während Alarmablaufs
unsigned long fadeZaehl=0; //siehe fadePointer
unsigned long LpTimer = 0; //Erkennung von langen und kurzen Drückern auf button1.
unsigned long DCTimer = 0; //Erkennung von Doppelklick auf Button2.
unsigned long LedPWMVal =0; //Smoothing und Ausgabe Der LEd-PWM
unsigned int leuchtVal1= 0; //für Übertragung des PWM-Werts zwischen Berechnung und Smoothing/Ausgabe
int smooBrigh=400; //Helligkeitssensor braucht smoothing, da die PWM der LED (wenn an) stark
//unterschiedliche Helligkeiten erzeugt. (besser wäre kleiner Elko)
byte mins=0; // Uhrzeit Minuten
byte hours=0; // Uhrzeit Stunden
byte Amins=0; // Anzeige-Weckzeit Minuten
byte Ahours=0; // Anzeige-Weckzeit Stunden
byte rAmins=0; // Alarmbeginnzeit Minuten = 30 Minuten vor Weckzeit (r für real)
byte rAhours=0; // Alarmbeginnzeit Stunden
byte folder01 = 1; //wieviele Tracks in folder#?
byte folder02 = 1;
byte folder03 = 1;
byte folder04 = 1;
byte playing = 0; //(welches Verzeichnis)wird gerade abgespielt? 0=stop
byte AlarmState=0; //Wird gerade geweckt? Wo sind wir in der Weckfunktion? (0-4)
bool AlarmV=false; //Weckfunktion an oder aus?
bool ZeigeAl=false; //Weckzeit anzeigen wenn true
bool lichtAn=false; //Variable für Lichtfunktion
unsigned long fadeULong=100; //Var für die Logarithmische Berechnung des Helligkeitswertes
byte RestSchlaf=0; //Restschlafanzeige während Alarm
bool zeigeRS=false;
bool button2Pressed=false; //für lange und kurze drücker brauchts ne extra Var
bool button1Pressed=false; //für lange und kurze drücker brauchts ne extra Var
bool button0State = false;
bool button1State = false;
bool button2State = false;
byte buttonCount = 0; //Wie weit ist der Doppelklick schon fortgeschritten?
bool encTarget=0; //encoder target wechselbar für Stunden/Minuten/Leuchtstärke(Nachtlicht)
unsigned long debTimer=0; //Button debounce
byte encVal = 0;
byte SleepTime=0; //Wie lang soll die Lampe Leuchten bei Aktivierung des Sleeptimers?
bool sleepStell=false; //wird gerade der Sleeptimer eingestellt?
int oldPosition=0;
int realBrigh=1; //Durchschnittsbildung Helligkeitsmessung für Displayhelligkeit
// Array geht von 1-255 Wird nach jedem Durchlauf mit neuen Zufallszahlen beschrieben und braucht Platz
// zum Abspeichern der schon gespielten Tracks
byte questionNumberArray[] = {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, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225,
226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246,
247, 248, 249, 250, 251, 252, 253, 254, 255};
/* restliche Zahlen aus Array werden akut nicht benötigt da unter 100 Songs, Speicherplatz sparen@ atmega168.
Zahlen hierhin verschieben:
---
---
-----*/
//---ende Array
byte shufflePos = 0; //wieviele Tracks wurden schon gespielt?
//------- nötig Zum Auslesen/schreiben von DS3231------------------------------------
// Convert normal decimal numbers to binary coded decimal
byte decToBcd(byte val){
return( (val/10*16) + (val%10) );
}
// Convert binary coded decimal to normal decimal numbers
byte bcdToDec(byte val){
return( (val/16*10) + (val%16) );
}
//--------------------------------------------------------------
//---------------------------------------------------------------
void setup(){
//Serial.begin(9600); //Debugging, if needed only.
//I2C für DS3231
Wire.begin();
//Eingänge
pinMode (button0Pin, INPUT_PULLUP);
pinMode (button1Pin, INPUT_PULLUP);
pinMode (button2Pin, INPUT_PULLUP);
pinMode (2, INPUT_PULLUP); //encoder
pinMode (3, INPUT_PULLUP);
//Ausgänge
pinMode (AmpEnPin, OUTPUT);
pinMode (PampEnPin, OUTPUT);
//pinMode (DcdcEnPin, OUTPUT);
digitalWrite(AmpEnPin,HIGH); //Amp(dfPlayer) Aus, Logik invertiert
digitalWrite(PampEnPin,LOW); //Amp(Pam8403) Aus
delay(10);
//serielle Verbindung zum DFplayer aufbauen
mySerial.begin(9600);
myMP3.begin(mySerial);
delay(400);
myMP3.volume(18); //Lautstärke (soll 18) Wird außerdem in void audioPlbk() gesetzt für Geräusche vs Musik
delay(10);
myMP3.EQSelect(3); //ohne Pam8403 -> EQ=3 ist cool, mit Pam EQ=aus, sonst Clipping im DAC!
delay(10);
//byte volume = myMP3.currentVolume();
folder01 = myMP3.numTracksInFolder(01); //Einlesen von Anzahl Dateien in #folder
delay(10);
folder02 = myMP3.numTracksInFolder(02);
delay(10);
folder03 = myMP3.numTracksInFolder(03);
delay(10);
folder04 = myMP3.numTracksInFolder(04);
delay(10);
/*
//Erkennung der Ordner, Anzahl Dateien
Serial.print("folder01 count"); //Kontrolle ob Kommunikation mit dfPlayer klappt, wenn nicht gibt er 255 für alle Verzeichnisinhalte aus
Serial.println(folder01); //häufiger Fehler: 12v Powersupply fehlt u. Arduino hängt nur am USB
Serial.print("folder02 count");
Serial.println(folder02);
Serial.print("folder03 count");
Serial.println(folder03);
Serial.print("folder04 count");
Serial.println(folder04);
Serial.println("starting...");
delay(10); */
//7myMP3.sleep(); //Audio aus @Startup
//TM1637
display.setBrightness(2);
//16bit PWM
setupPWM16(); //init
analogWrite16(ledPin, 0); //PWM an LED=0
analogWrite16(disPin, 55534); //PWM_DAC an Display=50000
while(digitalRead(button2Pin)==HIGH){ //@Startup wird randomSeed() verwendet, um den Zufall zu verbessern.
display.showNumberDec(millis(), true);
}
if (digitalRead(button2Pin)==LOW){ //Quelle für randomSeed() ist Button2Pin / User Eingabe
randomSeed(millis());
shuffle(); //gut mischeln
shuffle();
shuffle();
shuffle();
shuffle();
}
}//^setup^-------------------------------------
//---------------------------------------------
void setupPWM16() {
DDRB |= _BV(PB1) | _BV(PB2); /* set pins as outputs */
TCCR1A = _BV(COM1A1) | _BV(COM1B1) /* non-inverting PWM */
| _BV(WGM11); /* mode 14: fast PWM, TOP=ICR1 */
TCCR1B = _BV(WGM13) | _BV(WGM12)
| _BV(CS10); /* prescaler 1 */
ICR1 = 65535; /* TOP counter value (freeing OCR1A*/
}
//---------------------------------------------
void analogWrite16(uint8_t pin, uint16_t val){
switch (pin) {
case 9: OCR1A = val; break;
case 10: OCR1B = val; break;
}
}
//---------------------------------------------
void shuffle(){
byte n = folder03+1;
for (byte i = 0; i < n - 1; i++){
byte j = random(0, n - i);
int t = questionNumberArray[i];
questionNumberArray[i] = questionNumberArray[j];
questionNumberArray[j] = t;
}
for (byte i = 0; i < n - 1; i++){
Serial.print(questionNumberArray[i]);
Serial.print(", ");
}
Serial.println(" "); //*/
}
//-----audioPlbk()---------- Funktion zur Audiowiedergabe
void audioPlbk(byte what){
//wenn gerade gespielt wird, deswegen alles an ist und jetzt ausgeschaltet werden soll
//enthält Code zur Diagnose des dfPlayers. Popclick et Al.
//Wenn gespielt wird und ausgeschaltet werden soll
if (playing && !what){
//myMP3.volume(0); //PopKlickVerhinderungsversuch
//delay(10);
//Serial.println("Amp ausschalten");
digitalWrite(AmpEnPin, HIGH); //AMP ausschalten(HIGH=aus!)
digitalWrite(PampEnPin,LOW); //Pam8403 ausschalten
delay(10);
}
//Wenn nicht gespielt wird und daher alles aus ist, anschalten
if(!playing && what){
myMP3.volume(0); //Popklickverhinderungsversuch
delay(20);
digitalWrite(AmpEnPin, LOW); //AMP anschalten(HIGH=aus!)
digitalWrite(PampEnPin,HIGH); //Pam8403 anschalten, High =an
myMP3.volume(20); //Lautstärke (war=18) einstellen wg powercycle
}
//Was soll gespielt werden?
if (playing!=what){ //immer nur ein Mal das Kommando senden
playing=what;
if (what==1){
myMP3.playFolder(what, random(1,folder01));
}
if (what==2){
myMP3.playFolder(what, random(1,folder02));
}
if (what==3){
myMP3.volume(16); //(war=12)etwas leiser als Alarm, ist Musik und daher höherer RMS als Ambient. Außerdem Chill mal ;)
delay(10);
myMP3.playFolder(what, questionNumberArray[shufflePos]);
shufflePos++;
if(shufflePos>=folder03){ //Wenn alle Tracks gespielt wurden
shufflePos=0; //von vorne
shuffle(); //neu mischeln
}
}
if (what==4){
myMP3.playFolder(what, random(1,folder04));
}
//Serial.print("Spiele folder ");
//Serial.println(what);
}
}
//-----^audioPlbk()^-------------
//---dispTm1637 Anzeigefunktion-Led Display-----
/*-Variante ohne beleuchteten Button 1, Alarmstatus wird über Doppelpunkt angezeigt
*
//
//OLD -dispTm1637 Anzeigefunktion-Led Display----- OLD
void dispTm1637(byte Verbleib){
// erzeuge Zeitformat für die Anzeige:
int displaytime = 0;
if (Verbleib<1){
if(ZeigeAl==false && RestSchlaf<1){
displaytime=(hours * 100) + mins; //aktuelle Uhrzeit anzeigen
}
if(ZeigeAl==true ){
displaytime=(Ahours * 100) + Amins; // Alarmzeit anzeigen/einstellen
}
}
if (RestSchlaf>0){ //verbleibende Zeit im aktuellen Alarmzustand
displaytime=Verbleib;
}
//Alarm An/Aus wird über den Doppelpunkt angezeigt //besser über separate Led, -> toDo, Hardwareupgrade nötig
if (AlarmV){
display.showNumberDecEx(displaytime, 0b11100000, !Verbleib); //Wenn Alarm an, Doppelpunkt an. (...~decEx)
} //shownumberDecEx(AnzuzeigendeZahl, DoppelpunktAn, padding/w Zeroes)
//zero-Padding soll während Anzeige von Restschlaf aus sein wg Verwechslungsgefahr mit aktueller Uhrzeit
if (!AlarmV){ //deswegen !Verbleib
display.showNumberDec(displaytime, !Verbleib); //wenn Alarm aus, Doppelpunkt aus.
}
}
//OLD----------- /tm1637OLD--------------------------OLD
*
*/
void dispTm1637(byte Verbleib){
// erzeuge Zeitformat für die Anzeige:
int displaytime = 0;
if (Verbleib<1){
if(ZeigeAl==false && RestSchlaf<1){
displaytime=(hours * 100) + mins; //aktuelle Uhrzeit anzeigen
}
if(ZeigeAl==true ){
displaytime=(Ahours * 100) + Amins; // Alarmzeit anzeigen/einstellen
}
}
if (RestSchlaf){ //verbleibende Zeit im aktuellen Alarmzustand, Doppelpunkt aus
displaytime=Verbleib;
if (AlarmV){
display.showNumberDecEx(displaytime, 0b10100000, !Verbleib); //(alt:0b11100000) Wenn Alarm an, Tasterled. (...~decEx)
} //shownumberDecEx(AnzuzeigendeZahl, DoppelpunktAn, padding/w Zeroes)
//zero-Padding soll während Anzeige von Restschlaf aus sein wg Verwechslungsgefahr mit aktueller Uhrzeit
if (!AlarmV){ //deswegen !Verbleib
display.showNumberDecEx(displaytime, 0b00000000, !Verbleib); //(alt:0b01000000)wenn Alarm aus, Tasterled aus, Doppelpunkt an.
}
}
//Alarm An/Aus wird über den Doppelpunkt angezeigt //besser über separate Led, -> toDo, Hardwareupgrade nötig
if (!RestSchlaf){
if (AlarmV){
display.showNumberDecEx(displaytime, 0b11100000, !Verbleib); //Wenn Alarm an, Doppelpunkt an. (...~decEx)
} //shownumberDecEx(AnzuzeigendeZahl, DoppelpunktAn, padding/w Zeroes)
//zero-Padding soll während Anzeige von Restschlaf aus sein wg Verwechslungsgefahr mit aktueller Uhrzeit
if (!AlarmV){ //deswegen !Verbleib
display.showNumberDecEx(displaytime, 0b01000000, !Verbleib); //wenn Alarm aus, Tasterled aus, Doppelpunkt an.
}
}
}
//------------- /tm1637--------------------------
//-Helligkeitsanpassung Display-----------------
void setBrigh(){
//wenn kein Alarm, Helligkeit anpassen
const int heller=1200; //Offset für Korrektur der Helligkeit, falls Anzeige zu dunkel.
int readBrigh = analogRead(HellPin); //Mittelwertbildung für Sprungfreiheit, wichtig wen Licht an ist (PWM-> springende Werte an/aus)
readBrigh=constrain(readBrigh, 0, 900);
smooBrigh=(smooBrigh*5+readBrigh)/6;
int writeBrigh = map(smooBrigh, 0, 900, 1,4); //Dimminfunktion _im_ Display, ist nötig, da sonst der Strom bei wenig licht zu groß ist und Display flimmert.
unsigned int disDAC= map(smooBrigh, 0, 900, 34000, 61535); //Wenn unterer Wert zu niedrig geht nix oder flimmerts, bei Vollgas ist die Stromaufnahme zu hoch für den PWM-Pin(?)
//Displayhelligkeit über TM1637
display.setBrightness(writeBrigh); //, 1-4
//Displayhelligkeit über Versorgung
if(smooBrigh>8){ //unterhalb 7 ist das Licht aus-> dunkles Display, oberhalb Helligkeitsboost
analogWrite16(disPin, constrain((disDAC+heller),34000, 61535)); //65535 PWM_DAC an Display oberhalb 61535 ist der Stromverbrauch zu hoch für den Arduino Pin
}
if(smooBrigh<9){
analogWrite16(disPin, disDAC); // Boost ist ausgeschaltet, PWM_DAC an Display
}
/* Serielle Ausgabe für debugging des Helligkeitssensors
Serial.print("Einlesewert: "); //Kontrolle Displayfading
Serial.print(readBrigh);
Serial.print(" Wert Display: ");
Serial.print(writeBrigh);
Serial.print(" Wert PWM Ausgabe: ");
Serial.println(disDAC); // */
}
//---^setbrigh^---------------------------------
//Encoder mit ohne Beschleunigung (war race condition, wieder rausgeworfen)
void encoder() {
int newPosition = myEnc.read()/4 ; //Liest pro Rastung 4 neue Werte ein, daher /4
if (newPosition != oldPosition) {
int AccVal=(newPosition-oldPosition);
oldPosition=newPosition;
//Bei encTarget=1 werden Minuten bei 0 Stunden verstellt
if (ZeigeAl && !AlarmV && !sleepStell){ //bei aktiviertem Alarm und bei Sleeptimereinstellung soll nix verstellt werden
if (encTarget){
Amins = Amins+AccVal; //Bei enctarget werden Minuten verändert
}
if (!encTarget){
Ahours = Ahours+AccVal; //Bei !enctarget werden Stunden verändert
}
//Minuten, Überlauf
if (Amins>59&& Amins<201){ //Überläufe in Plus-Richtung, Amins ist byte(unsigned) und läuft nach unten zu 255 über
Amins=0;
Ahours++;
}
if (Amins>200){ //Überläufe in Minus-Richtung, Amins ist byte(unsigned) und läuft nach unten zu 255 über
Amins=59;
Ahours--;
}
//Stunden, Überlauf
if(Ahours>23 &&Ahours<201){ //Überläufe in Plus-Richtung, s.o.
Ahours=0;
}
if (Ahours>200){ //Überläufe in Minus-Richtung, s.o.
Ahours=23;
}
}
//Bei lichtAn=1 wird Helligkeit eingestellt
//bei Licht an, gehen die Werte bis 48, kein Überlauf zu 0/48 wg Blendwirkung von 0->48, dunkel nach hell, stattdessen Wert halten
if (lichtAn && !ZeigeAl && !sleepStell){
if(encVal>0 || encVal<48){
encVal = encVal+ AccVal; //keine Beschleunigung in der Beleuchtungsfunktion
if (encVal>100){ //Überlauf von byte 0 -> 255 abfangen. Möglich wg Beschleunigung
encVal=0;
}
if (encVal>48){ //hellste Stufe der Beleuchtung, bei constrain meckert der Compiler, warum auch immer(?)
encVal=48;
}
Leucht(encVal);
}
}
// Bei sleepStell=1 Wird SleepTimer eingestellt
if (sleepStell){
SleepTime = SleepTime + AccVal; // MaximalZeit ist 255Min wg Überlauf byte
RestSchlaf=SleepTime; // Ausgabe über Display via RestSchlaf
}
}
}
//----^encoder^--------------------------------------
//---Knöpfe einlesen, Dinge tun -----------------------------------------
void buttonLogic(){
button0State = digitalRead(button0Pin); //Encoder Pushbutton
button1State = digitalRead(button1Pin); //roter Knopf vorne
button2State = digitalRead(button2Pin); //schwarzer Knopf oben(arcade)
if(button2State==LOW || lichtAn){ //Encoder muss eingelesen werden
encoder();
}
//Umschaltung encTarget Minuten/Stunden
if(!button2State && !button0State && (millis()-debTimer)>300 ){ //nur ausführen, wenn Alarmzeit angezeigt wird, sonst kann der Sleeptimer nicht aktiviert werden (kollision mit debtimer)
encTarget=!encTarget;
debTimer=millis();
}
//--Erkennung von kurzen/langen Drückern auf button1-- Roter Knopf
if(button1State==LOW && button1Pressed==false ){ //press-Event
LpTimer=millis();
button1Pressed=true;
}
if(button1State==HIGH && button1Pressed==true){ //release-Event (2 Möglichkeiten)
//kurzer Knopfdruck = umschalten Alarm an/aus
if(millis()-LpTimer>20 && millis()-LpTimer<4000){
AlarmV=!AlarmV; //Wenn Alarm an, Alarm= aus
if(AlarmV){ //Wenn Alarm an, rAmins&rAhours schreiben für früheren Sonnenaufgangsbeginn
//Umrechnung der 30 Minuten Vorlauf auf Stunden
if (Amins>29 ){ //Minuten 30-59, Stunden 0-23
rAmins = Amins-30; //
rAhours = Ahours;
}
if (Amins<30 && Ahours>0){ //Minuten 0-29, Stunden 1-23
rAmins = Amins+30;
rAhours = Ahours-1;
}
if (Amins<30 && Ahours==0){ //Minuten 0-29, Stunde 0
rAmins = Amins+30;
rAhours = 23;
}
}
button1Pressed=false;
}
//langer Knopfdruck = Uhrzeit setzen
if(millis()-LpTimer>6000 &&AlarmV==false){
setDS3231time(); // schreibt aktuelle Amins&AHours in DS3231
button1Pressed=false;
}
}
//(neu) Button2 (Arcade) Einfach- und Doppelklick
//-press-Event ------
if(button2State==LOW && !buttonCount && millis()-debTimer > 600){
buttonCount=1;
debTimer=millis();
Serial.print("buttonCount");
Serial.println(buttonCount);
}
//release-Event
if(button2State&& buttonCount==1 &&millis()-debTimer>10){
buttonCount++;
Serial.print("buttonCount");
Serial.println(buttonCount);
}
//-Doubleclick -Event
if(buttonCount==2 &&!button2State && millis()-debTimer>10 &&millis()-debTimer<270){ //Test-Op:
lichtAn=!lichtAn;
if(lichtAn){ //Licht wird angeschaltet, Startwert Licht ist 24 von 48 Stufen
encVal=24;
Leucht(encVal); //muss hier einmal ausgeführt werden, weil encoder() nur bei veränderungen aufruft
}
if(!lichtAn){ //Licht wird ausgeschaltet, Encoder braucht die Werte aus Zeiteinstellung (es wird zu den Minuten gesprungen)
leuchtVal1=0; //Leucht() kann nur licht anschalten, aber nicht aus, deswegen hier
SleepTime=0; //Sleeptimer ausschalten
RestSchlaf=0; //zur Sicherheit mal auf 0 setzen (obsolet?)
}
buttonCount=0;
debTimer=millis();
Serial.print("buttonCount");
Serial.println(buttonCount);
//Serial.print("millis()");Serial.println(millis());
}
//-erase event -----
if(millis()-debTimer>270&&buttonCount){
buttonCount=0;
Serial.print("buttonCount");
Serial.println(buttonCount);
}
//Sleeptimer Einstellung aktivieren
if(lichtAn && !SleepTime && !sleepStell && !button0State && millis()-debTimer>400){
sleepStell=1; //Verstellung des Timers über Encoder wird aktiviert
SleepTime=10; //Default =10 Minuten
RestSchlaf=SleepTime; //Anzeige im Display über Variable RestSchlaf
debTimer=millis();
}
//Sleeptimer setzen und aktivieren, Einstellung abschalten
if(lichtAn && SleepTime && sleepStell && !button0State && millis()-debTimer>400){
sleepStell=0; //Einstellung fertig, deaktivieren
fadePointer=millis(); //fadePointer ist eine recycelte Variable, die auch in der Weckroutine verwendet wird. Dient hier für Zeitmessung seit sleeptimeraktivierung
debTimer=millis();
}
//Alarmzeit soll angezeigt werden
if(button2State==LOW && !AlarmState){
ZeigeAl=true; //notwendig auch zum Einstellen des Alarms u. der Zeit
}
if (button2State==HIGH){
ZeigeAl=false;
}
//Alarmlogik Button 2 (Arcade Button)
if(buttonCount==1 && AlarmState == 1 ){ //Weckphase 1 läuft, Schläfer ist wach-> Sprung zu 3, extra lange Debounce-Zeiten weil schläfriger User
fadePointer=millis(); //Zähler reset für einfacheres Debugging
fadeZaehl=0;
AlarmState=3;
}
if(buttonCount==1 && AlarmState == 2 ){ //WeckPhase 2(lauter als1) läuft, Schläfer ist wach-> Sprung zu 3
fadePointer = millis(); //Zähler reset für einfacheres Debugging
fadeZaehl = 0;
AlarmState = 3;
}
if(buttonCount==1 && AlarmState == 3 && millis()-fadePointer >900 ){ //Schläfer steht auf und verlässt das Bett
debTimer = millis();
fadePointer = millis();
fadeZaehl = 0;
AlarmState = 4;
}
if(buttonCount==1 && AlarmState == 4 && millis()-fadePointer >700){ //Schläfer will das Licht schnell aus haben
fadeULong = 100; //Alarm() A-state=4 macht den Rest
}
}//close ButtonLogic
//Lichtfunktion, bekommt bei lichtAn==1 Werte von encoder()und macht daraus logarithmische Helligkeitsstufen
void Leucht(byte intens){
unsigned int leuchtVal= 10;
for (byte i = 0; i <=intens; i++) { //logarithmische Berechnung der Helligkeit
leuchtVal=leuchtVal*1.2;
}
if(leuchtVal<13){ //minimal-Licht zur Verwendung als Nachtlicht
leuchtVal=9;
}
leuchtVal1= leuchtVal; //Ausgabe mit smoother(), der tut jetzt
//alt: analogWrite16(ledPin, leuchtVal);
//Sleeptimer: automatische Lichtabschaltung nach via Encoder und Buttonlogic eingestellte Minuten
if(!sleepStell && SleepTime && (millis()-fadePointer)>SleepTime*60000L){
encTarget=0;
leuchtVal1=0; //Ausgabe mit smoother()
SleepTime=0;
lichtAn=0;
}
}
//-------^void Leucht()^----------------------------------------------------------------------------------------
//---- smoothing für stufenlose Helligkeitseinstellung
void smoother(){
if(leuchtVal1 != LedPWMVal){
LedPWMVal=(20*LedPWMVal+leuchtVal1)/21;
if(LedPWMVal<leuchtVal1 && leuchtVal1-LedPWMVal<30){
LedPWMVal++; //Bei steigenden Werten wird sonst kein Endwert erreicht
}
/* if(LedPWMVal<5){ //not needed
LedPWMVal=0;*/
analogWrite16(ledPin, LedPWMVal);
/*
Serial.print("leuchtVal1= ");
Serial.print(leuchtVal1);
Serial.print("LedPWMVal= ");
Serial.println(LedPWMVal); // */
}
}//---Ende smoother
//-----------------------------------------------------------------
void setDS3231time(){
// sets time and date data to DS3231
Wire.beginTransmission(DS3231_I2C_ADDRESS);
Wire.write(0); // set next input to start at the seconds register
Wire.write(decToBcd(00)); // set seconds
Wire.write(decToBcd(Amins)); // set minutes
Wire.write(decToBcd(Ahours)); // set hours
//Wire.write(decToBcd(1)); // set day of week (1=Sunday, 7=Saturday)
//Wire.write(decToBcd(1)); // set date (1 to 31)
//Wire.write(decToBcd(1)); // set month
//Wire.write(decToBcd(0)); // set year (0 to 99)
Wire.endTransmission();
}
//----------------------------------------------------------------------
void readDS3231time(){
Wire.beginTransmission(DS3231_I2C_ADDRESS);
Wire.write(0); // set DS3231 register pointer to 00h
Wire.endTransmission();
Wire.requestFrom(DS3231_I2C_ADDRESS, 7);
// request seven bytes of data from DS3231 starting from register 00h
byte second = bcdToDec(Wire.read() & 0x7f); //wird gelesen, aber nicht gebraucht.
mins = bcdToDec(Wire.read());
hours = bcdToDec(Wire.read() & 0x3f);
//*dayOfWeek = bcdToDec(Wire.read());
//*dayOfMonth = bcdToDec(Wire.read());
//*month = bcdToDec(Wire.read());
//*year = bcdToDec(Wire.read());
}
//--------------------------------------------------
void alarm(){
//Sonnenaufgang: nach #Zeitintervall wird der bisherige Helligkeitswert mit 1,01 multipliziert.
//~22Minuten Fade
//MP3Start nach 12Minuten, random Track in Folder 01, Soundscapes sind mit Fade-In überlagert, Lautstärkekontrolle am dfPlayer Mini hat nur 30 Stufen (reicht nicht)
const int upSpeed=1000; //(1000neu=>20+x(?) Minuten, 100=>127sek.) sets Interval for multiplication of fadeULong(fade in)
//kleinere Werte=schnellerer Fade
const int dnSpeed=6; //(6) sets Interval for division of fadeULong (fade out)
const int lowMinim=20; // Offset für Einstellung der niedrigsten Helligkeitsstufe, damit der langsame Teil des Fades auch im nützlichen Helligkeitsbereich ist
//sollte nicht über 800 sein, sonst wird die auskommentierte constrain funktion in Sonnenaufgang notwendig
unsigned long fadeTime=(millis()-fadePointer); //wie lange läuft der Alarm schon? FadePointer bekommt von Buttonlogic() Reset bei Sprüngen in A-states 3+4
unsigned int fadeVal=1; //local Var für Ausgabe an 16Bit PWM
//Alarm Stufe 1: Sonnenaufgang, Gezwitscher
if (AlarmState==1 && fadeTime < 1200000){
//pre-sunrise linearer fade-in für niedrige Helligkeit
if(fadeTime<100){ //nur 1x am Anfang ausführen
leuchtVal1=lowMinim;
//Serial.print("1schnell= ");
//Serial.println(i);
}
//Start Audio wenn FadeTime>x
if(fadeTime>900000 && playing==0){ //12min nach Beginn(900K Millisekunden)
audioPlbk(1); //spielt Ordner 1 (Vogelgezwitscher, Ambient Sounds)
}
//Sonnenaufgang Berechnung der Helligkeitswerte abhänging von bereits abgelaufener Alarmzeit
if ((fadeZaehl+upSpeed)<fadeTime &&fadeULong<4901480){ //Fade-Funktion wird ausgeführt, solange keine 5M erreicht werden können
fadeZaehl=fadeTime;
fadeULong=(fadeULong*1.01); //
fadeVal=fadeULong/76.3+lowMinim; //5000000/76,3= 65535, der 100%wert für PWM16, map() macht mist bei Werten größer als int
leuchtVal1 = fadeVal;
//Serial.print("1langsam= ");
//Serial.println(fadeVal);
}
}
// Maximum, ist erreicht(1800000ms/30 Minuten preset) //Nach T>30 Minuten weiter bei AlarmState2,
if(AlarmState==1 &&fadeTime>1800000){
AlarmState=2;
}
//Alarm Stufe 2: Vollgas Licht, laute Weck-Musik
if(AlarmState==2){ //schläft noch&& bisherige Maßnahmen zeigten keine Wirkung
fadeULong=5000000; //maximum Warp
fadeVal=65535;
leuchtVal1 = fadeVal;
if(playing!=2){
audioPlbk(2); //spielt Ordner 2 (laute Weckroutine)
}
//renitenter Schläfer braucht nach 35Min noch härtere Gangart
if (fadeTime>2100000){
playing=1; //sonst nimmt audioPlbk() keine Befehle an
audioPlbk(2); //<-Track erstellen und neues Verzeichnis reinkopieren, nummer hierhin //35minuten Neuer, aggressiver Wecktrack, volle Lautstärkespielt laute Weckroutine
}
//40 Minuten vorbei. Genug geweckt, ist keiner Da-> ausschalten!
if (fadeTime>2400000){
AlarmState=4; //AlarmState=4 macht das Licht aus
AlarmV=false;
}
}//close AState2
//Alarm Stufe3: ist wach, braucht aber noch Licht, Fadeval auf angenehmen Wert
if(AlarmState==3){
if(playing!=3||playing==1){
audioPlbk(3); //Spielt Ordner 3 (angenehme leise Musik)
}
if(fadeULong>2000000){ //angenehm hell, mit zwischenFadeout
if ((fadeZaehl+dnSpeed)<fadeTime){
fadeZaehl=fadeTime;
fadeULong=(fadeULong/1.01);
}
if(fadeULong<2010000){
fadeULong=2000000;
}
}
if(fadeULong<2000000){ //angenehm hell, mit zwischenFadein
if ((fadeZaehl+dnSpeed)<fadeTime){
fadeZaehl=fadeTime;
fadeULong=(fadeULong*1.01);
}
if(fadeULong>1990000){
fadeULong=2000000;
}
}
fadeVal=(fadeULong/76.3)+lowMinim; //Ausgabe über Smoother
leuchtVal1 = fadeVal; //Wert wird gehalten */
/*umbauweg: fadeULong=2000000; //angenehm hell, mit zwischenFadeout
fadeVal=(fadeULong/76.3)+lowMinim;
leuchtVal1 = fadeVal; //Wert wird gehalten */
//Serial.print("3hold= ");
//Serial.println(fadeVal);
if (fadeTime>600000){ //ist Wach, hat Lichtausmachen vergessen(10 Minuten nach ButtonPress)
AlarmState=4;
}
}//close Astate3
//Alarm Stufe 4: Es wird aufgestanden, Licht kann ausfaden, kleiner Soundschnipsel als Bestätigung
if(AlarmState==4&&fadeULong>100){ //steht jetzt auf Licht soll ausfaden
if(playing!=4){ //Spielt Ordner 4 (kurzer Bestätigungssound, +1Up Mario)
audioPlbk(4);
}
if ((fadeZaehl+dnSpeed)<fadeTime){
fadeZaehl=fadeTime;
fadeULong=(fadeULong/1.01);
fadeVal=(fadeULong/76.3);
leuchtVal1 = fadeVal;
//Serial.print("4 out= ");
//Serial.println(fadeVal);
}
}
if(AlarmState==4&&fadeULong<101){ //Fade ist durch, alles zurück auf Ausgangswerte/abschalten
fadeULong=100;
fadeZaehl=0;
AlarmState=0;
audioPlbk(0);
AlarmV=false;
leuchtVal1 = 0;
}
}
//----------^void alarm()^-------------------------------
void loop(){
if (schedulT<millis()){ //Aufrufe begrenzen
readDS3231time(); //Zeit einlesen
setBrigh(); //Helligkeit im Display an Umgebung anpassen, bei AlarmState>0 max Brightness
//Restschlafanzeige und Sleeptimeranzeige
if (AlarmState || (SleepTime&&!sleepStell)){
zeigeRS=!zeigeRS; // Abwechselnd Uhrzeit + Restschlaf anzeigen
if (zeigeRS&&AlarmState==1){
RestSchlaf=((1800000-(millis()-fadePointer))/60000); //Weckroutine dauert 30 Minuten 1 800 000ms + 59000 für Trunkierung Ganzzahlarithmetik
}
if (zeigeRS&&AlarmState==2){ //A-State=2 Heißt Zeit ist abgelaufen
RestSchlaf=0;
}
if (zeigeRS&&AlarmState==3){
RestSchlaf=((659000-(millis()-fadePointer))/60000); //hat 10 Minuten Zeit zum Anziehen
}
//Sleeptimer anzeigen
if (zeigeRS && !AlarmState){
RestSchlaf= ((fadePointer + SleepTime*60000L)-millis()+59000)/60000 ; // Wie lange noch bis zur automatischen Lichtabschaltung?
Leucht(encVal); // Wird sonst nur bei Encodereingaben aufgerufen, dann bleibt das Licht an, auch wenn Zeit abgelaufen ist.
}
if (!zeigeRS){ // Bei Restschlaf= 0 wird nur die aktuelle Uhrzeit angezeigt
RestSchlaf=0;
}
}
if (!AlarmState && !encTarget &&!SleepTime){ //fängt Anzeige von Restschlaf ab, wenn nicht benötigt (obsolet?)
zeigeRS=false;
RestSchlaf=0;
}
//Zeit für Alarm?
if(AlarmV==true &&AlarmState==0 && hours==rAhours && mins==rAmins){ //Bedingung für Alarmauslösung
fadePointer=millis(); //Pointer setzen für Zeitablauf
//lichtAn=false;
lichtAn = 0; //Licht ausschalten, falls an
SleepTime=0; //Sleeptimer reset
AlarmState=1;
}
/*Serial.print("AlarmState: " );
Serial.println(AlarmState);
Serial.print("fadeULong= ");
Serial.println(fadeULong); */
// 1x pro Sekunde
schedulT= millis()+1000;
}//scheduler zumachen
//Solange der Alarm läuft, wird die zugehörige Funktion auch aufgerufen
if(AlarmState){
alarm();
}
//Knöpfe einlesen
buttonLogic();
// display auf dem tm1637
dispTm1637(RestSchlaf);
// smoother aufrufen
smoother();
}//loop
Außerdem hab ich noch ne kleine Bedienungsanleitung geschrieben. Beidseitig ausdrucken auf A4, in der Mitte falten, fertig.
Grad jetzt, wo man nicht so viel rauskommt, mal angenehm, Natur hören zu können. 
Sieht wirklich schön aus und ist sehr gut lesbar, aber ich habe noch keine Bib gefunden, die a) Meine Bedürfnisse erfüllt und b) tatsächlich das macht, was sie vorgibt. In Betrieb habe ich TM1637Display.h von hier. Ein Punkt der mich sehr geärgert hat, ist dass es so verkauft wird, als ob sowohl Dezimalpunkte, als auch der Doppelpunkt einzeln angesprochen werden können. Leider ist es so, dass nur entweder der Doppelpunkt, oder Die Dezimalpunkte funktionieren. Bei mir isses der Doppelpunkt. Das LED-Modul hat garnicht genügend Pins, damit man _alles_ ansprechen könnte, es sieht nur so aus als gäbe es Dezimalpunkte, wie doof ist denn das? Es gibt auf Ebay Displays mit nem anderen Controller, bei denen alles da ist, aber da steht nicht dran, welche Farbe die haben. 
Senkt auch den Stromverbrauch. 
