1、RTC 配置
调一个 RTC，刚开始运行都正常，设置的时间跟读出的时间一样。但是换了一个芯片出现读出的年不对的情况，调试才发现是RTC设置的时候有些参数漏掉没填导致的。
T_S32 DRIVER_RTC_Ioctl(T_S32 s32Cmd, T_VOID *pvData)
{
switch(s32Cmd)
{
case E_RTC_IOCTL_CMD_SET_WAKE_INT:
{
//T_U16 u16Cnt = *((T_U16 *)pvData);
}
break;
case E_RTC_IOCTL_CMD_READ_TIME:
{
S_RtcIoctlRead *pstTime = (S_RtcIoctlRead *)pvData;
RTC_DateTypeDef stDate;
RTC_TimeTypeDef stTime;
HAL_RTC_GetTime(&RtcHandle, &stTime, RTC_FORMAT_BCD);
HAL_RTC_GetDate(&RtcHandle, &stDate, RTC_FORMAT_BCD);
pstTime->u8Year = stDate.Year;
pstTime->u8Month = stDate.Month;
pstTime->u8Date = stDate.Date;
pstTime->u8WeekDay = stDate.WeekDay;
pstTime->u8Hours = stTime.Hours;
pstTime->u8Minutes = stTime.Minutes;
pstTime->u8Seconds = stTime.Seconds;
}
break;
case E_RTC_IOCTL_CMD_WRITE_TIME:
{
S_RtcIoctlWrite *pstTime = (S_RtcIoctlWrite *)pvData;
RTC_DateTypeDef stDate;
RTC_TimeTypeDef stTime;
stDate.Year = pstTime->u8Year;
stDate.Month = pstTime->u8Month;
stDate.Date = pstTime->u8Date;
stDate.WeekDay = 0x01; //这个参数要设置下 避免不在 1-7的范围里面
stTime.Hours = pstTime->u8Hours;
stTime.Minutes = pstTime->u8Minutes;
stTime.Seconds = pstTime->u8Seconds;
stTime.DayLightSaving = RTC_DAYLIGHTSAVING_NONE; //这个参数要设置下
stTime.StoreOperation = RTC_STOREOPERATION_RESET; //这个参数要设置下
HAL_RTC_SetTime(&RtcHandle, &stTime, RTC_FORMAT_BCD);
HAL_RTC_SetDate(&RtcHandle, &stDate, RTC_FORMAT_BCD);
}
break;
}
return RET_SUCCESS;
}
2、休眠启动
外设休眠后，启动时重新配置下
3、STM32F0系列 二级引导注意事项
STM32F0系列是M0的内核，没有VTOR的寄存器，所以在应用程序里面的配置还有些不一样
1）引导程序的KEIL配置
2）引导程序代码
/*********************************************
* @Îļþ: main.c
* @×÷Õß: cjx
* @°æ±¾: v1.0.0
* @ʱ¼ä: 2018-06-22
* @µç»°: 18770053277
* @¸ÅÒª:
*********************************************/
#include "ioctrl.h"
//Soft Update Explain
#define BOOT_SOFT_ADDR 0x08000000
#define APP_RUN_ADDR 0x08004000
#define FACTORY_BIN_ADDR 0x0800E800
#define VER_INFO_ADDR 0x0801B000
#define USER_INFO_ADDR 0x0801B800
#define EXT_APP_BIN_ADDR 0x00002000
#define APP_BIN_SIZE (50*1024)
#define FACTORY_VER 1
#define VER_FLAG_NULL 0
#define VER_FLAG_FACTORY 1
#define VER_FLAG_EXT 2
typedef struct{
T_U32 u32Ver;
T_U32 u32Flag;
}S_VerInfo;
S_VerInfo g_VerInfo;
S_FlashRead g_FlashRead;
S_FlashWrite g_FlashWrite;
S_FlashErase g_FlashErase;
S_ExtFlashRead g_ExtFlashRead;
S_ExtFlashWrite g_ExtFlashWrite;
S_ExtFlashErase g_ExtFlashErase;
T_U8 g_u8Cache[2*1024];
void UpdateFromFactory(void)
{
T_U32 u32i = 0;
//g_FlashErase.u32Addr = APP_RUN_ADDR;
//g_FlashErase.u32Pages = 18;//APP_BIN_SIZE/FLASH_PAGE_SIZE;
//DRIVER_FLASH_Ioctl(E_FLASH_IOCTL_CMD_ERASE, (T_VOID *)&g_FlashErase);
print_msg("\nErase_Okay!\n");
for(u32i = 0; u32i < (36*1024); u32i += sizeof(g_u8Cache))
{
g_FlashRead.u32Addr = FACTORY_BIN_ADDR + u32i;
g_FlashRead.pu8Data = (T_U8 *)g_u8Cache;
g_FlashRead.u32Len = sizeof(g_u8Cache);
DRIVER_FLASH_Ioctl(E_FLASH_IOCTL_CMD_READ, (T_VOID *)&g_FlashRead);
g_FlashErase.u32Addr = APP_RUN_ADDR + u32i;;
g_FlashErase.u32Pages = 1;
DRIVER_FLASH_Ioctl(E_FLASH_IOCTL_CMD_ERASE, (T_VOID *)&g_FlashErase);
g_FlashWrite.u32Addr = APP_RUN_ADDR + u32i;
g_FlashWrite.pu8Data = (T_U8 *)&g_u8Cache;
g_FlashWrite.u32Len = sizeof(g_u8Cache);
DRIVER_FLASH_Ioctl(E_FLASH_IOCTL_CMD_WRITE, (T_VOID *)&g_FlashWrite);
}
print_msg("\nCopy_Factory_Okay!\n");
g_FlashErase.u32Addr = VER_INFO_ADDR;
g_FlashErase.u32Pages = 1;
DRIVER_FLASH_Ioctl(E_FLASH_IOCTL_CMD_ERASE, (T_VOID *)&g_FlashErase);
g_VerInfo.u32Ver = FACTORY_VER;
g_VerInfo.u32Flag = VER_FLAG_NULL;
g_FlashWrite.u32Addr = VER_INFO_ADDR;
g_FlashWrite.pu8Data = (T_U8 *)&g_VerInfo;
g_FlashWrite.u32Len = sizeof(g_VerInfo);
DRIVER_FLASH_Ioctl(E_FLASH_IOCTL_CMD_WRITE, (T_VOID *)&g_FlashWrite);
print_msg("\nVer_Info_Write_Okay!\n");
}
void UpdateFromExtFlash(void)
{
T_U32 u32i = 0;
g_FlashErase.u32Addr = APP_RUN_ADDR;
g_FlashErase.u32Pages = APP_BIN_SIZE/FLASH_PAGE_SIZE;
DRIVER_FLASH_Ioctl(E_FLASH_IOCTL_CMD_ERASE, (T_VOID *)&g_FlashWrite);
for(u32i = 0; u32i < APP_BIN_SIZE; u32i += sizeof(g_u8Cache))
{
g_ExtFlashRead.u32Addr = EXT_APP_BIN_ADDR + u32i;
g_ExtFlashRead.pu8Data = (T_U8 *)g_u8Cache;
g_ExtFlashRead.u32Len = sizeof(g_u8Cache);
DRIVER_FLASH_Ioctl(E_FLASH_IOCTL_CMD_READ, (T_VOID *)&g_ExtFlashRead);
g_FlashWrite.u32Addr = APP_RUN_ADDR + u32i;
g_FlashWrite.pu8Data = (T_U8 *)&g_u8Cache;
g_FlashWrite.u32Len = sizeof(g_u8Cache);
DRIVER_FLASH_Ioctl(E_FLASH_IOCTL_CMD_WRITE, (T_VOID *)&g_FlashWrite);
}
g_FlashRead.u32Addr = VER_INFO_ADDR;
g_FlashRead.pu8Data = (T_U8 *)&g_VerInfo;
g_FlashRead.u32Len = sizeof(g_VerInfo);
DRIVER_FLASH_Ioctl(E_FLASH_IOCTL_CMD_READ, (T_VOID *)&g_FlashRead);
//g_VerInfo.u32Ver = FACTORY_VER;
g_VerInfo.u32Flag = VER_FLAG_NULL;
g_FlashWrite.u32Addr = VER_INFO_ADDR;
g_FlashWrite.pu8Data = (T_U8 *)&g_VerInfo;
g_FlashWrite.u32Len = sizeof(g_VerInfo);
DRIVER_FLASH_Ioctl(E_FLASH_IOCTL_CMD_WRITE, (T_VOID *)&g_FlashWrite);
}
typedef void (*pFunction)(void);
void Jump_Address(void)
{
if (((*(volatile u32*)APP_RUN_ADDR) & 0x2FFE0000 ) == 0x20000000)
{
T_U32 test,JumpAddress;
pFunction Jump_To_Application;
test = (*(volatile u32*)APP_RUN_ADDR);
JumpAddress = *(volatile u32*) (APP_RUN_ADDR + 4);
Jump_To_Application = (pFunction) JumpAddress;
print_msg("\nGoto_App!=0x%4x\n", JumpAddress);
__set_MSP(*(volatile u32*) APP_RUN_ADDR);
Jump_To_Application();
print_msg("\nNULL\n");
}
}
int main(void)
{
DRIVER_SYS_Open();
DRIVER_FLASH_Open();
DRIVER_EXTFLASH_Open();
DRIVER_SYS_EnableInterrupt();
//while(1);
T_U32 u32Delay = 1000000;
while(u32Delay--);
g_FlashRead.u32Addr = VER_INFO_ADDR;
g_FlashRead.pu8Data = (T_U8 *)&g_VerInfo;
g_FlashRead.u32Len = sizeof(g_VerInfo);
DRIVER_FLASH_Ioctl(E_FLASH_IOCTL_CMD_READ, (T_VOID *)&g_FlashRead);
print_msg("\nBoot_Start!\n");
if(100 == g_VerInfo.u32Flag){
}else if(VER_FLAG_FACTORY == g_VerInfo.u32Flag){
UpdateFromFactory();
}else if(VER_FLAG_EXT == g_VerInfo.u32Flag){
UpdateFromExtFlash();
}else{
UpdateFromFactory();
}
Jump_Address();
while(1);
return 0;
}
3）应用程序的配置
这里机的把RAM编译的起始地址也改下，预留前面一段用来存中断向量地址
4）应用程序代码
/*********************************************
* @Îļþ: main.c
* @×÷Õß: cjx
* @°æ±¾: v1.0.0
* @ʱ¼ä: 2018-06-22
* @µç»°: 18770053277
* @¸ÅÒª:
*********************************************/
#include "apll.h"
#include "ioctrl.h"
int main(void)
{
memcpy((uint32_t*)0x20000000, (uint32_t*)0x08004000, 48*4);
RCC->APB2ENR |= RCC_APB2ENR_SYSCFGEN;
uint32_t tmpctrl;
tmpctrl = SYSCFG->CFGR1;
tmpctrl &= (uint32_t) (~SYSCFG_CFGR1_MEM_MODE);
tmpctrl |= (uint32_t) 0x03;
SYSCFG->CFGR1 |= tmpctrl;
T_VOID *pvAllHandle = T_NULL;
if(RET_SUCCESS != ALL_Init(&pvAllHandle))
{
return -1;
}
ALL_Run(pvAllHandle);
ALL_DeInit(pvAllHandle);
}
5）Keil生成bin
fromelf.exe --bin -o "$L@L.bin" "#L"
6）bin合并工具
7）合并
4、基于xmodem协议的串口升级代码
1）main.c
*********************************************
* @文件: main.c
* @作者: cjx
* @版本: v1.0.0
* @时间: 2018-06-22
* @电话: 18770053277
* @概要:
*********************************************/
#include "ioctrl.h"
#include "xmodem.h"
//Soft Update Explain
#define BOOT_RUN_ADDR 0x08000000 //引导代码地址
#define APP_RUN_ADDR 0x08002800 //程序运行地址
#define OTA_STORE_ADDR 0x0800D800 //升级固件存储地址
#define VER_INFO_ADDR 0x0801B000 //信息存储地址
#define APP_BIN_SIZE (44*1024)
#define VER_INFO_RENEW_FLG 0xF4F3F2F1
#define VER_INFO_NO_RENEW_FLG 0xF1F2F3F4
typedef struct{
T_U32 u32Flg; //VER_INFO_FLG
T_U32 u32Ver;
T_U32 u32Addr;
}S_VerInfo;
S_VerInfo g_VerInfo;
S_FlashRead g_FlashRead;
S_FlashWrite g_FlashWrite;
S_FlashErase g_FlashErase;
T_U8 g_u8Cache[FALSH_BLOCK_SIZE];
typedef void (*pFunction)(void);
void Jump_Address(unsigned int addr)
{
if (((*(volatile u32*)addr) & 0x2FFE0000 ) == 0x20000000)
{
unsigned int JumpAddress;
pFunction Jump_To_Application;
JumpAddress = *(volatile T_U32 *) (addr + 4);
Jump_To_Application = (pFunction) JumpAddress;
printf("\r\nGoto App=0x%4x!\r\n", (unsigned int)JumpAddress);
__set_MSP(*(volatile u32*) addr);
Jump_To_Application();
printf("\r\nGoto App Fail!\r\n");
}
}
void UpdateVerInfo(T_U32 u32Flg, T_U32 u32Ver)
{
g_FlashErase.u32Addr = VER_INFO_ADDR;
g_FlashErase.u32Pages = 1;
DRIVER_FLASH_Ioctl(E_FLASH_IOCTL_CMD_ERASE, (T_VOID *)&g_FlashErase);
g_VerInfo.u32Ver = u32Ver;
g_VerInfo.u32Flg = u32Flg;
g_VerInfo.u32Addr = APP_RUN_ADDR;
g_FlashWrite.u32Addr = VER_INFO_ADDR;
g_FlashWrite.pu8Data = (T_U8 *)&g_VerInfo;
g_FlashWrite.u32Len = sizeof(g_VerInfo);
DRIVER_FLASH_Ioctl(E_FLASH_IOCTL_CMD_WRITE, (T_VOID *)&g_FlashWrite);
}
void UpdateFromOTA(void)
{
T_U32 u32i = 0;
//g_FlashErase.u32Addr = APP_RUN_ADDR;
//g_FlashErase.u32Pages = (APP_BIN_SIZE/FALSH_BLOCK_SIZE);
//DRIVER_FLASH_Ioctl(E_FLASH_IOCTL_CMD_ERASE, (T_VOID *)&g_FlashErase);
//print_msg("\nErase_Okay!\n");
for(u32i = 0; u32i < APP_BIN_SIZE; u32i += FALSH_BLOCK_SIZE)
{
g_FlashRead.u32Addr = OTA_STORE_ADDR + u32i;
g_FlashRead.pu8Data = (T_U8 *)g_u8Cache;
g_FlashRead.u32Len = FALSH_BLOCK_SIZE;
DRIVER_FLASH_Ioctl(E_FLASH_IOCTL_CMD_READ, (T_VOID *)&g_FlashRead);
g_FlashErase.u32Addr = APP_RUN_ADDR + u32i;
g_FlashErase.u32Pages = 1;
DRIVER_FLASH_Ioctl(E_FLASH_IOCTL_CMD_ERASE, (T_VOID *)&g_FlashErase);
g_FlashWrite.u32Addr = APP_RUN_ADDR + u32i;
g_FlashWrite.pu8Data = (T_U8 *)&g_u8Cache;
g_FlashWrite.u32Len = FALSH_BLOCK_SIZE;
DRIVER_FLASH_Ioctl(E_FLASH_IOCTL_CMD_WRITE, (T_VOID *)&g_FlashWrite);
}
printf("\r\nCopy OTA Okay!\r\n");
UpdateVerInfo(VER_INFO_NO_RENEW_FLG, 1);
printf("\r\nVer Info Write Okay!\r\n");
}
void EraseOTA(void)
{
T_U32 u32i = 0;
for(u32i = 0; u32i < APP_BIN_SIZE; u32i += FALSH_BLOCK_SIZE)
{
g_FlashErase.u32Addr = OTA_STORE_ADDR + u32i;
g_FlashErase.u32Pages = 1;
DRIVER_FLASH_Ioctl(E_FLASH_IOCTL_CMD_ERASE, (T_VOID *)&g_FlashErase);
}
}
int main(void)
{
char RxData;
char RxBuf[10];
unsigned char RxCnt = 0;
unsigned int nowTick = 0, oldTick = 0;
DRIVER_SYS_Open();
DRIVER_FLASH_Open();
DRIVER_UART_Open();
DRIVER_SYS_EnableInterrupt();
printf("\r\nBOOT RUN ADDR=0x%4x!\r\n", (unsigned int)BOOT_RUN_ADDR);
printf("\r\nAPP RUN ADDR=0x%4x!\r\n", (unsigned int)APP_RUN_ADDR);
printf("\r\nOTA STORE ADDR=0x%4x!\r\n", (unsigned int)OTA_STORE_ADDR);
printf("\r\nVER INFO ADDR=0x%4x!\r\n", (unsigned int)VER_INFO_ADDR);
printf("\r\nPlease Input 666 Into Update, Wait 3S!\r\n");
oldTick = HAL_GetTick();
while(1)
{
if(UART_RevByteNoClog((unsigned char*)&RxData))
{
RxBuf[RxCnt++] = RxData;
if(RxCnt >= 3)
{
if(0 == memcmp(RxBuf, "666", 3))
{
EraseOTA();
printf("\r\nInto Update!\r\n");
if(1 == xmodem(OTA_STORE_ADDR, OTA_STORE_ADDR+APP_BIN_SIZE))
{
UpdateVerInfo(VER_INFO_RENEW_FLG, 1);
}
break;
}
}
}
nowTick = HAL_GetTick();
if(nowTick > oldTick + 3000)
{
break;
}
}
g_FlashRead.u32Addr = VER_INFO_ADDR;
g_FlashRead.pu8Data = (T_U8 *)&g_VerInfo;
g_FlashRead.u32Len = sizeof(g_VerInfo);
DRIVER_FLASH_Ioctl(E_FLASH_IOCTL_CMD_READ, (T_VOID *)&g_FlashRead);
if(VER_INFO_RENEW_FLG == g_VerInfo.u32Flg)
{
UpdateFromOTA();
Jump_Address(APP_RUN_ADDR);
}else if(VER_INFO_NO_RENEW_FLG == g_VerInfo.u32Flg)
{
Jump_Address(APP_RUN_ADDR);
}
printf("\r\nNo App!\r\n");
//while(1);
return 0;
}
2) xmodem.c
#include <stdio.h>
#include "ioctrl.h"
#include "xmodem.h"
#define xputc(data) UART_SendByte(data)
#define xgetc() UART_RevByte()
#define xkbhit(data) UART_RevByteNoClog(data)
static unsigned int gRawBuf[2][sizeof(XMODEM_PACKET_TYPE)>>2];
static unsigned short CRC16E(unsigned char *lpBuf, unsigned short n)
{
unsigned short crc = 0x0;
unsigned short i;
for (i = 0; i < n; i++)
{
crc = (crc >> 8) | (crc << 8);
crc ^= lpBuf[i];
crc ^= (crc & 0xff) >> 4;
crc ^= crc << 12;
crc ^= (crc & 0xff) << 5;
}
return crc;
}
static short XMODEM_Verify(XMODEM_PACKET_TYPE *Struct, unsigned char Reference)
{
if (Struct->Number == Reference)
{
unsigned short crc = (Struct->CRCH<<8)|Struct->CRCL;
if(crc == CRC16E(Struct->Data, XMODEM_DATA_SIZE))
{
return 0;
}
}
return -1;
}
static unsigned char XMODEM_Wait(void)
{
unsigned char firstData;
unsigned int i;
while (1)
{
xputc(XMODEM_NCG);
for (i = 0; i < 100000; i++)
{
if(xkbhit(&firstData))
{
return firstData;
}
}
}
return 0;
}
int xmodem(unsigned int Base, unsigned int End)
{
XMODEM_PACKET_TYPE *Struct;
unsigned int Addr, i;
unsigned char Sequence = 1;
unsigned char Flag = 0;
unsigned char waitReturn = 0;
Addr = Base;
waitReturn = XMODEM_Wait();
while (1)
{
// Swap buffer for packet buffer.
Struct = (XMODEM_PACKET_TYPE *)gRawBuf[Sequence & 1];
// Fetch the first byte of the packet explicitly, as it defines the
// rest of the packet.
if(Flag)
{
Struct->Header = xgetc();
}else
{
Struct->Header = waitReturn;
}
Flag = 1;
// Check for end of transfer.
if (Struct->Header == XMODEM_EOT)
{
// Acknowledget End of transfer.
xputc(XMODEM_ACK);
return 1;
}
// If the header is not a start of header (SOH), then cancel
// the transfer.
if (Struct->Header != XMODEM_SOH)
{
return -1;
}
// Fill the remaining bytes packet.
// Byte 0 is padding, byte 1 is header.
for (i = 2; i < sizeof(XMODEM_PACKET_TYPE); i++)
{
((unsigned char *)Struct)[i] = xgetc();
}
/* Packet Verify */
if(0 != XMODEM_Verify(Struct, Sequence))
{
// On a malformed packet, we send a NAK, and start over.
xputc(XMODEM_NAK);
return -1;
}
Sequence++;
// Write data to flash.
if(Addr < End)
{
//BSP_FlashWrite(Addr, Struct->Data, XMODEM_DATA_SIZE);
//memset(Struct->Data, 0x11, XMODEM_DATA_SIZE);
S_FlashWrite stFlashWrite;
stFlashWrite.u32Addr = Addr;
stFlashWrite.pu8Data = Struct->Data;
stFlashWrite.u32Len = XMODEM_DATA_SIZE;
if(RET_FAILED==DRIVER_FLASH_Ioctl(E_FLASH_IOCTL_CMD_WRITE, &stFlashWrite))
{
return -1;
}
Addr += XMODEM_DATA_SIZE;
}
// Send ACK.
xputc(XMODEM_ACK);
}
}
3)driverFlash.c
/*********************************************
* @文件: driverFlash.c
* @作者: cjx
* @版本: v1.0.1
* @时间: 2018-11-09
* @概要: Flash驱动
*********************************************/
#include "baseType.h"
#include "ioctrl.h"
#if(FLASH_TYPE == E_FLASH_TYPE_STM32)
T_VOID Flash_Delay(T_VOID)
{
T_U32 u32Delay = 100000;
while(u32Delay--);
}
T_VOID Flash_Init(T_VOID)
{
}
T_VOID Flash_Read(S_FlashRead *pst)
{
T_U32 u32i = 0;
for(u32i = 0; u32i < pst->u32Len; u32i++)
{
pst->pu8Data[u32i] = *(T_U8 *)(pst->u32Addr + u32i);
}
}
T_VOID Flash_Erase(S_FlashErase *pst)
{
T_U32 PageError = 0;
FLASH_EraseInitTypeDef EraseInitStruct;
EraseInitStruct.TypeErase = FLASH_TYPEERASE_PAGES;
EraseInitStruct.PageAddress = pst->u32Addr;
EraseInitStruct.NbPages = pst->u32Pages;
DRIVER_SYS_DisableInterrupt();
HAL_FLASH_Unlock();
if (HAL_FLASHEx_Erase(&EraseInitStruct, (uint32_t *)&PageError) != HAL_OK)
{
print_msg("\nerase_error!\n");
}
HAL_FLASH_Lock();
DRIVER_SYS_EnableInterrupt();
}
T_VOID Flash_Write(S_FlashWrite *pst)
{
T_U32 u32i = 0;
T_U32 *pu32WriteData = T_NULL;
DRIVER_SYS_DisableInterrupt();
HAL_FLASH_Unlock();
for(u32i = 0; u32i < pst->u32Len; u32i+=4)
{
pu32WriteData = (T_U32 *)&pst->pu8Data[u32i];
if(HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, pst->u32Addr+u32i, *pu32WriteData) != HAL_OK)
{
print_msg("\nwrite_error!\n");
}
}
HAL_FLASH_Lock();
DRIVER_SYS_EnableInterrupt();
#if 0
T_U32 u32i = 0;
T_U32 *pu32WriteData = T_NULL;
T_U32 PageError = 0;
FLASH_EraseInitTypeDef EraseInitStruct;
EraseInitStruct.TypeErase = FLASH_TYPEERASE_PAGES;
EraseInitStruct.PageAddress = pst->u32Addr;
EraseInitStruct.NbPages = 1+(pst->u32Len / FLASH_PAGE_SIZE);
DRIVER_SYS_DisableInterrupt();
HAL_FLASH_Unlock();
if (HAL_FLASHEx_Erase(&EraseInitStruct, (uint32_t *)&PageError) != HAL_OK)
{
print_msg("\nerase_error!\n");
}
for(u32i = 0; u32i < pst->u32Len; u32i+=4)
{
pu32WriteData = (T_U32 *)&pst->pu8Data[u32i];
if(HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, pst->u32Addr+u32i, *pu32WriteData) != HAL_OK)
{
print_msg("\nwrite_error!\n");
}
}
HAL_FLASH_Lock();
DRIVER_SYS_EnableInterrupt();
#endif
}
#endif
/********************************************
*功能：打开函数
*输入：无
*输出：无
*条件：无
*返回：成功:RET_SUCCESS
失败:RET_FAILED
注意:
*********************************************/
T_S32 DRIVER_FLASH_Open(T_VOID)
{
Flash_Init();
return RET_SUCCESS;
}
/********************************************
*功能：读取函数
*输入：输出数据 及 数据长度
*输出：无
*条件：无
*返回：成功:RET_SUCCESS
失败:RET_FAILED
或者长度
注意:
*********************************************/
T_S32 DRIVER_FLASH_Read(T_S8 *ps8DataBuf, T_S32 s32BufLen)
{
T_S32 s32DataLen = 0;
return s32DataLen;
}
/********************************************
*功能：事件标志
*输入：无
*输出：无
*条件：无
*返回：成功:RET_SUCCESS
失败:RET_FAILED
注意:
*********************************************/
T_S32 DRIVER_FLASH_Pop(T_VOID)
{
return RET_SUCCESS;
}
/********************************************
*功能：控制接口
*输入：s32Cmd :命令类型
pvData:控制数据或者返回
数据
*条件：无
*返回：成功:RET_SUCCESS
失败:RET_FAILED
*********************************************/
T_S32 DRIVER_FLASH_Ioctl(T_S32 s32Cmd, T_VOID *pvData)
{
T_S32 s32Ret = RET_SUCCESS;
switch(s32Cmd)
{
case E_FLASH_IOCTL_CMD_ERASE:
{
Flash_Erase((S_FlashErase *)pvData);
}
break;
case E_FLASH_IOCTL_CMD_WRITE:
{
Flash_Write((S_FlashWrite *)pvData);
}
break;
case E_FLASH_IOCTL_CMD_READ:
{
Flash_Read((S_FlashRead *)pvData);
}
break;
}
return s32Ret;
}
/********************************************
*功能：写入函数
*输入：无
*输出：无
*条件：无
*返回：成功:RET_SUCCESS
失败:RET_FAILED
或者长度
注意:
*********************************************/
T_S32 DRIVER_FLASH_Write(T_S8 *ps8DataBuf, T_S32 s32BufLen)
{
return s32BufLen;
}
4)driverUart.c
/*********************************************
* @文件: driverUart.c
* @作者: cjx
* @版本: v1.0.1
* @时间: 2020-0103-09
* @概要: Uart驱动
*********************************************/
#include "baseType.h"
#include "ioctrl.h"
#define UART_TX_PORT GPIOA
#define UART_TX_PIN GPIO_PIN_0
#define UART_RX_PORT GPIOA
#define UART_RX_PIN GPIO_PIN_1
#define UART_BAUD_RATE 115200
UART_HandleTypeDef g_UartHandle;
T_U8 g_u8UartRx = 0;
void UART_SendByte(unsigned char data)
{
unsigned char buf[1];
buf[0] = data;
HAL_UART_Transmit(&g_UartHandle, buf, 1, 5000);
}
unsigned char UART_RevByte(void)
{
unsigned char buf[1];
while(HAL_OK != HAL_UART_Receive(&g_UartHandle, buf, 1, 10000))
{
}
return buf[0];
}
unsigned char UART_RevStatus(void)
{
unsigned char buf[1];
if(HAL_OK == HAL_UART_Receive(&g_UartHandle, buf, 1, 10))
{
return 1;
}
return 0;
}
unsigned char UART_RevByteNoClog(unsigned char *Rx)
{
unsigned char buf[1];
if(HAL_OK == HAL_UART_Receive(&g_UartHandle, buf, 1, 0))
{
*Rx = buf[0];
return 1;
}
return 0;
}
int fputc(int ch, FILE *f)
{
unsigned char p[1];
p[0] = ch;
HAL_UART_Transmit(&g_UartHandle, (uint8_t*)p, 1, 5000);
return (ch);
}
T_VOID UART_Init(T_VOID)
{
GPIO_InitTypeDef GPIO_InitStruct;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF4_USART4;
GPIO_InitStruct.Pin = UART_TX_PIN;
HAL_GPIO_Init(UART_TX_PORT, &GPIO_InitStruct);
GPIO_InitStruct.Pin = UART_RX_PIN;
HAL_GPIO_Init(UART_RX_PORT, &GPIO_InitStruct);
g_UartHandle.Instance = USART4;
g_UartHandle.Init.BaudRate = UART_BAUD_RATE;
g_UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
g_UartHandle.Init.StopBits = UART_STOPBITS_1;
g_UartHandle.Init.Parity = UART_PARITY_NONE;
g_UartHandle.Init.HwFlowCtl = UART_HWCONTROL_NONE;
g_UartHandle.Init.Mode = UART_MODE_TX_RX;
g_UartHandle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
if(HAL_UART_DeInit(&g_UartHandle) != HAL_OK)
{
Error_Handler();
}
if(HAL_UART_Init(&g_UartHandle) != HAL_OK)
{
Error_Handler();
}
}
/********************************************
*功能：打开函数
*输入：无
*输出：无
*条件：无
*返回：成功:RET_SUCCESS
失败:RET_FAILED
注意:
*********************************************/
T_S32 DRIVER_UART_Open(T_VOID)
{
UART_Init();
return RET_SUCCESS;
}
/********************************************
*功能：读取函数
*输入：输出数据 及 数据长度
*输出：无
*条件：无
*返回：成功:RET_SUCCESS
失败:RET_FAILED
或者长度
注意:
*********************************************/
T_S32 DRIVER_UART_Read(T_S8 *ps8DataBuf, T_S32 s32BufLen)
{
T_S32 s32DataLen = 0;
return s32DataLen;
}
/********************************************
*功能：事件标志
*输入：无
*输出：无
*条件：无
*返回：成功:RET_SUCCESS
失败:RET_FAILED
注意:
*********************************************/
T_S32 DRIVER_UART_Pop(T_VOID)
{
return RET_SUCCESS;
}
/********************************************
*功能：控制接口
*输入：s32Cmd :命令类型
pvData:控制数据或者返回
数据
*条件：无
*返回：成功:RET_SUCCESS
失败:RET_FAILED
*********************************************/
T_S32 DRIVER_UART_Ioctl(T_S32 s32Cmd, T_VOID *pvData)
{
T_S32 s32Ret = RET_SUCCESS;
switch(s32Cmd)
{
}
return s32Ret;
}
/********************************************
*功能：写入函数
*输入：无
*输出：无
*条件：无
*返回：成功:RET_SUCCESS
失败:RET_FAILED
或者长度
注意:
*********************************************/
T_S32 DRIVER_UART_Write(T_S8 *ps8DataBuf, T_S32 s32BufLen)
{
return s32BufLen;
}
5）升级工具
Tera Term
扫一扫
1755
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
