Skip to content
GitLab
Menu
Projects
Groups
Snippets
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in / Register
Toggle navigation
Menu
Open sidebar
Michal Rybka
openCanSat-2.0-library
Commits
f5b12c71
Commit
f5b12c71
authored
Sep 19, 2018
by
Markéta Jedličková
Browse files
Issue #2 fix: Time.h missing
parent
29188399
Changes
4
Hide whitespace changes
Inline
Side-by-side
src/DateStrings.cpp
0 → 100644
View file @
f5b12c71
/* DateStrings.cpp
* Definitions for date strings for use with the Time library
*
* Updated for Arduino 1.5.7 18 July 2014
*
* No memory is consumed in the sketch if your code does not call any of the string methods
* You can change the text of the strings, make sure the short strings are each exactly 3 characters
* the long strings can be any length up to the constant dt_MAX_STRING_LEN defined in Time.h
*
*/
#if defined(__AVR__)
#include <avr/pgmspace.h>
#else
// for compatiblity with Arduino Due and Teensy 3.0 and maybe others?
#define PROGMEM
#define PGM_P const char *
#define pgm_read_byte(addr) (*(const unsigned char *)(addr))
#define pgm_read_word(addr) (*(const unsigned char **)(addr))
#define strcpy_P(dest, src) strcpy((dest), (src))
#endif
#include <string.h> // for strcpy_P or strcpy
#include "Time.h"
// the short strings for each day or month must be exactly dt_SHORT_STR_LEN
#define dt_SHORT_STR_LEN 3 // the length of short strings
static
char
buffer
[
dt_MAX_STRING_LEN
+
1
];
// must be big enough for longest string and the terminating null
const
char
monthStr0
[]
PROGMEM
=
""
;
const
char
monthStr1
[]
PROGMEM
=
"January"
;
const
char
monthStr2
[]
PROGMEM
=
"February"
;
const
char
monthStr3
[]
PROGMEM
=
"March"
;
const
char
monthStr4
[]
PROGMEM
=
"April"
;
const
char
monthStr5
[]
PROGMEM
=
"May"
;
const
char
monthStr6
[]
PROGMEM
=
"June"
;
const
char
monthStr7
[]
PROGMEM
=
"July"
;
const
char
monthStr8
[]
PROGMEM
=
"August"
;
const
char
monthStr9
[]
PROGMEM
=
"September"
;
const
char
monthStr10
[]
PROGMEM
=
"October"
;
const
char
monthStr11
[]
PROGMEM
=
"November"
;
const
char
monthStr12
[]
PROGMEM
=
"December"
;
const
PROGMEM
char
*
const
PROGMEM
monthNames_P
[]
=
{
monthStr0
,
monthStr1
,
monthStr2
,
monthStr3
,
monthStr4
,
monthStr5
,
monthStr6
,
monthStr7
,
monthStr8
,
monthStr9
,
monthStr10
,
monthStr11
,
monthStr12
};
const
char
monthShortNames_P
[]
PROGMEM
=
"ErrJanFebMarAprMayJunJulAugSepOctNovDec"
;
const
char
dayStr0
[]
PROGMEM
=
"Err"
;
const
char
dayStr1
[]
PROGMEM
=
"Sunday"
;
const
char
dayStr2
[]
PROGMEM
=
"Monday"
;
const
char
dayStr3
[]
PROGMEM
=
"Tuesday"
;
const
char
dayStr4
[]
PROGMEM
=
"Wednesday"
;
const
char
dayStr5
[]
PROGMEM
=
"Thursday"
;
const
char
dayStr6
[]
PROGMEM
=
"Friday"
;
const
char
dayStr7
[]
PROGMEM
=
"Saturday"
;
const
PROGMEM
char
*
const
PROGMEM
dayNames_P
[]
=
{
dayStr0
,
dayStr1
,
dayStr2
,
dayStr3
,
dayStr4
,
dayStr5
,
dayStr6
,
dayStr7
};
const
char
dayShortNames_P
[]
PROGMEM
=
"ErrSunMonTueWedThuFriSat"
;
/* functions to return date strings */
char
*
monthStr
(
uint8_t
month
)
{
strcpy_P
(
buffer
,
(
PGM_P
)
pgm_read_word
(
&
(
monthNames_P
[
month
])));
return
buffer
;
}
char
*
monthShortStr
(
uint8_t
month
)
{
for
(
int
i
=
0
;
i
<
dt_SHORT_STR_LEN
;
i
++
)
buffer
[
i
]
=
pgm_read_byte
(
&
(
monthShortNames_P
[
i
+
(
month
*
dt_SHORT_STR_LEN
)]));
buffer
[
dt_SHORT_STR_LEN
]
=
0
;
return
buffer
;
}
char
*
dayStr
(
uint8_t
day
)
{
strcpy_P
(
buffer
,
(
PGM_P
)
pgm_read_word
(
&
(
dayNames_P
[
day
])));
return
buffer
;
}
char
*
dayShortStr
(
uint8_t
day
)
{
uint8_t
index
=
day
*
dt_SHORT_STR_LEN
;
for
(
int
i
=
0
;
i
<
dt_SHORT_STR_LEN
;
i
++
)
buffer
[
i
]
=
pgm_read_byte
(
&
(
dayShortNames_P
[
index
+
i
]));
buffer
[
dt_SHORT_STR_LEN
]
=
0
;
return
buffer
;
}
src/Time.cpp
0 → 100644
View file @
f5b12c71
/*
time.c - low level time and date functions
Copyright (c) Michael Margolis 2009-2014
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
1.0 6 Jan 2010 - initial release
1.1 12 Feb 2010 - fixed leap year calculation error
1.2 1 Nov 2010 - fixed setTime bug (thanks to Korman for this)
1.3 24 Mar 2012 - many edits by Paul Stoffregen: fixed timeStatus() to update
status, updated examples for Arduino 1.0, fixed ARM
compatibility issues, added TimeArduinoDue and TimeTeensy3
examples, add error checking and messages to RTC examples,
add examples to DS1307RTC library.
1.4 5 Sep 2014 - compatibility with Arduino 1.5.7
*/
#if ARDUINO >= 100
#include <Arduino.h>
#else
#include <WProgram.h>
#endif
#include "Time.h"
static
tmElements_t
tm
;
// a cache of time elements
static
time_t
cacheTime
;
// the time the cache was updated
static
uint32_t
syncInterval
=
300
;
// time sync will be attempted after this many seconds
void
refreshCache
(
time_t
t
)
{
if
(
t
!=
cacheTime
)
{
breakTime
(
t
,
tm
);
cacheTime
=
t
;
}
}
int
hour
()
{
// the hour now
return
hour
(
now
());
}
int
hour
(
time_t
t
)
{
// the hour for the given time
refreshCache
(
t
);
return
tm
.
Hour
;
}
int
hourFormat12
()
{
// the hour now in 12 hour format
return
hourFormat12
(
now
());
}
int
hourFormat12
(
time_t
t
)
{
// the hour for the given time in 12 hour format
refreshCache
(
t
);
if
(
tm
.
Hour
==
0
)
return
12
;
// 12 midnight
else
if
(
tm
.
Hour
>
12
)
return
tm
.
Hour
-
12
;
else
return
tm
.
Hour
;
}
uint8_t
isAM
()
{
// returns true if time now is AM
return
!
isPM
(
now
());
}
uint8_t
isAM
(
time_t
t
)
{
// returns true if given time is AM
return
!
isPM
(
t
);
}
uint8_t
isPM
()
{
// returns true if PM
return
isPM
(
now
());
}
uint8_t
isPM
(
time_t
t
)
{
// returns true if PM
return
(
hour
(
t
)
>=
12
);
}
int
minute
()
{
return
minute
(
now
());
}
int
minute
(
time_t
t
)
{
// the minute for the given time
refreshCache
(
t
);
return
tm
.
Minute
;
}
int
second
()
{
return
second
(
now
());
}
int
second
(
time_t
t
)
{
// the second for the given time
refreshCache
(
t
);
return
tm
.
Second
;
}
int
day
(){
return
(
day
(
now
()));
}
int
day
(
time_t
t
)
{
// the day for the given time (0-6)
refreshCache
(
t
);
return
tm
.
Day
;
}
int
weekday
()
{
// Sunday is day 1
return
weekday
(
now
());
}
int
weekday
(
time_t
t
)
{
refreshCache
(
t
);
return
tm
.
Wday
;
}
int
month
(){
return
month
(
now
());
}
int
month
(
time_t
t
)
{
// the month for the given time
refreshCache
(
t
);
return
tm
.
Month
;
}
int
year
()
{
// as in Processing, the full four digit year: (2009, 2010 etc)
return
year
(
now
());
}
int
year
(
time_t
t
)
{
// the year for the given time
refreshCache
(
t
);
return
tmYearToCalendar
(
tm
.
Year
);
}
/*============================================================================*/
/* functions to convert to and from system time */
/* These are for interfacing with time serivces and are not normally needed in a sketch */
// leap year calulator expects year argument as years offset from 1970
#define LEAP_YEAR(Y) ( ((1970+Y)>0) && !((1970+Y)%4) && ( ((1970+Y)%100) || !((1970+Y)%400) ) )
static
const
uint8_t
monthDays
[]
=
{
31
,
28
,
31
,
30
,
31
,
30
,
31
,
31
,
30
,
31
,
30
,
31
};
// API starts months from 1, this array starts from 0
void
breakTime
(
time_t
timeInput
,
tmElements_t
&
tm
){
// break the given time_t into time components
// this is a more compact version of the C library localtime function
// note that year is offset from 1970 !!!
uint8_t
year
;
uint8_t
month
,
monthLength
;
uint32_t
time
;
unsigned
long
days
;
time
=
(
uint32_t
)
timeInput
;
tm
.
Second
=
time
%
60
;
time
/=
60
;
// now it is minutes
tm
.
Minute
=
time
%
60
;
time
/=
60
;
// now it is hours
tm
.
Hour
=
time
%
24
;
time
/=
24
;
// now it is days
tm
.
Wday
=
((
time
+
4
)
%
7
)
+
1
;
// Sunday is day 1
year
=
0
;
days
=
0
;
while
((
unsigned
)(
days
+=
(
LEAP_YEAR
(
year
)
?
366
:
365
))
<=
time
)
{
year
++
;
}
tm
.
Year
=
year
;
// year is offset from 1970
days
-=
LEAP_YEAR
(
year
)
?
366
:
365
;
time
-=
days
;
// now it is days in this year, starting at 0
days
=
0
;
month
=
0
;
monthLength
=
0
;
for
(
month
=
0
;
month
<
12
;
month
++
)
{
if
(
month
==
1
)
{
// february
if
(
LEAP_YEAR
(
year
))
{
monthLength
=
29
;
}
else
{
monthLength
=
28
;
}
}
else
{
monthLength
=
monthDays
[
month
];
}
if
(
time
>=
monthLength
)
{
time
-=
monthLength
;
}
else
{
break
;
}
}
tm
.
Month
=
month
+
1
;
// jan is month 1
tm
.
Day
=
time
+
1
;
// day of month
}
time_t
makeTime
(
tmElements_t
&
tm
){
// assemble time elements into time_t
// note year argument is offset from 1970 (see macros in time.h to convert to other formats)
// previous version used full four digit year (or digits since 2000),i.e. 2009 was 2009 or 9
int
i
;
uint32_t
seconds
;
// seconds from 1970 till 1 jan 00:00:00 of the given year
seconds
=
tm
.
Year
*
(
SECS_PER_DAY
*
365
);
for
(
i
=
0
;
i
<
tm
.
Year
;
i
++
)
{
if
(
LEAP_YEAR
(
i
))
{
seconds
+=
SECS_PER_DAY
;
// add extra days for leap years
}
}
// add days for this year, months start from 1
for
(
i
=
1
;
i
<
tm
.
Month
;
i
++
)
{
if
(
(
i
==
2
)
&&
LEAP_YEAR
(
tm
.
Year
))
{
seconds
+=
SECS_PER_DAY
*
29
;
}
else
{
seconds
+=
SECS_PER_DAY
*
monthDays
[
i
-
1
];
//monthDay array starts from 0
}
}
seconds
+=
(
tm
.
Day
-
1
)
*
SECS_PER_DAY
;
seconds
+=
tm
.
Hour
*
SECS_PER_HOUR
;
seconds
+=
tm
.
Minute
*
SECS_PER_MIN
;
seconds
+=
tm
.
Second
;
return
(
time_t
)
seconds
;
}
/*=====================================================*/
/* Low level system time functions */
static
uint32_t
sysTime
=
0
;
static
uint32_t
prevMillis
=
0
;
static
uint32_t
nextSyncTime
=
0
;
static
timeStatus_t
Status
=
timeNotSet
;
getExternalTime
getTimePtr
;
// pointer to external sync function
//setExternalTime setTimePtr; // not used in this version
#ifdef TIME_DRIFT_INFO // define this to get drift data
time_t
sysUnsyncedTime
=
0
;
// the time sysTime unadjusted by sync
#endif
time_t
now
()
{
// calculate number of seconds passed since last call to now()
while
(
millis
()
-
prevMillis
>=
1000
)
{
// millis() and prevMillis are both unsigned ints thus the subtraction will always be the absolute value of the difference
sysTime
++
;
prevMillis
+=
1000
;
#ifdef TIME_DRIFT_INFO
sysUnsyncedTime
++
;
// this can be compared to the synced time to measure long term drift
#endif
}
if
(
nextSyncTime
<=
sysTime
)
{
if
(
getTimePtr
!=
0
)
{
time_t
t
=
getTimePtr
();
if
(
t
!=
0
)
{
setTime
(
t
);
}
else
{
nextSyncTime
=
sysTime
+
syncInterval
;
Status
=
(
Status
==
timeNotSet
)
?
timeNotSet
:
timeNeedsSync
;
}
}
}
return
(
time_t
)
sysTime
;
}
void
setTime
(
time_t
t
)
{
#ifdef TIME_DRIFT_INFO
if
(
sysUnsyncedTime
==
0
)
sysUnsyncedTime
=
t
;
// store the time of the first call to set a valid Time
#endif
sysTime
=
(
uint32_t
)
t
;
nextSyncTime
=
(
uint32_t
)
t
+
syncInterval
;
Status
=
timeSet
;
prevMillis
=
millis
();
// restart counting from now (thanks to Korman for this fix)
}
void
setTime
(
int
hr
,
int
min
,
int
sec
,
int
dy
,
int
mnth
,
int
yr
){
// year can be given as full four digit year or two digts (2010 or 10 for 2010);
//it is converted to years since 1970
if
(
yr
>
99
)
yr
=
yr
-
1970
;
else
yr
+=
30
;
tm
.
Year
=
yr
;
tm
.
Month
=
mnth
;
tm
.
Day
=
dy
;
tm
.
Hour
=
hr
;
tm
.
Minute
=
min
;
tm
.
Second
=
sec
;
setTime
(
makeTime
(
tm
));
}
void
adjustTime
(
long
adjustment
)
{
sysTime
+=
adjustment
;
}
// indicates if time has been set and recently synchronized
timeStatus_t
timeStatus
()
{
now
();
// required to actually update the status
return
Status
;
}
void
setSyncProvider
(
getExternalTime
getTimeFunction
){
getTimePtr
=
getTimeFunction
;
nextSyncTime
=
sysTime
;
now
();
// this will sync the clock
}
void
setSyncInterval
(
time_t
interval
){
// set the number of seconds between re-sync
syncInterval
=
(
uint32_t
)
interval
;
nextSyncTime
=
sysTime
+
syncInterval
;
}
src/Time.h
0 → 100644
View file @
f5b12c71
#include "TimeLib.h"
//Added by Sloeber
#pragma once
src/TimeLib.h
0 → 100644
View file @
f5b12c71
/*
time.h - low level time and date functions
*/
/*
July 3 2011 - fixed elapsedSecsThisWeek macro (thanks Vincent Valdy for this)
- fixed daysToTime_t macro (thanks maniacbug)
*/
#ifndef _Time_h
#ifdef __cplusplus
#define _Time_h
#include <inttypes.h>
#ifndef __AVR__
#include <sys/types.h> // for __time_t_defined, but avr libc lacks sys/types.h
#endif
#if !defined(__time_t_defined) // avoid conflict with newlib or other posix libc
typedef
unsigned
long
time_t
;
#endif
// This ugly hack allows us to define C++ overloaded functions, when included
// from within an extern "C", as newlib's sys/stat.h does. Actually it is
// intended to include "time.h" from the C library (on ARM, but AVR does not
// have that file at all). On Mac and Windows, the compiler will find this
// "Time.h" instead of the C library "time.h", so we may cause other weird
// and unpredictable effects by conflicting with the C library header "time.h",
// but at least this hack lets us define C++ functions as intended. Hopefully
// nothing too terrible will result from overriding the C library header?!
extern
"C++"
{
typedef
enum
{
timeNotSet
,
timeNeedsSync
,
timeSet
}
timeStatus_t
;
typedef
enum
{
dowInvalid
,
dowSunday
,
dowMonday
,
dowTuesday
,
dowWednesday
,
dowThursday
,
dowFriday
,
dowSaturday
}
timeDayOfWeek_t
;
typedef
enum
{
tmSecond
,
tmMinute
,
tmHour
,
tmWday
,
tmDay
,
tmMonth
,
tmYear
,
tmNbrFields
}
tmByteFields
;
typedef
struct
{
uint8_t
Second
;
uint8_t
Minute
;
uint8_t
Hour
;
uint8_t
Wday
;
// day of week, sunday is day 1
uint8_t
Day
;
uint8_t
Month
;
uint8_t
Year
;
// offset from 1970;
}
tmElements_t
,
TimeElements
,
*
tmElementsPtr_t
;
//convenience macros to convert to and from tm years
#define tmYearToCalendar(Y) ((Y) + 1970) // full four digit year
#define CalendarYrToTm(Y) ((Y) - 1970)
#define tmYearToY2k(Y) ((Y) - 30) // offset is from 2000
#define y2kYearToTm(Y) ((Y) + 30)
typedef
time_t
(
*
getExternalTime
)();
//typedef void (*setExternalTime)(const time_t); // not used in this version
/*==============================================================================*/
/* Useful Constants */
#define SECS_PER_MIN (60UL)
#define SECS_PER_HOUR (3600UL)
#define SECS_PER_DAY (SECS_PER_HOUR * 24UL)
#define DAYS_PER_WEEK (7UL)
#define SECS_PER_WEEK (SECS_PER_DAY * DAYS_PER_WEEK)
#define SECS_PER_YEAR (SECS_PER_WEEK * 52UL)
#define SECS_YR_2000 (946684800UL) // the time at the start of y2k
/* Useful Macros for getting elapsed time */
#define numberOfSeconds(_time_) (_time_ % SECS_PER_MIN)
#define numberOfMinutes(_time_) ((_time_ / SECS_PER_MIN) % SECS_PER_MIN)
#define numberOfHours(_time_) (( _time_% SECS_PER_DAY) / SECS_PER_HOUR)
#define dayOfWeek(_time_) ((( _time_ / SECS_PER_DAY + 4) % DAYS_PER_WEEK)+1) // 1 = Sunday
#define elapsedDays(_time_) ( _time_ / SECS_PER_DAY) // this is number of days since Jan 1 1970
#define elapsedSecsToday(_time_) (_time_ % SECS_PER_DAY) // the number of seconds since last midnight
// The following macros are used in calculating alarms and assume the clock is set to a date later than Jan 1 1971
// Always set the correct time before settting alarms
#define previousMidnight(_time_) (( _time_ / SECS_PER_DAY) * SECS_PER_DAY) // time at the start of the given day
#define nextMidnight(_time_) ( previousMidnight(_time_) + SECS_PER_DAY ) // time at the end of the given day
#define elapsedSecsThisWeek(_time_) (elapsedSecsToday(_time_) + ((dayOfWeek(_time_)-1) * SECS_PER_DAY) ) // note that week starts on day 1
#define previousSunday(_time_) (_time_ - elapsedSecsThisWeek(_time_)) // time at the start of the week for the given time
#define nextSunday(_time_) ( previousSunday(_time_)+SECS_PER_WEEK) // time at the end of the week for the given time
/* Useful Macros for converting elapsed time to a time_t */
#define minutesToTime_t ((M)) ( (M) * SECS_PER_MIN)
#define hoursToTime_t ((H)) ( (H) * SECS_PER_HOUR)
#define daysToTime_t ((D)) ( (D) * SECS_PER_DAY) // fixed on Jul 22 2011
#define weeksToTime_t ((W)) ( (W) * SECS_PER_WEEK)
/*============================================================================*/
/* time and date functions */
int
hour
();
// the hour now
int
hour
(
time_t
t
);
// the hour for the given time
int
hourFormat12
();
// the hour now in 12 hour format
int
hourFormat12
(
time_t
t
);
// the hour for the given time in 12 hour format
uint8_t
isAM
();
// returns true if time now is AM
uint8_t
isAM
(
time_t
t
);
// returns true the given time is AM
uint8_t
isPM
();
// returns true if time now is PM
uint8_t
isPM
(
time_t
t
);
// returns true the given time is PM
int
minute
();
// the minute now
int
minute
(
time_t
t
);
// the minute for the given time
int
second
();
// the second now
int
second
(
time_t
t
);
// the second for the given time
int
day
();
// the day now
int
day
(
time_t
t
);
// the day for the given time
int
weekday
();
// the weekday now (Sunday is day 1)
int
weekday
(
time_t
t
);
// the weekday for the given time
int
month
();
// the month now (Jan is month 1)
int
month
(
time_t
t
);
// the month for the given time
int
year
();
// the full four digit year: (2009, 2010 etc)
int
year
(
time_t
t
);
// the year for the given time
time_t
now
();
// return the current time as seconds since Jan 1 1970
void
setTime
(
time_t
t
);
void
setTime
(
int
hr
,
int
min
,
int
sec
,
int
day
,
int
month
,
int
yr
);
void
adjustTime
(
long
adjustment
);
/* date strings */
#define dt_MAX_STRING_LEN 9 // length of longest date string (excluding terminating null)
char
*
monthStr
(
uint8_t
month
);
char
*
dayStr
(
uint8_t
day
);
char
*
monthShortStr
(
uint8_t
month
);
char
*
dayShortStr
(
uint8_t
day
);
/* time sync functions */
timeStatus_t
timeStatus
();
// indicates if time has been set and recently synchronized
void
setSyncProvider
(
getExternalTime
getTimeFunction
);
// identify the external time provider
void
setSyncInterval
(
time_t
interval
);
// set the number of seconds between re-sync
/* low level functions to convert to and from system time */
void
breakTime
(
time_t
time
,
tmElements_t
&
tm
);
// break time_t into elements
time_t
makeTime
(
tmElements_t
&
tm
);
// convert time elements into time_t
}
// extern "C++"
#endif // __cplusplus
#endif
/* _Time_h */
//Added by Sloeber
#pragma once
Write
Preview
Supports
Markdown
0%
Try again
or
attach a new file
.
Attach a file
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Cancel
Please
register
or
sign in
to comment