DS3231

Graag had ik uitleg gehad van de programmatie van de klok zelf , de klok werkt perfect (controle via seriële monitor).

Ik wil een delay van 8h maar weet niet goed hoe ik dat kan programmeren op basis van de lopende klok. Wie kan mij hierover informeren? Alvast bedankt :slight_smile:
De code van de klok (zie hieronder) is in mijn bestaande project geïntegreerd buiten de delay is het af...

#include "Wire.h"
#define DS3231_I2C_ADDRESS 0x68
// Convert normal decimal numbers to binary coded decimal
byte decToBcd(byte val)
{
return( (val/1016) + (val%10) );
}
// Convert binary coded decimal to normal decimal numbers
byte bcdToDec(byte val)
{
return( (val/16
10) + (val%16) );
}
void setup()
{
Wire.begin();
Serial.begin(9600);
// set the initial time here:
// DS3231 seconds, minutes, hours, day, date, month, year

// DE TIJDEN IN DE ONDERSTE LIJN AANPASSEN OM DE KLOK JUIST TE ZETTEN DE DAG IS 1 DAG MEER TELLEN
//setDS3231time(00,27,20,4,4,04,18);
}
void setDS3231time(byte second, byte minute, byte hour, byte dayOfWeek, byte
dayOfMonth, byte month, byte year)
{
// 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(second)); // set seconds
Wire.write(decToBcd(minute)); // set minutes
Wire.write(decToBcd(hour)); // set hours
Wire.write(decToBcd(dayOfWeek)); // set day of week (1=Sunday, 7=Saturday)
Wire.write(decToBcd(dayOfMonth)); // set date (1 to 31)
Wire.write(decToBcd(month)); // set month
Wire.write(decToBcd(year)); // set year (0 to 99)
Wire.endTransmission();
}
void readDS3231time(byte *second,
byte *minute,
byte *hour,
byte *dayOfWeek,
byte *dayOfMonth,
byte *month,
byte *year)
{
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
*second = bcdToDec(Wire.read() & 0x7f);
*minute = bcdToDec(Wire.read());
*hour = bcdToDec(Wire.read() & 0x3f);
*dayOfWeek = bcdToDec(Wire.read());
*dayOfMonth = bcdToDec(Wire.read());
*month = bcdToDec(Wire.read());
*year = bcdToDec(Wire.read());
}
void displayTime()
{
byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;
// retrieve data from DS3231
readDS3231time(&second, &minute, &hour, &dayOfWeek, &dayOfMonth, &month,
&year);
// send it to the serial monitor
Serial.print(hour, DEC);
// convert the byte variable to a decimal number when displayed
Serial.print(":");
if (minute<10)
{
Serial.print("0");
}
Serial.print(minute, DEC);
Serial.print(":");
if (second<10)
{
Serial.print("0");
}
Serial.print(second, DEC);
Serial.print(" ");
Serial.print(dayOfMonth, DEC);
Serial.print("/");
Serial.print(month, DEC);
Serial.print("/");
Serial.print(year, DEC);
Serial.print(" Day of week: ");
switch(dayOfWeek){
case 1:
Serial.println("Sunday");
break;
case 2:
Serial.println("Monday");
break;
case 3:
Serial.println("Tuesday");
break;
case 4:
Serial.println("Wednesday");
break;
case 5:
Serial.println("Thursday");
break;
case 6:
Serial.println("Friday");
break;
case 7:
Serial.println("Saturday");
break;
}
}
void loop()
{
displayTime(); // display the real-time clock data on the Serial Monitor,
delay(1000); // every second
}

je weet de huidige tijd en telt daar 8 uur bij, en dan elke seconde kijken of je er al bent.

Hoe doe je dat juist? ik begrijp de code van de klok niet goed, daarom dat ik wat uitleg vraag :confused:

Je haalt in de functie displayTime al het uur binnen.
Dat is wat mij betreft een grote zwakte van je huidige code, want tijdens loop doe je helemaal niets voor 1 volle seconde (en dat is ook al twijfelachtig, maar daar gaan we nu maar even niet op in), nadat je uitsluitend displayTime een enkele keer hebt aangeroepen.
Daarna doe je dat "alles" nog een keer over.
Als je dit gewoon in loop doet, dan blijven de binnen gehaalde waarden ook voor iets anders beschikbaar.
En dat andere is dan dus kijken of je timer al verlopen is.

Nou dan dus die timer van 8 uur.
Dan ga je dus bij het starten van de timer opslaan hoe laat het is, en in dit geval heb je alleen de hele uren nodig.
Daarna ga je kijken of er al 8 uren verlopen zijn.
Aangezien je hebt opgeslagen hoe laat het was toen de timer startte, kun je dus uitrekenen hoe laat de timer moet stoppen.
Natuurlijk moet je daar dan wel rekening houden met het feit dat je op een klok zit te kijken...
En wellicht wil je toch iets meer opslaan, want straks wil je opdrachtgever ineens 8 uur en 12 minuten meten ofzo.

De code van de klok heb ik van het net gehaald,ben er nog niet ervaren genoeg mee om het zelf te programmeren, zijn er betere beschikbaar? Welke code raad je me wel aan?
De klok is het enigste dat waar ik over struikel, al de rest van men code is af en werkt (met servo ), gezien dat een delay van 8h omgerekend in milliseconden helemaal niet juist is ben ik afhankelijk van de klok.. Heb ondertussen al nieuwe plannen van projecten met arduino voor automatiseren lichten,rolgordijnen enzo. Heb al heel wat bijgeleerd maar soms is hulp nodig om dingen te begrijpen, ben geen ict'r :wink:

Het is heel verleidelijk om als je een idee hebt, te gaan zoeken op het internet naar dingen die er op lijken en die dan te gaan aanpassen om te doen wat jij in gedachten had, zeker als je denkt dat je zelf de ervaring mist om het in je eentje te maken.
Maar een bestaande code die je niet (volledig) begrijpt aanpassen, is veel lastiger dan de code zelf ontwikkelen.
Natuurlijk gaat daar tijd in zitten.
Maar zo ken je wel die code op je duimpje, en weet je precies wat er gebeurt.
Nu ben jij dus aan het goochelen met gevonden code en loop je al snel vast.
Ik kan niet veel meer bedenken dan dat je moet zien die code goed te begrijpen.
Aangezien er met functies word gewerkt, kan dat verwarrend zijn voor nieuwkomers.
Een functie is wat een nieuwkomer waarschijnlijk een void zou noemen; delen van code die aangeroepen worden door andere delen van de code.
Het voordeel daarvan is dat een grote code opgebroken word in kleinere stukjes waardoor het overzichtelijker wordt, en er iets efficiënter met het geheugen gewerkt zou kunnen worden.

Ik kan je overigens geen betere code adviseren, want ik heb hier zelf nog niet mee gespeeld.
Maar dat wil niet zeggen dat ik het eens moet zijn met hoe dingen in de door jou gevonden code afgehandeld worden, maar dat is een voorbeeld en voor dat voorbeeld volstaat het.
Maar als je het wil uitbreiden dan moet je er echt mee aan de slag.
Je kunt gaan uitzoeken hoe in die bestaande code de uren en de minuten worden opgehaald, dat moet te doen zijn.
Dan kun je een eigen functie schrijven die je alarm afhandelt en die ook aanroepen vanuit loop.

Ik ben ook geen ict'er.

Meest simpele en rechtlijnige zou zijn:
A) neem de tijd uit de rtc en maak daar een unix tijdsgetal van
B) verhoog die tijd met het aantal seconden
C) neem het voorbeeld zoals blink without delay. Alleen wordt milles vervangen doorhet unix getal.
Ik meen dat alles al in time.h zat en verder in rtclib

Bedankt allen voor de antwoorden, het zou simpel moeten zijn maar voor mij helemaal niet :frowning:
Ik ga iemand zoeken die me mee helpt programmeren+ met de nodige uitleg...

Mvg Raf

Tja programmeren is nu eenmaal een vak wat door velen wordt onderschat.

Ik ben ook bezig met het zoeken voor een vergelijkbare oplossing (tijdklok voor een aquarium).
M.i. moet het mogelijk zijn om gebruik te maken van de commando's die je met "time.h" tot je beschikking krijgt.
Ik ben er nog achter hoe je een substring uit getTimeStr () kunt halen. Voor de Arduino Zero heb ik wel zoiets gezien. Het moet voor de uno e.a. toch mogelijk zijn?
Ik help je zoeken. Misschien moet de de titel van je onderwerp aanassen/aanvullen met timer?

Dat laatste raad ik af.
De Arduino heeft ook ingebouwde hardware timers.
Als je dat woord gaat gebruiken, creëer je waarschijnlijk juist meer verwarring.
Dit is de reden waarom in mijn vorige post het woord timer niet voorkomt, en het woord "alarm" er voor in de plaats gebruikt is.

Gebruik TimeLib en TimeAlarms. Ze zitten beide in de Bibliotheek Beheer, zoek op "timealarms" dan vind je ze allebei.

Die TimeLib (ik noem die library "TimeLib") synchroniseert om de zoveel tijd met de RTC. In de TimeLib zit nog geen code om de compiler datum en tijd automatisch te gebruiken. Je hebt dus echt wel even tijd nodig om uit te zoeken hoe het werkt.

De TimeAlarms kan op een bepaald moment iets doen. Als je echter de Arduino aan zet, dan gaat de TimeAlarms niet al het voorgaande doen.
Stel om 8 uur zet je een lamp aan en om 10 uur uit. Wanneer je de Arduino om 9 uur aan zet, dan gebeurt er niets. Je zult dus zelf bij het aanzetten moeten kijken wat er nodig is om te doen.

Mits een vb van code voor uitlezen timer en deze integreren in men code werkt het perfect! een test van vb 8h werkt deze tot op de seconde juist, zalig gewoon :slight_smile:
Merk nu wel dat de arduino trager is, en enkele leds niet meer wil aansturen, de leds branden zachtjes, de uno polst steeds naar de klok wat alles enorm vertraagd, dien hem dus vb elke minuut laten polsen naar de tijd...

Ik snap de post hierboven niet.
Wat betekent vb ?
Virtual Basic ?
Of bijvoorbeeld of voorbeeld ?

Als je een probleem beschrijft, heel moeilijk kan het niet zijn om de Arduino niet elke iteratie (elke keer als loop word uitgevoerd) de RTC te laten raadplegen.
LEDs die nu niet met volledige helderheid oplichten, kan door verschillende zaken worden verklaard.
Maar daarvoor is het wel nodig dat we kunnen zien wat je gemaakt hebt.
Dus de hardware en de code.

je hebt een hele seconde om de tijd te halen, of zelfs een hele minuut, dus tijd genoeg om andere dingen te doen.

Had verschillende delays in men code, de vertraagde alles, nu het laatste obstakel: de klok in de timer van 12h op 24h zetten...