/************************************************************
 * Utils.h
 * general module of system utility functions
 **************************************************************/

#include "include.h"
#include <inc/hw_ints.h>
#include <inc/hw_memmap.h>
#include <driverlib/rom.h>
#include <time.h>
#include "Common/Utilities/Utils.h"
//#include <driverlib/systick.h>
#include "driverlib/hibernate.h"
#include <driverlib/Watchdog.h>
#include <ti/sysbios/hal/Seconds.h>
#include "drivers/Flash_ram/MCU_E2Prom.h"

//*****************************************************************************

/*#define MAX_MEM_LOG 100
int freeIndex=0,malloc_index=0;
uint32_t malloc_size[MAX_MEM_LOG+1];
uint32_t malloc_time[MAX_MEM_LOG+1];
void * malloc_addr[MAX_MEM_LOG+1];
void * free_addr[MAX_MEM_LOG+1];*/
//uint32_t total_allocated = 0;
void  *my_malloc(size_t _size)
{
    void * addr =  malloc (_size);
    if (_size == 0) return addr;
/*    int i;
    for (i=0; i< MAX_MEM_LOG;i++)
    {
        if (malloc_time[i] == 0)
        {
            malloc_index = i;
            break;
        }
    }
    assert (malloc_index<MAX_MEM_LOG);
    if (malloc_index<MAX_MEM_LOG)
    {
        malloc_addr[malloc_index] = addr;
        malloc_size[malloc_index] = _size;
        malloc_time[malloc_index] = msec_millisecondCounter;
    }
    */
    /*if ((addr)&&(_size>400))
    {
        malloc_addr[malloc_index] = addr;
        malloc_size[malloc_index] = _size;
        malloc_time[malloc_index] = msec_millisecondCounter;
        if (malloc_index++>=MAX_MEM_LOG)
            malloc_index = 0;
    }*/
    return addr;
}
int allocated_size = 0;
void   my_free(void *_ptr)
{
    //int i;
    free(_ptr);
    if (_ptr)
    {
/*        for (i=0; i< MAX_MEM_LOG;i++)
        {
            if ( malloc_addr[i] == _ptr)
            {
                malloc_addr[i] = 0;
                malloc_time[i] = 0;
                malloc_size[i] = 0;
                break;
            }
        }
        if (i==MAX_MEM_LOG)
        {
          //  LOG_ERROR(i,"free error");
                    return;
        }
        allocated_size = 0;
//        for (i=0; i< MAX_MEM_LOG;i++)
//            allocated_size+=malloc_size[i];
 *
 */
//        free_addr[freeIndex] = _ptr;
//        if (freeIndex++>=MAX_MEM_LOG)
//            freeIndex = 0;

    }
}

//*****************************************************************************
//
// Init WD timer
//
//*****************************************************************************
void InitWatchdog(uint32_t clock)
{
	//
	// Enable the watchdog interrupt.
	//
#ifdef WATCHDOG
    MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_WDOG0);
    ROM_WatchdogIntClear(WATCHDOG0_BASE);
    ROM_WatchdogIntTypeSet(WATCHDOG0_BASE,0);  //interrupt, not NMI
	ROM_IntEnable(INT_WATCHDOG);

	//
	// Set the period of the watchdog timer.
	//
	ROM_WatchdogReloadSet(WATCHDOG0_BASE, clock);

	//
	// Enable reset generation from the watchdog timer.
	//
	ROM_WatchdogResetEnable(WATCHDOG0_BASE);

	//
	// Enable the watchdog timer.
	//
	ROM_WatchdogEnable(WATCHDOG0_BASE);
#endif
}
void utilsInit(uint32_t ui32SysClock)
{

    // Configure Hibernate module clock.
    //
    HibernateEnableExpClk(ui32SysClock);


    // Enable RTC mode.
    //
    HibernateRTCEnable();

    //
    // Configure the hibernate module counter to 24-hour calendar mode.
    //
    // HibernateCounterMode(HIBERNATE_COUNTER_24HR);
    // Configure the hibernate module counter to RTC counter mode.
    HibernateCounterMode(HIBERNATE_COUNTER_24HR);

//#define  STARTTIME  1564403262
//    Seconds_set(STARTTIME);

}
void utilsUpdateDateTime(uint32_t StartTime)
{
    Seconds_set(StartTime);
}
void utilsStoreLocalTime()
{
    time_t time_store = umktime(&LocalTime);
    MCU_E2PromProgram(EEPROM_LOCAL_TIME,time_store);
}

uint32_t UsersysTickGet (void) {
    uint32_t tick = 0;
//    tick =  SysTickValueGet();
    tick = HibernateRTCSSGet()*10000/0x8000;
    return tick;
}

//*****************************************************************************
//
// The interrupt handler for the watchdog.  This feeds the dog (so that the
// processor does not get reset) and winks the LED connected to GPIO B3.
//
//*****************************************************************************
void WatchdogIntHandler(void)
{
     //
     // Clear the watchdog interrupt.
     //
     ROM_WatchdogIntClear(WATCHDOG0_BASE);
}

bool sendDataToHost = false;
void UtilsSetCommunicationOk(void)
{
    sendDataToHost = true;
}