//#include "FreeRTOS.h"
//#include "FreeRTOSConfig.h"
//#include "task.h"
#include "string.h"
//DJI头锟侥硷拷
#include "stmflash.h"
//#include "upgrade_platform_opt_stm32.h"
//#include "dji_logger.h"
#include "util_md5.h"
#include "usart.h"
#include "my_typedef.h"
//锟皆硷拷锟斤拷头锟侥硷拷
#include "upgrade.h"
#include "upgrade_opt.h"
// #include "data_frame.h"
#include "crc16ibm.h"



//// 锟结构锟斤拷
//TaskHandle_t 		DataRecHandle;
//TaskHandle_t 		FrameProcessHandle;
myUpgrade_t 		upgrade_parm = {0}; // 锟芥储锟斤拷锟斤拷锟斤拷锟斤拷
t_queue_info 		*frameHandle;
uint8_t 			devConnetState = 0;	// 锟借备锟斤拷锟街成癸拷锟斤拷志
// 锟解部锟斤拷锟斤拷
extern 	uint8_t 	ConnetReque[12]; 	// 锟斤拷锟斤拷帧
extern 	uint8_t 	ConntAnswer[12];	// 应锟斤拷帧

//锟斤拷锟斤拷锟斤拷锟斤拷
int8_t UpgradeTest_Init(void);
void Upgrade_Frame_Processing(void *arg);
int8_t Write_UpgradeFile(uint32_t offset, const uint8_t *data, uint16_t dataLen);
int8_t My_Flash_Write(uint32_t FlashAddress, const uint8_t *Data, uint32_t DataLength);
int8_t Flash_Write_Word(uint32_t addr, uint32_t *buff, uint32_t len);
int8_t Flash_Write_Byte(uint32_t addr, uint8_t *buff, uint32_t len);



/**
	@brief	锟斤拷始锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷帧锟斤拷锟斤拷锟诫处锟斤拷锟斤拷锟斤拷
	@param	no
	@return	no
*/
int8_t UpgradeTest_Init(void)
{
	uint32_t returnCode;
	T_UpgradeEndInfo upgradeEndInfo = {0};
	bool 		isUpgradeReboot = false;	// 锟斤拷锟斤拷状态
//	UART_Init(UART_NUM_1, 115200);//锟斤拷锟斤拷锟斤拷锟节筹拷始锟斤拷
	// 锟斤拷取锟斤拷锟斤拷状态,
	//printf("GetUpgradeRebootState\r\n");
	returnCode = GetUpgradeRebootState(&isUpgradeReboot, &upgradeEndInfo);
	if (returnCode != 0)
	{
		//printf("Get upgrade reboot state error");
		upgrade_parm.state = Upgrade_Stage_Error;
	}
	//printf("isUpgradeReboot:%x\n",isUpgradeReboot);
	// 锟叫讹拷锟角凤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
	if (isUpgradeReboot == true)
	{
		// 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟芥储锟斤拷
		returnCode = CleanUpgradeProgramFileStoreArea();
		if (returnCode != 0)
		{
			//printf("Clean upgrade reboot state error");
			upgrade_parm.state = Upgrade_Stage_Error;
		}
	}
	return 1;
}
/**
	@brief	锟斤拷锟斤拷锟斤拷榧帮拷锟绞硷拷锟
	@param	no
	@return no
*/
uint8_t upgrade_check(void)
{
	uint8_t		connetTim = 0;		// 锟借备锟斤拷锟斤拷时锟斤拷锟斤拷锟
	
	if(UpgradeTest_Init() == 0)
	{
		goto upgrade_check_error;
	}
	//printf("v3.9.3\r\n");
//	while (1)
//	{
//		if(devConnetState == 0)//未锟斤拷锟斤拷锟斤拷锟借备
//		{
//			connetTim++;
//			if (connetTim >= 30)	//锟斤拷时锟斤拷锟斤拷锟斤拷未锟斤拷锟秸碉拷锟斤拷锟斤拷帧锟斤拷锟截憋拷锟斤拷锟斤拷直锟斤拷锟斤拷锟斤拷锟斤拷循锟斤拷锟斤拷锟斤拷psdk
//			{
//				goto upgrade_check_error;
//			}
//		}
//		
//		HAL_Delay(100);
//	}
	upgrade_check_error:
	{
		//printf("connetTim:%d\r\n", connetTim);
		connetTim = 0;
		
//		vTaskDelete(DataRecHandle);
//		vTaskDelete(FrameProcessHandle);//删锟斤拷锟斤拷锟今，诧拷影锟斤拷锟斤拷锟絇SDK锟斤拷锟斤拷
//		free(frameHandle);// 锟酵凤拷 frameHandle 指锟斤拷锟斤拷诖锟,锟斤拷止影锟斤拷psdk锟斤拷锟斤拷
//		frameHandle = NULL;// 锟斤拷 frameHandle 指锟斤拷锟斤拷锟斤拷为 NULL锟斤拷锟皆憋拷锟斤拷锟轿爸革拷锟
	}
}
/**
	@brief	锟斤拷锟斤拷帧锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
	@param	no
	@note	锟斤拷锟斤拷锟斤拷源源锟斤拷锟斤拷< void Data_Analysis(void *pvParam) >锟斤拷锟斤拷
	@return	no
*/
//void Upgrade_Frame_Processing(void *arg)
//{
//	while (1)
//	{
//		// 锟叫讹拷锟斤拷锟斤拷帧锟斤拷志位锟角凤拷为1
//		if (frameHandle->frameinfo.flag == 1)
//		{
//			// 锟斤拷锟斤拷锟斤拷锟斤拷帧锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷帧锟斤拷锟叫达拷锟斤拷
//			DataFrame_Analyse(&frameHandle->frameinfo.buff[0], frameHandle->frameinfo.count);

//			// 锟斤拷锟斤拷锟斤拷帧锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
//			memset(frameHandle->frameinfo.buff, 0x00, sizeof(frameHandle->frameinfo.buff));

//			// 锟斤拷锟斤拷锟斤拷帧锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
//			frameHandle->frameinfo.count = 0;

//			// 锟斤拷锟斤拷锟斤拷帧锟斤拷志位锟斤拷锟斤拷
//			frameHandle->frameinfo.flag = 0;
//		}
//	}
//}
// 锟截革拷锟斤拷锟斤拷
// 锟斤拷锟斤拷锟斤拷锟斤拷AnswerUpgradeFrame
// 锟斤拷锟斤拷锟斤拷
//   port锟斤拷锟剿匡拷锟斤拷锟酵ｏ拷Uart_Port 锟斤拷示 UART1锟斤拷Usb_Port 锟斤拷示 USB
//   func锟斤拷锟斤拷锟斤拷位
//   data锟斤拷锟斤拷锟斤拷
// 锟斤拷锟斤拷值锟斤拷锟斤拷
//int8_t AnswerUpgradeFrame(uint8_t func, uint8_t data)
//{
//	// 锟斤拷锟斤拷锟截革拷帧锟斤拷锟斤拷锟斤拷
//	uint8_t upgradeAnswerBuff[12] = {0x5b, 0x5b, 0x77, 0x00, 0x0c, 0x00, 0x00, 0xa1, 0x01, 0x00, 0x00, 0x23};

//	// 锟斤拷锟矫癸拷锟斤拷位锟斤拷锟斤拷锟斤拷位
//	upgradeAnswerBuff[FUNC_BIT_2] = func;
//	upgradeAnswerBuff[DATA_BIT] = data;

//	// 锟斤拷锟捷端匡拷锟斤拷锟酵凤拷锟酵回革拷帧
//	UART_Write(UART_NUM_1, upgradeAnswerBuff, 12);
////		for (int i = 0; i < 12; ++i) {
////			//printf("%X ", upgradeAnswerBuff[i]); // 锟斤拷锟斤拷锟斤拷锟芥储锟斤拷锟斤拷锟街凤拷锟斤拷使锟斤拷%c锟斤拷印
////		}
////		//printf("\n");
//}
/**
 * @brief 锟斤拷锟斤拷准锟斤拷
 * @return 锟斤拷锟斤拷值锟斤拷0 - 锟缴癸拷锟斤拷1 - 锟斤拷准锟斤拷锟矫ｏ拷2 - 锟斤拷锟斤拷锟芥储锟斤拷失锟斤拷
 */
int8_t UpgradePreparation(void)
{
	uint32_t ret;

//	if (upgrade_parm.state == Upgrade_Stage_Ready)
//		return 1; // 锟窖撅拷准锟斤拷锟矫ｏ拷直锟接凤拷锟斤拷
	//printf("准锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷\r\n");
	upgrade_parm.state = Upgrade_Stage_Ready; // 锟斤拷锟斤拷锟斤拷锟斤拷状态为准锟斤拷锟阶讹拷

	// 锟斤拷锟斤拷锟芥储锟斤拷锟斤拷
	ret = CleanUpgradeProgramFileStoreArea();
	if (ret != 0)
	{
		//printf("锟斤拷锟斤拷锟芥储锟斤拷锟斤拷锟斤拷\r\n");
		upgrade_parm.state = Upgrade_Stage_Error;
		return 2; // 锟斤拷锟斤拷锟芥储锟斤拷失锟杰ｏ拷锟斤拷锟截达拷锟斤拷锟斤拷
	}

	// 锟斤拷锟斤拷锟斤拷锟斤拷...
	upgrade_parm.filesize = 0;
	memset(upgrade_parm.md5code, 0x00, sizeof(upgrade_parm.md5code));
	upgrade_parm.state = Upgrade_Stage_IDEL; // 锟斤拷锟斤拷状态为IDLE

	//printf("锟斤拷锟斤拷锟芥储锟斤拷锟缴癸拷\r\n");

	AnswerUpgradeFrame(0x01, 0x00);
	
	return 0; 
}

/**
 * @brief 锟斤拷取MD5校锟斤拷锟诫，锟斤拷锟节斤拷锟斤拷锟饺斤拷
 * @param buf 锟斤拷锟捷伙拷锟斤拷锟斤拷指锟斤拷
 * @param len 锟斤拷锟捷筹拷锟斤拷
 * @return 锟斤拷锟斤拷值锟斤拷0 - 锟缴癸拷锟斤拷1 - 锟斤拷锟斤拷锟斤拷锟斤拷2 - 锟窖伙拷取MD5校锟斤拷锟斤拷
 */
int8_t UpgradeFileMD5Code_Get(uint8_t *buf, uint32_t len)
{
	if (buf == NULL || len == 0)
		return 1; // 锟斤拷锟斤拷锟斤拷锟襟，凤拷锟斤拷

//	if (upgrade_parm.state == Upgrade_Stage_GetMd5)
//		return 2; // 锟窖伙拷取MD5校锟斤拷锟诫，直锟接凤拷锟斤拷

	memcpy(upgrade_parm.md5code, buf + DATA_BIT, len - 11); // 锟斤拷取MD5校锟斤拷锟斤拷

	//printf("锟斤拷取锟斤拷锟斤拷MD5校锟斤拷锟斤拷为锟斤拷%s\r\n", upgrade_parm.md5code);

	AnswerUpgradeFrame(0x02, 0x00); // 锟截革拷锟斤拷锟斤拷帧

	upgrade_parm.state = Upgrade_Stage_GetMd5; // 锟斤拷锟斤拷状态为锟斤拷取MD5校锟斤拷锟斤拷
	
	return 0; // 锟斤拷锟截成癸拷
}

/**
 * @brief 锟斤拷锟斤拷锟侥硷拷锟斤拷写锟斤拷Flash锟芥储
 * @param buf 锟侥硷拷锟斤拷锟捷伙拷锟斤拷锟斤拷指锟斤拷
 * @param len 锟斤拷锟捷筹拷锟斤拷
 * @return 锟斤拷锟斤拷值锟斤拷0 - 锟缴癸拷锟斤拷1 - 锟斤拷锟斤拷锟斤拷锟斤拷2 - 锟斤拷锟斤拷锟侥硷拷锟斤拷锟斤拷3 - 状态锟斤拷锟斤拷4 - 写锟斤拷锟侥硷拷锟斤拷锟斤拷
 */
int8_t UpgradeFile_Write(uint8_t *buf, uint16_t len)
{
	if (buf == NULL || len == 0)
		return 1; // 锟斤拷锟斤拷锟斤拷锟襟，凤拷锟斤拷

	int8_t ret;

	if (upgrade_parm.filesize > MAX_FILE_SIZE) // 锟斤拷锟斤拷锟侥硷拷锟斤拷锟节匡拷锟矫存储锟秸硷拷
	{
		upgrade_parm.state = Upgrade_Stage_Error;
		return 2; // 锟斤拷锟斤拷锟侥硷拷锟斤拷锟襟，凤拷锟截达拷锟斤拷锟斤拷
	}

	if (upgrade_parm.state == Upgrade_Stage_Error)
		return 3; // 状态锟斤拷锟斤拷直锟接凤拷锟斤拷

	if (upgrade_parm.state == Upgrade_Stage_GetMd5)
		upgrade_parm.state = Upgrade_Stage_OnGoing; // 锟斤拷锟斤拷状态为锟斤拷锟斤拷锟斤拷

	//printf("写锟斤拷锟侥硷拷锟斤拷小锟斤拷%d  锟斤拷锟饺ｏ拷%d\r\n", upgrade_parm.filesize, len);

	ret = Write_UpgradeFile(upgrade_parm.filesize, buf + DATA_BIT, len - 11); // 写锟斤拷锟斤拷锟斤拷锟侥硷拷锟斤拷锟斤拷
	if (ret != 0)
	{
		//printf("写锟斤拷锟斤拷锟斤拷锟侥硷拷锟斤拷锟斤拷\r\n");
		return 4; // 写锟斤拷锟侥硷拷锟斤拷锟斤拷锟斤拷锟斤拷锟截达拷锟斤拷锟斤拷
	}

	upgrade_parm.filesize = upgrade_parm.filesize + len - 11; // 锟斤拷锟斤拷锟侥硷拷锟斤拷小

	//printf("写锟斤拷晒锟, 锟侥硷拷锟斤拷小锟斤拷%d  \r\n", upgrade_parm.filesize);
	
	return 0; // 锟斤拷锟截成癸拷
}

// 锟斤拷锟斤拷锟侥硷拷锟斤拷锟斤拷
int8_t Upgrade_TransferFinnal(uint8_t val)
{
	AnswerUpgradeFrame(0x02, val);
}

// 锟斤拷锟斤拷锟斤拷锟斤拷锟侥硷拷锟斤拷MD5
int8_t UpgradeFile_MD5Create(void)
{
	uint8_t md5[16];			   // 锟芥储锟斤拷锟缴碉拷16锟斤拷锟斤拷 MD5 校锟斤拷锟斤拷
	uint8_t md5_32[32];			   // 锟斤拷 16锟斤拷锟斤拷 锟斤拷 MD5校锟斤拷锟斤拷 转锟斤拷为 32位锟斤拷 ASCII锟斤拷
	uint8_t fileBuffer[256] = {0}; // 每锟轿讹拷取锟侥硷拷锟侥伙拷锟斤拷锟斤拷
	uint32_t returnCode;
	uint32_t offset;
	MD5_CTX fileMd5Ctx;
	uint16_t realLen = 0;

	offset = 0;

	// 锟斤拷始锟斤拷 MD5 锟斤拷锟斤拷锟斤拷
	UtilMd5_Init(&fileMd5Ctx);

	if (upgrade_parm.filesize == 0)
		return 1;

	// 循锟斤拷锟斤拷取flash锟侥硷拷
	while (upgrade_parm.filesize - offset > 256)
	{
		returnCode = ReadUpgradeProgramFile(offset, 256,
																	fileBuffer, &realLen);
		if (returnCode != 0 || realLen != 256)
		{
//			USER_LOG_ERROR("Get file data error, return code = 0x%08llX", returnCode);
			return 2;
		}

		UtilMd5_Update(&fileMd5Ctx, fileBuffer, 256);

		offset += 256;
	}

	// 锟斤拷剩锟斤拷锟斤拷募锟叫★拷锟 256
	returnCode = ReadUpgradeProgramFile(offset, upgrade_parm.filesize - offset, fileBuffer, &realLen);
	if (returnCode != 0 || realLen != upgrade_parm.filesize - offset)
	{
//		USER_LOG_ERROR("Get file data error, return code = 0x%08llX", returnCode);
		return 1;
	}

	//printf("upgrade_parm.filesize = %d   %d  fileBuffer =%s \r\n", upgrade_parm.filesize, offset, fileBuffer);

	UtilMd5_Update(&fileMd5Ctx, fileBuffer, upgrade_parm.filesize - offset);
	UtilMd5_Final(&fileMd5Ctx, md5);

	// 锟斤拷锟斤拷取锟斤拷锟斤拷16锟斤拷锟斤拷 md5 校锟斤拷锟斤拷 转锟斤拷为 32位锟斤拷 ascii锟斤拷
	for (int8_t i = 0; i < 16; i++)
	{
		sprintf(&md5_32[i * 2], "%02x", md5[i]);
	}
	//printf("md5 check sum  = %s\r\n", md5_32);

	// 校锟斤拷锟斤拷锟斤拷傻锟 MD5 锟诫传锟斤拷锟 MD5 锟饺较诧拷锟斤拷
	if (memcmp(upgrade_parm.md5code, md5_32, 32) != 0)
	{
		// 锟斤拷锟斤拷锟斤拷锟斤拷状态为 锟斤拷锟斤拷状态
		upgrade_parm.filesize = 0;
		upgrade_parm.state = Upgrade_Stage_IDEL;
		memset(upgrade_parm.md5code, 0x00, sizeof(upgrade_parm.md5code));

		//printf("The md5 checksum is different\r\n");
				// 锟截革拷校锟斤拷失锟斤拷
		AnswerUpgradeFrame(0x05, 0x01);
		return 2;
	}

	// md5 校锟斤拷锟斤拷锟斤拷龋锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟街疚伙拷锟叫达拷锟絝lash
	upgrade_parm.upgradeEndInfo.upgradeEndState = UPGRADE_END_STATE_SUCCESS;

	// 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷状态
	returnCode = SetUpgradeRebootState(&upgrade_parm.upgradeEndInfo);
	if (returnCode != 0)
	{
		//printf("write upgrade flag error\r\n");
		return 3;
	}

	// 写锟斤拷锟侥硷拷锟斤拷小,锟斤拷 dji 锟皆达拷锟斤拷 loader 锟叫讹拷锟斤拷要锟矫碉拷
	stmflash_write(APPLICATION_STORE_ADDRESS_END - 1023, (uint16_t*)&upgrade_parm.filesize, 2);


	//printf("ready to reboot system\r\n");
	
		// 锟截革拷锟斤拷锟斤拷帧
	AnswerUpgradeFrame(0x05, 0x00);

//	HAL_Delay(2000);//裸机开发时，中断里面不能调用
	// 系统锟斤拷锟斤拷
	RebootSystem();

	return 0;
}
// 锟斤拷锟斤拷 5B 锟酵碉拷应锟斤拷帧锟斤拷锟斤拷
// 锟斤拷锟斤拷锟斤拷锟斤拷Make5BFrame_Test
// 锟斤拷锟斤拷锟斤拷
//   port锟斤拷锟剿匡拷锟斤拷锟酵ｏ拷0 锟斤拷示 UART1锟斤拷Usb_Port 锟斤拷示 USB
//   func_1锟斤拷锟斤拷锟斤拷位 1
//   func_2锟斤拷锟斤拷锟斤拷位 2
//   data锟斤拷要锟斤拷锟酵碉拷锟斤拷锟捷碉拷指锟斤拷
//   datalen锟斤拷要锟斤拷锟酵碉拷锟斤拷锟捷筹拷锟斤拷
// 锟斤拷锟斤拷值锟斤拷
//   0锟斤拷锟缴癸拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷应锟斤拷帧
//   1锟斤拷锟斤拷锟斤拷指锟斤拷为锟秸伙拷锟斤拷锟捷筹拷锟斤拷为 0
int8_t Make5BFrame_Test(uint8_t func_1, uint8_t func_2, uint8_t *data, uint16_t datalen)
{
	// 锟斤拷锟斤拷锟斤拷锟街革拷锟斤拷锟斤拷锟捷筹拷锟斤拷锟角凤拷锟斤拷效
	if (data == NULL || datalen == 0)
		return 1;

	uint8_t *SendFrame; // 锟芥储要锟斤拷锟酵碉拷帧锟斤拷锟捷碉拷锟斤拷锟斤拷指锟斤拷
	uint8_t Lenth;		// 锟斤拷锟斤拷帧锟斤拷锟斤拷

	// 锟斤拷锟斤拷锟斤拷锟斤拷帧锟斤拷锟斤拷
	Lenth = datalen + 11;

	// 锟斤拷锟斤拷锟斤拷锟斤拷占锟
	SendFrame = (uint8_t *)malloc(Lenth * sizeof(uint8_t));

	// 锟斤拷锟斤拷锟斤拷锟斤拷帧
	SendFrame[0] = 0x5b;
	SendFrame[1] = 0x5b;
	SendFrame[2] = 0x77;
	SendFrame[3] = Lenth / 256;
	SendFrame[4] = Lenth % 256;
	SendFrame[5] = 0x00;
	SendFrame[6] = 0x00;
	SendFrame[7] = func_1;
	SendFrame[8] = func_2;

	// 锟斤拷锟斤拷锟斤拷拼锟接碉拷锟斤拷锟斤拷帧锟斤拷
	memcpy(&SendFrame[9], data, datalen);

	SendFrame[Lenth - 2] = 0x00;
	SendFrame[Lenth - 1] = 0x23;

//	UART_Write(UART_NUM_1, SendFrame, Lenth);

	// 锟酵凤拷锟斤拷锟斤拷占锟
	free(SendFrame);

	return 0; // 锟斤拷锟截成癸拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷应锟斤拷帧状态
}

// 写锟斤拷锟斤拷锟侥硷拷
// 锟斤拷锟斤拷锟斤拷锟斤拷Write_UpgradeFile
// 锟斤拷锟斤拷锟斤拷
//   offset锟斤拷写锟斤拷偏锟斤拷锟斤拷锟斤拷指示要写锟斤拷锟斤拷锟捷碉拷锟斤拷始位锟斤拷
//   data锟斤拷要写锟斤拷锟斤拷锟斤拷莸锟街革拷锟
//   dataLen锟斤拷要写锟斤拷锟斤拷锟斤拷莩锟斤拷锟
// 锟斤拷锟斤拷值锟斤拷
//   0锟斤拷写锟斤拷晒锟
//   1锟斤拷写锟斤拷失锟斤拷
int8_t Write_UpgradeFile(uint32_t offset, const uint8_t *data, uint16_t dataLen)
{
//	uint32_t result; // 锟斤拷锟节存储写锟斤拷锟斤拷

	__disable_irq(); // 锟斤拷止锟叫断ｏ拷确锟斤拷写锟斤拷锟斤拷滩锟斤拷锟斤拷卸锟

	// 锟斤拷锟斤拷Flash写锟诫函锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷写锟诫到指锟斤拷偏锟斤拷位锟斤拷
	stmflash_write(APPLICATION_STORE_ADDRESS + offset, (uint16_t *)data, dataLen/2);
//	if (result != 0) // 锟斤拷锟叫达拷锟斤拷锟斤拷锟轿拷锟斤拷锟绞拘达拷锟绞э拷锟
//	{
//		__enable_irq(); // 锟斤拷锟斤拷锟叫讹拷
//		return 1;		// 锟斤拷锟斤拷写锟斤拷失锟斤拷状态
//	}

	__enable_irq(); // 锟斤拷锟斤拷锟叫讹拷

	return 0; // 锟斤拷锟斤拷写锟斤拷晒锟阶刺
}

//// 锟脚伙拷写flash锟斤拷锟斤拷,锟斤拷锟叫达拷锟斤拷俣锟
///*
//注:	flash 锟斤拷 Word 锟斤拷式写锟斤拷锟斤拷时, 锟斤拷址值要锟斤拷 4锟斤拷锟斤拷锟斤拷锟斤拷,锟斤拷然写锟斤拷锟斤拷锟
//		  锟斤拷 Byte 锟侥凤拷式写锟斤拷缘锟街访灰拷锟,锟斤拷写锟斤拷锟劫度斤拷锟斤拷

//锟斤拷:   锟斤拷 0x08080003	写锟斤拷 一锟斤拷 uint8_t buff[6] 锟斤拷锟斤拷锟斤拷
//	  0x08080003  锟斤拷址写 buff[0];						Byte 锟斤拷式写锟斤拷
//	  0x08080004 ~ 0x08080007 锟斤拷址写 buff[1]~buff[4]	Word 锟斤拷式写锟斤拷
//	  0x08080008  锟斤拷址写 buff[5]						Byte 锟斤拷式写锟斤拷

//*/

///**
// * @brief  锟斤拷Flash指锟斤拷锟斤拷址写锟斤拷锟斤拷锟斤拷
// * @param  FlashAddress: 要写锟斤拷锟紽lash锟斤拷址
// * @param  Data: 要写锟斤拷锟斤拷锟斤拷锟街革拷锟
// * @param  DataLength: 要写锟斤拷锟斤拷锟斤拷莩锟斤拷龋锟斤拷锟轿晃拷纸锟
// * @retval 锟斤拷锟斤拷写锟斤拷状态锟斤拷0锟斤拷示锟缴癸拷锟斤拷锟斤拷0锟斤拷示失锟斤拷
// */
//int8_t My_Flash_Write(uint32_t FlashAddress, const uint8_t *Data, uint32_t DataLength)
//{
//	uint32_t i = 0;
//	uint32_t dataLengthWord = DataLength / 4; // 锟斤拷锟捷筹拷锟斤拷转锟斤拷锟斤拷锟斤拷4锟街斤拷为锟斤拷位锟侥筹拷锟斤拷
//	uint32_t writeAddress = FlashAddress;	  // 写锟斤拷锟街
//	uint32_t ret;							  // 锟斤拷锟斤拷值

//	uint32_t dataLen = DataLength; // 锟斤拷锟捷筹拷锟斤拷
//	uint8_t writeByteCount;		   // 写锟斤拷锟街斤拷锟斤拷

//	// 锟斤拷锟斤拷Flash
//	HAL_FLASH_Unlock();

//	// 锟斤拷锟斤拷锟街疚
//	__HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR |
//						   FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR | FLASH_FLAG_PGSERR);

//	// step 1 : 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷莩锟斤拷锟 锟侥革拷锟街斤拷 时,锟斤拷锟叫断碉拷址锟角凤拷锟斤拷 4锟斤拷锟斤拷锟斤拷锟斤拷,锟斤拷锟角的伙拷锟斤拷锟斤拷 Byte锟侥凤拷式 写锟诫补锟斤拷
//	if (dataLengthWord)
//	{
//		// 锟叫断碉拷址锟角凤拷锟斤拷 4 锟斤拷锟斤拷锟斤拷锟斤拷
//		if (writeAddress % 4) // 锟斤拷址锟斤拷锟杰憋拷 4 锟斤拷锟斤拷
//		{
//			dataLen = dataLen - 4 + (writeAddress % 4); // 锟斤拷锟斤拷锟斤拷锟捷筹拷锟斤拷
//			writeByteCount = 4 - (writeAddress % 4);	// 锟斤拷锟揭达拷锟侥碉拷锟街斤拷锟斤拷
//			dataLengthWord = dataLen / 4;				// 锟斤拷锟斤拷 dataLengthWord

//			for (i = 0; i < writeByteCount; i++)
//			{
//				// 锟斤拷锟斤拷写锟斤拷一锟斤拷锟斤拷锟斤拷
//				if (HAL_FLASH_Program(TYPEPROGRAM_BYTE, writeAddress, *(uint8_t *)(Data + i)) == HAL_OK)
//				{
//					// 写锟斤拷之锟斤拷锟饺lash 锟斤拷值锟斤拷锟斤拷锟斤拷锟斤拷斜冉锟,锟叫讹拷锟角凤拷写锟斤拷晒锟
//					if (*(uint8_t *)writeAddress != *(uint8_t *)(Data + i))
//					{
//						ret = 1;
//						goto out;
//					}
//					writeAddress += 1;
//				}
//				else
//				{
//					ret = 2;
//					goto out;
//				}
//			}
//		}
//	}

//	// step 2 : 锟斤拷 Word 锟斤拷式写锟斤拷剩锟斤拷锟斤拷锟斤拷
//	for (i = 0; (i < dataLengthWord) && (writeAddress <= (FLASH_END_ADDRESS - 4)); i++)
//	{
//		// 一锟斤拷写锟斤拷锟侥革拷锟街节碉拷锟斤拷锟斤拷
//		if (HAL_FLASH_Program(TYPEPROGRAM_WORD, writeAddress, *(uint32_t *)(Data + 4 * i + writeByteCount)) == HAL_OK)
//		{
//			// 校锟斤拷写锟斤拷锟街
//			if (*(uint32_t *)writeAddress != *(uint32_t *)(Data + 4 * i + writeByteCount))
//			{
//				// Flash 锟斤拷锟斤拷锟斤拷 SRAM 锟斤拷锟捷诧拷匹锟斤拷
//				ret = 3;
//				goto out;
//			}
//			// 锟斤拷锟斤拷写锟斤拷锟街
//			writeAddress += 4;
//		}
//		else
//		{
//			// 锟斤拷Flash锟节达拷写锟斤拷锟斤拷锟斤拷时锟斤拷锟斤拷锟斤拷锟斤拷
//			ret = 4;
//			goto out;
//		}
//	}

//	// step 3 : 锟斤拷 Byte 锟斤拷式写锟斤拷剩锟斤拷锟斤拷锟斤拷
//	for (i = 0; i < dataLen % 4; i++)
//	{
//		// 锟斤拷锟斤拷写锟斤拷一锟斤拷锟街节碉拷锟斤拷锟斤拷
//		if (HAL_FLASH_Program(TYPEPROGRAM_BYTE, writeAddress,
//							  *(uint8_t *)(Data + writeAddress - FlashAddress)) == HAL_OK)
//		{
//			if (*(uint8_t *)writeAddress != *(uint8_t *)(Data + writeAddress - FlashAddress))
//			{
//				ret = 1;
//				goto out;
//			}
//			writeAddress += 1;
//		}
//		else
//		{
//			ret = 2;
//			goto out;
//		}
//	}
//	ret = 0;
//out:
//	// 锟斤拷锟斤拷Flash
//	HAL_FLASH_Lock();

//	return ret;
//}