心城追梦

STM32基于BootLoader进行网络远程更新程序

以前在学习STM32的时候，看到有的开发板用BootLoader下载程序，觉得脱离下载器程序下载进去挺有意思的，于是就自己琢磨着也做一个，采用RL-TCPnet实现网络通信，还涉及到RTX嵌入式操作系统（不用也行的，没多大必要，因为例程自带RTX所以我用了，注意用RTX前要用注册机添加RTX的注册码）。

一、BootLoader的作用

BootLoader也是一段程序，简单来说，就是运行应用程序之前，先运行BootLoader做一些必要的处理，再跳到应用程序去执行。对于咱今天要做的事情来说，就是通过局域网把程序下载到芯片里，实现远程升级。因为用下载器下载程序同样也是擦除Flash后把程序文件烧写进Flash，而STM32支持程序运行的时候擦写其他地方的Flash区域，所以可以实现下载功能。

二、Flash空间划分

我用的芯片是STM32F4系列的，有1M的Flash大小，准备划分为以下几个区域。

（1）BootLoader区（0x8000000~0x8020000）：128KB，放置BootLoader代码。

（2）Download区（0x8020000~0x8080000）：384KB，放置下载的文件，因为下载过程中可能中途断电或者出错，如果直接把下载过程中的数据覆盖到APP区会导致应用程序遭到损坏，Download区起到暂存文件的作用。

（3）APP区（0x8080000~0x80E0000）：384KB，放置要运行的应用程序，就是真正想跑的代码。

（4）Reserve区（0x80E0000~0x8100000）：128KB，预留一段空间供用户保存信息，可以当做EEPROM用，掉电数据不丢失。

区间的划分可以根据实际使用情况划分。

三、程序怎样从BootLoader跳转到APP

说再多不如直接上代码，把APP区的首地址传入就可以实现跳转了：

void(*Boot_Jump2App)();

//传入要跳转到的程序地址进行跳转
void Boot_LoadApp(DWORD dwAddr)
{
	BYTE i;

	//检查栈顶地址是否合法
	if (((*(vu32*)dwAddr) & 0x2FFE0000) == 0x20000000)	
	{
		//设置跳转地址
		Boot_Jump2App = (void(*)())*(vu32*)(dwAddr + 4);		
		//初始化APP堆栈指针(用户代码区的第一个字用于存放栈顶地址)
		__set_MSP(*(vu32*)dwAddr);
		//关闭所有中断
		for (i = 0; i < 8; i++)
		{
			NVIC->ICER[i] = 0xFFFFFFFF;	
			NVIC->ICPR[i] = 0xFFFFFFFF;	
		}
		//跳转到APP Code
		Boot_Jump2App();		
		//跳转之前用死循环卡住
		while (1);
	}
}

不知道大家会不会这样想，如果我又想从APP段跳回BootLoader，不想以断电的方式重新运行BootLoader下载程序，怎么做？我的想法是调用STM32的软件复位函数NVIC_SystemReset()。

__set_FAULTMASK(1);
NVIC_SystemReset();

为什么前面加了一句__set_FAULTMASK(1)，作用是关闭所有中断，这里有一个要注意的问题：如果只调用NVIC_SystemReset()，从SYSRESETREQ 被置为有效，到复位发生器执行复位命令，往往会有一个延时。在此延时期间，处理器仍然可以响应中断请求。但我们的本意往往是要程序执行到此为止，不要再做任何其它事情了。所以，最好在发出复位请求前，先把FAULTMASK 置位才万无一失。

四、BootLoader程序和APP程序的配置

BootLoader程序有一点要注意，要对应BootLoader区地址进行如下设置。

APP程序有三点要注意，（1）也要设置对应的开始地址和大小

（2）APP程序还要在程序一开始设置中断向量的偏移，就是程序一开始调用这样一条语句，0x80000是APP程序的起始偏移，根据实际情况填写。

NVIC_SetVectorTable(NVIC_VectTab_FLASH, 0x80000);

（3）要下载的文件不是Keil编译生成的Hex文件，而是bin文件，怎么生成呢？照着下面依葫芦画瓢就可以了。

就是加上这一句 E:/keil/ARM/ARMCC/bin/fromelf.exe --bin -o Flash/MC-IOV3248.bin Flash/Obj/output.axf

实际路径根据自己的情况修改。

四、程序实现流程

程序实现的大致流程如下图：

BootLoader初始化IP地址为192.168.1.41，根据需要设置了两个端口可以分别独立进行通信。第一个端口为5198，为程序下载端口；第二个端口为5199，为Debug端口，用来输出调试信息和Boot Debug模式下使用，当然这个端口也可以用STM32的串口来代替输出调试信息，因为接线繁琐，所以用了网络端口调试。

程序一开始创建4个任务如下：

int main (void) 
{
	
	bsp_Init();

	/* 创建启动任务 */
 	os_sys_init_user (AppTaskStart,              /* 任务函数 */
	                  4,                         /* 任务优先级 */
	                  &AppTaskStartStk,          /* 任务栈 */
	                  sizeof(AppTaskStartStk));  /* 任务栈大小，单位字节数 */
	while(1);
}

//启动任务，也是最高优先级任务，	创建任务 ,时间基准更新。
__task void AppTaskStart(void)
{
	//这里实现RL-TCPnet的时间基准更新。
	HandleTaskTCPMain = os_tsk_create_user(RL_TCPnet_timer_tick,
											4,
											&RL_TCPnet_timer_tick_stk,
											sizeof(RL_TCPnet_timer_tick_stk));

	//TCP数据收发处理任务
	HandleTaskTCPMain = os_tsk_create_user(AppTaskTCPMain,
											3,
											&AppTaskTCPMainStk,
											sizeof(AppTaskTCPMainStk));

	//用户任务
	HandleTaskUserIF = os_tsk_create_user(AppTaskUserIF,
											2,
											&AppTaskUserIFStk,
											sizeof(AppTaskUserIFStk));
		
	//LED闪烁任务
	HandleTaskTCPMain = os_tsk_create_user(led_bling_task,
											1,
											&led_bling_taskStk,
											sizeof(led_bling_taskStk));
	
    while(1)
	{
		os_dly_wait(1000);
    }
}

我们只关心TCP数据收发任务AppTaskTCPMain和用户任务AppTaskUserIF。

介绍这两个任务之前，先介绍一下程序里涉及到的几个结构体，首先是tyDownloadHead，就是下载bin文件之前要先发送含有特定格式的下载头，验证成功后才能进行程序下载，否则随便乱发了一些数据过来也当做文件数据的话就太不可靠了。

#define BYTE unsigned char
#define WORD unsigned short
#define DWORD unsigned int

#define DOWNLOAD_HEAD_FLAG			0x55591012

typedef struct
{
	DWORD dwStructFLag;						//识别头 
	DWORD dwStructFLagInverse;              //识别头反码
	BYTE  bFileType;						//文件类型，0：APP程序，1：BootLoader程序
	BYTE  bReserve[3];						//预留，四字节对齐
	DWORD dwFileLen;						//下载文件大小
	DWORD dwFileCRC;						//文件数据校验
	DWORD dwStructCRC;						//结构体校验
}tyDownloadHead;

还有就是tyBoot结构体，就是控制流程运行的一些变量。

#define BOOT_STATE_DISCONNECT  	        0  //未连接
#define BOOT_STATE_IDL				    1  //空闲
#define BOOT_STATE_DEBUG			    2  //Debug模式
#define BOOT_STATE_DOWNLOADING	        3  //下载模式

typedef struct
{
	BYTE bBootState;          //连接状态
	BYTE bIsNeedSelCmd;
	BYTE bSelCmdNum;
	DWORD dwDownloadLen;
	DWORD dwRecFileLen;
	DWORD dwFileCRC;
}tyBoot;

最后一个是socketNature_t，是对TCP收发数据的控制。

typedef struct{
	U8 *recvBuf;  // 接收数据缓存
	U8 *sendBuf;  // 发送数据缓存
	U16 port;     // 套接字端口
	U8 id;        // 套接字id
	U8 recvFlag;  // 接收到数据的标志：0空闲，1有数据，2正在处理
	U8 recvLen;   // 接收到数据的长度
	U8 sendFlag;  // 待发送标志
	U8 sendLen;   // 要发送的长度
} socketNature_t; // 套接字描述结构

TCP数据收发任务只调用了下面这个函数，完成下载端口和Debug端口的创建，随后不断的侦测是否有数据需要收发，至于RL-TCPnet的具体使用设置网上资料很多，就不解释了。

void TCPnetTest(void)
{
	static U8 socket_pc_recvBuf[256];
	static U8 socket_pc_sendBuf[256];
	static U8 socket_debug_recvBuf[256];
	static U8 socket_debug_sendBuf[256];

	//创建TCP Socket并创建监听
	socket_pc.port = 5198;
	socket_pc.recvBuf = socket_pc_recvBuf;
	socket_pc.sendBuf = socket_pc_sendBuf;
	socket_pc.id = tcp_get_socket(TCP_TYPE_SERVER | TCP_TYPE_KEEP_ALIVE, 0, 10, socket_callback);
	if(socket_pc.id!=0)
	{
		tcp_listen(socket_pc.id,socket_pc.port);
	}
	
	//创建TCP Socket并创建监听
	socket_debug.port = 5199;
	socket_debug.recvBuf = socket_debug_recvBuf;
	socket_debug.sendBuf = socket_debug_sendBuf;
	socket_debug.id = tcp_get_socket(TCP_TYPE_SERVER | TCP_TYPE_KEEP_ALIVE, 0, 10, socket_callback);
	if(socket_debug.id != 0)
	{
		tcp_listen(socket_debug.id,socket_debug.port);
	}

	while (1) 
	{
		main_TcpNet();/* RL-TCPnet处理函数 */
		send_poll(&socket_pc);
		send_poll(&socket_debug);
		os_dly_wait (2);
	}
}

同样这一堆代码我们只关心socket_callback这个回调函数和send_poll这个发送数据函数。

（1）socket_callback函数如下

U16 socket_callback (U8 soc, U8 evt, U8 *ptr, U16 par)
{
	switch (evt) 
	{
		//远程客户端连接消息
		//1、数组ptr存储远程设备的IP地址，par中存储端口号。
		//2、返回数值1允许连接，返回数值0禁止连接。
		case TCP_EVT_CONREQ:return (1);
		case TCP_EVT_ABORT:break;/* 连接终止 */
		case TCP_EVT_CONNECT:
			if (soc == socket_pc.id)
			{
				tBoot.bBootState = BOOT_STATE_IDL;
			}
		
			if (soc == socket_debug.id)
			{
				tBoot.bBootState = BOOT_STATE_DEBUG;
			}
			
			break;/* Socket远程连接已经建立 */
		case TCP_EVT_CLOSE:break;/* 连接断开 */
		case TCP_EVT_ACK:break;/* 发送的数据收到远程设备应答 */
		case TCP_EVT_DATA:/* 接收到TCP数据帧，ptr指向数据地址，par记录数据长度，单位字节 */
			if (soc == socket_debug.id)
			{
				socket_debug.recvLen = par;
				memcpy(socket_debug.recvBuf, ptr, socket_debug.recvLen);
				socket_debug.recvFlag = 1;

				socket_debug.sendLen = par;
				memcpy(socket_debug.sendBuf, ptr, socket_debug.sendLen);
				socket_debug.sendFlag = 1;
			}
			else if (soc == socket_pc.id)
			{
				switch (tBoot.bBootState)
				{
					case BOOT_STATE_IDL:
						if (DOWNLOAD_HEAD_FLAG == ((tyDownloadHead *)ptr)->dwStructFLag)
						{
							if (sizeof(tyDownloadHead) == par &&
								~DOWNLOAD_HEAD_FLAG == ((tyDownloadHead *)ptr)->dwStructFLagInverse &&
								CalculateCRC((DWORD *)ptr, sizeof(tyDownloadHead) - 4, 0) == ((tyDownloadHead *)ptr)->dwStructCRC)
							{
								tBoot.dwRecFileLen = ((tyDownloadHead *)ptr)->dwFileLen;
								tBoot.dwDownloadLen = 0;
								tBoot.dwFileCRC = ((tyDownloadHead *)ptr)->dwFileCRC;
								tBoot.bBootState = BOOT_STATE_DOWNLOADING;
							}
						}

						break;

					case BOOT_STATE_DOWNLOADING:
						socket_pc.recvLen = par;
						memcpy(socket_pc.recvBuf, ptr, socket_pc.recvLen);
						socket_pc.recvFlag = 1;

						socket_pc.sendLen = socket_pc.recvLen;
						memcpy(socket_pc.sendBuf, ptr, socket_pc.sendLen);
						socket_pc.sendFlag = 1;

						STMFLASH_Write(DOWNLOAD_ADDR + tBoot.dwDownloadLen, (DWORD *)socket_pc.recvBuf, socket_pc.recvLen / 4);
						tBoot.dwDownloadLen += socket_pc.recvLen;

						if (tBoot.dwDownloadLen >= tBoot.dwRecFileLen)
						{
							tBoot.bBootState = BOOT_STATE_IDL;
						}
						break;

					default:
						break;
				}

			}
			break;
	}
	return (0);
}

这段代码完成对数据的接收，同时对下载头进行校验，校验成功后转到下载模式接收文件。

（2）send_poll函数

void send_poll(socketNature_t *socket){
	switch (tcp_get_state(socket->id))/* 用于网线插拔的处理 */
	{
		case TCP_STATE_FREE:
		case TCP_STATE_CLOSED:
			tcp_listen (socket->id,socket->port);//网络断开边接后，开始监听
			return;
		case TCP_STATE_LISTEN://处于监听时不发送
		default:
			socket->sendFlag=0;
			return;
		case TCP_STATE_CONNECT://处于连接状态
			break;
	}
	if(socket->sendFlag)
	{
		U8 *sendbuf;
		S32 iCount;
		U16 maxlen;
		socket->sendFlag=0;
		iCount = socket->sendLen;
		do{
			main_TcpNet();
			if (tcp_check_send(socket->id) == __TRUE)
			{
				maxlen = tcp_max_dsize (socket->id);
				iCount -= maxlen;

				if(iCount < 0)
				{
					maxlen = iCount + maxlen;/* 这么计算没问题的 */
				}
				sendbuf = tcp_get_buf(maxlen);
				memcpy(sendbuf,socket->sendBuf,maxlen);
				tcp_send (socket->id, sendbuf, maxlen);/* 测试发现只能使用获取的内存 */

			}
		}while(iCount > 0);
	}
}

纯粹就是发送TCP数据而已，当哪个port的sendBuf里有数据，就发出去。

下面贴出所有文件的实现代码：

（1）main.c

#include "includes.h"
#include "includeAll.H"
#include "bsp.h"
#include "bootLoader.h"

__task void AppTaskStart(void);
__task void RL_TCPnet_timer_tick(void);
__task void AppTaskTCPMain(void);
__task void AppTaskUserIF(void);
__task void led_bling_task(void);

/* 任务栈 */
static uint64_t AppTaskStartStk[1024/8];
static uint64_t RL_TCPnet_timer_tick_stk[1028/8];
static uint64_t AppTaskTCPMainStk[2048/8];
static uint64_t AppTaskUserIFStk[2028/8];
static uint64_t led_bling_taskStk[2028/8];

/* 任务句柄 */
OS_TID HandleTaskUserIF = NULL;
OS_TID HandleTaskTCPMain = NULL;

//IP地址等设置
LOCALM ip_config = {
	{ 192, 168, 1, 41 },             // IP address
	{ 192, 168, 1, 1 },               // Default Gateway
	{ 255, 255, 255, 0 },             // Net mask
	{ 194, 25, 2, 129 },              // Primary DNS server
	{ 194, 25, 2, 130 }               // Secondary DNS server
};

int main (void) 
{
	、、NVIC_SetVectorTable(NVIC_VectTab_FLASH, 0x80000);
	
	bsp_Init();

	/* 创建启动任务 */
 	os_sys_init_user (AppTaskStart,              /* 任务函数 */
	                  4,                         /* 任务优先级 */
	                  &AppTaskStartStk,          /* 任务栈 */
	                  sizeof(AppTaskStartStk));  /* 任务栈大小，单位字节数 */
	while(1);
}

//启动任务，也是最高优先级任务，	创建任务 ,时间基准更新。
__task void AppTaskStart(void)
{
	//这里实现RL-TCPnet的时间基准更新。
	HandleTaskTCPMain = os_tsk_create_user(RL_TCPnet_timer_tick,
											4,
											&RL_TCPnet_timer_tick_stk,
											sizeof(RL_TCPnet_timer_tick_stk));

	//TCP数据收发处理任务
	HandleTaskTCPMain = os_tsk_create_user(AppTaskTCPMain,
											3,
											&AppTaskTCPMainStk,
											sizeof(AppTaskTCPMainStk));

	//用户任务
	HandleTaskUserIF = os_tsk_create_user(AppTaskUserIF,
											2,
											&AppTaskUserIFStk,
											sizeof(AppTaskUserIFStk));
		
	//LED闪烁任务
	HandleTaskTCPMain = os_tsk_create_user(led_bling_task,
											1,
											&led_bling_taskStk,
											sizeof(led_bling_taskStk));
	
    while(1)
	{
		os_dly_wait(1000);
    }
}

//这里实现RL-TCPnet的时间基准更新。
__task void RL_TCPnet_timer_tick(void)
{
	U32 CpuID[3];
	U8 mac_adr[6] = { 0, 1, 2, 50, 60, 70 };
	extern U8 own_hw_adr[];
	extern U8 lhost_name[];
	extern LOCALM localm[];
		
	//根据CPU唯一ID设置MAC地址
	//CpuID[0]=*(vu32*)(0x1ffff7e8);//获取CPU唯一ID（F1的）
	//CpuID[1]=*(vu32*)(0x1ffff7ec);
	//CpuID[2]=*(vu32*)(0x1ffff7f0);
	CpuID[0]=*(vu32*)(0x1FFF7A10);//获取CPU唯一ID（F4的）
	CpuID[1]=*(vu32*)(0x1FFF7A10 + 4);
	CpuID[2]=*(vu32*)(0x1FFF7A10 + 8);
	mac_adr[0] = (u8)((CpuID[1] & 0x00FF0000)>>16);
	mac_adr[1] = (u8)((CpuID[1] & 0xFF000000)>>24);
	mac_adr[2] = (u8)( CpuID[2] & 0x000000FF);
	mac_adr[3] = (u8)((CpuID[2] & 0x0000FF00)>>8);
	mac_adr[4] = (u8)((CpuID[2] & 0x00FF0000)>>16);
	mac_adr[5] = (u8)((CpuID[2] & 0xFF000000)>>24);
	
	//设置网卡物理地址
	mem_copy (own_hw_adr, (U8 *)mac_adr, 6);

	init_TcpNet ();/* 初始化RL-TCPnet */

	//设置主机的名字
	str_copy (lhost_name,"BootLoader");

	//设置ip地址等
	dhcp_disable();
	mem_copy((U8 *)&localm[NETIF_ETH], (U8 *)&ip_config, sizeof(ip_config));

	os_itv_set (100);

    while(1)
	{
		timer_tick ();/* RL-TCPnet时间基准更新函数 */
		os_itv_wait ();
    }
}

//TCP数据收发处理任务
__task void AppTaskTCPMain(void)
{
	while (1)
	{
		TCPnetTest();
	}
}

//用户任务
__task void AppTaskUserIF(void)
{
	BYTE overtimeCnt = 0;
	
	Boot_Init();

	while(1)
	{
		if (BOOT_STATE_DOWNLOADING == tBoot.bBootState)
		{
			Boot_Download();
			tBoot.bBootState = BOOT_STATE_IDL;
			overtimeCnt = 0;
		}
		else if(BOOT_STATE_DEBUG == tBoot.bBootState)
		{
			Boot_Debug();
			overtimeCnt = 0;
		}

		overtimeCnt++;
		
		if(overtimeCnt > 50 && BOOT_STATE_DISCONNECT == tBoot.bBootState)
		{
			Boot_LoadApp(APP_ADDR);
		}
		
		os_dly_wait(100);
	}
}

//LED指示灯闪烁
__task void led_bling_task(void)
{

	U8 flag = 0;

    while(1)
	{
		BOARD_LED = flag;
		flag = flag ? 0 : 1;
		os_dly_wait(50);
    }
}

（2）app_tcpnet_lib.c

#include "app_tcpnet_lib.h"
#include "includes.h"	
#include "bootLoader.h"

socketNature_t socket_pc;   // 与pc端通讯的套接字描述
socketNature_t socket_debug;  // 与plc通讯的套接字描述


/********************************************************************
 * 描述：套接字发送数据函数。
 * 参数：[*socket]套接字描述
 *     [len]要发送的数据长度
 ********************************************************************/
void socket_send(socketNature_t *socket,U8 len){
	socket->sendLen=len;
	socket->sendFlag=1;
}

void send_poll(socketNature_t *socket);
/*
*********************************************************************************************************
*	函 数 名: tcp_callback
*	功能说明: TCP Socket的回调函数
*	形    参: soc  TCP Socket类型
*             evt  事件类型
*             ptr  事件类型是TCP_EVT_DATA，ptr指向的缓冲区记录着接收到的TCP数据，其余事件记录IP地址
*             par  事件类型是TCP_EVT_DATA，记录接收到的数据个数，其余事件记录端口号
*	返 回 值:
*********************************************************************************************************
*/
//			if (soc == socket_debug.id)
//			{
//					char buf[50];
//					sprintf(buf, "This is BootLoader Code\r\n");
//				
//					socket_debug.sendLen = strlen(buf);
//					memcpy(socket_debug.sendBuf, buf, socket_debug.sendLen);
//					socket_debug.sendFlag = 1;
//			}

U16 socket_callback (U8 soc, U8 evt, U8 *ptr, U16 par)
{
	switch (evt) 
	{
		//远程客户端连接消息
		//1、数组ptr存储远程设备的IP地址，par中存储端口号。
		//2、返回数值1允许连接，返回数值0禁止连接。
		case TCP_EVT_CONREQ:return (1);
		case TCP_EVT_ABORT:break;/* 连接终止 */
		case TCP_EVT_CONNECT:

			if (soc == socket_pc.id)
			{
				tBoot.bBootState = BOOT_STATE_IDL;
			}
		
			if (soc == socket_debug.id)
			{
				tBoot.bBootState = BOOT_STATE_DEBUG;
			}
			
			break;/* Socket远程连接已经建立 */
		case TCP_EVT_CLOSE:break;/* 连接断开 */
		case TCP_EVT_ACK:break;/* 发送的数据收到远程设备应答 */
		case TCP_EVT_DATA:/* 接收到TCP数据帧，ptr指向数据地址，par记录数据长度，单位字节 */
			if (soc == socket_debug.id)
			{
				socket_debug.recvLen = par;
				memcpy(socket_debug.recvBuf, ptr, socket_debug.recvLen);
				socket_debug.recvFlag = 1;

				socket_debug.sendLen = par;
				memcpy(socket_debug.sendBuf, ptr, socket_debug.sendLen);
				socket_debug.sendFlag = 1;
			}
			else if (soc == socket_pc.id)
			{
				switch (tBoot.bBootState)
				{
					case BOOT_STATE_IDL:
						if (DOWNLOAD_HEAD_FLAG == ((tyDownloadHead *)ptr)->dwStructFLag)
						{
							if (sizeof(tyDownloadHead) == par &&
								~DOWNLOAD_HEAD_FLAG == ((tyDownloadHead *)ptr)->dwStructFLagInverse &&
								CalculateCRC((DWORD *)ptr, sizeof(tyDownloadHead) - 4, 0) == ((tyDownloadHead *)ptr)->dwStructCRC)
							{
								tBoot.dwRecFileLen = ((tyDownloadHead *)ptr)->dwFileLen;
								tBoot.dwDownloadLen = 0;
								tBoot.dwFileCRC = ((tyDownloadHead *)ptr)->dwFileCRC;
								tBoot.bBootState = BOOT_STATE_DOWNLOADING;
							}
						}

						break;

					case BOOT_STATE_DOWNLOADING:
						socket_pc.recvLen = par;
						memcpy(socket_pc.recvBuf, ptr, socket_pc.recvLen);
						socket_pc.recvFlag = 1;

						socket_pc.sendLen = socket_pc.recvLen;
						memcpy(socket_pc.sendBuf, ptr, socket_pc.sendLen);
						socket_pc.sendFlag = 1;

						STMFLASH_Write(DOWNLOAD_ADDR + tBoot.dwDownloadLen, (DWORD *)socket_pc.recvBuf, socket_pc.recvLen / 4);
						tBoot.dwDownloadLen += socket_pc.recvLen;

						if (tBoot.dwDownloadLen >= tBoot.dwRecFileLen)
						{
							tBoot.bBootState = BOOT_STATE_IDL;
						}
						break;

					default:
						break;
				}

			}
			break;
	}
	return (0);
}

void TCPnetTest(void)
{
	static U8 socket_pc_recvBuf[256];
	static U8 socket_pc_sendBuf[256];
	static U8 socket_debug_recvBuf[256];
	static U8 socket_debug_sendBuf[256];

	//创建TCP Socket并创建监听
	socket_pc.port = 5198;
	socket_pc.recvBuf = socket_pc_recvBuf;
	socket_pc.sendBuf = socket_pc_sendBuf;
	socket_pc.id = tcp_get_socket(TCP_TYPE_SERVER | TCP_TYPE_KEEP_ALIVE, 0, 10, socket_callback);
	if(socket_pc.id!=0)
	{
		tcp_listen(socket_pc.id,socket_pc.port);
	}
	
	//创建TCP Socket并创建监听
	socket_debug.port = 5199;
	socket_debug.recvBuf = socket_debug_recvBuf;
	socket_debug.sendBuf = socket_debug_sendBuf;
	socket_debug.id = tcp_get_socket(TCP_TYPE_SERVER | TCP_TYPE_KEEP_ALIVE, 0, 10, socket_callback);
	if(socket_debug.id != 0)
	{
		tcp_listen(socket_debug.id,socket_debug.port);
	}

	while (1) 
	{
		main_TcpNet();/* RL-TCPnet处理函数 */
		send_poll(&socket_pc);
		send_poll(&socket_debug);
		os_dly_wait (2);
	}
}

void send_poll(socketNature_t *socket){
	switch (tcp_get_state(socket->id))/* 用于网线插拔的处理 */
	{
		case TCP_STATE_FREE:
		case TCP_STATE_CLOSED:
			tcp_listen (socket->id,socket->port);//网络断开边接后，开始监听
			return;
		case TCP_STATE_LISTEN://处于监听时不发送
		default:
			socket->sendFlag=0;
			return;
		case TCP_STATE_CONNECT://处于连接状态
			break;
	}
	if(socket->sendFlag)
	{
		U8 *sendbuf;
		S32 iCount;
		U16 maxlen;
		socket->sendFlag=0;
		iCount = socket->sendLen;
		do{
			main_TcpNet();
			if (tcp_check_send(socket->id) == __TRUE)
			{
				maxlen = tcp_max_dsize (socket->id);
				iCount -= maxlen;

				if(iCount < 0)
				{
					maxlen = iCount + maxlen;/* 这么计算没问题的 */
				}
				sendbuf = tcp_get_buf(maxlen);
				memcpy(sendbuf,socket->sendBuf,maxlen);
				tcp_send (socket->id, sendbuf, maxlen);/* 测试发现只能使用获取的内存 */

			}
		}while(iCount > 0);
	}
}

（3）bootloader.h

#ifndef BOOT_LOADER_H_
#define BOOT_LOADER_H_

#include "includes.h"
#include "includeAll.H"
#include "bsp.h"

#define BOOT_ADDR 			0x8000000  			//bootLoader 128K 
#define DOWNLOAD_ADDR 	0x8020000  			//固件		 384K
#define APP_ADDR 				0x8080000				//应用程序区 384K
#define RESERVED_ADDR		0x80E0000				//预留空间	 128K

#define TRUE 1
#define FALSE 0

#define FUN_SUC 0
#define FUN_FAIL 1

#define BYTE unsigned char
#define WORD unsigned short
#define DWORD unsigned int

#define DOWNLOAD_HEAD_FLAG			0x55591012
#define DEBUG_HEAD_FLAG				0x55591013

#define BOOT_STATE_DISCONNECT  	0
#define BOOT_STATE_IDL					1
#define BOOT_STATE_DEBUG				2
#define BOOT_STATE_DOWNLOADING	3

typedef struct
{
	DWORD dwStructFLag;				//识别头 
	DWORD dwStructFLagInverse;		//识别头取反
	DWORD dwStructCRC;				//结构体校验
}tyDebugHead;

typedef struct
{
	DWORD dwStructFLag;								//识别头 
	DWORD dwStructFLagInverse;				//识别头反码
	BYTE  bFileType;									//文件类型，0：APP程序，1：BootLoader程序
	BYTE  bReserve[3];								//预留，四字节对齐
	DWORD dwFileLen;									//下载文件大小
	DWORD dwFileCRC;									//文件数据校验
	DWORD dwStructCRC;								//结构体校验
}tyDownloadHead;

typedef struct
{
	BYTE bBootState;  //连接状态 
	BYTE bIsNeedSelCmd;
	BYTE bSelCmdNum;
	DWORD dwDownloadLen;
	DWORD dwRecFileLen;
	DWORD dwFileCRC;
}tyBoot;

extern tyBoot tBoot;

void Boot_Init(void);  //初始化 
extern BYTE Boot_Debug(void);  //进入Debug模式
extern BYTE Boot_Download(void);  //进入下载模式
extern void Boot_LoadApp(DWORD dwAddr);  //跳转到APP
extern DWORD CalculateCRC(DWORD *pdwDataBuff, DWORD dwByteLen, DWORD dwOrigXorValue);  //计算CRC

#endif

（4）bootloader.c

#include "bootLoader.h"

tyBoot tBoot;

void Boot_Init(void)
{
	tBoot.bIsNeedSelCmd = FALSE;
	tBoot.bSelCmdNum = 0xFF;
	tBoot.dwDownloadLen = 0;
	tBoot.dwRecFileLen = 0;
	tBoot.bBootState = BOOT_STATE_DISCONNECT;
}

void Debug_Print(char *str)
{
	strcpy(socket_debug.sendBuf, str);
	socket_debug.sendLen = strlen(socket_debug.sendBuf);
	socket_debug.sendFlag = 1;
	while (1 == socket_debug.sendFlag)
	{
		os_dly_wait(2);
	}
}

BYTE Boot_Download(void)
{
	char bBuf[50] = { 0 };
	char overtimeCnt = 0;

	Debug_Print("\r\nDownload Start ...... ");

	
	
	while (tBoot.dwDownloadLen <  tBoot.dwRecFileLen)
	{
		os_dly_wait(200);
		sprintf(bBuf, "\r\nDownloading Download/Total %d/%d ", tBoot.dwDownloadLen, tBoot.dwRecFileLen);
		Debug_Print(bBuf);
		
		overtimeCnt++;
		
		if(overtimeCnt > 50)  //下载超时
		{
			Debug_Print("\r\nDownload Overtime");
			return FUN_FAIL;
		}
	}

	Debug_Print("\r\nDownload Success, Checking File CRC ...... ");
	if(CalculateCRC((DWORD *)DOWNLOAD_ADDR, tBoot.dwRecFileLen, 0) != tBoot.dwFileCRC)
	{
		Debug_Print("\r\nFile CRC Error");
		return FUN_FAIL;
	}
	
	Debug_Print("\r\nFile CRC Pass");
	
	sprintf(bBuf, "\r\nPrograming to App Area 0x%8X ...... ", APP_ADDR);
	Debug_Print(bBuf);

	//从Download区搬移程序到App区
	STMFLASH_Write(APP_ADDR, (u32 *)DOWNLOAD_ADDR, (APP_ADDR - DOWNLOAD_ADDR) / 4);
	
	Debug_Print("\r\nProgram Success");
	//break;

	Debug_Print("\r\nJump to APP Code ");
	Boot_LoadApp(APP_ADDR);

	return FUN_SUC;
}

BYTE Boot_Debug(void)
{
	char bBuf[50] = { 0 };
	char i;

	//打印地址列表
	Debug_Print("\r\n******* BootLoader *******"
					"\r\nBOOT_ADDR    : 0x8000000 - 0x8020000"
					"\r\nDOWNLOAD_ADDR: 0x8020000 - 0x8080000"
					"\r\nAPP_ADDR     : 0x8080000 - 0x80E0000"
					"\r\nRESERVED_ADDR: 0x80E0000 - 0x8100000");

	//等待激活BootLoader命令
//	for (i = 3; i > 0; i--)
//	{
//		sprintf(bBuf, "\r\nPress any key to stop: %d", i);
//		Debug_Print(bBuf);
//		os_dly_wait(1000);

//		if (socket_debug.recvFlag)
//		{
//			socket_debug.recvFlag = 0;
//			tBoot.bIsNeedSelCmd = TRUE;
//			break;
//		}
//	}
	
	tBoot.bIsNeedSelCmd = TRUE;
	
	//跳转到App执行或者选择BootLoader命令
	if (TRUE != tBoot.bIsNeedSelCmd)
	{
		Debug_Print("\r\nJump to APP Code ");
		Boot_LoadApp(APP_ADDR);
	}
	else
	{
		Debug_Print("\r\n1 -> Download App\r\n2 -> Run App");

		//等待用户输入有效的序号
		while ((1 != tBoot.bSelCmdNum) && (2 != tBoot.bSelCmdNum))
		{
			os_dly_wait(100);
			if (socket_debug.recvFlag)
			{
				socket_debug.recvFlag = 0;
				tBoot.bSelCmdNum = *socket_debug.recvBuf;
			}
		}
		
		//根据选择的序号处理命令
		switch (tBoot.bSelCmdNum)
		{
			case 1:
				tBoot.bBootState = BOOT_STATE_IDL;
				break;

			case 2:
				Debug_Print("\r\nJump to APP Code ");
				Boot_LoadApp(APP_ADDR);
				break;

			default:
				break;
		}
	}

	return FUN_SUC;
}

void(*Boot_Jump2App)();

void Boot_LoadApp(DWORD dwAddr)
{
	BYTE i;

	//检查栈顶地址是否合法
	if (((*(vu32*)dwAddr) & 0x2FFE0000) == 0x20000000)	
	{
		//设置跳转地址
		Boot_Jump2App = (void(*)())*(vu32*)(dwAddr + 4);		
		//初始化APP堆栈指针(用户代码区的第一个字用于存放栈顶地址)
		__set_MSP(*(vu32*)dwAddr);
		//关闭所有中断
		for (i = 0; i < 8; i++)
		{
			NVIC->ICER[i] = 0xFFFFFFFF;	
			NVIC->ICPR[i] = 0xFFFFFFFF;	
		}
		//跳转到APP Code
		Boot_Jump2App();		
		//跳转之前用死循环卡住
		while (1);
	}
}

DWORD CalculateCRC(DWORD *pdwDataBuff, DWORD dwByteLen, DWORD dwOrigXorValue)
{
	DWORD i;
	DWORD dwXorResult;

	dwXorResult = dwOrigXorValue;

	for (i = 0; i < (dwByteLen / sizeof(DWORD)); i++)
	{
		dwXorResult ^= pdwDataBuff[i];
	}

	return dwXorResult;
}

五、客户端实现

江湖有句传言“人生苦短，我用Python”，基于Python的高效率开发，所以我用了Python来实现TCP客户端，废话少说，直接上代码：

from socket import *
import os
import ctypes

class DownloadTool():
    def __init__(self):
        pass

    def Connect(self):
        self.tcpHost = 'localhost'
        self.tcpPort = 5198
        self.tcpRecBufSize = 2048
        self.tcpAddr = ("192.168.1.41", self.tcpPort)
        self.tcpSock = socket(AF_INET, SOCK_STREAM)
        self.tcpSock.connect(self.tcpAddr)

    def CalculateFileSizeAndCRC(self, filePath):
        file = open(filePath, "rb")
        size = os.path.getsize(filePath)
        print("Bin Size = %d" % (size))

        buf = file.read(4)
        crc = 0

        while len(buf) > 0:
            crc = crc ^ (int.from_bytes(buf, byteorder='little', signed=False))
            buf = file.read(4)

        file.close()

        return size, crc

    def DownloadFile(self):
        #传输下载头
        fileLen, fileCRC = self.CalculateFileSizeAndCRC("MC-IOV3248.bin")

        headInfo = []
        headInfo.append(ctypes.c_uint32(0x55591012))
        headInfo.append(ctypes.c_uint32(~0x55591012))
        headInfo.append(ctypes.c_uint32(0x00000000))
        headInfo.append(ctypes.c_uint32(fileLen))
        headInfo.append(ctypes.c_uint32(fileCRC))
        headInfo.append(ctypes.c_uint32(headInfo[0].value ^ headInfo[1].value ^ headInfo[2].value ^ headInfo[3].value ^ headInfo[4].value))

        DownloadHead = bytes()
        for item in headInfo:
            DownloadHead = DownloadHead + bytes(item)

        self.tcpSock.send(DownloadHead)

        //传输bin文件
        file = open("MC-IOV3248.bin", "rb")
        downloadLen = 0

        while True:
            buf = file.read(120)

            if len(buf) <= 0:
                break;

            self.tcpSock.send(buf)
            rec = self.tcpSock.recv(self.tcpRecBufSize)

            if buf != rec:
                print("check err")
                break

            downloadLen = downloadLen + len(buf)
            print("download/Total %d/%d" % (downloadLen, fileLen))

        self.tcpSock.close()

if __name__ == '__main__':
    demo = DownloadTool()
    demo.Connect()
    demo.DownloadFile()

这样就完成了基本的BootLoader下载功能了。

六、实验演示

用网络调试助手连接Debug端口，选择01号下载命令后启动Python程序对下载端口进行程序下载。

网络调试助手输出信息如下：


[2019-10-27 21:04:44.420]# RECV ASCII>

******* BootLoader *******
BOOT_ADDR    : 0x8000000 - 0x8020000
DOWNLOAD_ADDR: 0x8020000 - 0x8080000
APP_ADDR     : 0x8080000 - 0x80E0000
RESERVED_ADDR: 0x80E0000 - 0x8100000

[2019-10-27 21:04:44.422]# RECV ASCII>

1 -> Download App
2 -> Run App

[2019-10-27 21:04:46.869]# SEND HEX>
01 

[2019-10-27 21:04:46.872]# RECV ASCII>


[2019-10-27 21:04:51.095]# RECV ASCII>

Download Start ...... 

[2019-10-27 21:04:51.296]# RECV ASCII>

Downloading Download/Total 5280/29532 

[2019-10-27 21:04:51.500]# RECV ASCII>

Downloading Download/Total 9480/29532 

[2019-10-27 21:04:51.701]# RECV ASCII>

Downloading Download/Total 13680/29532 

[2019-10-27 21:04:51.905]# RECV ASCII>

Downloading Download/Total 18720/29532 

[2019-10-27 21:04:52.105]# RECV ASCII>

Downloading Download/Total 23640/29532 

[2019-10-27 21:04:52.306]# RECV ASCII>

Downloading Download/Total 28920/29532 

[2019-10-27 21:04:52.508]# RECV ASCII>

Downloading Download/Total 29532/29532 

[2019-10-27 21:04:52.512]# RECV ASCII>

Download Success, Checking File CRC ...... 

[2019-10-27 21:04:52.516]# RECV ASCII>

File CRC Pass
Programing to App Area 0x 8080000 ...... 

[2019-10-27 21:04:55.216]# RECV ASCII>

Program Success

[2019-10-27 21:04:55.220]# RECV ASCII>

Jump to APP Code

Python端输出信息如下


Bin Size = 29532
download/Total 120/29532
download/Total 240/29532
download/Total 360/29532
download/Total 480/29532
download/Total 600/29532
download/Total 720/29532
download/Total 840/29532
download/Total 960/29532
download/Total 1080/29532
download/Total 1200/29532
download/Total 1320/29532
download/Total 1440/29532
download/Total 1560/29532
download/Total 1680/29532
download/Total 1800/29532
download/Total 1920/29532
download/Total 2040/29532
download/Total 2160/29532
download/Total 2280/29532
download/Total 2400/29532
download/Total 2520/29532
download/Total 2640/29532
download/Total 2760/29532
download/Total 2880/29532
download/Total 3000/29532
download/Total 3120/29532
download/Total 3240/29532
download/Total 3360/29532
download/Total 3480/29532
download/Total 3600/29532
download/Total 3720/29532
download/Total 3840/29532
download/Total 3960/29532
download/Total 4080/29532
download/Total 4200/29532
download/Total 4320/29532
download/Total 4440/29532
download/Total 4560/29532
download/Total 4680/29532
download/Total 4800/29532
download/Total 4920/29532
download/Total 5040/29532
download/Total 5160/29532
download/Total 5280/29532
download/Total 5400/29532
download/Total 5520/29532
download/Total 5640/29532
download/Total 5760/29532
download/Total 5880/29532
download/Total 6000/29532
download/Total 6120/29532
download/Total 6240/29532
download/Total 6360/29532
download/Total 6480/29532
download/Total 6600/29532
download/Total 6720/29532
download/Total 6840/29532
download/Total 6960/29532
download/Total 7080/29532
download/Total 7200/29532
download/Total 7320/29532
download/Total 7440/29532
download/Total 7560/29532
download/Total 7680/29532
download/Total 7800/29532
download/Total 7920/29532
download/Total 8040/29532
download/Total 8160/29532
download/Total 8280/29532
download/Total 8400/29532
download/Total 8520/29532
download/Total 8640/29532
download/Total 8760/29532
download/Total 8880/29532
download/Total 9000/29532
download/Total 9120/29532
download/Total 9240/29532
download/Total 9360/29532
download/Total 9480/29532
download/Total 9600/29532
download/Total 9720/29532
download/Total 9840/29532
download/Total 9960/29532
download/Total 10080/29532
download/Total 10200/29532
download/Total 10320/29532
download/Total 10440/29532
download/Total 10560/29532
download/Total 10680/29532
download/Total 10800/29532
download/Total 10920/29532
download/Total 11040/29532
download/Total 11160/29532
download/Total 11280/29532
download/Total 11400/29532
download/Total 11520/29532
download/Total 11640/29532
download/Total 11760/29532
download/Total 11880/29532
download/Total 12000/29532
download/Total 12120/29532
download/Total 12240/29532
download/Total 12360/29532
download/Total 12480/29532
download/Total 12600/29532
download/Total 12720/29532
download/Total 12840/29532
download/Total 12960/29532
download/Total 13080/29532
download/Total 13200/29532
download/Total 13320/29532
download/Total 13440/29532
download/Total 13560/29532
download/Total 13680/29532
download/Total 13800/29532
download/Total 13920/29532
download/Total 14040/29532
download/Total 14160/29532
download/Total 14280/29532
download/Total 14400/29532
download/Total 14520/29532
download/Total 14640/29532
download/Total 14760/29532
download/Total 14880/29532
download/Total 15000/29532
download/Total 15120/29532
download/Total 15240/29532
download/Total 15360/29532
download/Total 15480/29532
download/Total 15600/29532
download/Total 15720/29532
download/Total 15840/29532
download/Total 15960/29532
download/Total 16080/29532
download/Total 16200/29532
download/Total 16320/29532
download/Total 16440/29532
download/Total 16560/29532
download/Total 16680/29532
download/Total 16800/29532
download/Total 16920/29532
download/Total 17040/29532
download/Total 17160/29532
download/Total 17280/29532
download/Total 17400/29532
download/Total 17520/29532
download/Total 17640/29532
download/Total 17760/29532
download/Total 17880/29532
download/Total 18000/29532
download/Total 18120/29532
download/Total 18240/29532
download/Total 18360/29532
download/Total 18480/29532
download/Total 18600/29532
download/Total 18720/29532
download/Total 18840/29532
download/Total 18960/29532
download/Total 19080/29532
download/Total 19200/29532
download/Total 19320/29532
download/Total 19440/29532
download/Total 19560/29532
download/Total 19680/29532
download/Total 19800/29532
download/Total 19920/29532
download/Total 20040/29532
download/Total 20160/29532
download/Total 20280/29532
download/Total 20400/29532
download/Total 20520/29532
download/Total 20640/29532
download/Total 20760/29532
download/Total 20880/29532
download/Total 21000/29532
download/Total 21120/29532
download/Total 21240/29532
download/Total 21360/29532
download/Total 21480/29532
download/Total 21600/29532
download/Total 21720/29532
download/Total 21840/29532
download/Total 21960/29532
download/Total 22080/29532
download/Total 22200/29532
download/Total 22320/29532
download/Total 22440/29532
download/Total 22560/29532
download/Total 22680/29532
download/Total 22800/29532
download/Total 22920/29532
download/Total 23040/29532
download/Total 23160/29532
download/Total 23280/29532
download/Total 23400/29532
download/Total 23520/29532
download/Total 23640/29532
download/Total 23760/29532
download/Total 23880/29532
download/Total 24000/29532
download/Total 24120/29532
download/Total 24240/29532
download/Total 24360/29532
download/Total 24480/29532
download/Total 24600/29532
download/Total 24720/29532
download/Total 24840/29532
download/Total 24960/29532
download/Total 25080/29532
download/Total 25200/29532
download/Total 25320/29532
download/Total 25440/29532
download/Total 25560/29532
download/Total 25680/29532
download/Total 25800/29532
download/Total 25920/29532
download/Total 26040/29532
download/Total 26160/29532
download/Total 26280/29532
download/Total 26400/29532
download/Total 26520/29532
download/Total 26640/29532
download/Total 26760/29532
download/Total 26880/29532
download/Total 27000/29532
download/Total 27120/29532
download/Total 27240/29532
download/Total 27360/29532
download/Total 27480/29532
download/Total 27600/29532
download/Total 27720/29532
download/Total 27840/29532
download/Total 27960/29532
download/Total 28080/29532
download/Total 28200/29532
download/Total 28320/29532
download/Total 28440/29532
download/Total 28560/29532
download/Total 28680/29532
download/Total 28800/29532
download/Total 28920/29532
download/Total 29040/29532
download/Total 29160/29532
download/Total 29280/29532
download/Total 29400/29532
download/Total 29520/29532
download/Total 29532/29532
end

Process finished with exit code 0

你可能感兴趣的:(STM32)

STM32中的计时与延时 lupinjia STM32 stm32 单片机
前言在裸机开发中，延时作为一种规定循环周期的方式经常被使用，其中尤以HAL库官方提供的HAL_Delay为甚。刚入门的小白可能会觉得既然有官方提供的延时函数，而且精度也还挺好，为什么不用呢？实际上HAL_Delay中有不少坑，而这些也只是HAL库中无数坑的其中一些。想从坑里跳出来还是得加强外设原理的学习和理解，切不可只依赖HAL库。除了延时之外，我们在开发中有时也会想要确定某段程序的耗时，这就需要
基于STM32与Qt的自动平衡机器人：从控制到人机交互的的详细设计流程极客小张 stm32 qt 机器人物联网人机交互毕业设计 c语言
一、项目概述目标和用途本项目旨在开发一款基于STM32控制的自动平衡机器人，结合步进电机和陀螺仪传感器，实现对平衡机器人的精确控制。该机器人可以用于教育、科研、娱乐等多个领域，帮助用户了解自动控制、机器人运动学等相关知识。技术栈关键词STM32单片机步进电机陀螺仪传感器AD采集电路Qt人机界面实时数据监控二、系统架构系统架构设计本项目的系统架构设计包括以下主要组件：控制单元:STM32单片机传感器
基于STM32的汽车仪表显示系统：集成CAN、UART与I2C总线设计流程极客小张 stm32 汽车嵌入式硬件物联网单片机 c语言
一、项目概述项目目标与用途本项目旨在设计和实现一个基于STM32微控制器的汽车仪表显示系统。该系统能够实时显示汽车的速度、转速、油量等关键信息，并通过CAN总线与其他汽车控制单元进行通信。这种仪表显示系统不仅提高了驾驶的安全性和便捷性，还能为汽车提供更智能的用户体验。技术栈关键词微控制器：STM32显示技术：TFTLCD/OLED传感器：速度传感器、温度传感器、油量传感器通信协议：CAN总线、UA
基于STM32的简易RTOS分析-预备知识騏威嵌入式
写下这篇文章的主要目的是对自己学习RTOS的历程做一个记录和总结，方便以后回忆翻看。以下内容主要来自宋岩先生翻译的《Cortex-M3权威指南》。目录一、Cortex-M3寄存器简介二、堆栈操作简介三、汇编指令简介LDR和STR指令STMDB和LDMIA指令B、BX、BL、BLX指令MRS和MSR指令四、中断简介中断响应过程简介SVC和PensSV中断简介软件中断五、汇编基础一、Cortex-M3
15-自编写rtos-结合stm32实际调试(ladylolo-os) Ladylolo-lsm stm32 嵌入式硬件单片机
一、任务调度:1.理解:任务切换，用堆栈指针SP保存即将要切换的任务的前后文，然后是用PendSV来执行这些操作的；由于是基于优先级的调度策略，所以每次“心跳”都会看有没有优先级更高的出现，如果有就用PendSV进行上下文切换。2.编写部分:①每个任务自己的属性统称为TCB任务控制块。②任务就绪表有设置优先级(设置的时候变量或上优先级的变量让某个位数等于1)，从任务就绪表中删除(删除时用与来得等于
小米嵌入式面试题目RTOS面试题目嵌入式面试题目好家伙VCC 面试杂谈杂谈面试职场和发展
第一章-非RTOSbootloader工作流程MCU启动流程通信协议，SPIIICMCU怎么选型，STM32F1和F4有什么区别外部RAM和内部RAM区别，怎么分配外部总线和内部总线区别MCU上的固件，数据是怎么分配的MCU启动流程IAP是怎么升级的，突然断电怎么办挑了麦轮项目（因为大疆RM也是麦轮，面试官看样子比较感兴趣）为什么用的CAN总线你说一下spi和i2c和UART的各自的工作方式优缺点
基于STM32F103C8T6定时器的PWM通道的重映射 —你的鼬先生 stm32 嵌入式硬件单片机
在我们平时的的使用中，我们最常使用的是TIM2和TIM3的PWM通道，但是由于C8T6的IO口有限，所以可能会出现PWM通道的资源不够的情况，从而我们可能会使用PWM4的PWM通道，但是TIM4的PWM通道并不能直接使用，它需要进行一个重映射，不然可能会导致PWM波不能正常发送。以下就是对PWM4的PWM通道进行一个重映射#include"stm32f10x.h"//Deviceheadervoi
【STM32系统】基于STM32设计的锂电池电量/电压检测报警器系统——文末完整资料下载（程序源码/电路原理图/电路PCB/设计文档/模块资料/元器件清单/实物图/答辩问题技巧/PPT模版等）阿齐Archie 单片机嵌入式项目 stm32 嵌入式硬件单片机
基于STM32设计的锂电池电量/电压检测报警器系统系统视频：摘要：本设计旨在研究一个基于STM32F103C8T6微控制器的锂电池电量/电压检测报警器系统，应用于便携式电子设备电池管理。系统通过STM32的ADC模块对锂电池电压进行采集，利用LCD1602显示模块实时显示电池电压，当检测到电池电量不足或电压异常时，蜂鸣器报警模块会发出警报提醒用户。系统采用简单的硬件结构和优化的软件架构，通过对实际
使用STM32实现简单的智能温控系统棂梓知识 stm32 单片机嵌入式硬件
智能温控系统是一种能够根据环境温度实时调整设备的工作状态的系统。在本篇文章中，我们将使用STM32微控制器来实现一个简单的智能温控系统。该系统将会有以下功能：实时监测环境温度，并显示在LCD屏幕上。当环境温度超过设定的阈值时，自动开启风扇。当环境温度恢复正常时，自动关闭风扇。通过按键模拟调节设定的阈值。系统设计首先，我们需要准备一些硬件设备。具体而言，我们需要以下组件：STM32F103C8T6开
STM32 HAL freertos零基础（九）任务通知啥也不会的小白研究生零基础学习Freertos stm32 嵌入式硬件单片机
1、任务通知任务通知用于任务之间同步和通信。任务通知允许一个任务向另一个任务发送一个32位的值，并可以选择是否唤醒正在等待通知的任务。这使得任务之间的同步更加简单和灵活。任务通知功能：发送通知：一个任务可以向另一个任务发送一个32位的值。接收通知：接收任务可以根据接收到的通知来决定何时执行某些操作。通知状态：可以检查任务的当前通知状态。2、相关APIxTaskNotify()//发送通知，带有通知
4×4矩阵键盘详解（STM32）辰哥单片机设计 STM32传感器教学矩阵计算机外设 stm32 嵌入式硬件单片机传感器
目录一、介绍二、传感器原理1.原理图2.工作原理介绍三、程序设计main.c文件button4_4.h文件button4_4.c文件四、实验效果五、资料获取项目分享一、介绍矩阵键盘，又称为行列式键盘，是用4条I/O线作为行线，4条I/O线作为列线组成的键盘。在行线和列线的每一个交叉点上设置一个按键，因此键盘中按键的个数是4×4个。这种行列式键盘结构能够有效地提高单片机系统中I/O口的利用率，节约单
STM32的寄存器深度解析千千道 STM32 stm32 单片机物联网
目录一、STM32寄存器概述二、寄存器的定义与作用三、寄存器分类1.内核寄存器2.外设寄存器四、重要寄存器详解1.GPIO相关寄存器2.定时器相关寄存器3.中断相关寄存器4.RCC相关寄存器五、寄存器操作方法1.直接操作寄存器2.使用库函数操作寄存器六、总结在嵌入式系统开发中，STM32微控制器以其强大的性能和丰富的功能而备受青睐。而理解和掌握STM32的寄存器是深入学习和开发STM32的关键。本
STM32 如何生成随机数千千道 STM32 stm32 单片机物联网
目录一、引言二、STM32随机数发生器概述三、工作原理1.噪声源2.线性反馈移位寄存器（LFSR）3.数据寄存器（RNG_DR）4.监控和检测电路：5.控制和状态寄存器6.生成流程四、使用方法1.使能随机数发生器2.读取随机数3.错误处理五、注意事项1.随机数的质量2.安全性3.性能考虑六、总结一、引言在嵌入式系统开发中，随机数的生成常常是一个重要的需求。无论是用于加密、模拟、游戏还是其他需要不确
STM32——看门狗通俗解析百里与司空 stm32 嵌入式硬件单片机门控循环单元
笔者在学习看门狗的视频后，对看门狗仍然是一知半解，后面在实际应用中发现它是一个很好用的检测或者调试工具。所以总结一下笔者作为初学小白对看门狗的理解。主函数初始化阶段、循环阶段和复位众所周知，程序的运行一般是这样的：程序在进入循环阶段之前，会在初始化阶段将每个寄存器或者某些变量赋值。初始化阶段的代码执行一次后，就不再执行了。而循环阶段的代码会执行很多次，一直循环反复的执行下去。这时，如果进行了复位，
STM32 的 RTC（实时时钟）详解千千道 STM32 stm32 物联网单片机
目录一、引言二、RTC概述三、RTC的工作原理1.时钟源2.计数器3.闹钟功能4.备份寄存器四、RTC寄存器1.RTC_TR（TimeRegister，时间寄存器）2.RTC_DR（DateRegister，日期寄存器）3.RTC_SSR（SubsecondRegister，亚秒寄存器）4.RTC_PRER（PrescalerRegister，预分频器寄存器）5.RTC_CR（ControlReg
2020-11-12 写单片机内存的脚本 nc openocd 事务自动测试 linuxScripter
这是写单片机内存的脚本：z@z-ThinkPad-T400:~/zworkT400/EDA_heiche/zREPOgit/simple-gcc-stm32-project$catz.wholeRun.oneCase.cmdcattmp6.toWrite|awk'{system("echomwb"$1""$2"|nclocalhost4444");}'catUSER/DEBUG/debug.h|g
arm-none-eabi-gcc 不识别__attribute__((at(xxx))命令如何将数据定义到外部SDAM（已验证）梓默 #C
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录可以利用__attribute__((section(".xxx")))实现同样的效果步骤：1.在linker链接文件中添加指定SDRAM加偏移地址2.添加SDRAM自定义section3.将数据定义到自定义区可以利用__attribute__((section(".xxx")))实现同样的效果步骤：从STM32H7xx参考手
Error: No STM32 target found! If your product embeds Debug Authentication, please perform a discover BABA8891 stm32 嵌入式硬件单片机
这个错误信息“Error:NoSTM32targetfound!IfyourproductembedsDebugAuthentication,pleaseperformadiscoveryusingDebugAuthentication”通常出现在使用STM32微控制器的开发过程中，尤其是在尝试通过调试接口（如SWD或JTAG）与设备通信时。这个错误表明调试器或开发工具无法识别或连接到STM32目
STM32与ESP8266的使用每天的积累嵌入式学习日记 stm32 stm32 单片机嵌入式硬件
串口透传“透传”通常指的是数据的透明传输，意思是在不对数据进行任何处理或修改的情况下，将数据从一个接口转发到另一个接口。值得注意的是要避免串口之间无限制的透明，可以采用互斥锁的方式进行限制使用方法对USART1和USART3(用他俩举例)的模式都是设置为Asynchronous，并开启对应的中断。RCC的HighSPeedCLock模式设置为Crystal/Ceramic配置对应的时钟为64Mhz
ARM-Cortex-M架构：1、STM32函数参数传递天城寺电子嵌入式软件开发 arm开发 stm32 汇编 C语言
文章目录参数传递概览堆栈传递参数具体过程参数传递概览在调用子函数时，ARMCortex-M3处理器可以使用寄存器和堆栈来传递参数。具体使用哪种方式取决于传递的参数数量和调用约定（callingconvention）。参数传递方式ARMCortex-M3处理器使用ARMEABI(EmbeddedApplicationBinaryInterface)标准来定义参数传递的约定。根据这个约定：1、寄存器传
物流系统中的嵌入式：STM32微控制器与智能算法驱动的物理循迹小车详细流程极客小张 stm32 嵌入式硬件单片机机器人算法物联网 c语言
一、项目概述本项目旨在开发一款基于STM32微控制器的物理循迹小车，具备二维码识别能力，并能够将物品送到指定的物流位置。通过传感器和算法的结合，小车将实现自主导航和路径规划，从而提高物流效率和准确性。项目的目标是为智能物流提供一种新颖的解决方案，适用于仓库、工厂等场景。技术栈关键词硬件平台：STM32微控制器（如STM32F4系列）传感器：红外循迹传感器、摄像头模块、超声波传感器驱动模块：电机驱动
大疆开发型c板BMI088-IMU零漂问题优化解决（1）一流L 单片机 stm32 嵌入式硬件
在基于clion开发大疆开发型c板STM32F407IG过程中出现的零点漂移严重情况的解决1.首先我们先了解一下IMU零漂校准IMU数据的目的是消除传感器本身固有的偏差和不确定性，使得测量数据更加准确和可靠。在这个函数中，校准过程主要是通过乘以比例因子和加上偏移量来实现的，具体步骤如下：首先需要进行传感器的零偏校准（offsetcalibration）。这一步骤的目的是测量出传感器在静止状态下的输
STM32裸机-时间片任务轮询妖异的小尾巴代码结构
瞎逼逼部分程序的编写裸机有几大类，分别是顺序执行前后台程序时间片任务轮询带系统的程序我们平常学习裸机开发程序中最常使用的可能就是顺序执行和前后台程序程序顺序执行的示例简单直接，直接往while(1)循环里放就是了前后台程序则是在顺序执行的基础上加上了中断，用于处理一些外部信号和比较紧急的事件但是这样出来的程序，实际的运行效果就比较乱了，我们无法确定某段程序能不能在我们需要的时候调用，比如让一些实时
STM32 Cube IDE HAL库驱动 W25Q128 进行读、写、擦除操作_w25q128驱动程序(1) 2401_85012262 2024年程序员学习物联网嵌入式硬件面试
收集整理了一份《2024年最新物联网嵌入式全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升的朋友。如果你需要这些资料，可以戳这里获取需要这些体系化资料的朋友，可以加我V获取：vip1024c（备注嵌入式）一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习
stm32 RTC guanjianhe
#include"stm32f10x.h"staticvoidRTC_Configuration(void){/*使能PWR和Backup时钟*/RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR|RCC_APB1Periph_BKP,ENABLE);/*允许访问Backup区域*/PWR_BackupAccessCmd(ENABLE);/*复位Backup区域*/
基于STM32F407实现土壤湿度检测 Yu.y1 stm32 单片机嵌入式硬件
土壤湿度传感器它利用电磁脉冲原理、根据电磁波在介质中传播频率来测量土壤的表观介电常数,从而得到土壤相对含水量。代码流程1.看原理图确定GPIO与ADC通道PA5，ADC1IN52.配置GPIO为模拟模式3.ADC初始化a.结构体申明ADC_CommonInitTypeDefb.时钟使能c.结构体配置d.初始化4.ADC通道初始化a.结构体申明ADC_InitTypeDefb.结构体配置c.初始化5
stm32f4串口接收与发送朴实妲己单片机 stm32 嵌入式硬件
之前有写一篇stm32f1串口接收与发送的文章，stm32f4与f1只有配置上的一点不同，今天把f4的串口接收与发送代码分享一下详细解释推荐大家看f1那篇，都是一样的，stm32f1串口发送与接收_居安士的博客-CSDN博客_stm32串口通信的接收与发送直接上代码voiduart_init(u32bound){//GPIO端口设置GPIO_InitTypeDefGPIO_InitStructur
STM32 HAL freertos零基础（六）计数型信号量啥也不会的小白研究生零基础学习Freertos stm32 嵌入式硬件单片机
1、计数型信号量计数型信号量（CountingSemaphore）是另一种类型的信号量，它可以保持一个大于等于0的整数值，这个值表示可用资源的数量。本质上相当于队列长度大于1得队列。经典问题就是剩余车辆统计，出入车辆，车辆数据可以实时更新。2、相关API函数xSemaphoreCreateCounting()//使用动态方法创建计数型信号量。xSemaphoreCreateCountingStat
STM32实现简单的智能手环心梓知识 stm32 单片机嵌入式硬件
智能手环是一种智能穿戴设备，可以用于监测用户的运动、心率、睡眠等健康数据，并提供相应的分析和提醒功能。在本案例中，我们将使用STM32微控制器来实现一个简单的智能手环。首先，我们需要准备以下硬件和软件：STM32开发板（如STM32F103C8T6）OLED显示屏（128x64像素）心率传感器模块（如MAX30102）加速度传感器模块（如MPU6050）蓝牙模块（如HC-05）KeilMDK开发环
STM32 HAL freertos零基础（七）互斥量啥也不会的小白研究生零基础学习Freertos stm32 嵌入式硬件单片机
1、互斥量互斥量主要用于保护共享资源的访问，确保在同一时刻只有一个任务可以访问该资源。互斥性：当一个任务获取了一个互斥量后，其他任务将无法再获取同一个互斥量，直到原始任务释放该互斥量。优先级继承：为了防止优先级反转问题，FreeRTOS的互斥量支持优先级继承机制。当一个高优先级任务被低优先级任务阻塞时，低优先级任务会暂时提升自己的优先级，以尽快释放互斥量，让高优先级任务继续执行。递归锁定：互斥量支
Enum 枚举 120153216 enum 枚举
原文地址：http://www.cnblogs.com/Kavlez/p/4268601.html Enumeration 于Java 1.5增加的enum type...enum type是由一组固定的常量组成的类型，比如四个季节、扑克花色。在出现enum type之前，通常用一组int常量表示枚举类型。比如这样： public static final int APPLE_FUJI = 0
Java8简明教程 bijian1013 java jdk1.8
Java 8已于2014年3月18日正式发布了，新版本带来了诸多改进，包括Lambda表达式、Streams、日期时间API等等。本文就带你领略Java 8的全新特性。一.允许在接口中有默认方法实现 Java 8 允许我们使用default关键字，为接口声明添
Oracle表维护快速备份删除数据 cuisuqiang oracle 索引快速备份删除
我知道oracle表分区，不过那是数据库设计阶段的事情，目前是远水解不了近渴。当前的数据库表，要求保留一个月数据，且表存在大量录入更新，不存在程序删除。为了解决频繁查询和更新的瓶颈，我在oracle内根据需要创建了索引。但是随着数据量的增加，一个半月数据就要超千万，此时就算有索引，对高并发的查询和更新来说，让然有所拖累。为了解决这个问题，我一般一个月会进行一次数据库维护，主要工作就是备
java多态内存分析麦田的设计者 java 内存分析多态原理接口和抽象类
“ 时针如果可以回头，熟悉那张脸，重温嬉戏这乐园，墙壁的松脱涂鸦已经褪色才明白存在的价值归于记忆。街角小店尚存在吗？这大时代会不会牵挂，过去现在花开怎么会等待。但有种意外不管痛不痛都有伤害，光阴远远离开，那笑声徘徊与脑海。但这一秒可笑不再可爱，当天心
Xshell实现Windows上传文件到Linux主机被触发 windows
经常有这样的需求，我们在Windows下载的软件包，如何上传到远程Linux主机上？还有如何从Linux主机下载软件包到Windows下；之前我的做法现在看来好笨好繁琐，不过也达到了目的，笨人有本方法嘛；我是怎么操作的： 1、打开一台本地Linux虚拟机，使用mount 挂载Windows的共享文件夹到Linux上，然后拷贝数据到Linux虚拟机里面；（经常第一步都不顺利，无法挂载Windo
类的加载ClassLoader 肆无忌惮_ ClassLoader
类加载器ClassLoader是用来将java的类加载到虚拟机中，类加载器负责读取class字节文件到内存中，并将它转为Class的对象（类对象），通过此实例的 newInstance()方法就可以创建出该类的一个对象。其中重要的方法为findClass(String name)。如何写一个自己的类加载器呢？首先写一个便于测试的类Student
html5写的玫瑰花知了ing html5
<html> <head> <title>I Love You!</title> <meta charset="utf-8" /> </head> <body> <canvas id="c"></canvas>
google的ConcurrentLinkedHashmap源代码解析矮蛋蛋 LRU
原文地址： http://janeky.iteye.com/blog/1534352 简述 ConcurrentLinkedHashMap 是google团队提供的一个容器。它有什么用呢？其实它本身是对 ConcurrentHashMap的封装，可以用来实现一个基于LRU策略的缓存。详细介绍可以参见 http://code.google.com/p/concurrentlinke
webservice获取访问服务的ip地址 alleni123 webservice
1. 首先注入javax.xml.ws.WebServiceContext, @Resource private WebServiceContext context; 2. 在方法中获取交换请求的对象。 javax.xml.ws.handler.MessageContext mc=context.getMessageContext(); com.sun.net.http
菜鸟的java基础提升之道——————>是否值得拥有百合不是茶
1，c++，java是面向对象编程的语言，将万事万物都看成是对象；java做一件事情关注的是人物，java是c++继承过来的，java没有直接更改地址的权限但是可以通过引用来传值操作地址，java也没有c++中繁琐的操作，java以其优越的可移植型，平台的安全型，高效性赢得了广泛的认同，全世界越来越多的人去学习java，我也是其中的一员 java组成：
通过修改Linux服务自动启动指定应用程序 bijian1013 linux
Linux中修改系统服务的命令是chkconfig (check config)，命令的详细解释如下: chkconfig 功能说明：检查，设置系统的各种服务。语　　法：chkconfig [ -- add][ -- del][ -- list][系统服务] 或 chkconfig [ -- level <</SPAN>
spring拦截器的一个简单实例 bijian1013 java spring 拦截器 Interceptor
Purview接口 package aop; public interface Purview { void checkLogin(); } Purview接口的实现类PurviesImpl.java package aop; public class PurviewImpl implements Purview { public void check
[Velocity二]自定义Velocity指令 bit1129 velocity
什么是Velocity指令在Velocity中，#set,#if, #foreach, #elseif, #parse等，以#开头的称之为指令，Velocity内置的这些指令可以用来做赋值，条件判断，循环控制等脚本语言必备的逻辑控制等语句，Velocity的指令是可扩展的，即用户可以根据实际的需要自定义Velocity指令自定义指令(Directive)的一般步骤 &nbs
【Hive十】Programming Hive学习笔记 bit1129 programming
第二章 Getting Started 1.Hive最大的局限性是什么？一是不支持行级别的增删改(insert, delete, update)二是查询性能非常差(基于Hadoop MapReduce）,不适合延迟小的交互式任务三是不支持事务2. Hive MetaStore是干什么的？Hive persists table schemas and other system metadata.
nginx有选择性进行限制 ronin47 nginx 动静　限制
http { limit_conn_zone $binary_remote_addr zone=addr:10m; limit_req_zone $binary_remote_addr zone=one:10m rate=5r/s;... server {... location ~.*\.(gif|png|css|js|icon)$ {
java-4.-在二元树中找出和为某一值的所有路径 . bylijinnan java
/* * 0.use a TwoWayLinkedList to store the path.when the node can't be path,you should/can delete it. * 1.curSum==exceptedSum:if the lastNode is TreeNode,printPath();delete the node otherwise
Netty学习笔记 bylijinnan java netty
本文是阅读以下两篇文章时： http://seeallhearall.blogspot.com/2012/05/netty-tutorial-part-1-introduction-to.html http://seeallhearall.blogspot.com/2012/06/netty-tutorial-part-15-on-channel.html 我的一些笔记 ===
js获取项目路径 cngolon js
//js获取项目根路径，如： http://localhost:8083/uimcardprj function getRootPath(){ //获取当前网址，如： http://localhost:8083/uimcardprj/share/meun.jsp var curWwwPath=window.document.locati
oracle 的性能优化 cuishikuan oracle SQL Server
在网上搜索了一些Oracle性能优化的文章，为了更加深层次的巩固[边写边记]，也为了可以随时查看，所以发表这篇文章。 1.ORACLE采用自下而上的顺序解析WHERE子句，根据这个原理，表之间的连接必须写在其他WHERE条件之前，那些可以过滤掉最大数量记录的条件必须写在WHERE子句的末尾。（这点本人曾经做过实例验证过，的确如此哦！
Shell变量和数组使用详解 daizj linux shell 变量数组
Shell 变量定义变量时，变量名不加美元符号（$，PHP语言中变量需要），如： your_name="w3cschool.cc" 注意，变量名和等号之间不能有空格，这可能和你熟悉的所有编程语言都不一样。同时，变量名的命名须遵循如下规则：首个字符必须为字母（a-z，A-Z）。中间不能有空格，可以使用下划线（_）。不能使用标点符号。不能使用ba
编程中的一些概念，KISS、DRY、MVC、OOP、REST dcj3sjt126com REST
KISS、DRY、MVC、OOP、REST （1）KISS是指Keep It Simple,Stupid（摘自wikipedia），指设计时要坚持简约原则，避免不必要的复杂化。（2）DRY是指Don't Repeat Yourself（摘自wikipedia），特指在程序设计以及计算中避免重复代码，因为这样会降低灵活性、简洁性，并且可能导致代码之间的矛盾。（3）OOP 即Object-Orie
[Android]设置Activity为全屏显示的两种方法 dcj3sjt126com Activity
1. 方法1：AndroidManifest.xml 里，Activity的 android:theme 指定为" @android:style/Theme.NoTitleBar.Fullscreen" 示例: <application
solrcloud 部署方式比较 eksliang solrCloud
solrcloud 的部署其实有两种方式可选，那么我们在实践开发中应该怎样选择呢？第一种：当启动solr服务器时，内嵌的启动一个Zookeeper服务器，然后将这些内嵌的Zookeeper服务器组成一个集群。第二种：将Zookeeper服务器独立的配置一个集群，然后将solr交给Zookeeper进行管理谈谈第一种：每启动一个solr服务器就内嵌的启动一个Zoo
Java synchronized关键字详解 gqdy365 synchronized
转载自：http://www.cnblogs.com/mengdd/archive/2013/02/16/2913806.html 多线程的同步机制对资源进行加锁，使得在同一个时间，只有一个线程可以进行操作，同步用以解决多个线程同时访问时可能出现的问题。同步机制可以使用synchronized关键字实现。当synchronized关键字修饰一个方法的时候，该方法叫做同步方法。当s
js实现登录时记住用户名 hw1287789687 记住我记住密码 cookie 记住用户名记住账号
在页面中如何获取cookie值呢? 如果是JSP的话,可以通过servlet的对象request 获取cookie,可以参考:http://hw1287789687.iteye.com/blog/2050040 如果要求登录页面是html呢?html页面中如何获取cookie呢? 直接上代码了页面:loginInput.html 代码: <!DOCTYPE html PUB
开发者必备的 Chrome 扩展 justjavac chrome
Firebug：不用多介绍了吧https://chrome.google.com/webstore/detail/bmagokdooijbeehmkpknfglimnifench ChromeSnifferPlus：Chrome 探测器，可以探测正在使用的开源软件或者 js 类库https://chrome.google.com/webstore/detail/chrome-sniffer-pl
算法机试题李亚飞 java 算法机试题
在面试机试时，遇到一个算法题，当时没能写出来，最后是同学帮忙解决的。这道题大致意思是：输入一个数，比如4,。这时会输出： &n
正确配置Linux系统ulimit值字符串 ulimit
在Linux下面部署应用的时候，有时候会遇上Socket/File: Can’t open so many files的问题；这个值也会影响服务器的最大并发数，其实Linux是有文件句柄限制的，而且Linux默认不是很高，一般都是1024，生产服务器用其实很容易就达到这个数量。下面说的是，如何通过正解配置来改正这个系统默认值。因为这个问题是我配置Nginx+php5时遇到了，所以我将这篇归纳进
hibernate调用返回游标的存储过程 Supanccy2013 java DAO oracle Hibernate jdbc
注：原创作品，转载请注明出处。上篇博文介绍的是hibernate调用返回单值的存储过程，本片博文说的是hibernate调用返回游标的存储过程。此此扁博文的存储过程的功能相当于是jdbc调用select 的作用。 1，创建oracle中的包，并在该包中创建的游标类型。 ---创建oracle的程
Spring 4.2新特性-更简单的Application Event wiselyman application
1.1 Application Event Spring 4.1的写法请参考10点睛Spring4.1-Application Event 请对比10点睛Spring4.1-Application Event 使用一个@EventListener取代了实现ApplicationListener接口,使耦合度降低; 1.2 示例包依赖 <p