motor_ctl-2/User/Src/eeprom_24c02.c

#include "eeprom_24c02.h"

#define Time_OUT    3000

#define EEPROM_WP_GPIOx         GPIOB
#define EEPROM_WP_GPIO_PIN_x    GPIO_PIN_1

const uint8_t EEPROM_24C02_Flag[2] = {0x55,0xAA};

int8_t AT24C02_OK = ACK_FAIL;	
I2C_Handle_Struct_t I2C_Handle_EEPROM = {GPIOB, GPIO_PIN_11, GPIOB, GPIO_PIN_10};

//I2C引脚初始化
void EEPROM_24C02_Init(I2C_Handle_Struct_t* I2C_Handle)
{
  //保护
	GPIO_InitTypeDef GPIO_InitStruct;

  GPIO_InitStruct.Pin = EEPROM_WP_GPIO_PIN_x;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
	GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_MEDIUM;
  HAL_GPIO_Init(EEPROM_WP_GPIOx, &GPIO_InitStruct); 

	HAL_GPIO_WritePin(EEPROM_WP_GPIOx, EEPROM_WP_GPIO_PIN_x, GPIO_PIN_SET);

	I2C_GPIO_Config(I2C_Handle);
}

//指定地址读取1字节
int8_t EEPROM_24C02_ReadOneByte(I2C_Handle_Struct_t* I2C_Handle, uint8_t ReadAddr, uint8_t *data)			    //指定地址读取一个字节
{
  uint16_t Timeout_Cnt = 0;
	
  I2C_Start(I2C_Handle); 
	
	I2C_Write_Byte(I2C_Handle, AT24C02_ADDR_WR);	   //发送写命令
  Timeout_Cnt = 0;
	do
	{
		Timeout_Cnt++;
		if(Timeout_Cnt>Time_OUT)
		{
	   	return ACK_FAIL;
		}
  }while(I2C_Check_Ack(I2C_Handle));
	
	I2C_Write_Byte(I2C_Handle, ReadAddr);
	Timeout_Cnt = 0;
	do
	{
		Timeout_Cnt++;
		if(Timeout_Cnt>Time_OUT)
		{
	   	return ACK_FAIL;
		}
  }while(I2C_Check_Ack(I2C_Handle));
	
	I2C_Start(I2C_Handle); 
	
	I2C_Write_Byte(I2C_Handle, AT24C02_ADDR_RD);	   //发送读命令
	Timeout_Cnt = 0;
	do
	{
		Timeout_Cnt++;
		if(Timeout_Cnt>Time_OUT)
		{
	   	return ACK_FAIL;
		}
  }while(I2C_Check_Ack(I2C_Handle));
	
	I2C_Read_Byte(I2C_Handle, data);
	I2C_Send_Nack(I2C_Handle);
	I2C_Stop(I2C_Handle);

	return ACK_OK;
}

//指定地址写入1字节
int8_t EEPROM_24C02_WriteOneByte(I2C_Handle_Struct_t* I2C_Handle, uint8_t WriteAddr,uint8_t DataToWrite)  //指定地址写入一个字节
{
  uint16_t Timeout_Cnt = 0;

	HAL_GPIO_WritePin(EEPROM_WP_GPIOx, EEPROM_WP_GPIO_PIN_x, GPIO_PIN_RESET);
	
  I2C_Start(I2C_Handle); 
	
	I2C_Write_Byte(I2C_Handle, AT24C02_ADDR_WR);	   //发送写命令
  Timeout_Cnt = 0;
	do
	{
		Timeout_Cnt++;
		if(Timeout_Cnt>Time_OUT)
		{
	   	return ACK_FAIL;
		}
  }while(I2C_Check_Ack(I2C_Handle));
	
	I2C_Write_Byte(I2C_Handle, WriteAddr);
	Timeout_Cnt = 0;
	do
	{
		Timeout_Cnt++;
		if(Timeout_Cnt>Time_OUT)
		{
	   	return ACK_FAIL;
		}
  }while(I2C_Check_Ack(I2C_Handle));

	I2C_Write_Byte(I2C_Handle, DataToWrite);
	Timeout_Cnt = 0;
	do
	{
		Timeout_Cnt++;
		if(Timeout_Cnt>Time_OUT)
		{
	   	return ACK_FAIL;
		}
  }while(I2C_Check_Ack(I2C_Handle));

	I2C_Stop(I2C_Handle);
	HAL_Delay(10);
	
	HAL_GPIO_WritePin(EEPROM_WP_GPIOx, EEPROM_WP_GPIO_PIN_x, GPIO_PIN_SET);
	
	//看门狗清零
	#if DEBUG
	HAL_IWDG_Refresh(&hiwdg);
	#endif
	
	return ACK_OK;
}

//指定地址写入有效数据
int8_t SaveParamToEEprom_24C02(I2C_Handle_Struct_t* I2C_Handle, uint8_t AddrBegin, uint8_t DataLen, uint8_t *Data)
{
  uint8_t Temp_8 = 0, i;
	uint16_t CRC_Result = 0;
		
	//按字节存储数据
	for(i=0;i<DataLen;i++)
	{
		if(EEPROM_24C02_ReadOneByte(I2C_Handle, AddrBegin + i, &Temp_8) == ACK_FAIL)
		{
		  return ACK_FAIL;
		}
		if(Temp_8 != Data[i])
		{
			Temp_8 = Data[i];
			if(EEPROM_24C02_WriteOneByte(I2C_Handle, AddrBegin + i, Temp_8) == ACK_FAIL)
			{
				return ACK_FAIL;
			}
		}
	}
	
	//存储校验位
	CRC_Result = CRC16_Xmodem(Data, DataLen);
	Temp_8 = (uint8_t)(CRC_Result >> 8);
  if(EEPROM_24C02_WriteOneByte(I2C_Handle, AddrBegin + DataLen , Temp_8) == ACK_FAIL)
	{
  	return ACK_FAIL;
	}
	Temp_8 = (uint8_t)(CRC_Result & 0xFF);
	if(EEPROM_24C02_WriteOneByte(I2C_Handle, AddrBegin + DataLen + 1 , Temp_8) == ACK_FAIL)
	{
	  return ACK_FAIL;
	}
	 return ACK_OK;
}

//指定地址读取有效数据
uint8_t EEPROM_ReadDataBuf[256];
int8_t GetParamFromEEprom_24C02(I2C_Handle_Struct_t* I2C_Handle, uint8_t AddrBegin, uint8_t DataLen, uint8_t *Data)
{
  uint8_t i, Temp2_8[2];
	uint16_t CRC_Data, CRC_Result;
	
	//读取DataLen个字节
	for(i=0;i<DataLen;i++)
	{
	  if(EEPROM_24C02_ReadOneByte(I2C_Handle, AddrBegin + i, (EEPROM_ReadDataBuf + i)) == ACK_FAIL)
		{
	  	return ACK_FAIL;
		}
	}
	//计算校验
	CRC_Result = CRC16_Xmodem(EEPROM_ReadDataBuf, DataLen);
	
	//读取校验
	EEPROM_24C02_ReadOneByte(I2C_Handle, AddrBegin + DataLen, Temp2_8);
	EEPROM_24C02_ReadOneByte(I2C_Handle, AddrBegin + DataLen + 1, (Temp2_8 + 1));
	CRC_Data = (uint16_t)(Temp2_8[0] << 8) + Temp2_8[1];
	
	//判断数据是否有效
	if((CRC_Data - CRC_Result) == 0)
	{
	  memcpy(Data, EEPROM_ReadDataBuf, DataLen);
		return ACK_OK;
	}
	else
	{
  	return ACK_FAIL;
	}
}

//写入默认数据
int8_t CopyDefaultDataToEEpprom_24C02(I2C_Handle_Struct_t* I2C_Handle)
{	
	uint8_t Temp_8[2];
	uint16_t CRC_Result = 0;
	
	Var_SetToDefaultParam();
	Var_SetToDefaultLog();

	EEPROM_24C02_ParamReset(I2C_Handle);//1363ms
	EEPROM_24C02_LogReset(I2C_Handle);//1240ms
		
	//写入数据有效标志
	memcpy((uint8_t*)Temp_8, (uint8_t*)EEPROM_24C02_Flag, sizeof(EEPROM_24C02_Flag));
	if(EEPROM_24C02_WriteOneByte(I2C_Handle, EEPROM_24C02_ADDR_FLAG, Temp_8[0]) == ACK_FAIL)//11ms
	{
  	EEPROM_24C02_WriteOneByte(I2C_Handle, EEPROM_24C02_ADDR_FLAG, Temp_8[0]);
	}
	if(EEPROM_24C02_WriteOneByte(I2C_Handle, EEPROM_24C02_ADDR_FLAG + 1, Temp_8[1]) == ACK_FAIL)//11ms
	{
  	EEPROM_24C02_WriteOneByte(I2C_Handle, EEPROM_24C02_ADDR_FLAG + 1, Temp_8[1]);
	}
	CRC_Result = CRC16_Xmodem(Temp_8, 2);
	if(EEPROM_24C02_WriteOneByte(I2C_Handle, EEPROM_24C02_ADDR_FLAG + 2, (uint8_t)(CRC_Result >> 8)) == ACK_FAIL)//11ms
	{
  	EEPROM_24C02_WriteOneByte(I2C_Handle, EEPROM_24C02_ADDR_FLAG + 2, (uint8_t)(CRC_Result >> 8));
	}
	if(EEPROM_24C02_WriteOneByte(I2C_Handle, EEPROM_24C02_ADDR_FLAG + 3, (uint8_t)(CRC_Result & 0xFF)) == ACK_FAIL)//11ms
	{
  	EEPROM_24C02_WriteOneByte(I2C_Handle, EEPROM_24C02_ADDR_FLAG + 3, (uint8_t)(CRC_Result & 0xFF));
	}
	return ACK_OK;
}

//从EEPROM读取数据
int8_t CopyDataFromEEpprom_24C02(I2C_Handle_Struct_t* I2C_Handle)
{
	//读出校验码 13ms
	if(GetParamFromEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_CHECKCODE, sizeof(MC_CheckInfo.CheckCode), MC_CheckInfo.CheckCode) == ACK_FAIL)
	{
	  GetParamFromEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_CHECKCODE, sizeof(MC_CheckInfo.CheckCode), MC_CheckInfo.CheckCode);
	}
	//读出力矩传感器1校正系数 5ms
	if(GetParamFromEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_TORQUE_1_CAL_K, sizeof(TorqueSensor_1_Param.Torque_Cal_K), &TorqueSensor_1_Param.Torque_Cal_K) == ACK_FAIL)
	{
	  GetParamFromEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_TORQUE_1_CAL_K, sizeof(TorqueSensor_1_Param.Torque_Cal_K), &TorqueSensor_1_Param.Torque_Cal_K);
	}
	//读出力矩传感器1零点偏移 5ms
	if(GetParamFromEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_TORQUE_OFFSET_1, sizeof(TorqueSensor_1_Param.Torque_OffSetData), (uint8_t*)&TorqueSensor_1_Param.Torque_OffSetData.Data) == ACK_FAIL)
	{
	  GetParamFromEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_TORQUE_OFFSET_1, sizeof(TorqueSensor_1_Param.Torque_OffSetData), (uint8_t*)&TorqueSensor_1_Param.Torque_OffSetData.Data);
	}
	//读出力矩传感器2校正系数 5ms
	if(GetParamFromEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_TORQUE_2_CAL_K, sizeof(TorqueSensor_2_Param.Torque_Cal_K), &TorqueSensor_2_Param.Torque_Cal_K) == ACK_FAIL)
	{
	  GetParamFromEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_TORQUE_2_CAL_K, sizeof(TorqueSensor_2_Param.Torque_Cal_K), &TorqueSensor_2_Param.Torque_Cal_K);
	}
	//读出力矩传感器2零点偏移 5ms
	if(GetParamFromEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_TORQUE_OFFSET_2, sizeof(TorqueSensor_2_Param.Torque_OffSetData), (uint8_t*)&TorqueSensor_2_Param.Torque_OffSetData.Data) == ACK_FAIL)
	{
	  GetParamFromEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_TORQUE_OFFSET_2, sizeof(TorqueSensor_2_Param.Torque_OffSetData), (uint8_t*)&TorqueSensor_2_Param.Torque_OffSetData.Data);
	}
	//读出力矩传感器3校正系数 5ms
	if(GetParamFromEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_TORQUE_3_CAL_K, sizeof(TorqueSensor_3_Param.Torque_Cal_K), &TorqueSensor_3_Param.Torque_Cal_K) == ACK_FAIL)
	{
	  GetParamFromEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_TORQUE_3_CAL_K, sizeof(TorqueSensor_3_Param.Torque_Cal_K), &TorqueSensor_3_Param.Torque_Cal_K);
	}
	//读出力矩传感器3零点偏移 5ms
	if(GetParamFromEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_TORQUE_OFFSET_3, sizeof(TorqueSensor_3_Param.Torque_OffSetData), (uint8_t*)&TorqueSensor_3_Param.Torque_OffSetData.Data) == ACK_FAIL)
	{
	  GetParamFromEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_TORQUE_OFFSET_3, sizeof(TorqueSensor_3_Param.Torque_OffSetData), (uint8_t*)&TorqueSensor_3_Param.Torque_OffSetData.Data);
	}
	//读出运行历史1 44ms
	if(GetParamFromEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_RUN_LOG1, sizeof(MC_RunLog1_Struct_t), (uint8_t*)&MC_RunLog1.PowerOnCnt) == ACK_FAIL)
	{
	  GetParamFromEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_RUN_LOG1, sizeof(MC_RunLog1_Struct_t), (uint8_t*)&MC_RunLog1.PowerOnCnt);
	}
	MC_RunLog1.PowerOnCnt++;
	//写入开机次数 75ms
	if(SaveParamToEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_RUN_LOG1, sizeof(MC_RunLog1_Struct_t), (uint8_t*)&MC_RunLog1.PowerOnCnt) == ACK_FAIL)
	{
	  SaveParamToEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_RUN_LOG1, sizeof(MC_RunLog1_Struct_t), (uint8_t*)&MC_RunLog1.PowerOnCnt);
	}
  //读出运行历史2
	if(GetParamFromEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_RUN_LOG2, sizeof(MC_RunLog2_Struct_t), (uint8_t*)&MC_RunLog2.MCU_FaultCnt) == ACK_FAIL)
	{
	  GetParamFromEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_RUN_LOG2, sizeof(MC_RunLog2_Struct_t), (uint8_t*)&MC_RunLog2.MCU_FaultCnt);
	}
  //读取骑行历史信息
	if(GetParamFromEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_RIDE_LOG, sizeof(MC_RideLog_Struct_t), (uint8_t*)&MC_RideLog.ODO_Km) == ACK_FAIL)
	{
	  GetParamFromEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_RIDE_LOG, sizeof(MC_RideLog_Struct_t), (uint8_t*)&MC_RideLog.ODO_Km);
	}
	//读出密钥 11ms
	if(GetParamFromEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_SECRET_KEY, sizeof(Secret_Key), Secret_Key) == ACK_FAIL)
	{
	  GetParamFromEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_SECRET_KEY, sizeof(Secret_Key), Secret_Key);
	}
	//读取平均功耗 16ms
	if(GetParamFromEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_AVG_POWER, sizeof(MC_AvgPower_Struct_t), (uint8_t*)&MC_AvgPower.GearSt_ECO) == ACK_FAIL)
	{
	  GetParamFromEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_AVG_POWER, sizeof(MC_AvgPower_Struct_t), (uint8_t*)&MC_AvgPower.GearSt_ECO);
	}
	//读取启动值
	if(GetParamFromEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_TORQUE_STARDATA, sizeof(TorqueSensorStartData), (uint8_t*)&TorqueSensorStartData) == ACK_FAIL)
	{
	  GetParamFromEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_TORQUE_STARDATA, sizeof(TorqueSensorStartData), (uint8_t*)&TorqueSensorStartData);
	}

	return ACK_OK;
}

//EEPROM_24C02检测
int8_t EEPROM_24C02_Check(I2C_Handle_Struct_t* I2C_Handle)
{
  uint8_t Temp_8[2] = {0}; 
	uint16_t FlagCRC, FlagCRC_Result;
	
	//读取存储标志并计算校验码
	EEPROM_24C02_ReadOneByte(I2C_Handle, EEPROM_24C02_ADDR_FLAG, Temp_8);//1ms
	EEPROM_24C02_ReadOneByte(I2C_Handle, EEPROM_24C02_ADDR_FLAG + 1, (Temp_8 + 1));//1ms
	FlagCRC_Result = CRC16_Xmodem(Temp_8, 2);
	//读取存储的校验码
	EEPROM_24C02_ReadOneByte(I2C_Handle, EEPROM_24C02_ADDR_FLAG + 2, Temp_8);
	EEPROM_24C02_ReadOneByte(I2C_Handle, EEPROM_24C02_ADDR_FLAG + 3, (Temp_8 + 1));
	FlagCRC = ((uint16_t)Temp_8[0] << 8) + Temp_8[1];
	
	//判断数据是否有效
	if((FlagCRC - FlagCRC_Result) == 0) // 数据有效
	{
		return(CopyDataFromEEpprom_24C02(I2C_Handle));
	}
	else if(IsFirstPowerOnFlag == TRUE) // 数据无效且开机次数为0时，写入默认参数
	{
		return(CopyDefaultDataToEEpprom_24C02(I2C_Handle));
	}
	else
	{
	  return ACK_FAIL;
	}
}

//清除指定区间段有效数据
void EEPROM_24C02_ClearData(I2C_Handle_Struct_t* I2C_Handle, uint8_t AddrBegin, uint8_t EndAddr, uint8_t Data)
{
  uint8_t i, Length;
	
	Length = EndAddr - AddrBegin;
	for(i=0; i<Length; i++)
	{
	  EEPROM_24C02_WriteOneByte(I2C_Handle, AddrBegin + i ,Data);
	}
}	

//配置参数还原 958ms
void EEPROM_24C02_ParamReset(I2C_Handle_Struct_t* I2C_Handle)
{	
	//写入校验码
	if(SaveParamToEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_CHECKCODE, sizeof(MC_CheckInfo.CheckCode), MC_CheckInfo.CheckCode) == ACK_FAIL)
	{
	  SaveParamToEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_CHECKCODE, sizeof(MC_CheckInfo.CheckCode), MC_CheckInfo.CheckCode);
	}
	//力矩传感器1校正系数
	if(SaveParamToEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_TORQUE_1_CAL_K, sizeof(TorqueSensor_1_Param.Torque_Cal_K), &TorqueSensor_1_Param.Torque_Cal_K) == ACK_FAIL)
	{
	  SaveParamToEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_TORQUE_1_CAL_K, sizeof(TorqueSensor_1_Param.Torque_Cal_K), &TorqueSensor_1_Param.Torque_Cal_K);
	}
	//力矩传感器1零点偏移
	if(SaveParamToEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_TORQUE_OFFSET_1, sizeof(TorqueSensor_1_Param.Torque_OffSetData), (uint8_t*)TorqueSensor_1_Param.Torque_OffSetData.Data) == ACK_FAIL)
	{
	  SaveParamToEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_TORQUE_OFFSET_1, sizeof(TorqueSensor_1_Param.Torque_OffSetData), (uint8_t*)TorqueSensor_1_Param.Torque_OffSetData.Data);
	}
	//力矩传感器2校正系数
	if(SaveParamToEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_TORQUE_2_CAL_K, sizeof(TorqueSensor_2_Param.Torque_Cal_K), &TorqueSensor_2_Param.Torque_Cal_K) == ACK_FAIL)
	{
	  SaveParamToEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_TORQUE_2_CAL_K, sizeof(TorqueSensor_2_Param.Torque_Cal_K), &TorqueSensor_2_Param.Torque_Cal_K);
	}
	//力矩传感器2零点偏移
	if(SaveParamToEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_TORQUE_OFFSET_2, sizeof(TorqueSensor_2_Param.Torque_OffSetData), (uint8_t*)TorqueSensor_2_Param.Torque_OffSetData.Data) == ACK_FAIL)
	{
	  SaveParamToEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_TORQUE_OFFSET_2, sizeof(TorqueSensor_2_Param.Torque_OffSetData), (uint8_t*)TorqueSensor_2_Param.Torque_OffSetData.Data);
	}
	//力矩传感器3校正系数
	if(SaveParamToEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_TORQUE_3_CAL_K, sizeof(TorqueSensor_3_Param.Torque_Cal_K), &TorqueSensor_3_Param.Torque_Cal_K) == ACK_FAIL)
	{
	  SaveParamToEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_TORQUE_3_CAL_K, sizeof(TorqueSensor_3_Param.Torque_Cal_K), &TorqueSensor_3_Param.Torque_Cal_K);
	}
	//力矩传感器3零点偏移
	if(SaveParamToEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_TORQUE_OFFSET_3, sizeof(TorqueSensor_3_Param.Torque_OffSetData), (uint8_t*)TorqueSensor_3_Param.Torque_OffSetData.Data) == ACK_FAIL)
	{
	  SaveParamToEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_TORQUE_OFFSET_3, sizeof(TorqueSensor_3_Param.Torque_OffSetData), (uint8_t*)TorqueSensor_3_Param.Torque_OffSetData.Data);
	}
	//写入密钥
	if(SaveParamToEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_SECRET_KEY, sizeof(Secret_Key), Secret_Key) == ACK_FAIL)
	{
	  SaveParamToEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_SECRET_KEY, sizeof(Secret_Key), Secret_Key);
	}
	//写入力矩传感器启动值
	if(SaveParamToEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_TORQUE_STARDATA, sizeof(TorqueSensorStartData), (uint8_t*)&TorqueSensorStartData) == ACK_FAIL)
	{
	  SaveParamToEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_TORQUE_STARDATA, sizeof(TorqueSensorStartData), (uint8_t*)&TorqueSensorStartData);
	}
}

//历史数据还原
void EEPROM_24C02_LogReset(I2C_Handle_Struct_t* I2C_Handle)
{
  //写入运行历史1
	if(SaveParamToEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_RUN_LOG1, sizeof(MC_RunLog1_Struct_t), (uint8_t*)&MC_RunLog1.PowerOnCnt) == ACK_FAIL)
	{
	  SaveParamToEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_RUN_LOG1, sizeof(MC_RunLog1_Struct_t), (uint8_t*)&MC_RunLog1.PowerOnCnt);
	}
  //写入运行历史2
  if(SaveParamToEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_RUN_LOG2, sizeof(MC_RunLog2_Struct_t), (uint8_t*)&MC_RunLog2.MCU_FaultCnt) == ACK_FAIL)
	{
	  SaveParamToEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_RUN_LOG2, sizeof(MC_RunLog2_Struct_t), (uint8_t*)&MC_RunLog2.MCU_FaultCnt);
	}
  //写入骑行历史信息
	if(SaveParamToEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_RIDE_LOG, sizeof(MC_RideLog_Struct_t), (uint8_t*)&MC_RideLog.ODO_Km) == ACK_FAIL)
	{
	  SaveParamToEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_RIDE_LOG, sizeof(MC_RideLog_Struct_t), (uint8_t*)&MC_RideLog.ODO_Km);
	}
  //写入平均功耗
	if(SaveParamToEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_AVG_POWER, sizeof(MC_AvgPower_Struct_t), (uint8_t*)&MC_AvgPower.GearSt_ECO) == ACK_FAIL)
	{
	  SaveParamToEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_AVG_POWER, sizeof(MC_AvgPower_Struct_t), (uint8_t*)&MC_AvgPower.GearSt_ECO);
	}
}

//掉电数据从Flash转移到24C02
int8_t SavePowerOffBakData(I2C_Handle_Struct_t* I2C_Handle, TrueOrFalse_Flag_Struct_t IsSaveFlag)
{
	if(IsSaveFlag == TRUE)  //关机前有存储记录，则把从FLASH取出的数据转移到EEPROM中
	{
		//更新历史信息存储数据
		MC_RunLog1.RunTime = MC_PowerOffBkp.Run_Time;
		if(SaveParamToEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_RUN_LOG1, sizeof(MC_RunLog1_Struct_t), (uint8_t*)&MC_RunLog1.PowerOnCnt) == ACK_FAIL)
		{
			SaveParamToEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_RUN_LOG1, sizeof(MC_RunLog1_Struct_t), (uint8_t*)&MC_RunLog1.PowerOnCnt);
		}
		
		//更新骑行信息存储数据
		MC_RideLog.ODO_Km = MC_PowerOffBkp.ODO_Km;
		MC_RideLog.ODO_Time = MC_PowerOffBkp.ODO_Time;
		MC_RideLog.TRIP_Km = MC_PowerOffBkp.Trip_Km;
		MC_RideLog.TRIP_Time = MC_PowerOffBkp.Trip_Time;
		MC_RunLog1.ODO_Km = MC_PowerOffBkp.Log_ODO_Km;
		MC_RunLog1.ODO_Time = MC_PowerOffBkp.Log_ODO_Time;
		if(SaveParamToEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_RIDE_LOG, sizeof(MC_RideLog_Struct_t), (uint8_t*)&MC_RideLog.ODO_Km) == ACK_FAIL)
		{
			SaveParamToEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_RIDE_LOG, sizeof(MC_RideLog_Struct_t), (uint8_t*)&MC_RideLog.ODO_Km);
		}
	}
	
	//更新运行信息中ODO信息
	MC_RunInfo.ODO_Km = MC_RideLog.ODO_Km / 10;
	
	return 0;
}

//存储历史数据
int8_t RunLogSave_Process(uint8_t* RunLogIndex)
{
  if(*RunLogIndex == 1)
	{
	  SaveParamToEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_RUN_LOG1, sizeof(MC_RunLog1_Struct_t), (uint8_t*)&MC_RunLog1.PowerOnCnt);
		*RunLogIndex = 0;
	}
	else if(*RunLogIndex == 2)
	{
	  SaveParamToEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_RUN_LOG2, sizeof(MC_RunLog2_Struct_t), (uint8_t*)&MC_RunLog2.MCU_FaultCnt);
		*RunLogIndex = 0;
	}
	return 0;
}

//根据历史信息中开机次数判断是否进行第一次开机
TrueOrFalse_Flag_Struct_t CheckFactoryModeFromEEPROM(I2C_Handle_Struct_t* I2C_Handle, uint8_t Addr)
{
  uint8_t Temp_8[4] = {0}; 
	
	//读取存储标志并计算校验码
	EEPROM_24C02_ReadOneByte(I2C_Handle, Addr, Temp_8);
	EEPROM_24C02_ReadOneByte(I2C_Handle, Addr + 1, (Temp_8 + 1));
	EEPROM_24C02_ReadOneByte(I2C_Handle, Addr + 2, (Temp_8 + 2));
	EEPROM_24C02_ReadOneByte(I2C_Handle, Addr + 3, (Temp_8 + 3));
	
	return((Temp_8[0] & Temp_8[1] & Temp_8[2] & Temp_8[3] == 0xFF) ? TRUE : FALSE);
}