DigistumpMirror/DigistumpArduino
1
0
Fork 0
mirror of https://github.com/digistump/DigistumpArduino.git synced 2025-11-02 12:34:49 -08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Initial import of support files for all Digistump boards - Digispark, Pro, DigiX - including libraries, examples, tools, and other support files for the Arduino IDE

Browse Source
This commit is contained in:
Erik Tylek Kettenburg
2014-12-19 08:45:50 -08:00
parent 97abdbf157
commit 7e7473a2d6
3567 changed files with 722870 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
hardware/digistump/sam/libraries/RTC/.gitignore vendored Normal file
View File

@@ -0,0 +1,13 @@
# Compiled Object files
*.slo
*.lo
*.o
# Compiled Dynamic libraries
*.so
*.dylib
# Compiled Static libraries
*.lai
*.la
*.a

4
hardware/digistump/sam/libraries/RTC/README.md Normal file
View File

@@ -0,0 +1,4 @@
Arduino-Due-RTC-Library
=======================
RTC Library for the Arduino Due

90
hardware/digistump/sam/libraries/RTC/change.log Normal file
View File

@@ -0,0 +1,90 @@
2013/01/04 Due RTC Library v1.8
added
- Function rtc_clock.set_clock()
function to set Time and Date from compliertime -/date in 1 line
fixed
- Bug in rtc_clock.unixtime()
- Bug in rtc_clock.summertime()
2013/04/03 Due RTC Library v1.7
added
- Function rtc_clock.date_already_set()
function to proof if date is already set
- Sketch Due_RTC_Simple_test_of_date
for rtc_clock.date_already_set()
2013/04/03 Due RTC Library v1.6
added
- Function rtc_clock.timing()
function to test if time and date set in summer or not musst be done in the inital
part when the clock is setup works in connection with rtc_clock.summertime() so
thats if the clock is setup in the range of summertime the function
rtc_clock.summertime() makes the right correct between the time changes
for Germany usefull
- Sketch Due_RTC_Simple_german_timing_summertime_sample
for rtc_clock.timing() & rtc_clock.summertime()
2013/04/03 Due RTC Library v1.5
modify
- Sketch Due_RTC_Simple_Germay_Summertime
some changes in the Sketch for an better Output on the Serialmonitor
2013/04/03 Due RTC Library v1.4
added
- Function rtc_clock.summertime()
function to show if summertime or not returns 1 for summertime (for Germany only)
- Sketch Due_RTC_Simple_Germay_Summertime
for rtc_clock.summertime()
- Function rtc_clock.switch_years()
function returns 1 if year is an switch year
modify
- Function rtc_clock.unixtime()
add support for timezone Germay now summer- wintertime automatic supported
2013/02/03 Due RTC Library v1.3
modify
- Function rtc_clock.unixtime()
add support for timezones to change automatic the unixtime to the right value
- Sketch Due_RTC_Simple_Unixtime_timezone
for rtc_clock.unixtime()
2013/01/03 Due RTC Library v1.2
added
- Function rtc_clock.get_time()
to get Time in one operation
- Function rtc_clock.get_date()
to get Date in one operation
- Sketch Due_RTC_Simple_Sample_oneline_time_and_date
for rtc_clock.get_time() & rtc_clock.get_date()
- Changelog and versioning
to get some overview for me and users
modify
- Function rtc_clock.unixtime()
some changes in the codelines
- Sketch Due_RTC_Simple_Unixtime_Compilertime
some cosmetic changes in this Sketch
fixed
- Bug in rtc_clock.set_alarmdate function
wrong value name
2013/28/02 Due RTC Library v1.1
added
- Function rtc_clock.unixtime()
for unixtime support
- Sample Due_RTC_Simple_Unixtime_Compilertime
for unixtime and compilertime
modify
- Function rtc_clock.set_time()
to support compilertime with the value __TIME__
- Function rtc_clock.set_date()
to support compilertime with the value __DATE__
- Syntax Coloring
set rtc_clock to KEYWORD3 now rtc_clock printed bold
2012/07/12 Due RTC Library v1.0
Initial Release

32
hardware/digistump/sam/libraries/RTC/examples/Due_RTC_Alarm_Sample/Due_RTC_Alarm_Sample.ino Normal file
View File

@@ -0,0 +1,32 @@
#include <rtc_clock.h>
// Select the Slowclock source
//RTC_clock rtc_clock(RC);
RTC_clock rtc_clock(XTAL);
char* daynames[]={"Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"};
void setup() {
Serial.begin(9600);
rtc_clock.init();
rtc_clock.set_time(10, 29, 49);
rtc_clock.set_alarmtime(10, 30, 0);
rtc_clock.attachalarm(announcement);
// rtc_clock.disable_alarm();
}
void loop() {
Serial.print("At the third stroke, it will be ");
Serial.print(rtc_clock.get_hours());
Serial.print(":");
Serial.print(rtc_clock.get_minutes());
Serial.print(":");
Serial.println(rtc_clock.get_seconds());
}
void announcement() {
Serial.println();
Serial.println("Get up and buy an Arduino Due.");
}

88
hardware/digistump/sam/libraries/RTC/examples/Due_RTC_Simple_Germany_Summertime/Due_RTC_Simple_Germany_Summertime.ino Normal file
View File

@@ -0,0 +1,88 @@
#include <rtc_clock.h>
// Select the Slowclock source
//RTC_clock rtc_clock(RC);
RTC_clock rtc_clock(XTAL);
char* daynames[]={"Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"};
boolean toggle = false;
int old_unixtime;
void setup() {
Serial.begin(9600);
rtc_clock.init();
//Summertimebegin Germany in 2013
rtc_clock.set_time(1,59,50);
rtc_clock.set_date(31,3,2013);
}
void loop() {
if ( rtc_clock.unixtime() != old_unixtime) {
old_unixtime = rtc_clock.unixtime();
output();
}
if ( rtc_clock.get_seconds() == 10 ) {
Serial.print("Timeleap ");
toggle = !toggle;
}
if ( rtc_clock.get_seconds() == 10 && toggle == false ) {
//Summertimebegin Germany in 2013
Serial.println("back to summer");
rtc_clock.set_time(1,59,50);
rtc_clock.set_date(31,3,2013);
} else if (rtc_clock.get_seconds() == 10 && toggle == true ) {
//Wintertimebegin Germany in 2013
Serial.println("forward to the end of summer");
rtc_clock.set_time(1,59,50);
rtc_clock.set_date(27,10,2013);
}
}
void output() {
Serial.print("Unixtime: ");
Serial.println(rtc_clock.unixtime(Germany));
Serial.println("And in plain for everyone");
Serial.print("Time: ");
digitprint(rtc_clock.get_hours() + rtc_clock.summertime(), 2);
Serial.print(":");
digitprint(rtc_clock.get_minutes(), 2);
Serial.print(":");
digitprint(rtc_clock.get_seconds(), 2);
Serial.println("");
Serial.print("Date: ");
Serial.print(daynames[rtc_clock.get_day_of_week()-1]);
Serial.print(" ");
digitprint(rtc_clock.get_days(), 2);
Serial.print(".");
digitprint(rtc_clock.get_months(), 2);
Serial.print(".");
Serial.println(rtc_clock.get_years());
Serial.print("Is Summertime?: ");
if ( rtc_clock.summertime() == 1 ) {
Serial.println("Yes!");
} else {
Serial.println("No!");
}
Serial.println("");
}
void digitprint(int value, int lenght){
for (int i = 0; i < (lenght - numdigits(value)); i++){
Serial.print("0");
}
Serial.print(value);
}
int numdigits(int i){
int digits;
if (i < 10)
digits = 1;
else
digits = (int)(log10((double)i)) + 1;
return digits;
}

30
hardware/digistump/sam/libraries/RTC/examples/Due_RTC_Simple_Sample/Due_RTC_Simple_Sample.ino Normal file
View File

@@ -0,0 +1,30 @@
#include <rtc_clock.h>
// Select the Slowclock source
//RTC_clock rtc_clock(RC);
RTC_clock rtc_clock(XTAL);
char* daynames[]={"Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"};
void setup() {
Serial.begin(9600);
rtc_clock.init();
rtc_clock.set_time(10, 29, 9);
rtc_clock.set_date(22, 10, 2012);
}
void loop() {
Serial.print("At the third stroke, it will be ");
Serial.print(rtc_clock.get_hours());
Serial.print(":");
Serial.print(rtc_clock.get_minutes());
Serial.print(":");
Serial.println(rtc_clock.get_seconds());
Serial.print(daynames[rtc_clock.get_day_of_week()-1]);
Serial.print(": ");
Serial.print(rtc_clock.get_days());
Serial.print(".");
Serial.print(rtc_clock.get_months());
Serial.print(".");
Serial.println(rtc_clock.get_years());
}

52
hardware/digistump/sam/libraries/RTC/examples/Due_RTC_Simple_Sample_oneline_time_and_date/Due_RTC_Simple_Sample_oneline_time_and_date.ino Normal file
View File

@@ -0,0 +1,52 @@
#include <rtc_clock.h>
// Select the Slowclock source
//RTC_clock rtc_clock(RC);
RTC_clock rtc_clock(XTAL);
char* daynames[]={"Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"};
int hh,mm,ss,dow,dd,mon,yyyy;
void setup() {
Serial.begin(9600);
rtc_clock.init();
rtc_clock.set_time(__TIME__);
rtc_clock.set_date(__DATE__);
}
void loop() {
Serial.print("Time: ");
rtc_clock.get_time(&hh,&mm,&ss);
rtc_clock.get_date(&dow,&dd,&mon,&yyyy);
digitprint(hh, 2);
Serial.print(":");
digitprint(mm, 2);
Serial.print(":");
digitprint(ss, 2);
Serial.println("");
Serial.print("Date: ");
Serial.print(daynames[dow-1]);
Serial.print(" ");
digitprint(dd, 2);
Serial.print(".");
digitprint(mon, 2);
Serial.print(".");
Serial.println(yyyy);
Serial.println("");
}
void digitprint(int value, int lenght){
for (int i = 0; i < (lenght - numdigits(value)); i++){
Serial.print("0");
}
Serial.print(value);
}
int numdigits(int i){
int digits;
if (i < 10)
digits = 1;
else
digits = (int)(log10((double)i)) + 1;
return digits;
}

52
hardware/digistump/sam/libraries/RTC/examples/Due_RTC_Simple_Unixtime_Compilertime/Due_RTC_Simple_Unixtime_Compilertime.ino Normal file
View File

@@ -0,0 +1,52 @@
#include <rtc_clock.h>
// Select the Slowclock source
//RTC_clock rtc_clock(RC);
RTC_clock rtc_clock(XTAL);
char* daynames[]={"Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"};
void setup() {
Serial.begin(9600);
rtc_clock.init();
rtc_clock.set_time(__TIME__);
rtc_clock.set_date(__DATE__);
}
void loop() {
Serial.print("Unixtime: ");
Serial.println(rtc_clock.unixtime());
Serial.println("And in plain for everyone");
Serial.print("Time: ");
digitprint(rtc_clock.get_hours(), 2);
Serial.print(":");
digitprint(rtc_clock.get_minutes(), 2);
Serial.print(":");
digitprint(rtc_clock.get_seconds(), 2);
Serial.println("");
Serial.print("Date: ");
Serial.print(daynames[rtc_clock.get_day_of_week()-1]);
Serial.print(" ");
digitprint(rtc_clock.get_days(), 2);
Serial.print(".");
digitprint(rtc_clock.get_months(), 2);
Serial.print(".");
Serial.println(rtc_clock.get_years());
Serial.println("");
}
void digitprint(int value, int lenght){
for (int i = 0; i < (lenght - numdigits(value)); i++){
Serial.print("0");
}
Serial.print(value);
}
int numdigits(int i){
int digits;
if (i < 10)
digits = 1;
else
digits = (int)(log10((double)i)) + 1;
return digits;
}

53
hardware/digistump/sam/libraries/RTC/examples/Due_RTC_Simple_Unixtime_timezone/Due_RTC_Simple_Unixtime_timezone.ino Normal file
View File

@@ -0,0 +1,53 @@
#include <rtc_clock.h>
// Select the Slowclock source
//RTC_clock rtc_clock(RC);
RTC_clock rtc_clock(XTAL);
char* daynames[]={"Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"};
void setup() {
Serial.begin(9600);
rtc_clock.init();
rtc_clock.set_time(__TIME__);
rtc_clock.set_date(__DATE__);
}
void loop() {
Serial.print("Unixtime: ");
//All known Timezones are supported set in this style "UTC+1" or "UTC-930" without colon
Serial.println(rtc_clock.unixtime(UTC-5));
Serial.println("And in plain for everyone");
Serial.print("Time: ");
digitprint(rtc_clock.get_hours(), 2);
Serial.print(":");
digitprint(rtc_clock.get_minutes(), 2);
Serial.print(":");
digitprint(rtc_clock.get_seconds(), 2);
Serial.println("");
Serial.print("Date: ");
Serial.print(daynames[rtc_clock.get_day_of_week()-1]);
Serial.print(" ");
digitprint(rtc_clock.get_days(), 2);
Serial.print(".");
digitprint(rtc_clock.get_months(), 2);
Serial.print(".");
Serial.println(rtc_clock.get_years());
Serial.println("");
}
void digitprint(int value, int lenght){
for (int i = 0; i < (lenght - numdigits(value)); i++){
Serial.print("0");
}
Serial.print(value);
}
int numdigits(int i){
int digits;
if (i < 10)
digits = 1;
else
digits = (int)(log10((double)i)) + 1;
return digits;
}

88
hardware/digistump/sam/libraries/RTC/examples/Due_RTC_Simple_german_timing_summertime_sample/Due_RTC_Simple_german_timing_summertime_sample.ino Normal file
View File

@@ -0,0 +1,88 @@
#include <rtc_clock.h>
// Select the Slowclock source
//RTC_clock rtc_clock(RC);
RTC_clock rtc_clock(XTAL);
char* daynames[]={"Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"};
boolean toggle = false;
int old_unixtime;
void setup() {
Serial.begin(9600);
rtc_clock.init();
rtc_clock.set_time(1,59,50);
rtc_clock.set_date(15,6,2013);
rtc_clock.timing();
}
void loop() {
if ( rtc_clock.unixtime() != old_unixtime) {
old_unixtime = rtc_clock.unixtime();
output();
}
if ( rtc_clock.get_seconds() == 10 ) {
Serial.print("Timeleap ");
toggle = !toggle;
}
if ( rtc_clock.get_seconds() == 10 && toggle == false ) {
//Summertimebegin Germany in 2013
Serial.println("back to summer");
rtc_clock.set_time(1,59,50);
rtc_clock.set_date(31,3,2013);
} else if (rtc_clock.get_seconds() == 10 && toggle == true ) {
//Wintertimebegin Germany in 2013
Serial.println("forward to the end of summer");
rtc_clock.set_time(1,59,50);
rtc_clock.set_date(27,10,2013);
}
}
void output() {
Serial.print("Unixtime: ");
Serial.println(rtc_clock.unixtime(Germany));
Serial.println("And in plain for everyone");
Serial.print("Time: ");
digitprint(rtc_clock.get_hours() + rtc_clock.summertime(), 2);
Serial.print(":");
digitprint(rtc_clock.get_minutes(), 2);
Serial.print(":");
digitprint(rtc_clock.get_seconds(), 2);
Serial.println("");
Serial.print("Date: ");
Serial.print(daynames[rtc_clock.get_day_of_week()-1]);
Serial.print(" ");
digitprint(rtc_clock.get_days(), 2);
Serial.print(".");
digitprint(rtc_clock.get_months(), 2);
Serial.print(".");
Serial.println(rtc_clock.get_years());
Serial.print("Is Summertime?: ");
if ( rtc_clock.summertime() == 1 ) {
Serial.println("Yes!");
} else {
Serial.println("No!");
}
Serial.println("");
}
void digitprint(int value, int lenght){
for (int i = 0; i < (lenght - numdigits(value)); i++){
Serial.print("0");
}
Serial.print(value);
}
int numdigits(int i){
int digits;
if (i < 10)
digits = 1;
else
digits = (int)(log10((double)i)) + 1;
return digits;
}

55
hardware/digistump/sam/libraries/RTC/examples/Due_RTC_Simple_test_of_date/Due_RTC_Simple_test_of_date.ino Normal file
View File

@@ -0,0 +1,55 @@
#include <rtc_clock.h>
#define START_VALUE "Jan 01 2007"
// Select the Slowclock source
//RTC_clock rtc_clock(RC);
RTC_clock rtc_clock(XTAL);
int counter = 0;
void setup() {
Serial.begin(9600);
rtc_clock.init();
}
void loop() {
if (rtc_clock.date_already_set() == 0) {
Serial.print("no ");
} else {
Serial.print("yes ");
}
digitprint(counter, 3, 1);
Serial.println();
delay(125);
if (counter == 50) {
rtc_clock.set_date(__DATE__);
}
if (counter == 100) {
counter = 0;
// technical all the same
//rtc_clock.set_date( 1, 1, 2007);
//rtc_clock.set_date("Jan 01 2007");
rtc_clock.set_date(START_VALUE);
}
counter++;
}
void digitprint(int value, int lenght, int placeholder){
for (int i = 0; i < (lenght - numdigits(value)); i++){
if (placeholder == 0)
Serial.print("0");
else
Serial.print(" ");
}
Serial.print(value);
}
int numdigits(int i){
int digits;
if (i < 10)
digits = 1;
else
digits = (int)(log10((double)i)) + 1;
return digits;
}

65
hardware/digistump/sam/libraries/RTC/keywords.txt Normal file
View File

@@ -0,0 +1,65 @@
#######################################
# Syntax Coloring Map For Due-RTC
#######################################
#######################################
# Datatypes (KEYWORD1)
#######################################
RTC_clock KEYWORD1
#######################################
# Methods and Functions (KEYWORD2)
#######################################
init KEYWORD2
set_time KEYWORD2
set_date KEYWORD2
set_seconds KEYWORD2
set_minutes KEYWORD2
set_hours KEYWORD2
set_days KEYWORD2
set_months KEYWORD2
set_years KEYWORD2
set_alarmtime KEYWORD2
set_alarmdate KEYWORD2
get_seconds KEYWORD2
get_minutes KEYWORD2
get_hours KEYWORD2
get_days KEYWORD2
get_day_of_week KEYWORD2
get_months KEYWORD2
get_years KEYWORD2
attachalarm KEYWORD2
disable_alarm KEYWORD2
unixtime KEYWORD2
get_time KEYWORD2
get_date KEYWORD2
summertime KEYWORD2
switch_years KEYWORD2
timing KEYWORD2
date_already_set KEYWORD2
set_clock KEYWORD2
#######################################
# Instances (KEYWORD2)
#######################################
#######################################
# Mean Instances (KEYWORD3)
#######################################
rtc_clock KEYWORD3
#######################################
# Constants (LITERAL1)
#######################################
RC LITERAL1
XTAL LITERAL1
__TIME__ LITERAL1
__DATE__ LITERAL1
Germany LITERAL1

729
hardware/digistump/sam/libraries/RTC/rtc_clock.cpp Normal file
View File

@@ -0,0 +1,729 @@
#include "rtc_clock.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "Arduino.h"
int daysInMonth[] = {31,28,31,30,31,30,31,31,30,31,30,31};
int meztime;
RTC_clock::RTC_clock (int source)
{
_source = source;
if (_source) {
pmc_switch_sclk_to_32kxtal(0);
while (!pmc_osc_is_ready_32kxtal());
}
}
void RTC_clock::init ()
{
RTC_SetHourMode(RTC, 0);
NVIC_DisableIRQ(RTC_IRQn);
NVIC_ClearPendingIRQ(RTC_IRQn);
NVIC_SetPriority(RTC_IRQn, 0);
// NVIC_EnableIRQ(RTC_IRQn);
// RTC_EnableIt(RTC, RTC_IER_SECEN | RTC_IER_ALREN);
// RTC_EnableIt(RTC, RTC_IER_SECEN);
}
void RTC_clock::set_time (int hour, int minute, int second)
{
_hour = hour;
_minute = minute;
_second = second;
RTC_SetTime (RTC, _hour, _minute, _second);
}
int conv2d(char* p)
{
int v = 0;
if ('0' <= *p && *p <= '9')
v = *p - '0';
return 10 * v + *++p - '0';
}
void RTC_clock::set_time (char* time)
{
_hour = conv2d(time);
_minute = conv2d(time + 3);
_second = conv2d(time + 6);
RTC_SetTime (RTC, _hour, _minute, _second);
}
uint32_t RTC_clock::current_time ()
{
uint32_t dwTime;
/* Get current RTC time */
dwTime = RTC->RTC_TIMR ;
while ( dwTime != RTC->RTC_TIMR ) {
dwTime = RTC->RTC_TIMR ;
}
return (dwTime);
}
void RTC_clock::get_time (int *hour, int *minute, int *second)
{
RTC_GetTime(RTC, (uint8_t*)hour, (uint8_t*)minute, (uint8_t*)second);
}
int RTC_clock::get_hours ()
{
_current_time = current_time();
return (((_current_time & 0x00300000) >> 20) * 10 + ((_current_time & 0x000F0000) >> 16));
}
int RTC_clock::get_minutes ()
{
_current_time = current_time();
return (((_current_time & 0x00007000) >> 12) * 10 + ((_current_time & 0x00000F00) >> 8));
}
int RTC_clock::get_seconds ()
{
_current_time = current_time();
return (((_current_time & 0x00000070) >> 4) * 10 + ((_current_time & 0x0000000F)));
}
/**
* \brief Calculate day_of_week from year, month, day.
*/
int RTC_clock::calculate_day_of_week (uint16_t _year, int _month, int _day)
{
int _week;
if (_month == 1 || _month == 2) {
_month += 12;
--_year;
}
_week = (_day + 2 * _month + 3 * (_month + 1) / 5 + _year + _year / 4 - _year / 100 + _year / 400) % 7;
++_week;
return _week;
}
void RTC_clock::set_date (int day, int month, uint16_t year)
{
_day = day;
_month = month;
_year = year;
_day_of_week = calculate_day_of_week(_year, _month, _day);
daysInMonth[1] = 28 + switch_years (_year);
RTC_SetDate (RTC, (uint16_t)_year, (uint8_t)_month, (uint8_t)_day, (uint8_t)_day_of_week);
}
void RTC_clock::set_date (char* date)
{
_day = conv2d(date + 4);
//Month
switch (date[0]) {
case 'J': _month = date[1] == 'a' ? 1 : _month = date[2] == 'n' ? 6 : 7; break;
case 'F': _month = 2; break;
case 'A': _month = date[2] == 'r' ? 4 : 8; break;
case 'M': _month = date[2] == 'r' ? 3 : 5; break;
case 'S': _month = 9; break;
case 'O': _month = 10; break;
case 'N': _month = 11; break;
case 'D': _month = 12; break;
}
_year = conv2d(date + 9);
_day_of_week = calculate_day_of_week(_year, _month, _day);
daysInMonth[1] = 28 + switch_years (_year);
RTC_SetDate (RTC, (uint16_t)_year, (uint8_t)_month, (uint8_t)_day, (uint8_t)_day_of_week);
}
uint32_t RTC_clock::current_date ()
{
uint32_t dwTime;
/* Get current RTC date */
dwTime = RTC->RTC_CALR ;
while ( dwTime != RTC->RTC_CALR ) {
dwTime = RTC->RTC_CALR ;
}
return (dwTime);
}
int RTC_clock::date_already_set ()
{
uint32_t dateregister;
/* Get current RTC date */
dateregister = current_date ();
if ( RESET_VALUE != dateregister ) {
return 1;
} else {
return 0;
}
}
// set the internal clock using a timestamp using the epoch passed as argument
uint8_t RTC_clock::set_timestamp(uint32_t timestamp, uint16_t epoch) {
uint32_t dayT;
if (timestamp > 951847199UL) { timestamp -= 86400UL; } //year 2000 is a special leap year, so 1 day must be added if date is greater than 29/02/2000
timestamp += 86400UL; //days in the calendar start from Jan., 1 not from Jan., 0
dayT = timestamp / (60UL * 60UL * 24UL);
float remaining = timestamp - dayT * (60UL * 60UL * 24UL);
uint16_t yearT = (dayT / 365.2422);
float dayRemaining = dayT - yearT * 365.2422;
if (epoch == 0) {
epoch = 1970;
} else if (epoch < 1900) {
epoch = 1900;
} else if (epoch > 1970) {
epoch = 1970;
} else if ((epoch != 1900) && (epoch != 1970)) {
epoch = 1970;
}
yearT += epoch;
if (dayRemaining >= 365.2422) {
return 1;//my math is wrong!
}
if (yearT < epoch) {
return 2;//year not supported!
}
uint8_t monthT = 0;
while (dayRemaining > daysInMonth[monthT]){
dayRemaining -= daysInMonth[monthT];
if (monthT == 1 && (((yearT % 4) == 0) && ((yearT % 100) != 0) || ((yearT % 400) == 0))) {
dayRemaining--;
}
monthT++;
}
monthT++;//because month 0 doesn't exist
if (monthT > 12) {
return 3;//my math is wrong!
}
if (dayRemaining >= (60UL*60UL*24UL)) {
return 4;//my math is wrong!
}
dayT = dayRemaining;
if (dayRemaining - dayT > 0){ //add partial day!
dayT++;
}
uint8_t hoursT = remaining / (60UL * 60UL);
remaining = remaining - hoursT * (60UL * 60UL);
if (remaining >= (60UL * 60UL)) {
return 5;//my math is wrong!
}
uint8_t minutesT = remaining / 60UL;
remaining = remaining - minutesT * 60UL;
if (remaining >= 60) {
return 6;//my math is wrong!
}
set_time(hoursT, minutesT, remaining);
set_date(dayT, monthT, yearT);
return 0;
}
void RTC_clock::get_date (int *day_of_week, int *day, int *month, int *year)
{
RTC_GetDate(RTC, (uint16_t*)year, (uint8_t*)month, (uint8_t*)day, (uint8_t*)day_of_week);
}
uint16_t RTC_clock::get_years ()
{
_current_date = current_date();
return ((((_current_date >> 4) & 0x7) * 1000) + ((_current_date & 0xF) * 100)
+ (((_current_date >> 12) & 0xF) * 10) + ((_current_date >> 8) & 0xF));
}
int RTC_clock::get_months ()
{
_current_date = current_date();
return ((((_current_date >> 20) & 1) * 10) + ((_current_date >> 16) & 0xF));
}
int RTC_clock::get_days ()
{
_current_date = current_date();
return ((((_current_date >> 28) & 0x3) * 10) + ((_current_date >> 24) & 0xF));
}
int RTC_clock::get_day_of_week ()
{
_current_date = current_date();
return (((_current_date >> 21) & 0x7));
}
int RTC_clock::set_hours (int hour)
{
_hour = hour;
uint32_t _current_time = current_time();
uint32_t _changed;
_changed = ((_hour%10) | ((_hour/10)<<4))<<16 ;
_current_time = (_current_time & 0xFFC0FFFF) ^ _changed ;
change_time(_current_time);
}
int RTC_clock::set_minutes (int minute)
{
_minute = minute;
uint32_t _current_time = current_time();
uint32_t _changed;
_changed = ((_minute%10) | ((_minute/10)<<4))<<8 ;
_current_time = (_current_time & 0xFFFF80FF) ^ _changed ;
change_time(_current_time);
}
int RTC_clock::set_seconds (int second)
{
_second = second;
uint32_t _current_time = current_time();
uint32_t _changed;
_changed = ((_second%10) | ((_second/10)<<4)) ;
_current_time = (_current_time & 0xFFFFFF80) ^ _changed ;
change_time(_current_time);
}
uint32_t RTC_clock::change_time (uint32_t now)
{
_now = now;
RTC->RTC_CR |= RTC_CR_UPDTIM ;
while ((RTC->RTC_SR & RTC_SR_ACKUPD) != RTC_SR_ACKUPD) ;
RTC->RTC_SCCR = RTC_SCCR_ACKCLR ;
RTC->RTC_TIMR = _now ;
RTC->RTC_CR &= (uint32_t)(~RTC_CR_UPDTIM) ;
RTC->RTC_SCCR |= RTC_SCCR_SECCLR ;
return (int)(RTC->RTC_VER & RTC_VER_NVTIM) ;
}
int RTC_clock::set_days (int day)
{
_day = day;
uint32_t _current_date = current_date();
uint32_t _changed;
_day_of_week = calculate_day_of_week(get_years(), get_months(), _day) ;
_day_of_week = ((_day_of_week%10) | (_day_of_week/10)<<4)<<21 ;
_changed = ((_day%10) | (_day/10)<<4)<<24 ;
_current_date = (_current_date & (0xC0FFFFFF & 0xFF1FFFFF) ) ^ ( _changed | _day_of_week ) ;
change_date(_current_date);
}
int RTC_clock::set_months (int month)
{
_month = month;
uint32_t _current_date = current_date();
uint32_t _changed;
_day_of_week = calculate_day_of_week(get_years(), _month, get_days()) ;
_day_of_week = ((_day_of_week%10) | (_day_of_week/10)<<4)<<21 ;
_changed = ((_month%10) | (_month/10)<<4)<<16 ;
_current_date = (_current_date & (0xFFE0FFFF & 0xFF1FFFFF) ) ^ ( _changed | _day_of_week ) ;
change_date(_current_date);
}
int RTC_clock::set_years (uint16_t year)
{
_year = year;
uint32_t _current_date = current_date();
uint32_t _changed;
_day_of_week = calculate_day_of_week(_year, get_months(), get_days()) ;
_day_of_week = ((_day_of_week%10) | (_day_of_week/10)<<4)<<21 ;
_changed = (((_year/100)%10) | ((_year/1000)<<4)) | ((_year%10) | (((_year/10)%10))<<4)<<8 ;
_current_date = (_current_date & (0xFFFF0080 & 0xFF1FFFFF) ) ^ ( _changed | _day_of_week ) ;
daysInMonth[1] = 28 + switch_years (_year);
change_date(_current_date);
}
uint32_t RTC_clock::change_date (uint32_t now)
{
_now = now;
RTC->RTC_CR |= RTC_CR_UPDCAL ;
while ((RTC->RTC_SR & RTC_SR_ACKUPD) != RTC_SR_ACKUPD) ;
RTC->RTC_SCCR = RTC_SCCR_ACKCLR ;
RTC->RTC_CALR = _now ;
RTC->RTC_CR &= (uint32_t)(~RTC_CR_UPDCAL) ;
RTC->RTC_SCCR |= RTC_SCCR_SECCLR ;
return (int)(RTC->RTC_VER & RTC_VER_NVCAL) ;
}
void RTC_clock::set_clock (char* date, char* time)
{
uint32_t wDate ;
uint32_t dwTime=0 ;
_day = conv2d(date + 4);
//Month
switch (date[0]) {
case 'J': _month = date[1] == 'a' ? 1 : _month = date[2] == 'n' ? 6 : 7; break;
case 'F': _month = 2; break;
case 'A': _month = date[2] == 'r' ? 4 : 8; break;
case 'M': _month = date[2] == 'r' ? 3 : 5; break;
case 'S': _month = 9; break;
case 'O': _month = 10; break;
case 'N': _month = 11; break;
case 'D': _month = 12; break;
}
_year = conv2d(date + 9);
_day_of_week = calculate_day_of_week(_year, _month, _day);
daysInMonth[1] = 28 + switch_years (_year);
_hour = conv2d(time);
_minute = conv2d(time + 3);
_second = conv2d(time + 6);
uint8_t _yearcent = ((_year/100)%10) | ((_year/1000)<<4);
_year = (_year%10) | (((_year/10)%10)<<4);
_month = ((_month%10) | (_month/10)<<4);
_day = ((_day%10) | (_day/10)<<4);
_day_of_week = ((_day_of_week%10) | (_day_of_week/10)<<4);
_hour = (_hour%10) | ((_hour/10)<<4) ;
_minute = (_minute%10) | ((_minute/10)<<4) ;
_second = (_second%10) | ((_second/10)<<4) ;
/* Convert values to register value */
wDate = _yearcent | (_year << 8) | (_month << 16) | (_day_of_week << 21) | (_day << 24);
dwTime = _second | (_minute << 8) | (_hour<<16) ;
/* Update time register */
RTC->RTC_CR |= RTC_CR_UPDTIM ;
while ((RTC->RTC_SR & RTC_SR_ACKUPD) != RTC_SR_ACKUPD) ;
RTC->RTC_SCCR = RTC_SCCR_ACKCLR ;
RTC->RTC_TIMR = dwTime ;
// waiting for second event
while ((RTC->RTC_SR & RTC_SR_SEC) != RTC_SR_SEC) ;
RTC->RTC_CR &= (uint32_t)(~RTC_CR_UPDTIM) ;
RTC->RTC_SCCR |= RTC_SCCR_SECCLR; /* clear SECENV in SCCR */
/* Update calendar register */
RTC->RTC_CR |= RTC_CR_UPDCAL ;
while ((RTC->RTC_SR & RTC_SR_ACKUPD) != RTC_SR_ACKUPD) ;
RTC->RTC_SCCR = RTC_SCCR_ACKCLR;
RTC->RTC_CALR = wDate ;
// waiting for second event
while ((RTC->RTC_SR & RTC_SR_SEC) != RTC_SR_SEC) ;
RTC->RTC_CR &= (uint32_t)(~RTC_CR_UPDCAL) ;
RTC->RTC_SCCR |= RTC_SCCR_SECCLR; /* clear SECENV in SCCR */
}
void (*useralarmFunc)(void);
void RTC_clock::attachalarm(void (*userFunction)(void))
{
useralarmFunc = userFunction;
}
void RTC_Handler(void)
{
uint32_t status = RTC->RTC_SR;
/* Time or date alarm */
if ((status & RTC_SR_ALARM) == RTC_SR_ALARM) {
/* Disable RTC interrupt */
RTC_DisableIt(RTC, RTC_IDR_ALRDIS);
//Bepfehl ausf<73>hren
useralarmFunc();
/* Clear notification */
RTC_ClearSCCR(RTC, RTC_SCCR_ALRCLR);
RTC_EnableIt(RTC, RTC_IER_ALREN);
}
}
void RTC_clock::set_alarmtime (int hour, int minute, int second)
{
uint8_t _hour = hour;
uint8_t _minute = minute;
uint8_t _second = second;
RTC_EnableIt(RTC, RTC_IER_ALREN);
RTC_SetTimeAlarm(RTC, &_hour, &_minute, &_second);
NVIC_EnableIRQ(RTC_IRQn);
}
void RTC_clock::set_alarmdate (int month, int day)
{
uint8_t _month = month;
uint8_t _day = day;
RTC_EnableIt(RTC, RTC_IER_ALREN);
RTC_SetDateAlarm(RTC, &_month, &_day);
NVIC_EnableIRQ(RTC_IRQn);
}
uint32_t RTC_clock::unixtime()
{
unixtime(0);
}
uint32_t RTC_clock::unixtime(int timezone)
{
uint32_t _ticks;
uint16_t _days;
float adjustment;
_current_date = current_date();
_current_time = current_time();
_second = (((_current_time & 0x00000070) >> 4) * 10 + ((_current_time & 0x0000000F)));
_minute = (((_current_time & 0x00007000) >> 12) * 10 + ((_current_time & 0x00000F00) >> 8));
_hour = (((_current_time & 0x00300000) >> 20) * 10 + ((_current_time & 0x000F0000) >> 16));
_day = ((((_current_date >> 28) & 0x3) * 10) + ((_current_date >> 24) & 0xF));
_day_of_week = ((_current_date >> 21) & 0x7);
_month = ((((_current_date >> 20) & 1) * 10) + ((_current_date >> 16) & 0xF));
//_year = ((((_current_date >> 4) & 0x7) * 1000) + ((_current_date & 0xF) * 100)
// + (((_current_date >> 12) & 0xF) * 10) + ((_current_date >> 8) & 0xF));
//_year = _year - 2000;
_year = (((_current_date >> 12) & 0xF) * 10) + ((_current_date >> 8) & 0xF);
_days = _day;
for (int i = 1; i < _month; ++i)
_days += daysInMonth[i - 1];
if (_month > 2 && _year % 4 == 0)
++_days;
_days += 365 * _year + (_year + 3) / 4 - 1;
_ticks = ((_days * 24 + _hour) * 60 + _minute) * 60 + _second;
_ticks += SECONDS_FROM_1970_TO_2000;
if (timezone == Germany) {
timezone = 1 + summertime();
}
switch (timezone) {
case -12:
adjustment = -12 * SECONDS_PER_HOUR;
break;
case -11:
adjustment = -11 * SECONDS_PER_HOUR;
break;
case -10:
adjustment = -10 * SECONDS_PER_HOUR;
break;
case -930:
adjustment = -9.5 * SECONDS_PER_HOUR;
break;
case -9:
adjustment = -9 * SECONDS_PER_HOUR;
break;
case -8:
adjustment = -8 * SECONDS_PER_HOUR;
break;
case -7:
adjustment = -7 * SECONDS_PER_HOUR;
break;
case -6:
adjustment = -6 * SECONDS_PER_HOUR;
break;
case -5:
adjustment = -5 * SECONDS_PER_HOUR;
break;
case -4:
adjustment = -4 * SECONDS_PER_HOUR;
break;
case -330:
adjustment = -3.5 * SECONDS_PER_HOUR;
break;
case -3:
adjustment = -3 * SECONDS_PER_HOUR;
break;
case -2:
adjustment = -2 * SECONDS_PER_HOUR;
break;
case -1:
adjustment = -1 * SECONDS_PER_HOUR;
break;
case 0:
default:
adjustment = 0;
break;
case 1:
adjustment = 1 * SECONDS_PER_HOUR;
break;
case 2:
adjustment = 2 * SECONDS_PER_HOUR;
break;
case 3:
adjustment = 3 * SECONDS_PER_HOUR;
break;
case 330:
adjustment = 3.5 * SECONDS_PER_HOUR;
break;
case 4:
adjustment = 4 * SECONDS_PER_HOUR;
break;
case 430:
adjustment = 4.5 * SECONDS_PER_HOUR;
break;
case 5:
adjustment = 5 * SECONDS_PER_HOUR;
break;
case 530:
adjustment = 5.5 * SECONDS_PER_HOUR;
break;
case 545:
adjustment = 5.75 * SECONDS_PER_HOUR;
break;
case 6:
adjustment = 6 * SECONDS_PER_HOUR;
break;
case 630:
adjustment = 6.5 * SECONDS_PER_HOUR;
break;
case 7:
adjustment = 7 * SECONDS_PER_HOUR;
break;
case 8:
adjustment = 8 * SECONDS_PER_HOUR;
break;
case 845:
adjustment = 8.75 * SECONDS_PER_HOUR;
break;
case 9:
adjustment = 9 * SECONDS_PER_HOUR;
break;
case 930:
adjustment = 9.5 * SECONDS_PER_HOUR;
break;
case 10:
adjustment = 10 * SECONDS_PER_HOUR;
break;
case 1030:
adjustment = 10.5 * SECONDS_PER_HOUR;
break;
case 11:
adjustment = 11 * SECONDS_PER_HOUR;
break;
case 1130:
adjustment = 11.5 * SECONDS_PER_HOUR;
break;
case 12:
adjustment = 12 * SECONDS_PER_HOUR;
break;
case 1245:
adjustment = 12.75 * SECONDS_PER_HOUR;
break;
case 13:
adjustment = 13 * SECONDS_PER_HOUR;
break;
case 14:
adjustment = 14 * SECONDS_PER_HOUR;
break;
}
_ticks = _ticks - (int)adjustment;
return _ticks;
}
int RTC_clock::switch_years (uint16_t year)
{
if ( ((year %4 == 0) && (year % 100 != 0)) || (year % 400 == 0) ) {
return 1;
} else {
return 0;
}
}
int RTC_clock::summertime ()
{
int sundaysommertime, sundaywintertime, today, sundaysommertimehours, sundaywintertimehours, todayhours;
_current_date = current_date();
_current_time = current_time();
_hour = (((_current_time & 0x00300000) >> 20) * 10 + ((_current_time & 0x000F0000) >> 16));
_day = ((((_current_date >> 28) & 0x3) * 10) + ((_current_date >> 24) & 0xF));
_month = ((((_current_date >> 20) & 1) * 10) + ((_current_date >> 16) & 0xF));
_year = (((_current_date >> 12) & 0xF) * 10) + ((_current_date >> 8) & 0xF);
sundaysommertime = 31 - ( 5 + _year * 5 / 4 ) % 7;
sundaywintertime = 31 - ( 2 + _year * 5 / 4 ) % 7;
today = _day;
//Summertimebegin in March
for (int i = 1; i < 2; ++i) {
sundaysommertime += daysInMonth[i - 1];
}
//Wintertimebegin in October
for (int i = 1; i < 9; ++i) {
sundaywintertime += daysInMonth[i - 1];
}
for (int i = 1; i < (_month - 1); ++i) {
today += daysInMonth[i - 1];
}
sundaysommertimehours = sundaysommertime * 24 + 2;
sundaywintertimehours = sundaywintertime * 24 + 3;
todayhours = today * 24 + _hour;
if (todayhours >= sundaysommertimehours && (todayhours + 1) < sundaywintertimehours) {
return (1 * meztime);
} else {
return 0;
}
}
int RTC_clock::timing ()
{
if ( summertime() == 1 ) {
meztime = MESZ;
} else {
meztime = MEZ;
}
}

83
hardware/digistump/sam/libraries/RTC/rtc_clock.h Normal file
View File

@@ -0,0 +1,83 @@
#ifndef RTC_clock_h
#define RTC_clock_h
#include "Arduino.h"
// Includes Atmel CMSIS
#include <chip.h>
#define SUPC_KEY 0xA5u
#define RESET_VALUE 0x01210720
#define RC 0
#define XTAL 1
// Unixtimeseconds from 1. Januar 1970 00:00:00 to 1. Januar 2000 00:00:00 UTC-0
#define SECONDS_FROM_1970_TO_2000 946684800
#define SECONDS_PER_HOUR 3600
#define UTC 0
#define Germany 2000
#define MEZ 1
#define MESZ -1
class RTC_clock
{
public:
RTC_clock (int source);
void init ();
void set_time (int hour, int minute, int second);
void set_time (char* time);
int get_hours ();
int get_minutes ();
int get_seconds ();
void set_date (int day, int month, uint16_t year);
void set_date (char* date);
void set_clock (char* date, char* time);
uint8_t set_timestamp(uint32_t timestamp, uint16_t epoch=1970);
uint16_t get_years ();
int get_months ();
int date_already_set ();
int get_days ();
int get_day_of_week ();
int calculate_day_of_week (uint16_t _year, int _month, int _day);
int set_hours (int _hour);
int set_minutes (int minute);
int set_seconds (int second);
int set_days (int day);
int set_months (int month);
int set_years (uint16_t year);
void set_alarmtime (int hour, int minute, int second);
void set_alarmdate (int month, int day);
void attachalarm (void (*)(void));
uint32_t unixtime ();
uint32_t unixtime (int timezone);
void get (int *hour, int *minute, int *second, int *day, int *month, int *year);
void get_time (int *hour, int *minute, int *second);
void get_date (int *day_of_week, int *day, int *month, int *year);
int switch_years (uint16_t year);
int summertime ();
int timing ();
private:
int _source;
int _hour;
int _minute;
int _second;
int _day;
int _month;
uint16_t _year;
int _day_of_week;
uint32_t current_time ();
uint32_t current_date ();
uint32_t _current_time;
uint32_t _current_date;
uint32_t change_time (uint32_t _now);
uint32_t change_date (uint32_t _now);
uint32_t _now;
uint32_t _changed;
};
#endif