427 lines
14 KiB
C
Executable File
427 lines
14 KiB
C
Executable File
#include "../main/SystemInclude.h"
|
|
/******************************************************************************
|
|
recordTime must be define
|
|
*******************************************************************************/
|
|
// for save data
|
|
u16 historyPeriodSet;
|
|
static u16 lastState;
|
|
u16 saveTimeCounter;
|
|
|
|
/******************************************************************************/
|
|
void SaveParameterInit(void)
|
|
{
|
|
// history record period
|
|
recordTime = (u16)ReadShortParameterFromMemory(RECORD_TIME, RECORD_TIME_DEFAULT);
|
|
}
|
|
|
|
/******************************************************************************/
|
|
void CopyTimeToBackUpArray(u8 *backups)
|
|
{
|
|
backups[0] = timer[YEAR];
|
|
backups[1] = timer[MONTH];
|
|
backups[2] = timer[DATE];
|
|
backups[3] = timer[HOUR];
|
|
backups[4] = timer[MINUTE];
|
|
}
|
|
|
|
/******************************************************************************/
|
|
void CopyAccToBackUpArray(u8 *backups)
|
|
{
|
|
backups[5] = Total[0];
|
|
backups[6] = Total[1];
|
|
backups[7] = Total[2];
|
|
backups[8] = Total[3];
|
|
backups[9] = Total[4];
|
|
backups[10] = Total[5];
|
|
}
|
|
|
|
/******************************************************************************/
|
|
u16 WriteaAnAlarmData(u16 pointer)
|
|
{
|
|
u8 temp[ALARM_WIDTH];
|
|
|
|
pointer = ALARM_BASE + pointer * ALARM_WIDTH;
|
|
|
|
CopyTimeToBackUpArray(temp);
|
|
CopyAccToBackUpArray(&temp[5]); // 6 Byte
|
|
//------------------------------------------------------------------------------
|
|
tempL.Word[0] = alarmState;
|
|
temp[11] = tempL.Byte[1];
|
|
temp[12] = tempL.Byte[0];
|
|
|
|
tempL.Word[0] = voltageDetected[NIDX];
|
|
temp[13] = tempL.Byte[1];
|
|
temp[14] = tempL.Byte[0];
|
|
|
|
tempL.Word[0] = voltageDetected[RHRES];
|
|
temp[15] = tempL.Byte[1];
|
|
temp[16] = tempL.Byte[0];
|
|
|
|
tempL.Word[0] = voltageDetected[RHVOL];
|
|
temp[17] = tempL.Byte[1];
|
|
temp[18] = tempL.Byte[0];
|
|
|
|
tempL.Word[0] = voltageDetected[VHPA];
|
|
temp[19] = tempL.Byte[1];
|
|
temp[20] = tempL.Byte[0];
|
|
|
|
tempL.Word[0] = voltageDetected[IVHDX];
|
|
temp[21] = tempL.Byte[1];
|
|
temp[22] = tempL.Byte[0];
|
|
|
|
tempL.Word[0] = voltageDetected[BATT];
|
|
temp[23] = tempL.Byte[1];
|
|
temp[24] = tempL.Byte[0];
|
|
//------------------------------------------------------------------------------
|
|
temp[ALARM_WIDTH_CRC] = CRC8(temp, ALARM_WIDTH_CRC);
|
|
|
|
WriteMultiByteToEEPROM(pointer, temp, ALARM_WIDTH, DATA_EEPROM);
|
|
//ReadMultiByteFromEEPROM(pointer, buffer, ALARM_WIDTH, DATA_EEPROM);
|
|
|
|
//for(pointer=0; pointer<ALARM_WIDTH; pointer++)
|
|
//{
|
|
// if(buffer[pointer] != temp[pointer]) return 1;
|
|
//}
|
|
|
|
return 0;
|
|
}
|
|
/******************************************************************************/
|
|
// write alarm data state
|
|
u16 AlarmWrite(void)
|
|
{
|
|
|
|
// write alarm information into external EEPROM
|
|
// input: date, alarmState, VL, VH, AlarmPointer
|
|
// output: AlarmPointer
|
|
|
|
#ifndef REC_ALARM_DATA
|
|
#pragma message("[undefined] REC_ALARM_DATA")
|
|
#elif(REC_ALARM_DATA)
|
|
|
|
// The Zero record: Factory initial state
|
|
ReadMultiByteFromEEPROM(ALARM_POINTER, tempL.Byte, ALARM_POINTER_WIDTH, DATA_EEPROM);
|
|
if(tempL.Byte[ALARM_POINTER_CRC] != CRC8(tempL.Byte, ALARM_POINTER_CRC)) tempL.Word[0] = 1;
|
|
else if(tempL.Word[0] >= ALARM_DEPTH) tempL.Word[0] = 1;
|
|
else if(tempL.Word[0] == 0) tempL.Word[0] = 1;
|
|
else tempL.Word[0]++;
|
|
|
|
tempL.Byte[ALARM_POINTER_CRC] = CRC8(tempL.Byte, ALARM_POINTER_CRC);
|
|
WriteMultiByteToEEPROM(ALARM_POINTER, tempL.Byte, ALARM_POINTER_WIDTH, DATA_EEPROM);
|
|
|
|
if(WriteaAnAlarmData(tempL.Word[0])) return 1;
|
|
else return 0;
|
|
|
|
#else
|
|
return 0;
|
|
#endif
|
|
}
|
|
/******************************************************************************/
|
|
void SetHistoryRecordTime(void)
|
|
{
|
|
/*
|
|
u16 wrt_base, pointer;
|
|
|
|
ReadMultiByteFromEEPROM(HISTORY_POINTER_H, temp, 2, DATA_EEPROM);
|
|
pointer = make16(temp[0], temp[1]);
|
|
|
|
historyPeriodSet = (unsigned int)RTCHOUR;
|
|
historyPeriodSet *= 60;
|
|
historyPeriodSet += (unsigned int)RTCMIN;
|
|
if(pointer >= HISTORY_DEPTH) { historyPeriodSet++; return; }
|
|
|
|
wrt_base = HISTORY_BASE + pointer * HISTORY_WIDTH;
|
|
ReadMultiByteFromEEPROM(wrt_base, timer, 5, DATA_EEPROM);
|
|
|
|
wrt_base = (unsigned int)timer[HOUR];
|
|
wrt_base *= 60;
|
|
wrt_base += (unsigned int)timer[MINUTE];
|
|
wrt_base += historyPeriod;
|
|
if(wrt_base >= 1440) { historyPeriodSet = 0; return;}
|
|
if(historyPeriodSet < wrt_base) historyPeriodSet = wrt_base;
|
|
*/
|
|
historyPeriodSet = 0xffff;
|
|
}
|
|
|
|
/******************************************************************************/
|
|
u16 WriteAnHistoryData(u16 pointer)
|
|
{
|
|
u8 temp[HISTORY_WIDTH];
|
|
|
|
pointer = HISTORY_BASE + tempL.Word[0] * HISTORY_WIDTH;
|
|
|
|
CopyTimeToBackUpArray(temp); // 5 Byte
|
|
CopyAccToBackUpArray(&temp[5]); // 6 Byte
|
|
|
|
tempL.Word[0] = alarmState;
|
|
temp[11] = tempL.Byte[1];
|
|
temp[12] = tempL.Byte[0];
|
|
|
|
tempL.DWord = flowRate;
|
|
temp[13] = tempL.Byte[2];
|
|
temp[14] = tempL.Byte[1];
|
|
temp[15] = tempL.Byte[0];
|
|
|
|
temp[HISTORY_WIDTH_CRC] = CRC8(temp, HISTORY_WIDTH_CRC);
|
|
|
|
WriteMultiByteToEEPROM(pointer, temp, HISTORY_WIDTH, DATA_EEPROM);
|
|
// ReadMultiByteFromEEPROM(pointer, buffer, HISTORY_WIDTH, DATA_EEPROM);
|
|
//
|
|
// for(pointer=0; pointer<HISTORY_WIDTH; pointer++)
|
|
// {
|
|
// if(buffer[pointer] != temp[pointer]) return 1;
|
|
// }
|
|
|
|
return 0;
|
|
}
|
|
|
|
/******************************************************************************/
|
|
u16 HistoryRecordWrite(void)
|
|
{
|
|
#ifndef REC_HISTORY_DATA
|
|
#pragma message("[undefined] REC_HISTORY_DATA")
|
|
#elif(REC_HISTORY_DATA)
|
|
|
|
ReadMultiByteFromEEPROM(HISTORY_POINTER, tempL.Byte, HISTORY_POINTER_WIDTH, DATA_EEPROM);
|
|
if(tempL.Byte[HISTORY_POINTER_CRC] != CRC8(tempL.Byte, HISTORY_POINTER_CRC)) tempL.Word[0] = 1;
|
|
else if(tempL.Word[0] >= HISTORY_DEPTH) tempL.Word[0] = 1;
|
|
else if(tempL.Word[0] == 0) tempL.Word[0] = 1;
|
|
else tempL.Word[0]++;
|
|
|
|
tempL.Byte[HISTORY_POINTER_CRC] = CRC8(tempL.Byte, HISTORY_POINTER_CRC);
|
|
WriteMultiByteToEEPROM(HISTORY_POINTER, tempL.Byte, HISTORY_POINTER_WIDTH, DATA_EEPROM);
|
|
if(WriteAnHistoryData(tempL.Word[0])) return 1;
|
|
else return 0;
|
|
#else
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
/******************************************************************************/
|
|
u16 ReadRecentHistoryData(u8 *recent)
|
|
{
|
|
ReadMultiByteFromEEPROM(HISTORY_POINTER, tempL.Byte, HISTORY_POINTER_WIDTH, DATA_EEPROM);
|
|
if(tempL.Byte[HISTORY_POINTER_CRC] != CRC8(tempL.Byte, HISTORY_POINTER_CRC)) return 0;
|
|
|
|
tempL.Word[0] = HISTORY_BASE + tempL.Word[0] * HISTORY_WIDTH;
|
|
ReadMultiByteFromEEPROM(tempL.Word[0], recent, HISTORY_WIDTH, DATA_EEPROM);
|
|
|
|
if(recent[HISTORY_WIDTH_CRC] != CRC8(recent, HISTORY_WIDTH_CRC)) return 0;
|
|
else return 1;
|
|
}
|
|
|
|
/******************************************************************************/
|
|
// write history record
|
|
// record: 2000
|
|
// format: year-month-date-hour-min-second-ACC-FLOW-STATE
|
|
/******************************************************************************/
|
|
void WriteRecordTimeData(void)
|
|
{
|
|
u8 temp[RECORD_TIME_WIDTH];
|
|
|
|
CopyTimeToBackUpArray(temp);
|
|
temp[RECORD_TIME_CRC] = CRC8(temp, RECORD_TIME_CRC);
|
|
WriteMultiByteToEEPROM(HISTORY_BASE, temp, RECORD_TIME_WIDTH, DATA_EEPROM);
|
|
|
|
saveTimeCounter = 0;
|
|
HWState.EnableSaveData = 0;
|
|
}
|
|
|
|
/******************************************************************************/
|
|
// write date acc every day
|
|
/******************************************************************************/
|
|
u16 ReadRecentDateAccData(u8 *recent)
|
|
{
|
|
ReadMultiByteFromEEPROM(DATE_POINTER, tempL.Byte, DATE_POINTER_WIDTH, DATA_EEPROM);
|
|
if(tempL.Byte[DATE_POINTER_CRC] != CRC8(tempL.Byte, DATE_POINTER_CRC)) return 0;
|
|
if(tempL.Word[0] >= DATE_DEPTH) return 0;
|
|
|
|
tempL.Word[0] = DATE_BASE + tempL.Word[0] * DATE_WIDTH;
|
|
ReadMultiByteFromEEPROM(tempL.Word[0], recent, DATE_WIDTH, DATA_EEPROM);
|
|
|
|
if(recent[DATE_WIDTH_CRC] != CRC8(recent, DATE_WIDTH_CRC)) return 0;
|
|
else return 1;
|
|
}
|
|
|
|
/******************************************************************************/
|
|
u16 DateAccWrite(void)
|
|
{
|
|
u8 temp[DATE_WIDTH];
|
|
|
|
// write date and accumulation into external EEPROM and update dateAccPointer
|
|
// input: date, flowAcc, dateAccPointer
|
|
// output: dateAccPointer
|
|
|
|
#ifndef REC_DATE_DATA
|
|
#pragma message("[undefined] REC_DATE_DATA")
|
|
#elif(REC_DATE_DATA)
|
|
u16 wrt_base;
|
|
unsigned char buffer[DATE_WIDTH];
|
|
|
|
ReadMultiByteFromEEPROM(DATE_POINTER, tempL.Byte, DATE_POINTER_WIDTH, DATA_EEPROM);
|
|
if(tempL.Byte[DATE_POINTER_CRC] != CRC8(tempL.Byte, DATE_POINTER_CRC)) tempL.Word[0] = 1;
|
|
if(tempL.Word[0] >= DATE_DEPTH) tempL.Word[0] = 1;
|
|
else if(tempL.Word[0] >= DATE_DEPTH) tempL.Word[0] = 1;
|
|
else tempL.Word[0]++;
|
|
|
|
tempL.Byte[DATE_POINTER_CRC] = CRC8(tempL.Byte, DATE_POINTER_CRC);
|
|
WriteMultiByteToEEPROM(DATE_POINTER, tempL.Byte, DATE_POINTER_WIDTH, DATA_EEPROM);
|
|
|
|
wrt_base = DATE_BASE + tempL.Word[0] * DATE_WIDTH;
|
|
|
|
CopyTimeToBackUpArray(temp);
|
|
CopyAccToBackUpArray(&temp[5]); // 6 Byte
|
|
temp[DATE_WIDTH_CRC] = CRC8(temp, DATE_WIDTH_CRC);
|
|
|
|
WriteMultiByteToEEPROM(wrt_base, temp, DATE_WIDTH, DATA_EEPROM);
|
|
ReadMultiByteFromEEPROM(wrt_base, buffer, DATE_WIDTH, DATA_EEPROM);
|
|
for(wrt_base=0; wrt_base<DATE_WIDTH; wrt_base++)
|
|
{
|
|
if(buffer[wrt_base] != temp[wrt_base]) return 1;
|
|
}
|
|
|
|
return 0;
|
|
#else
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
/******************************************************************************/
|
|
void ClearAlarmRecord(void)
|
|
{
|
|
u16 I, wrtBase;
|
|
|
|
wrtBase = ALARM_BASE + ALARM_DEPTH*ALARM_WIDTH;
|
|
I = ALARM_BASE + ALARM_WIDTH;
|
|
while(1)
|
|
{
|
|
if(wrtBase > I+100)
|
|
{
|
|
ClearMultiByteToEEPROM(I, 100, DATA_EEPROM);
|
|
I += 100;
|
|
}
|
|
else
|
|
{
|
|
wrtBase -= I;
|
|
ClearMultiByteToEEPROM(I, wrtBase, DATA_EEPROM);
|
|
break;
|
|
}
|
|
}
|
|
|
|
tempL.Word[0] = 0;
|
|
tempL.Byte[ALARM_POINTER_CRC] = CRC8(tempL.Byte, ALARM_POINTER_CRC);
|
|
WriteMultiByteToEEPROM(ALARM_POINTER, tempL.Byte, ALARM_POINTER_WIDTH, DATA_EEPROM);
|
|
|
|
}
|
|
/******************************************************************************/
|
|
void ClearHistoryRecord(void)
|
|
{
|
|
u16 I, wrtBase;
|
|
|
|
wrtBase = HISTORY_BASE + HISTORY_DEPTH*HISTORY_WIDTH;
|
|
I = HISTORY_BASE + HISTORY_WIDTH;
|
|
while(1)
|
|
{
|
|
if(wrtBase > I+100)
|
|
{
|
|
ClearMultiByteToEEPROM(I, 100, DATA_EEPROM);
|
|
I += 100;
|
|
}
|
|
else
|
|
{
|
|
wrtBase -= I;
|
|
ClearMultiByteToEEPROM(I, wrtBase, DATA_EEPROM);
|
|
break;
|
|
}
|
|
}
|
|
|
|
tempL.Word[0] = 0;
|
|
tempL.Byte[HISTORY_POINTER_CRC] = CRC8(tempL.Byte, HISTORY_POINTER_CRC);
|
|
WriteMultiByteToEEPROM(HISTORY_POINTER, tempL.Byte, HISTORY_POINTER_WIDTH, DATA_EEPROM);
|
|
}
|
|
|
|
/******************************************************************************/
|
|
void ClearDateRecord(void)
|
|
{
|
|
u16 I, wrtBase;
|
|
|
|
wrtBase = DATE_BASE + DATE_DEPTH*DATE_WIDTH;
|
|
I = DATE_BASE + DATE_WIDTH;
|
|
|
|
while(1)
|
|
{
|
|
if(wrtBase > I+100)
|
|
{
|
|
ClearMultiByteToEEPROM(I, 100, DATA_EEPROM);
|
|
I += 100;
|
|
}
|
|
else
|
|
{
|
|
wrtBase -= I;
|
|
ClearMultiByteToEEPROM(I, wrtBase, DATA_EEPROM);
|
|
break;
|
|
}
|
|
}
|
|
|
|
tempL.Word[0] = 0;
|
|
tempL.Byte[DATE_POINTER_CRC] = CRC8(tempL.Byte, DATE_POINTER_CRC);
|
|
WriteMultiByteToEEPROM(DATE_POINTER, tempL.Byte, DATE_POINTER_WIDTH, DATA_EEPROM);
|
|
|
|
}
|
|
|
|
/******************************************************************************/
|
|
void DataStorageManagement(void)
|
|
{
|
|
systemProcessing.Bit.SaveHandle = 0;
|
|
|
|
if(alarmState != lastState)
|
|
{
|
|
lastState = alarmState;
|
|
disable_interrupts();
|
|
if(AlarmWrite()) systemAlarm.Bit.EEPROMAlarm = 1;
|
|
else systemAlarm.Bit.EEPROMAlarm = 0;
|
|
enable_interrupts();
|
|
}
|
|
|
|
// save history data
|
|
if(HWState.EnableSaveHistoryData)
|
|
{
|
|
disable_interrupts();
|
|
if(HistoryRecordWrite()) systemAlarm.Bit.EEPROMAlarm = 1;
|
|
else systemAlarm.Bit.EEPROMAlarm = 0;
|
|
historyPeriodSet = 0;
|
|
HWState.EnableSaveHistoryData = 0;
|
|
enable_interrupts();
|
|
}
|
|
|
|
// save acc data
|
|
if(HWState.EnableSaveDateAcc)
|
|
{
|
|
disable_interrupts();
|
|
if(DateAccWrite()) systemAlarm.Bit.EEPROMAlarm = 1;
|
|
else systemAlarm.Bit.EEPROMAlarm = 0;
|
|
HWState.EnableSaveDateAcc = 0;
|
|
enable_interrupts();
|
|
}
|
|
|
|
if(HWState.EnableSaveRTC)
|
|
{
|
|
disable_interrupts();
|
|
WriteRecordTimeData();
|
|
enable_interrupts();
|
|
}
|
|
|
|
HWState.EnableSaveData = 0;
|
|
}
|
|
|
|
/******************************************************************************/
|
|
void ReadRecordToComBuf(void)
|
|
{
|
|
disable_interrupts();
|
|
ReadMultiByteFromEEPROM(MBBuf.StartAddr, &MBBuf.RxPointer[3], MBBuf.ByteNumber, DATA_EEPROM);
|
|
MBBuf.ByteNumber -= 1;
|
|
|
|
if(MBBuf.RxPointer[3+MBBuf.ByteNumber] == CRC8(&MBBuf.RxPointer[3], MBBuf.ByteNumber)) MBBuf.RxPointer[3+MBBuf.ByteNumber] = 0xaa;
|
|
enable_interrupts();
|
|
}
|
|
|