/*
 * rw_logging.c
 *
 *  Created on: Jul 29, 2025
 *      Author: cc
 */
#include "includes.h"
#include <string.h>

/*获取SRAM中日志当前写入地址*/
__attribute__((section(".non_0_wait"))) uint32_t Get_Log_Current_Address(void)
{
    uint32_t Last_addr = 0;
    uint8_t temp_d = 0;

    temp_d = SRAM_Read_Byte(SRAM_LOG_Start_Address+3);
    Last_addr = temp_d;
    Last_addr <<= 8;
    temp_d = SRAM_Read_Byte(SRAM_LOG_Start_Address+2);
    Last_addr |= temp_d;
    Last_addr <<= 8;
    temp_d = SRAM_Read_Byte(SRAM_LOG_Start_Address+1);
    Last_addr |= temp_d;
    Last_addr <<= 8;
    temp_d = SRAM_Read_Byte(SRAM_LOG_Start_Address);
    Last_addr |= temp_d;

    if((Last_addr < SRAM_LOG_DATA_Address) || (Last_addr > SRAM_LOG_End_Address)) Last_addr = SRAM_LOG_DATA_Address;
    return Last_addr;
}

/*设置SRAM中日志当前写入地址*/
__attribute__((section(".non_0_wait"))) void Set_Log_Current_Address(uint32_t W_addr)
{
    uint32_t Last_addr = W_addr;
    uint8_t temp = 0;

    if((Last_addr < SRAM_LOG_DATA_Address) || (Last_addr > SRAM_LOG_End_Address)) Last_addr = SRAM_LOG_DATA_Address;

    temp = Last_addr & 0xFF;
    SRAM_Write_Byte(temp,SRAM_LOG_Start_Address);
    temp = (Last_addr >> 8) & 0xFF;
    SRAM_Write_Byte(temp,SRAM_LOG_Start_Address+1);
    temp = (Last_addr >> 16) & 0xFF;
    SRAM_Write_Byte(temp,SRAM_LOG_Start_Address+2);
    temp = (Last_addr >> 24) & 0xFF;
    SRAM_Write_Byte(temp,SRAM_LOG_Start_Address+3);
}

/*设置SRAM中TFTP当前读日志地址*/
__attribute__((section(".non_0_wait"))) void SRAM_Set_TFTP_READ_LOG_Address(uint32_t r_addr)
{
    uint32_t Last_addr = r_addr;
    uint8_t temp = 0;

    /*判断地址是否合法*/
    if((Last_addr < SRAM_LOG_DATA_Address) || (Last_addr > SRAM_LOG_End_Address)) Last_addr = SRAM_LOG_DATA_Address;

    temp = Last_addr & 0xFF;
    SRAM_Write_Byte(temp,SRAM_TFTP_LOG_READ_Address);
    temp = (Last_addr >> 8) & 0xFF;
    SRAM_Write_Byte(temp,SRAM_TFTP_LOG_READ_Address+1);
    temp = (Last_addr >> 16) & 0xFF;
    SRAM_Write_Byte(temp,SRAM_TFTP_LOG_READ_Address+2);
    temp = (Last_addr >> 24) & 0xFF;
    SRAM_Write_Byte(temp,SRAM_TFTP_LOG_READ_Address+3);
}

/*获取SRAM中TFTP当前读日志地址*/
__attribute__((section(".non_0_wait"))) uint32_t SRAM_Get_TFTP_READ_Log_Address(void)
{
    uint32_t Last_addr = 0;
    uint8_t temp_d = 0;

    temp_d = SRAM_Read_Byte(SRAM_TFTP_LOG_READ_Address+3);
    Last_addr = temp_d;
    Last_addr <<= 8;
    temp_d = SRAM_Read_Byte(SRAM_TFTP_LOG_READ_Address+2);
    Last_addr |= temp_d;
    Last_addr <<= 8;
    temp_d = SRAM_Read_Byte(SRAM_TFTP_LOG_READ_Address+1);
    Last_addr |= temp_d;
    Last_addr <<= 8;
    temp_d = SRAM_Read_Byte(SRAM_TFTP_LOG_READ_Address);
    Last_addr |= temp_d;

    if((Last_addr < SRAM_LOG_DATA_Address) || (Last_addr > SRAM_LOG_End_Address)) Last_addr = SRAM_LOG_DATA_Address;
    return Last_addr;
}

/*******************************************************************************
* Function Name  : 日志保存功能
* Description    : 日志每一个小时将SRAM中的日志数据进行封装，
    封装就只是加上包头包尾及当前的年月日时，
*******************************************************************************/
__attribute__((section(".non_0_wait"))) uint8_t Log_write_sram(uint8_t data_type,uint8_t *buff,uint16_t len)
{
    uint16_t temp_date = 0;
    uint32_t Last_add = 0;
    uint32_t Log_Hour_Tick = SysTick_1ms - Log_Time_ms;     //2021-09-23  Log_Time_ms该变量在中断中有进行写操作，防止出错，禁止全局变量在中断与while中同时读写
    Log_Hour_Tick += HEX_Conversion_To_DEC(RTC_Raw_Data.minute)*60000;
    Log_Hour_Tick += HEX_Conversion_To_DEC(RTC_Raw_Data.hour)*3600000;

    uint8_t temp = 0;
    uint16_t data_len = len;

    if(data_len >= Log_Data_Len_MAX)    data_len = Log_Data_Len_MAX;        //限定数据长度
    uint16_t write_len = S_Log_Data + data_len + 1;
    /*第一步：读取日志写入地址*/
    Last_add = Get_Log_Current_Address();

    //当前地址是否有效，并且可以将该日志保存
    if((Last_add + write_len) >= SRAM_LOG_End_Address)
    {
        Dbg_Println(DBG_BIT_SYS_STATUS_bit," SRAM Space is not enough");
        Last_add = SRAM_LOG_DATA_Address;
    }

    /*第二步：按照指定格式保存日志*/
    SRAM_Write_Byte(LOG_Data_Hand,Last_add + S_Log_Hand);       //数据头
    temp = SRAM_Read_Byte(SRAM_Flash_Serial_Number);
    SRAM_Write_Byte(temp,Last_add + S_Log_SN);                  //数据序列号
    temp++;
    SRAM_Write_Byte(temp,SRAM_Flash_Serial_Number);             //将序列号刷新，并保存
    SRAM_Write_Word(write_len,Last_add + S_Log_Len);            //数据长度 2Byte
    SRAM_Write_Byte(0x00,Last_add + S_Log_Check);               //校验值清零

    temp_date = (HEX_Conversion_To_DEC(RTC_Raw_Data.year) << 10) + (HEX_Conversion_To_DEC(RTC_Raw_Data.month) << 5) + HEX_Conversion_To_DEC(RTC_Raw_Data.day);

    temp = (temp_date >> 8) & 0xFF;
    SRAM_Write_Byte(temp,Last_add + S_Log_Date_H);              //数据日期H - 年：4bit 月：4bit
    temp = temp_date & 0xFF;
    SRAM_Write_Byte(temp,Last_add + S_Log_Date_L);              //数据日期L - 日：4bit 时：4bit
    SRAM_Write_Byte(data_type,Last_add + S_Log_Type);           //数据类型
    temp = Log_Hour_Tick & 0xFF;
    SRAM_Write_Byte(temp,Last_add + S_Log_Time8B);              //时间戳
    temp = (Log_Hour_Tick >> 8) & 0xFF;
    SRAM_Write_Byte(temp,Last_add + S_Log_Time16B);
    temp = (Log_Hour_Tick >> 16) & 0xFF;
    SRAM_Write_Byte(temp,Last_add + S_Log_Time24B);
    temp = (Log_Hour_Tick >> 24) & 0xFF;
    SRAM_Write_Byte(temp,Last_add + S_Log_Time32B);

    SRAM_DMA_Write_Buff(buff,data_len,Last_add + S_Log_Data);       //数据
    SRAM_Write_Byte(Log_Data_End,Last_add + S_Log_Data + data_len); //数据尾

    /*计算数据校验*/
    temp = Log_CheckSum(Last_add,write_len);
    SRAM_Write_Byte(temp,Last_add + S_Log_Check);               //校验值

    /*第三：刷新日志写入地址*/
    Last_add = Last_add + write_len;
    Set_Log_Current_Address(Last_add);
    Dbg_Println(DBG_BIT_SYS_STATUS_bit,"SRAM LOG Addr : %08X",Last_add);
    return 0;
}

/*******************************************************************************
* Function Name  : Retain_Flash_Register_Data
* Description    : 保存项目寄存器值
* Return         : None
*******************************************************************************/
__attribute__((section(".non_0_wait"))) void Retain_Flash_Register_Data(void)
{
    uint8_t temp = 0,temp1 = 0;
    uint16_t i = 0;

    memset(Global_Large_Buff,0,Register_OFFSET_LEN);

    Flash_Read(Global_Large_Buff,Register_OFFSET_LEN,SPIFLASH_Register_Start_ADDRESS);

    for(i = 0;i<Register_OFFSET_LEN;i++)
    {
        temp1 = SRAM_Read_Byte(SRAM_Register_Start_ADDRESS+i);
        if(temp1 != Global_Large_Buff[i])
        {
            Global_Large_Buff[i] = temp1;
            temp++;
        }
    }

    /*将数据保存到Flash中*/
    if(temp != 0x00)
    {
        Flash_Write(Global_Large_Buff,Register_OFFSET_LEN,SPIFLASH_Register_Start_ADDRESS);
    }
}

/*******************************************************************************
* Function Name  : Read_Flash_Register_Data
* Description    : 读取项目寄存器值
* Return         : None
*******************************************************************************/
__attribute__((section(".non_0_wait"))) void Read_Flash_Register_Data(void)
{
    memset(Global_Large_Buff,0,Register_OFFSET_LEN);

    Flash_Read(Global_Large_Buff,Register_OFFSET_LEN,SPIFLASH_Register_Start_ADDRESS);
    SRAM_DMA_Write_Buff(Global_Large_Buff,Register_OFFSET_LEN,SRAM_Register_Start_ADDRESS);
}

/*******************************************************************************
* Function Name  : LOG_Save_Global_Parameters
* Description    : 保存全局参数
* Return         : None
*******************************************************************************/
__attribute__((section(".non_0_wait"))) void LOG_Save_Global_Parameters(void)
{
    static uint32_t polling_tick = 0;
    uint8_t log_len = 0;
    uint8_t log_buff[22];
    memset(log_buff,0,22);

    /*2025-09-08 修改
        全局变量定期查看变量是否发生变化
            取电状态、睡眠模式状态、全局色温、全局亮度、无卡取电中的有无人状态
    */
    if(SysTick_1ms - polling_tick >= 2000)
    {
        polling_tick = SysTick_1ms;

        if( (DevActionGlobal.DevActionU64Cond.EleState != DevActionGlobal.Last_EleState)
            || (DevActionGlobal.DimGlobalValue != DevActionGlobal.Last_DimGlobalValue)
            || (DevActionGlobal.CCTValue != DevActionGlobal.Last_CCTValue)
            || (DevActionGlobal.SleepMode_State != DevActionGlobal.Last_SleepMode_State)
            || (DevActionGlobal.SleepLight_State != DevActionGlobal.Last_SleepLight_State)
            || (DevActionGlobal.Person_Detected != DevActionGlobal.Last_Person_Detected)
            || (DevActionGlobal.CardState != DevActionGlobal.Last_CardState)
            || (DevActionGlobal.Rs485CardType != DevActionGlobal.Last_Rs485CardType)
            || (DevActionGlobal.DevActionU64Cond.NeightState != DevActionGlobal.Last_NeightState)       )
        {
            DevActionGlobal.Last_EleState = DevActionGlobal.DevActionU64Cond.EleState;
            DevActionGlobal.Last_DimGlobalValue = DevActionGlobal.DimGlobalValue ;
            DevActionGlobal.Last_CCTValue = DevActionGlobal.CCTValue;
            DevActionGlobal.Last_SleepMode_State = DevActionGlobal.SleepMode_State;
            DevActionGlobal.Last_SleepLight_State = DevActionGlobal.SleepLight_State;
            DevActionGlobal.Last_Person_Detected = DevActionGlobal.Person_Detected;
            DevActionGlobal.Last_CardState = DevActionGlobal.CardState;
            DevActionGlobal.Last_Rs485CardType = DevActionGlobal.Rs485CardType;

            log_len = 0x00;
            log_buff[log_len++] = 0xA8;         //保存标志位
            log_buff[log_len++] = 0x00;         //数据长度
            log_buff[log_len++] = 0x00;         //数据校验位

            log_buff[log_len++] = DevActionGlobal.Last_EleState;                            //取电状态
            log_buff[log_len++] = (DevActionGlobal.Last_DimGlobalValue & 0xFF);             //全局亮度
            log_buff[log_len++] = ((DevActionGlobal.Last_DimGlobalValue >> 8) & 0xFF);      //全局亮度
            log_buff[log_len++] = (DevActionGlobal.Last_CCTValue & 0xFF);                   //全局色温
            log_buff[log_len++] = ((DevActionGlobal.Last_CCTValue >> 8) & 0xFF);            //全局色温
            log_buff[log_len++] = DevActionGlobal.Last_SleepMode_State;                     //睡眠模式
            log_buff[log_len++] = DevActionGlobal.Last_SleepLight_State;                    //睡眠灯光状态
            log_buff[log_len++] = DevActionGlobal.Last_Person_Detected;                     //无卡取电中，有无人状态
            log_buff[log_len++] = DevActionGlobal.Last_CardState;
            log_buff[log_len++] = DevActionGlobal.Last_Rs485CardType;
            log_buff[log_len++] = DevActionGlobal.Last_NeightState;

            log_buff[1] = log_len;          //数据长度
            log_buff[2] = Data_CheckSum(log_buff,log_len);           //计算校验值

            Dbg_Println(DBG_BIT_SYS_STATUS_bit,"%s %d",__func__,DevActionGlobal.Last_Person_Detected);

            SRAM_DMA_Write_Buff(log_buff,log_len,SRAM_PowerOn_Restore_StartAddr );
        }
    }
}

/*上电后，读取外部SRAM中的参数信息 */
__attribute__((section(".non_0_wait"))) uint8_t SRAM_PowerOn_Restore_ParaInfo(void)
{
    uint8_t log_len = 0;
    uint8_t log_buff[22];
    uint16_t temp_val = 0;
    memset(log_buff,0,22);

    SRAM_DMA_Read_Buff(log_buff,20,SRAM_PowerOn_Restore_StartAddr );

    if(log_buff[0] == 0xA8)     //校验标志位
    {
        if(log_buff[1] == 0x0E) //校验数据长度
        {
            if(Data_CheckSum(log_buff,0x0E) == 0x00)
            {
                log_len = 0x03;
                DevActionGlobal.Last_EleState = log_buff[log_len++];

                temp_val = log_buff[log_len++];
                temp_val <<= 8;
                temp_val |= log_buff[log_len++];
                DevActionGlobal.Last_DimGlobalValue = temp_val;

                temp_val = log_buff[log_len++];
                temp_val <<= 8;
                temp_val |= log_buff[log_len++];
                DevActionGlobal.Last_CCTValue = temp_val;

                DevActionGlobal.Last_SleepMode_State = log_buff[log_len++];

                DevActionGlobal.Last_SleepLight_State = log_buff[log_len++];

                DevActionGlobal.Last_Person_Detected = log_buff[log_len++];

                DevActionGlobal.Last_CardState = log_buff[log_len++];

                DevActionGlobal.Last_Rs485CardType  = log_buff[log_len++];

                DevActionGlobal.Last_NeightState  = log_buff[log_len++];

                DevActionGlobal.DevActionU64Cond.EleState = DevActionGlobal.Last_EleState;
                DevActionGlobal.DimGlobalValue = DevActionGlobal.Last_DimGlobalValue;
                DevActionGlobal.CCTValue = DevActionGlobal.Last_CCTValue;
                DevActionGlobal.SleepMode_State = DevActionGlobal.Last_SleepMode_State;
                DevActionGlobal.SleepLight_State = DevActionGlobal.Last_SleepLight_State;
                DevActionGlobal.Person_Detected = DevActionGlobal.Last_Person_Detected;
                DevActionGlobal.CardState= DevActionGlobal.Last_CardState;
                DevActionGlobal.Rs485CardType= DevActionGlobal.Last_Rs485CardType;
                DevActionGlobal.DevActionU64Cond.NeightState = DevActionGlobal.Last_NeightState;



                DevActionGlobal.sram_save_flag = 0xA8;
                Dbg_Println(DBG_BIT_SYS_STATUS_bit,"Last_EleState:%d ",DevActionGlobal.Last_EleState);
                Dbg_Println(DBG_BIT_SYS_STATUS_bit,"Last_DimGlobalValue:%d ",DevActionGlobal.Last_DimGlobalValue);
                Dbg_Println(DBG_BIT_SYS_STATUS_bit,"Last_CCTValue:%d ",DevActionGlobal.Last_CCTValue);
                Dbg_Println(DBG_BIT_SYS_STATUS_bit,"Last_SleepMode_State:%d ",DevActionGlobal.Last_SleepMode_State);
                Dbg_Println(DBG_BIT_SYS_STATUS_bit,"Last_SleepLight_State:%d ",DevActionGlobal.Last_SleepLight_State);
                Dbg_Println(DBG_BIT_SYS_STATUS_bit,"Last_Person_Detected:%d ",DevActionGlobal.Last_Person_Detected);
                Dbg_Println(DBG_BIT_SYS_STATUS_bit,"Last_CardState:%d ",DevActionGlobal.Last_CardState);
                Dbg_Println(DBG_BIT_SYS_STATUS_bit,"Last_NeightState:%d ",DevActionGlobal.Last_NeightState);

                return 0x00;
            }
        }
    }

    return 0x01;
}