/**
* \brief Execute oven control step.
*
* This function takes information from the user interface, temperature sensor
* and plate (QTouch) sensing and controls the output to the induction elements
* via a frequency signal.
*
* The oven has three states:
* - POWER_OFF where we just wait for input from the user interface to turn
* on.
* - ON_NO_POT where the user has indicated that power should be applied, but
* there is no pot in the plate. A safety timer changes the state back to
* POWER_OFF.
* - ON_ACTUATING where we have a pot on the oven, and actuate the induction
* elements while waiting for user input, and check if there is a pot on
* the oven.
*
* \param time Current system time in milliseconds.
* \param *wattage Pointer to the variable representing the desired effect
* \param *power Pointer to the variable controlling whether the induction
* coils should be actuated.
* \param potstate A variable representing the latest information on whether
* anything is present on the plate (QTouch sensor)
*/
void ovenctl_execute_control_step(uint32_t time, uint8_t *wattage, bool *power,
enum pot_t potstate)
{
/* Current state of the oven */
static enum ovenctl_plate_state plate_control_state = POWER_OFF;
static uint32_t time_pot_off = 0;
switch (plate_control_state) {
case POWER_OFF:
/* If the user has requested that the power be turned on,
* run Class B tests and go to ON_NO_POT
*/
if (*wattage > 0) {
ovenctl_turn_on_plate();
time_pot_off = rtc_get_time();
plate_control_state = ON_NO_POT;
}
break;
case ON_NO_POT:
/* If too long has passed without pot on the plate, turn off
* oven
*/
if ((rtc_get_time() - time_pot_off) > (20 * 1000)) {
ovenctl_turn_off_plate(wattage, power);
plate_control_state = POWER_OFF;
/* If user turned off power, turn off power. */
} else if (*wattage == 0) {
ovenctl_turn_off_plate(wattage, power);
plate_control_state = POWER_OFF;
/* If pot is put back before timeout, go back to active mode */
} else if (potstate == POT_ON) {
*power = true;
plate_control_state = ON_ACTUATING;
}
break;
case ON_ACTUATING:
/* Check if pot is on. If it is not, go to inactive mode. */
if (potstate == POT_OFF) {
*power = false;
time_pot_off = rtc_get_time();
plate_control_state = ON_NO_POT;
/* If user turned off power, turn off power. */
} else if (*wattage == 0) {
ovenctl_turn_off_plate(wattage, power);
plate_control_state = POWER_OFF;
}
break;
}
/* Update the output signal to the induction element according to
* selected power level, and whether power should be applied.
*/
ovenctl_actuate_induction_element(*power ? *wattage : 0);
}
/**
* rtc_show_configuration - output configuration to uart
*/
void rtc_show_configuration(void)
{
uart_send_text_sram("Time: ");
uint8_t i;
char time[3][3];
for (i = RTC_SECOND; i < (RTC_SECOND + 3); i++) {
uint8_t time_temp;
rtc_get_time(i, &time_temp);
int_to_string_fixed_length(time[i], 3, time_temp);
}
uart_send_text_buffer(time[2]);
uart_send_text_sram(":");
uart_send_text_buffer(time[1]);
uart_send_text_sram(":");
uart_send_text_buffer(time[0]);
UART_NEWLINE();
uart_send_text_sram("Date: ");
for (i = RTC_DATE; i < (RTC_DATE + 3); i++) {
uint8_t time_temp;
rtc_get_time(i, &time_temp);
int_to_string_fixed_length(time[i - RTC_DATE], 3, time_temp);
}
uart_send_text_sram("20");
uart_send_text_buffer(time[2]);
uart_send_text_sram("-");
uart_send_text_buffer(time[1]);
uart_send_text_sram("-");
uart_send_text_buffer(time[0]);
UART_NEWLINE();
}
/**
* Initialize the system controller. In particular:
* - Load settings
* - Setup the log interval alarm.
*/
Controller::Controller() {
m_sleeping=false;
m_powerup=false;
//m_log_interval_seconds = 60*30;
m_log_interval_seconds = 0; // default set to zero to save power
rtc_clear_alarmed();
rtc_enable_alarm(RTC);
m_interval_stored = rtc_get_time(RTC);
m_counts_stored = 0;
m_alarm_log = false;
system_controller = this;
m_last_switch_state = true;
m_never_dim = false;
bool sstate = switch_state();
m_last_switch_state = sstate;
m_warning_raised = false;
m_dim_off = false;
m_cpm_cps_switch = false;
m_current_units = 2;
m_cpm_cps_threshold = 1100.0;
m_cps_cpm_threshold = 1000.0;
// Get warning cpm from flash
m_warncpm = 0;
const char *swarncpm = flashstorage_keyval_get("WARNCPM");
if(swarncpm != 0) {
int32_t c;
sscanf(swarncpm, "%"PRIu32"", &c);
m_warncpm = c;
}
// Get never dim from flash
m_warncpm = -1;
const char *sneverdim = flashstorage_keyval_get("NEVERDIM");
if(sneverdim != 0) {
if(strcmp(sneverdim,"true") == 0) m_never_dim=true;
else m_never_dim=false;
} else m_never_dim=false;
if(m_never_dim) tick_item("Never Dim" ,true);
// Get logging interval from flash
const char *sloginter = flashstorage_keyval_get("LOGINTERVAL");
if(sloginter != 0) {
int32_t c;
sscanf(sloginter, "%"PRIu32"", &c);
m_log_interval_seconds = c;
} else {
// m_log_interval_seconds = 30*60;
m_log_interval_seconds = 0; // default set to zero to save power
}
rtc_set_alarm(RTC,rtc_get_time(RTC)+m_log_interval_seconds);
}
/*
* Hah! We'll see if this works (switching from usecs to nsecs).
*/
static unsigned long tmu_timer_get_frequency(void)
{
u32 freq;
struct timespec ts1, ts2;
unsigned long diff_nsec;
unsigned long factor;
/* Setup the timer: We don't want to generate interrupts, just
* have it count down at its natural rate.
*/
ctrl_outb(0, TMU_TSTR);
#if !defined(CONFIG_CPU_SUBTYPE_SH7300) && !defined(CONFIG_CPU_SUBTYPE_SH7760)
ctrl_outb(TMU_TOCR_INIT, TMU_TOCR);
#endif
ctrl_outw(TMU0_TCR_CALIB, TMU0_TCR);
ctrl_outl(0xffffffff, TMU0_TCOR);
ctrl_outl(0xffffffff, TMU0_TCNT);
rtc_get_time(&ts2);
do {
rtc_get_time(&ts1);
} while (ts1.tv_nsec == ts2.tv_nsec && ts1.tv_sec == ts2.tv_sec);
/* actually start the timer */
ctrl_outb(TMU_TSTR_INIT, TMU_TSTR);
do {
rtc_get_time(&ts2);
} while (ts1.tv_nsec == ts2.tv_nsec && ts1.tv_sec == ts2.tv_sec);
freq = 0xffffffff - ctrl_inl(TMU0_TCNT);
if (ts2.tv_nsec < ts1.tv_nsec) {
ts2.tv_nsec += 1000000000;
ts2.tv_sec--;
}
diff_nsec = (ts2.tv_sec - ts1.tv_sec) * 1000000000 + (ts2.tv_nsec - ts1.tv_nsec);
/* this should work well if the RTC has a precision of n Hz, where
* n is an integer. I don't think we have to worry about the other
* cases. */
factor = (1000000000 + diff_nsec/2) / diff_nsec;
if (factor * diff_nsec > 1100000000 ||
factor * diff_nsec < 900000000)
panic("weird RTC (diff_nsec %ld)", diff_nsec);
return freq * factor;
}
/**
* Append a new entry to the log if necessary. Checks the
* state of m_alarm_log to determine if we should append a log
* entry.
*/
void Controller::do_logging() {
if(rtc_alarmed()) {
m_alarm_log = true;
m_last_alarm_time = rtc_get_time(RTC);
#ifndef DISABLE_ACCEL
accel_read_state(&m_accel_x_stored,&m_accel_y_stored,&m_accel_z_stored);
#endif
//m_magsensor_stored = gpio_read_bit(PIN_MAP[29].gpio_device,PIN_MAP[29].gpio_bit);
// set new alarm for log_interval_seconds from now.
rtc_clear_alarmed();
}
if(m_alarm_log == true) {
if(system_geiger->is_cpm30_valid()) {
log_data_t data;
#ifndef DISABLE_ACCEL
accel_read_state(&data.accel_x_end,&data.accel_y_end,&data.accel_z_end);
#endif
//data.magsensor_end = gpio_read_bit(PIN_MAP[29].gpio_device,PIN_MAP[29].gpio_bit);
data.time = rtc_get_time(RTC);
data.cpm = system_geiger->get_cpm30();
data.accel_x_start = m_accel_x_stored;
data.accel_y_start = m_accel_y_stored;
data.accel_z_start = m_accel_z_stored;
//data.magsensor_start = m_magsensor_stored;
data.log_type = UINT_MAX;
flashstorage_log_pushback((uint8_t *) &data,sizeof(log_data_t));
bool full = flashstorage_log_isfull();
if((full == true) && (!m_sleeping)) {
m_gui->show_dialog("Flash Log","is full",0,0,0,43,44,255,255);
}
m_alarm_log = false;
rtc_set_alarm(RTC,m_last_alarm_time+m_log_interval_seconds);
rtc_enable_alarm(RTC);
if(m_sleeping) {
power_standby();
}
}
}
}
void lcd_scroll_disp(unsigned char *scroll_data, unsigned char position)
{
unsigned char i, j, *d;
position += 0x80;
d = scroll_data;
comdr(position);
for(j = 15; j>0 ; j--)
{
position = j + 0x80;
comdr(position);
ms_delay(5);
for(i=0; *d!='\0'; i++)
{
datar(*d);
ms_delay(1);
d++;
}
d = scroll_data++;
rtc_get_time(); //--------------
lcd_line4_disp(&Uc_real_time[0],12); //------------------
ms_delay(9000);
clrscr();
}
}
static void app_neb_insert_abs_time(struct nbps_neb_record_send_req *req)
{
#if (RTC_SUPPORT)
struct rtc_time time;
// Get time stamp from RTC
rtc_get_time(&time);
// Format result
req->neb_rec.timestamp.year = time.tm_year;
req->neb_rec.timestamp.month = time.tm_mon;
req->neb_rec.timestamp.day = time.tm_mday;
req->neb_rec.timestamp.hour = time.tm_hour;
req->neb_rec.timestamp.min = time.tm_min;
req->neb_rec.timestamp.sec = time.tm_sec;
#else //(RTC_SUPPORT)
// Default time
req->neb_rec.timestamp.year = 2015;
req->neb_rec.timestamp.month = 10;
req->neb_rec.timestamp.day = 21;
req->neb_rec.timestamp.hour = 16;
req->neb_rec.timestamp.min = 29;
req->neb_rec.timestamp.sec = 0;
#endif //(RTC_SUPPORT)
}
void ZP_CreateLogFile(void)
{
char file[50];
uint32_t ul_hour, ul_minute, ul_second;
uint32_t ul_year, ul_month, ul_day, ul_week;
rtc_get_time(RTC, &ul_hour, &ul_minute, &ul_second);
rtc_get_date(RTC, &ul_year, &ul_month, &ul_day, &ul_week);
f_mkdir("0:Logs");
sprintf(file, "0:logs/%04u", ul_year);
f_mkdir((char const *)file);
sprintf(file, "0:logs/%04u/%02u", ul_year, ul_month);
f_mkdir((char const *)file);
sprintf(file, "0:logs/%04u/%02u/%02u", ul_year, ul_month, ul_day);
f_mkdir((char const *)file);
sprintf(file, "0:Logs/%04u/%02u/%02u/Flight_Log_%02u.%02u.%02u.log", ul_year, ul_month, ul_day, ul_hour, ul_minute, ul_second);
f_open(&f_log, (char const *)file, FA_CREATE_ALWAYS | FA_WRITE);
f_puts("Goblin-Tech", &f_log);
f_puts("GT101-0001", &f_log);
f_puts("00.00.00", &f_log);
uint16_t size = f_size(&f_script);
uint8_t dummy;
f_write(&f_log, &size, 2, &dummy);
f_write(&f_log, &Script, size, &dummy);
f_sync(&f_log);
}
static int
rtc_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
unsigned long arg)
{
struct rtc_time rtc_tm;
ulong curr_time;
switch (cmd) {
case RTC_RD_TIME: /* Read the time/date from RTC */
curr_time = rtc_get_time();
to_tm(curr_time, &rtc_tm);
rtc_tm.tm_year -= 1900;
return copy_to_user((void *) arg, &rtc_tm, sizeof(rtc_tm)) ?
-EFAULT : 0;
case RTC_SET_TIME: /* Set the RTC */
if (!capable(CAP_SYS_TIME))
return -EACCES;
if (copy_from_user(&rtc_tm,
(struct rtc_time *) arg,
sizeof(struct rtc_time)))
return -EFAULT;
curr_time = mktime(rtc_tm.tm_year + 1900,
rtc_tm.tm_mon,
rtc_tm.tm_mday,
rtc_tm.tm_hour,
rtc_tm.tm_min,
rtc_tm.tm_sec);
return rtc_set_time(curr_time);
default:
return -EINVAL;
}
}
void __init time_init(void)
{
if (board_time_init)
board_time_init();
clk_init();
if (rtc_get_time) {
rtc_get_time(&xtime);
} else {
xtime.tv_sec = mktime(2000, 1, 1, 0, 0, 0);
xtime.tv_nsec = 0;
}
set_normalized_timespec(&wall_to_monotonic,
-xtime.tv_sec, -xtime.tv_nsec);
/*
* Find the timer to use as the system timer, it will be
* initialized for us.
*/
sys_timer = get_sys_timer();
printk(KERN_INFO "Using %s for system timer\n", sys_timer->name);
#if defined(CONFIG_SH_KGDB)
/*
* Set up kgdb as requested. We do it here because the serial
* init uses the timer vars we just set up for figuring baud.
*/
kgdb_init();
#endif
}
void __init time_init(void)
{
int ret;
/*
* Make sure we don't get any COMPARE interrupts before we can
* handle them.
*/
sysreg_write(COMPARE, 0);
xtime.tv_sec = rtc_get_time();
xtime.tv_nsec = 0;
set_normalized_timespec(&wall_to_monotonic,
-xtime.tv_sec, -xtime.tv_nsec);
ret = avr32_hpt_init();
if (ret) {
pr_debug("timer: failed setup: %d\n", ret);
return;
}
ret = clocksource_register(&clocksource_avr32);
if (ret)
pr_debug("timer: could not register clocksource: %d\n", ret);
ret = avr32_hpt_start();
if (ret) {
pr_debug("timer: failed starting: %d\n", ret);
return;
}
}
/**
* \brief Callback function for ADC interrupts
*
* \param adc Pointer to ADC module.
* \param channel ADC channel number.
* \param result Conversion result from ADC channel.
*/
static void app_sampling_handler(ADC_t *adc, uint8_t channel,
adc_result_t result)
{
/* Store ADC convertion result for the coresponding on-board sensor */
switch (adc_conv[adc_mux_index]) {
case LIGHT_SENSOR_ADC_INPUT:
light = 2048 - result;
break;
default:
break;
}
/* Parse table of ADC conversions */
if (++adc_mux_index < sizeof(adc_conv)) {
app_sampling_start_next_conversion();
return;
}
/* End of all conversions */
adc_mux_index = 0;
/* Save values in FIFO */
if (2 > fifo_get_free_size(&app_sampling_fifo_desc)) {
return; /* Error */
}
fifo_push_uint16_nocheck(&app_sampling_fifo_desc, rtc_get_time());
fifo_push_uint16_nocheck(&app_sampling_fifo_desc, (uint16_t)light);
LED_Off(LED1_GPIO);
/* Enable the next RTC alarm */
app_sampling_rtc_run = true;
rtc_set_alarm_relative(app_sampling_rate - 1);
}
static int tcube_rtc_read_proc(char *page, char **start, off_t off, int count, int *eof, void *data)
{
char *p = page;
int len;
struct rtc_time tm;
unsigned long curr_time;
#if defined(RTC_ALARM_SUPPORT)
unsigned char ctrl_reg[2];
#endif
curr_time = rtc_get_time();
to_tm(curr_time, &tm);
tm.tm_year -= 1900;
p += sprintf(p, "rtc_time\t: %02d:%02d:%02d\n"
"rtc_date\t: %04d-%02d-%02d\n"
"rtc_epoch\t: %04d\n",
tm.tm_hour, tm.tm_min, tm.tm_sec,
tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, 1970);
#if defined(RTC_ALARM_SUPPORT)
rtc_get_alm_time(&tm);
rtc_get_ctrl_reg(&ctrl_reg[0]);
p += sprintf(p, "alrm_time\t: %02d:%02d\n", tm.tm_hour, tm.tm_min);
p += sprintf(p, "alarm_IRQ\t: %s\n",
(ctrl_reg[0] & 0x40) ? "yes" : "no" );
#endif
len = (p - page) - off;
if (len < 0)
len = 0;
*eof = (len <= count) ? 1 : 0;
*start = page + off;
return len;
}
/**
* RTCの時間を取得します。
*
* @param[out] year 年の格納先を指定します。
* @param[out] mon 月の格納先を指定します。
* @param[out] day 日の格納先を指定します。
* @param[out] hour 時の格納先を指定します。
* @param[out] min 分の格納先を指定します。
* @param[out] sec 秒の格納先を指定します。
* @param[out] week 曜日の格納先を指定します。
*
* @return 時間の取得に成功した場合はtrueを返却します。失敗した場合はfalseを返却します。
*
* @attention なし
***************************************************************************/
bool RTC::getDateTime(int &year, int &mon, int &day, int &hour, int &min, int &sec, int &week)
{
bool bError = true;
RTC_TIMETYPE time;
if (rtc_get_time(&time) == 0) {
year = 0;
mon = 0;
day = 0;
hour = 0;
sec = 0;
week = 0;
bError = false;
}
else {
year = time.year;
mon = time.mon;
day = time.day;
hour = time.hour;
min = time.min;
sec = time.second;
week = time.weekday;
}
return (bError);
}
void __init time_init(void)
{
if (board_time_init)
board_time_init();
xtime.tv_sec = rtc_get_time();
xtime.tv_usec = 0;
/* choose appropriate gettimeoffset routine */
do_gettimeoffset = null_gettimeoffset;
/*
* Call board specific timer interrupt setup.
*
* this pointer must be setup in machine setup routine.
*
* Even if the machine choose to use low-level timer interrupt,
* it still needs to setup the timer_irqaction.
* In that case, it might be better to set timer_irqaction.handler
* to be NULL function so that we are sure the high-level code
* is not invoked accidentally.
*/
board_timer_setup(&timer_irqaction);
}
/**
* \brief Set the time using a spinner widget
*/
static void set_time_application(void)
{
struct keyboard_event input;
struct calendar_date date;
uint32_t timestamp;
uint8_t tz_hours;
uint8_t tz_minutes;
struct gfx_mono_spinctrl hour_spinner;
struct gfx_mono_spinctrl minute_spinner;
struct gfx_mono_spinctrl_spincollection time_spinners;
uint8_t spinner_status;
int16_t spinner_results[2];
// Prepare the spinner widget for time selection
gfx_mono_spinctrl_init(&hour_spinner, SPINTYPE_INTEGER,
datetime_date_spinner_string_hour, NULL, 0, 23, 0);
gfx_mono_spinctrl_init(&minute_spinner, SPINTYPE_INTEGER,
datetime_date_spinner_string_minute, NULL, 0, 59, 0);
// Create time spincollector
gfx_mono_spinctrl_spincollection_init(&time_spinners);
gfx_mono_spinctrl_spincollection_add_spinner(&hour_spinner,
&time_spinners);
gfx_mono_spinctrl_spincollection_add_spinner(&minute_spinner,
&time_spinners);
// Get timezone settings
tz_hours = timezone_get_hours();
tz_minutes = timezone_get_minutes();
timestamp = rtc_get_time();
calendar_timestamp_to_date_tz(timestamp, tz_hours, tz_minutes, &date);
// Set spinners to current time as initial position
hour_spinner.integer_data = date.hour;
minute_spinner.integer_data = date.minute;
gfx_mono_spinctrl_spincollection_show(&time_spinners);
do {
do {
keyboard_get_key_state(&input);
// Wait for key release
} while (input.type != KEYBOARD_RELEASE);
// Send key to spinnercollection
spinner_status = gfx_mono_spinctrl_spincollection_process_key(
&time_spinners, input.keycode, spinner_results);
} while (spinner_status != GFX_MONO_SPINCTRL_EVENT_FINISH);
date.hour = spinner_results[0];
date.minute = spinner_results[1];
timestamp = calendar_date_to_timestamp_tz(&date, tz_hours, tz_minutes);
if(timestamp != 0) {
rtc_set_time(timestamp);
}
}
void gettime()
{
if(time_start){
rtc_get_time(&t.hour,&t.min,&t.sec);
rtc_get_date(&t.dow,&t.date,&t.month,&t.year);
time_start=0;
}
}
static void _prepare_next_alarm(void)
{
struct tm time;
rtc_get_time(&time);
/* set initial alarm */
time.tm_sec += PERIOD;
mktime(&time);
rtc_set_alarm(&time, rtc_cb, NULL);
}
//returns timestamp as string YYYY-MM-DD HH:MM:SS
void rtc_get_time_str(char* buf, int buf_size){
uint32_t ul_year, ul_month, ul_day, ul_week;
uint32_t ul_hour, ul_minute, ul_second;
rtc_get_date(NULL,&ul_year,&ul_month,&ul_day,&ul_week);
rtc_get_time(NULL,&ul_hour,&ul_minute,&ul_second);
snprintf(buf,buf_size,"%02lu-%02lu-%02lu %02lu:%02lu:%02lu",ul_year,ul_month,ul_day,
ul_hour,ul_minute,ul_second);
return;
}
static void rtc_set_time(RTCState *s)
{
struct tm tm;
rtc_get_time(s, &tm);
s->base_rtc = mktimegm(&tm);
s->last_update = qemu_clock_get_ns(rtc_clock);
qapi_event_send_rtc_change(qemu_timedate_diff(&tm), &error_abort);
}
// ------------------------------------------------------------------------------------------------
static void cmd_datetime(uint argc, const char** argv)
{
char buf[TIME_STRING_SIZE];
DateTime dt;
rtc_get_time(&dt);
format_time(buf, sizeof(buf), &dt);
console_print("%s\n", buf);
}
static void _rtc_gettime(void)
{
struct tm t;
if (rtc_get_time(&t) == 0) {
_print_time(&t);
}
else {
puts("rtc: error getting time");
}
}
static void rtc_set_time(RTCState *s)
{
struct tm tm;
rtc_get_time(s, &tm);
s->base_rtc = mktimegm(&tm);
s->last_update = qemu_get_clock_ns(rtc_clock);
rtc_change_mon_event(&tm);
}
void draw_time() {
unsigned long ts = rtc_get_time();
struct calendar_date rtc_date;
uint8_t hour[] = {12, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
// might need to build in something for daylight savings time
calendar_timestamp_to_date_tz(ts, -6, 0, &rtc_date);
char string_buf[15];
snprintf(string_buf, sizeof(string_buf),"%d:%.2d", hour[rtc_date.hour], rtc_date.minute);
gfx_draw_string_aligned(string_buf, gfx_get_width()-35, 2, &sysfont, GFX_COLOR_TRANSPARENT, GFX_COLOR_WHITE, TEXT_POS_CENTER_X, TEXT_ALIGN_LEFT);
}
static void run_test_clock_ver2(void)
{
unsigned int seconds = rtc_get_time().second;
for (uint8_t i = 0; i < 60; i++) {
if (i <= seconds)
display_watch_set_led_color(&m_watch_frame2, i, &c_lightblue_dim);
else
display_watch_set_led_color(&m_watch_frame2, i, &c_yellow_dim);
}
display_watch_write_frame(&m_watch_frame2);
}
extern int
rtc_get_time_test(int autotest)
{
rtc_time_t time;
rtc_get_time(&time);
printf("RTC Time = W%d %d%d:%d%d:%d%d:%d\n", time.dow, time.ten_hr, time.hr, \
time.ten_min, time.min, time.ten_sec, time.sec, time.sos);
return 0;
}
unsigned int get_rtc_time(struct rtc_time *time)
{
unsigned long nowtime;
spin_lock(&mips_rtc_lock);
nowtime = rtc_get_time();
to_tm(nowtime, time);
time->tm_year -= 1900;
spin_unlock(&mips_rtc_lock);
return RTC_24H;
}
void main(void)
{
struct tm* t = NULL;
char buf[32];
uint8_t hour, min, sec;
uartInit();
uartSetBaudRate(9600);
uartSendString("DS RTC Library Test\n");
LED_DDR |= _BV(LED_BIT); // indicator led
for (int i = 0; i < 5; i++) {
LED_HIGH;
_delay_ms(100);
LED_LOW;
_delay_ms(100);
}
uartSendString("Before Init\n");
twi_init_master();
rtc_init();
rtc_set_time_s(12, 0, 50);
uartSendString("After Init\n");
if (rtc_is_ds1307())
uartSendString("DS1307\n");
else
uartSendString("DS3231\n");
rtc_set_alarm_s(12, 1, 0);
rtc_get_alarm_s(&hour, &min, &sec);
sprintf(buf, "Alarm is set -%d:%d:%d-\n", hour, min, sec);
uartSendString(buf);
uartSendString("---\n");
uartSendString("---\n");
uartSendString("---\n");
while (1) {
t = rtc_get_time();
sprintf(buf, "%d:%d:%d\n", t->hour, t->min, t->sec);
uartSendString(buf);
uartSendString("---\n");
if (rtc_check_alarm())
uartSendString("ALARM!\n");
_delay_ms(500);
}
}
time_t time(time_t *timer)
{
struct tm timedate;
ER ercd;
if(timer == NULL)
return 0;
ercd = rtc_get_time(&timedate);
if(ercd == E_OK)
*timer = mktime(&timedate);
else
*timer = 0;
return *timer;
}
void get_time(unsigned char time[][6], int sensor_count)
{
time[sensor_count][0] = rtc_get_time(0x00); //get second
time[sensor_count][1] = rtc_get_time(0x01); //get minute
time[sensor_count][2] = rtc_get_time(0x02); //get hour
time[sensor_count][3] = rtc_get_time(0x04); //get day
time[sensor_count][4] = rtc_get_time(0x05); //get month
time[sensor_count][5] = rtc_get_time(0x06); //get year
}
