Skip to content

H
HaoJin232
Commit 829e80c3 authored by 高士达's avatar 高士达
Browse files
Options

✨ feat:增加里程库，存储未调试完成

parent c67bd76f
Hide whitespace changes
Inline Side-by-side
Showing with 599 additions and 0 deletions
HJ232_Source/source/Application/Mileage/Services_Mileage.h 0 → 100644
View file @ 829e80c3
/**
* @file Services_Mileage.c
* @brief 里程服务函数
* @details 里程服务函数，包括大计、小计
* @author myliu
* @date 2022.05.10
* @version V1.0
* @copyright myiu
*/
#ifndef SERVICE_MILEAGE_H
#define SERVICE_MILEAGE_H
/*
Platform_32Bit
Platform_16Bit
*/
#ifdef Platform_16Bit
#define Millib_uint8_t unsigned char
#define Millib_uint16_t unsigned int
#define Millib_uint32_t unsigned long
#else
#define Millib_uint8_t unsigned char
#define Millib_uint16_t unsigned short
#define Millib_uint32_t unsigned int
#define Millib_uint64_t unsigned long long
#endif
#ifndef Millib_NULL
#define Millib_NULL (void *)0u
#endif /* NULL */
/**@enum 小计里程枚举
* @brief 用来区分每个小计里程数
*/
typedef enum
{
EM_TRIP_A,
EM_TRIP_B,
EM_TRIP_C,
EM_TRIP_D,
EM_TRIP_MAX,
} DataTripEnum_t;
/**@enum EEPROM存储块枚举类型
* @brief 用来区分EEPORM存储区域
*/
typedef enum
{
EM_MILEAGE_BLOCK = 0u, /**< 累计里程 */
EM_ODO_BLOCK, /**< 总计里程 */
EM_TRIP_BLOCK, /**< 小计里程 */
EM_Maintenance_BLOCK, /**< 保养里程 */
EM_ODOSYNC_CNT_BLOCK, /**< 里程备份次数 */
EM_ENGODO_BLOCK, /**< 发动机总里程 */
} Data_EEPROM_Enum_t;
typedef void (*EEPromWrite)(Data_EEPROM_Enum_t BlockID, Millib_uint32_t u32Data[], Millib_uint16_t u16Len);
typedef Millib_uint8_t (*GetRunValid)(void);
typedef struct
{
Millib_uint8_t (*Get_Sys_IG_Sts)(void); /**< 获取系统电源状态，请务必填写函数名或NULL */
Millib_uint8_t (*Get_Act_V_Speed_Valid)(void); /**< 实际车速有效位，请务必填写函数名或NULL */
Millib_uint16_t (*Get_Act_V_Speed)(void); /**< 实际车速，请务必填写函数名或NULL */
Millib_uint16_t (*Get_TireSize)(void); /**< 轮胎系数，请务必填写函数名或NULL */
EEPromWrite EEPromWrite_Cbk; /**< 写EEPROM回调函数，请务必填写函数名或NULL */
} Mileage_Func_t;
typedef struct
{
Millib_uint32_t Mileage; /**< KL30初始化时，从EEPROM读取的数据 */
} Mileage_Init_t;
typedef struct
{
Millib_uint32_t Stamp; /**< 在Mileage上记录的里程戳 */
Millib_uint32_t Offset; /**< 里程偏移量，暂不使用，预留 */
Millib_uint32_t MaxValue; /**< 最大的总计里程，单位100m */
} ODO_Init_t;
typedef struct
{
Millib_uint32_t EngODO; /**< 在Mileage上记录的里程戳 */
Millib_uint32_t MaxValue; /**< 最大的总计里程，单位100m */
} EngODO_Init_t;
typedef struct
{
Millib_uint32_t Stamp; /**< 在Mileage上记录的里程戳 */
Millib_uint32_t MaxValue; /**< 最大的小计里程，单位100m */
Millib_uint8_t IsRestart; /**< 小计里程达到最大值后，是否自动从0开始，重新累计小计里程 */
} Trip_Init_t;
#define Data_MEM_Block_Mileage ((Millib_uint8_t)12u)
#define Data_MEM_Block_ODO ((Millib_uint8_t)16u)
#define Data_MEM_Block_EngODO ((Millib_uint8_t)8u)
#define Data_MEM_Block_Trip ((Millib_uint8_t)16u)
/*
total size =Data_MEM_Block_Trip*EM_TRIP_MAX
*/
/**
* @brief 里程服务初始化，KL30调用，必须调用，否则造成空指针
* @param[in] pMemSpace 内存空间，需要的空间大小至少大于Data_MEM_Block_Mileage，此内存需在休眠唤醒后不丢失
* @param[in] pInitData 从EEPROM读取上次下电前累计的里程
* @param[in] pFunc 底层发送回调函数, 详见Mileage_Func_t
*
* @warning 此函数必须后于EEPROM初始化，因为要读取EEPROM数据，否则每次都是从0开始
*
* @since 1.0.0
*/
void Data_Mileage_KL30_Init(Millib_uint8_t *pMemSpace,
Mileage_Init_t *pInitData, Mileage_Func_t *pFunc);
/**
* @brief 里程服务初始化，唤醒时调用，必须调用，否则造成空指针
* @param[in] pMemSpace 内存空间，需要的空间大小至少大于Data_MEM_Block_Mileage，此内存需在休眠唤醒后不丢失
* @param[in] pFunc 底层发送回调函数, 详见Mileage_Func_t
*
* @since 1.0.0
*/
void Data_Mileage_Wakeup_Init(Millib_uint8_t *pMemSpace, Mileage_Func_t *pFunc);
/**
* @brief 里程累计服务，在100ms中断调用
*
* @since 1.0.0
*/
void Data_Mileage_ISR(void);
/**
* @brief 里程读取
* @return 当前累计里程数，单位100m
* @warning 此数据非总计里程，总计里程属于此里程数的一部分
*
* @since 1.0.0
*/
Millib_uint32_t Data_Mileage_Read(void);
/**
* @brief 里程读取
* @return 当前累计里程数，单位mm
* @warning 此数据非总计里程，总计里程属于此里程数的一部分
*
* @since 1.0.0
*/
Millib_uint32_t Data_Mileage_Readmm(void);
/**
* @brief 写里程
* @param[in] NewMileage 新里程数，单位100m
* @return 成功 - 1 失败 - 0
* @warning 调用此函数前，需要调用Data_Mileage_Clear函数
*
* @since 1.0.0
*/
Millib_uint8_t Data_Mileage_Write(Millib_uint32_t NewMileage);
/**
* @brief 清里程，出厂时使用
* @warning 此函数包含功能：清Mileage，清ODO以及清trip，调用此函数后，需要复位后，里程才会继续走动
*
* @since 1.0.0
*/
void Data_Mileage_Clear(void);
/**
* @brief 清里程，出厂时使用
* @warning 此函数包含功能：清Mileage，清ODO以及清Trip，调用此函数，不影响里程的走动
*
* @since 1.0.0
*/
void Data_Mileage_Clear_GoOn(void);
/**
* @brief 将累计的里程存入EEPROM, 10ms任务中调用
*
* @since 1.0.0
*/
void Data_Mileage_Write_EEPROM(void);
/**
* @brief 获取里程库软件版本号
* @return 版本号 1.01
* @since 1.0.0
*/
Millib_uint8_t *Get_Data_Mileage_Version(void);
/**
* @brief 总计里程初始化，KL30调用，必须调用，否则造成空指针
* @param[in] pMemSpace 内存空间，需要的空间大小至少大于Data_MEM_Block_ODO，此内存需在休眠唤醒后不丢失
* @param[in] pInitData 详见ODO_Init_t
* @param[in] Func 写EEPROM回调函数
*
* @warning 在Data_Mileage_KL30_Init之后调用
*
* @since 1.0.0
*/
void Data_ODO_KL30_Init(Millib_uint8_t *pMemSpace, ODO_Init_t *pInitData, EEPromWrite Func);
/**
* @brief 总计里程初始化，唤醒调用，必须调用，否则造成空指针
* @param[in] pMemSpace 内存空间，需要的空间大小至少大于Data_MEM_Block_ODO，此内存需在休眠唤醒后不丢失
* @param[in] Func 写EEPROM回调函数
*
* @warning 在Data_Mileage_Wakeup_Init之后调用
*
* @since 1.0.0
*/
void Data_ODO_Wakeup_Init(Millib_uint8_t *pMemSpace, EEPromWrite Func);
/**
* @brief 总计里程计算服务，为了其他服务获取总计里程无0.1m的偏差，需要此服务函数
*
* @warning 在100ms任务重调用
*
* @since 1.0.0
*/
void Data_ODO_Processing(void);
/**
* @brief 总计里程读取
* @return 当前总计里程数，单位100m
* @warning 此数据为上次Data_ODO_Clear后，到调用此函数为止，累计的Mileage，属于Mileage的一部分
*
* @since 1.0.0
*/
Millib_uint32_t Data_ODO_Read(void);
/**
* @brief 清总计里程，车厂使用
* @warning 此函数只是将总计里程的里程戳标记为当前的Mileage，不属于完全清除，如出厂请调用Data_Mileage_Clear
*
* @since 1.0.0
*/
void Data_ODO_Clear(void);
/**
* @brief 总计里程偏移量读取
* @return 当前偏移量，单位100m
* @warning 里程备份时使用
*
* @since 1.0.0
*/
Millib_uint32_t Data_Offset_Read(void);
/**
* @brief 总计里程偏移量修改
* @return 当前偏移量，单位100m
* @warning 里程备份时使用
*
* @since 1.0.0
*/
void Data_ODO_Modify(Millib_uint32_t Offset);
/**
* @brief 发动机总计里程初始化，KL30调用，必须调用，否则造成空指针
* @param[in] pMemSpace 内存空间，需要的空间大小至少大于Data_MEM_Block_EngODO，此内存需在休眠唤醒后不丢失
* @param[in] pInitData 详见EngODO_Init_t
* @param[in] pFunc1 累计发动机总里程的条件
* @param[in] pFunc2 写EEPROM回调函数
*
* @warning 在Data_Mileage_KL30_Init之后调用
*
* @since 1.0.0
*/
void Data_EngODO_KL30_Init(Millib_uint8_t *pMemSpace, EngODO_Init_t *pInitData, GetRunValid pFunc1, EEPromWrite pFunc2);
/**
* @brief 发动机总计里程初始化，唤醒调用，必须调用，否则造成空指针
* @param[in] pMemSpace 内存空间，需要的空间大小至少大于Data_MEM_Block_EngODO，此内存需在休眠唤醒后不丢失
* @param[in] pFunc1 累计发动机总里程的条件
* @param[in] pFunc2 写EEPROM回调函数
*
* @warning 在Data_Mileage_Wakeup_Init之后调用
*
* @since 1.0.0
*/
void Data_EngODO_Wakeup_Init(Millib_uint8_t *pMemSpace, GetRunValid pFunc1, EEPromWrite pFunc2);
/**
* @brief 发动机总计里程计算服务，为了其他服务获取总计里程无0.1m的偏差，需要此服务函数
*
* @warning 在100ms任务重调用
*
* @since 1.0.0
*/
void Data_EngODO_Processing(void);
/**
* @brief 发动机总计里程读取
* @return 当前总计里程数，单位100m
* @warning 此数据为上次Data_ODO_Clear后，到调用此函数为止，累计的Mileage，属于Mileage的一部分
*
* @since 1.0.0
*/
Millib_uint32_t Data_EngODO_Read(void);
/**
* @brief 发动机总计里程写
* @return 当前发动机总计里程数，单位100m
* @warning 此数据为上次Data_EngODO_Clear后，累计的Mileage
*
* @since 1.0.0
*/
void Data_EngODO_Write(Millib_uint32_t newEngODO);
/**
* @brief 清发动机总计里程，车厂使用
* @warning 此函数只是将发送机总计里程清除，如需工厂清除，需要调用Data_Mileage_Clear
*
* @since 1.0.0
*/
void Data_EngODO_Clear(void);
/**
* @brief 小计里程初始化，KL30调用，必须调用，否则造成空指针
* @param[in] pMemSpace 内存空间，需要的空间大小至少大于Data_MEM_Block_Trip*EM_TRIP_MAX，此内存需在休眠唤醒后不丢失
* @param[in] pInitData Trip_Init_t
* @param[in] TotalTrip 小计总数，（例如：1个小计， 2个小计，3个小计）
* @param[in] Func 写EEPROM回调函数
*
* @warning 在Data_Mileage_KL30_Init之后调用
*
* @since 1.0.0
*/
void Data_Trip_KL30_Init(Millib_uint8_t *pMemSpace, Trip_Init_t *pInitData, Millib_uint8_t TotalTrip, EEPromWrite pFunc);
/**
* @brief 小计里程初始化，唤醒调用，必须调用，否则造成空指针
* @param[in] pMemSpace 内存空间，需要的空间大小至少大于Data_MEM_Block_Trip*EM_TRIP_MAX，此内存需在休眠唤醒后不丢失
* @param[in] TotalTrip 小计总数，（例如：1个小计， 2个小计，3个小计）
* @param[in] Func 写EEPROM回调函数
*
* @warning 在Data_Mileage_Wakeup_Init之后调用
*
* @since 1.0.0
*/
void Data_Trip_Wakeup_Init(Millib_uint8_t *pMemSpace, Millib_uint8_t TotalTrip, EEPromWrite pFunc);
/**
* @brief 小计里程计算服务，为了其他服务获取小计里程无0.1m的偏差，需要此服务函数
*
* @warning 在100ms任务重调用
*
* @since 1.0.0
*/
void Data_Trip_Processing(void);
/**
* @brief 清小计里程
* @param[in] TripN DataTripEnum_t
* @warning 此函数只是将小计里程的里程戳标记为当前的Mileage，不属于完全清除，如出厂请调用Data_Mileage_Clear
*
* @since 1.0.0
*/
void Data_Clear_Trip(DataTripEnum_t TripN);
/**
* @brief 清小计里程
* @warning 此函数只是将小计里程的里程戳标记为当前的Mileage，不属于完全清除，如出厂请调用Data_Mileage_Clear
*
* @since 1.0.0
*/
void Data_Clear_Trip_All(void);
/**
* @brief 小计里程读取
* @param[in] TripN DataTripEnum_t
* @return 当前小计里程数，单位100m
* @warning 此数据为上次Data_ODO_Clear后，到调用此函数为止，累计的Mileage，属于Mileage的一部分
*
* @since 1.0.0
*/
Millib_uint32_t Data_Read_Trip(DataTripEnum_t TripN);
#endif
HJ232_Source/source/Application/Mileage/Services_Mileage_User.c 0 → 100644
View file @ 829e80c3
#include "Services_Mileage_User.h"
#include "Services_Mileage.h"
#include "eepromManage.h"
#include <string.h>
#include "Common_Interface.h"
#include "Services_Mileage.h"
uint8_t DataMilleageBuf [ Data_MEM_Block_Mileage ];
uint8_t DataODOBuf [ Data_MEM_Block_ODO ];
uint8_t DataTripBuf [ Data_MEM_Block_Trip * EM_TRIP_MAX ];
Mileage_t g_WriteMileage;
Mileage_t g_ReadMileage;
uint8_t odo_writeState;
uint8_t odo_readState;
static uint32_t Data_User_EEPROM_Read(uint16_t u16BlockID, uint32_t u32Data [], uint16_t u16Len);
static void Data_User_EEPROM_Write(Data_EEPROM_Enum_t BlockID, uint32_t u32Data [], uint16_t u16Len);
#define EEPROM_BLOCK_00 0X00
#define EEPROM_BLOCK_01 0X16
#define EEPROM_BLOCK_02 0X32
#define EEPROM_BLOCK_03 0X48
#define EEPROM_BLOCK_04 0X64
#define EEPROM_BLOCK_05 0X80
#define EEPROM_BLOCK_06 0X90
uint32_t Milleage_InitFlag = 0U;
uint32_t RiskStop_Flag = 0u;
uint8_t ChangAn_ODOClear_Sts;
uint8_t ChangAn_ODOClear_Timer;
uint8_t ChangAn_ODOClear;
/******************************************************************************
Function：Data_ODO_KL30Init
Description：
Input:
Output:
******************************************************************************/
void Data_User_Mileage_KL30Init(void)
{
uint32_t TempBuf [ 8 ] = {0};
Mileage_Init_t MileInit = {0};
Mileage_Func_t Func = {0};
ODO_Init_t ODOInit = {0};
EngODO_Init_t EngODOInit = {0};
Trip_Init_t TripInit [ 4 ] = {0};
Milleage_InitFlag = 0U;
//�������ݴ�EEPROM�ж�ȡ
( void )Data_User_EEPROM_Read(EM_MILEAGE_BLOCK, TempBuf, 1);
if ( TempBuf [ 0 ] == 0xFFFFFFFF )
{
MileInit.Mileage = 0u;
}
else
{
MileInit.Mileage = TempBuf [ 0 ];
}
Func.Get_Sys_IG_Sts = Common_Get_IG_Sts;
Func.Get_Act_V_Speed_Valid = Common_Get_Act_V_Speed_Valid;
Func.Get_Act_V_Speed = Common_Get_Act_V_Speed;
Func.Get_TireSize = ( void *)0;
Func.EEPromWrite_Cbk = Data_User_EEPROM_Write; //��ʱδ����
Data_Mileage_KL30_Init(DataMilleageBuf, &MileInit, &Func);
( void )Data_User_EEPROM_Read(EM_ODO_BLOCK, TempBuf + 1, 2);
if ( TempBuf [ 1 ] == 0xFFFFFFFF )
{
ODOInit.Stamp = 0;
}
else
{
ODOInit.Stamp = TempBuf [ 1 ];
}
if ( TempBuf [ 1 ] == 0xFFFFFFFF )
{
ODOInit.Offset = 0;
}
else
{
ODOInit.Offset = TempBuf [ 2 ];
}
ODOInit.MaxValue = 9999999;
Data_ODO_KL30_Init(DataODOBuf, &ODOInit, Func.EEPromWrite_Cbk);
( void )Data_User_EEPROM_Read(EM_TRIP_BLOCK, TempBuf + 3, 4);
TripInit [ EM_TRIP_A ].Stamp = 0xFFFFFFFFu;
TripInit [ EM_TRIP_A ].MaxValue = 99999;
TripInit [ EM_TRIP_A ].IsRestart = 1u;
TripInit [ EM_TRIP_B ].Stamp = 0xFFFFFFFFu;
TripInit [ EM_TRIP_B ].MaxValue = 99999;
TripInit [ EM_TRIP_B ].IsRestart = 1u;
TripInit [ EM_TRIP_C ].Stamp = 0xFFFFFFFFu;
TripInit [ EM_TRIP_C ].MaxValue = 99999;
TripInit [ EM_TRIP_C ].IsRestart = 1u;
TripInit [ EM_TRIP_D ].Stamp = 0xFFFFFFFFu;
TripInit [ EM_TRIP_D ].MaxValue = 99999;
TripInit [ EM_TRIP_D ].IsRestart = 1u;
Data_Trip_KL30_Init(DataTripBuf, TripInit, EM_TRIP_MAX, Func.EEPromWrite_Cbk);
Milleage_InitFlag = 0X5AA53AA3UL;
RiskStop_Flag = 0;
ChangAn_ODOClear_Sts = 0xAA;
ChangAn_ODOClear_Timer = 0;
}
void Data_User_Mileage_WakeupInit(void)
{
Mileage_Func_t Func = {0};
Milleage_InitFlag = 0U;
Func.Get_Sys_IG_Sts = Common_Get_IG_Sts;
Func.Get_Act_V_Speed_Valid = Common_Get_Act_V_Speed_Valid;
Func.Get_Act_V_Speed = Common_Get_Act_V_Speed;
Func.Get_TireSize = ( void *)0;
Func.EEPromWrite_Cbk = Data_User_EEPROM_Write; //��ʱδ����
Data_Mileage_Wakeup_Init(DataMilleageBuf, &Func);
Data_ODO_Wakeup_Init(DataODOBuf, Func.EEPromWrite_Cbk);
Data_Trip_Wakeup_Init(DataTripBuf, EM_TRIP_MAX, Func.EEPromWrite_Cbk);
Milleage_InitFlag = 0X5AA53AA3UL;
RiskStop_Flag = 0;
}
uint32_t Get_MileageInit_Status(void)
{
return Milleage_InitFlag;
}
static uint32_t Data_User_EEPROM_Read(uint16_t u16BlockID, uint32_t u32Data [], uint16_t u16Len)
{
switch ( u16BlockID )
{
case EM_MILEAGE_BLOCK:
odo_readState = eeprom_ReadODO(&g_ReadMileage);
u32Data [ 0 ] = g_ReadMileage.Odo;
// g_EngineRunMileage = g_ReadMileage.Trip;
// eeprom_ReadRecord(EEPROM_BLOCK_00, ( uint8_t * )u32Data, u16Len * 4);
break;
case EM_ODO_BLOCK:
eeprom_ReadRecord(EEPROM_BLOCK_01, ( uint8_t * )u32Data, u16Len * 4);
break;
case EM_TRIP_BLOCK:
eeprom_ReadRecord(EEPROM_BLOCK_03, ( uint8_t * )u32Data, u16Len * 4);
break;
default:
break;
}
return 0;
}
static void Data_User_EEPROM_Write(Data_EEPROM_Enum_t BlockID, uint32_t u32Data [], uint16_t u16Len)
{
uint8_t i = 0u;
switch ( BlockID )
{
case EM_MILEAGE_BLOCK:
if ( u32Data [ 0 ] == 0 )
{
eeprom_ClearOdoSection( );
}
else
{
g_WriteMileage.Odo = u32Data [ 0 ];
// g_WriteMileage.Trip = 0;
g_WriteMileage.IsTripClear = 0;
// g_WriteMileage.Trip = g_EngineRunMileage;
odo_writeState = WRITE_FAIL;
if(g_WriteMileage.Odo % 10 == 0)
{
while(odo_writeState != WRITE_COMPLETE)
{
odo_writeState = eeprom_WriteODO(&g_WriteMileage, distance_100m, 1);
i++;
if(i > 10)
{
break;
}
}
}
}
// eeprom_WriteRecord(EEPROM_BLOCK_00, ( uint8_t * )u32Data, u16Len * 4);
break;
case EM_ODO_BLOCK:
eeprom_WriteRecord(EEPROM_BLOCK_01, ( uint8_t * )u32Data, u16Len * 4);
break;
case EM_TRIP_BLOCK:
eeprom_WriteRecord(EEPROM_BLOCK_03, ( uint8_t * )u32Data, u16Len * 4);
break;
default:
break;
}
}
void Services_Mileage_Callback(void)
{
Data_Mileage_ISR( );
}
HJ232_Source/source/Application/Mileage/Services_Mileage_User.h 0 → 100644
View file @ 829e80c3
#ifndef __SERVICE_ODO_USER_H__
#define __SERVICE_ODO_USER_H__
#include "common.h"
//#define ONLY_CLEAR_ODO_MIL 0x01u /*仅根据距离信息进行ODO清除*/
//#define ONLY_CLEAR_ODO_NUM 0x01u /*仅根据次数信息进行ODO清除*/
#define CLEAR_ODO_NUM_MIL 0x01u /*以距离信息以及次数信息进行ODO清除*/
#define ODO_CLEAR_NUM 5u /*清除次数上限值 */
#define ODO_CLEAR_MIL 50000u /*清除距离上限值 单位0.1KM*/
extern uint8_t ODO_Clear_Num_Value;
void Data_User_Mileage_KL30Init(void);
void Data_User_Mileage_WakeupInit(void);
void Services_Mileage_Callback(void);
uint32_t Get_MileageInit_Status(void);
#endif
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment