/*
 * Copyright (c) 2015, Freescale Semiconductor, Inc.
 * Copyright 2016-2019 NXP
 * All rights reserved.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */

#include <stdio.h>
#include "fsl_debug_console.h"
#include "fsl_common.h"
#include "fsl_rtc.h"
#include "pin_mux.h"
#include "clock_config.h"
#include "board.h"

/*******************************************************************************
 * Variables
 ******************************************************************************/
volatile uint8_t g_AlarmPending = 0U;
volatile bool g_SecsFlag        = false;

static char g_StrNewline[] = "\r\n";
static char g_StrInvalid[] = "Invalid input format\r\n";

//uint8_t index; 
//uint8_t secs; 
char recvBuf[20]; 
uint32_t result; 
uint16_t year; 
uint16_t month; 
uint16_t day; 
uint16_t hour; 
uint16_t minute; 
uint16_t second; 
rtc_datetime_t date;
rtc_config_t rtcConfig;

/*******************************************************************************
 * Code
 ******************************************************************************/

/*!
 * @brief Override the RTC IRQ handler.
 */
void RTC_IRQHandler(void)
{
    // Verifica se il flag dell'allarme RTC è stato impostato
    if (RTC_GetStatusFlags(RTC) & kRTC_AlarmFlag)
    {
        // Imposta la variabile globale g_AlarmPending a 1, indicando che è in attesa un allarme
        g_AlarmPending = 1U;
         // Pulisce il flag dell'allarme per permettere future interruzioni
        RTC_ClearStatusFlags(RTC, kRTC_AlarmInterruptEnable);
    }
}

/*!
 * @brief Override the RTC Second IRQ handler.
 */
void RTC_Seconds_IRQHandler(void)
{
    // Imposta la variabile globale g_SecsFlag a true, indicando che è trascorso un secondo
    g_SecsFlag = true;
}

static void CommandSeconds(void)
{
    uint32_t count = 0U;  // Contatore per tracciare il numero di secondi trascorsi
    rtc_datetime_t date; // Struttura per memorizzare la data e l'ora correnti
    char sourceBuff[] = "\r10:10:00"; // Buffer per memorizzare la stringa del tempo formattato

    g_SecsFlag = false; // Resetta il flag dei secondi all'inizio
    while (count < 20U) // Esegui il ciclo per 20 secondi count < 20U
    {
        //Se è avvenuta un'interruzione dei secondi, stampa il nuovo tempo
        if (g_SecsFlag)
        {
            //Resetta il flag dei secondi
            g_SecsFlag = false;
            count++; // Incrementa il contatore dei secondi
            RTC_GetDatetime(RTC, &date); // Ottieni la data e l'ora correnti dal RTC

            // Costruisce la stringa con l'ora, i minuti e i secondi in formato hh:mm:ss
            sourceBuff[1] = ((date.hour / 10) + 0x30);  // Decodifica le decine dell'ora
            sourceBuff[2] = ((date.hour % 10) + 0x30);  // Decodifica le unità dell'ora
            sourceBuff[3] = ':';                         // Aggiungi il separatore dei minuti
            sourceBuff[4] = ((date.minute / 10) + 0x30); // Decodifica le decine dei minuti
            sourceBuff[5] = ((date.minute % 10) + 0x30); // Decodifica le unità dei minuti
            sourceBuff[6] = ':';                         // Aggiungi il separatore dei secondi
            sourceBuff[7] = ((date.second / 10) + 0x30); // Decodifica le decine dei secondi
            sourceBuff[8] = ((date.second % 10) + 0x30); // Decodifica le unità dei secondi
            //Stampa l'orario formattato 
            PRINTF("%s\r\n",sourceBuff);
        }
    }
    //Disabilita l'interruzione per i secondi
    RTC_DisableInterrupts(RTC, kRTC_SecondsInterruptEnable);
    PRINTF(g_StrNewline);
}

static void ConfigRTC(){
    //Inizializzo l'RTC in questo stato: wakeupSelect = false, updateMode = false, supervisorAccess = false, compensationInterval = 0, rtcConfig.compensationTime = 0;
    RTC_GetDefaultConfig(&rtcConfig); 
    RTC_Init(RTC, &rtcConfig); 

    //Non so a che serve sto pezzo
    #if (defined(EXAMPLE_CAP_LOAD_VALUE) && EXAMPLE_CAP_LOAD_VALUE)
    #if (defined(FSL_FEATURE_RTC_HAS_OSC_SCXP) && FSL_FEATURE_RTC_HAS_OSC_SCXP)
    /* Change the RTC oscillator capacity load value. */
    RTC_SetOscCapLoad(RTC, EXAMPLE_CAP_LOAD_VALUE);
    #endif /* FSL_FEATURE_RTC_HAS_OSC_SCXP */
    #endif /* EXAMPLE_CAP_LOAD_VALUE */
    #if !(defined(FSL_FEATURE_RTC_HAS_NO_CR_OSCE) && FSL_FEATURE_RTC_HAS_NO_CR_OSCE)

    //seleziono la sorgente di clock
    RTC_SetClockSource(RTC);
    #endif /* FSL_FEATURE_RTC_HAS_NO_CR_OSCE */

    //setto la data e l'ora che deve iniziare il mio RTC
    date.year = 2015U; 
    date.month = 11U; 
    date.day = 11U; 
    date.hour = 11U; 
    date.minute = 11U; 
    date.second = 11U; 

    // Il contatore del tempo RTC deve essere fermato prima di impostare la data e l'ora nel traduttore di registro TSR
    RTC_StopTimer(RTC); 

    //Enable at the NVIC Abilito per Interrupt ogni secondo
    EnableIRQ(RTC_IRQn); 
    #ifdef RTC_SECONDS_IRQS 
    EnableIRQ(RTC_Seconds_IRQn); 
    #endif /* RTC_SECONDS_IRQS */ 

    //Faccio partire il timer RTC
    RTC_StartTimer(RTC); 
    PRINTF("\r\nRTC partito...\r\n"); //scrivo che è partito
}


/*!
 * @brief Main function
 */
/*! * @brief Mainloop function */ 
void Mainloop(void) { 
    while (1) {
        /* Enable seconds interrupt */ 
        RTC_EnableInterrupts(RTC, kRTC_SecondsInterruptEnable); 
        CommandSeconds(); 
    } 
}

/*! * @brief Main function */ 
int main(void) { 
    //Inizializza la board (Pins, Clocks, DebugConsole)
    BOARD_InitBootPins(); 
    BOARD_InitBootClocks(); 
    BOARD_InitDebugConsole(); 
    //Configura i registri dell'RTC
    ConfigRTC();
    //Start the main loop
    Mainloop(); 
}