寂寞的风来

STM32学习笔记八——I2C通信&SPI通信

I2C通信协议

I2C总线简介

硬件电路

I2C时序基本单元

I2C时序

MPU6050

MPU6050简介

MPU6050参数

MPU6050硬件电路

MPU6050框图

软件I2C读写MPU6050

软件I2C是通过GPIO引脚模拟I2C协议来进行通信的方法。以下是使用软件I2C读写MPU6050传感器的步骤：

初始化GPIO引脚：配置用于模拟I2C通信的GPIO引脚，包括SDA和SCL。

编写I2C函数：编写函数来模拟I2C通信协议，包括发送启动条件、发送停止条件、发送数据、接收数据等操作。

编写MPU6050函数：使用编写的I2C函数，实现MPU6050传感器的读写函数，包括初始化、读取加速度、读取陀螺仪等操作。

硬件I2C读写MPU6050

硬件I2C是使用STM32的硬件I2C外设来进行通信的方法。以下是使用硬件I2C读写MPU6050传感器的步骤：

初始化I2C外设：配置I2C外设，包括SDA、SCL引脚，以及I2C通信速率等。

编写I2C读写函数：使用HAL库或直接操作寄存器，编写I2C读写函数来发送启动条件、发送停止条件、发送数据、接收数据等操作。

编写MPU6050函数：使用编写的I2C函数，实现MPU6050传感器的读写函数，包括初始化、读取加速度、读取陀螺仪等操作。

软件I2C读写MPU6050

第一步：连接线路

第二步：编写程序

实验现象：在OLED屏幕上的第一行显示（MPU6050的ID号固定为0x68）ID号：68，第二行到第四行的左边内容是加速度传感器的输出数据，分别是X轴、Y轴和Z轴的加速度；右边三个是陀螺仪传感器的输出数据，分别是X轴、Y轴和Z轴的角速度。可以改变MPU6050的姿态，这些数据会发生变化。
main.c文件

#include "stm32f10x.h"                  // Device header
#include "Delay.h"
#include "OLED.h"
#include "MPU6050.h"

uint8_t ID;
//加速度和角速度的值
int16_t AX, AY, AZ, GX, GY, GZ;

int main(void)
{
	OLED_Init();
	MPU6050_Init();
	
	OLED_ShowString(1, 1, "ID:");
	ID = MPU6050_GetID();
	OLED_ShowHexNum(1, 4, ID, 2);
	
	while (1)
	{
		//读取数据
		MPU6050_GetData(&AX, &AY, &AZ, &GX, &GY, &GZ);
		OLED_ShowSignedNum(2, 1, AX, 5);
		OLED_ShowSignedNum(3, 1, AY, 5);
		OLED_ShowSignedNum(4, 1, AZ, 5);
		OLED_ShowSignedNum(2, 8, GX, 5);
		OLED_ShowSignedNum(3, 8, GY, 5);
		OLED_ShowSignedNum(4, 8, GZ, 5);
	}
}

MyI2C.c文件

#include "stm32f10x.h"                  // Device header
#include "Delay.h"

//引脚配置
//配置 I2C 时钟线的函数，BitValue 决定是否将时钟线拉高或拉低。
void MyI2C_W_SCL(uint8_t BitValue)
{
	GPIO_WriteBit(GPIOB,GPIO_Pin_10,(BitAction )BitValue );
	Delay_us(10);
}

//配置 I2C 数据线的函数，BitValue 决定是否将数据线拉高或拉低。
void MyI2C_W_SDA(uint8_t BitValue)
{
	GPIO_WriteBit(GPIOB,GPIO_Pin_11,(BitAction )BitValue );
	Delay_us(10);
}

//读取 I2C 数据线的函数，返回当前数据线的状态（高或低）。
uint8_t MyI2C_R_SDA(void )
{
	uint8_t BitValue;
	BitValue = GPIO_ReadInputDataBit(GPIOB ,GPIO_Pin_11);
	Delay_us(10);
	return BitValue ;
}

//初始化I2C
void MyI2C_Init(void)
{
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);
	
	GPIO_InitTypeDef GPIO_InitStructure;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD ;//开漏输出模式
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10 | GPIO_Pin_11; 
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz ;
	GPIO_Init(GPIOB ,&GPIO_InitStructure );
	
	GPIO_SetBits (GPIOB ,GPIO_Pin_10 | GPIO_Pin_11);
}

//发送 I2C 起始信号的函数。在 I2C 通信中，起始信号由数据线从高电平跳变到低电平，而时钟线保持高电平。
void MyI2C_Start(void)
{	
	MyI2C_W_SDA(1);
	MyI2C_W_SCL(1);
	MyI2C_W_SDA(0);
	MyI2C_W_SCL(0);
}

//发送 I2C 停止信号的函数。在 I2C 通信中，停止信号由数据线从低电平跳变到高电平，而时钟线保持高电平。
void MyI2C_Stop(void)
{	
	MyI2C_W_SDA(0);
	MyI2C_W_SCL(1);
	MyI2C_W_SDA(1);
}

//发送一个字节数据的函数。依次将字节的每个位（从高位到低位）写入数据线，并通过时钟线的上升沿和下降沿来进行数据传输。
void MyI2C_SendByte(uint8_t Byte)
{	
	uint8_t i;
	for (i = 0; i < 8; i ++)
	{
		MyI2C_W_SDA(Byte & (0x80 >> i));
		MyI2C_W_SCL(1);
		MyI2C_W_SCL(0);
	}
	//i=0,取Byte的最高位，结果为0x80(1)或0x00(0)
	//i=1,取Byte的次高位，结果为0x40(1)或0x00(0)
	//……依次取Byte的8位
}

//接收一个字节数据的函数。依次读取数据线的每个位，并在时钟线的上升沿和下降沿之间采样数据。
uint8_t MyI2C_ReceiveByte(void)
{
	uint8_t i,Byte = 0x00;
	MyI2C_W_SDA(1);
	for (i = 0; i < 8; i ++)
	{
		MyI2C_W_SCL(1);
		if (MyI2C_R_SDA() == 1){Byte |= (0x80 >> i);}
		MyI2C_W_SCL(0);
	}
	return Byte;
}

//发送应答信号的函数。根据 ACKBit 的值决定是否将数据线拉低（发送应答）或拉高（发送非应答）。
void MyI2C_SendAck(uint8_t AckBit)
{	
	MyI2C_W_SDA(AckBit);
	MyI2C_W_SCL(1);
	MyI2C_W_SCL(0);
}

//接收应答信号的函数。读取数据线的状态以确定是否接收到应答信号。
uint8_t MyI2C_ReceiveAck(void)
{
	uint8_t AckBit;
	MyI2C_W_SDA(1);
	MyI2C_W_SCL(1);
	AckBit = MyI2C_R_SDA();
	MyI2C_W_SCL(0);
	return AckBit;
}

MyI2C.h文件

#ifndef __MYI2C_H
#define __MYI2C_H

void MyI2C_Init(void);
void MyI2C_Start(void);
void MyI2C_Stop(void);
void MyI2C_SendByte(uint8_t Byte);
uint8_t MyI2C_ReceiveByte(void);
void MyI2C_SendAck(uint8_t AckBit);
uint8_t MyI2C_ReceiveAck(void);

#endif

MPU6050.c文件

#include "stm32f10x.h"                  // Device header
#include "MyI2C.h"
#include "MPU6050_Reg.h"

//宏定义了 MPU6050 设备的 I2C 地址
#define MPU6050_ADDRESS		0xD0

//写入 MPU6050 寄存器的函数。该函数通过 I2C 通信写入数据到指定寄存器。
void MPU6050_WriteReg(uint8_t RegAddress, uint8_t Data)
{
	MyI2C_Start();
	MyI2C_SendByte(MPU6050_ADDRESS);
	MyI2C_ReceiveAck();
	MyI2C_SendByte(RegAddress);
	MyI2C_ReceiveAck();
	MyI2C_SendByte(Data);
	MyI2C_ReceiveAck();
	MyI2C_Stop();
}

//读取 MPU6050 寄存器的函数。该函数通过 I2C 通信从指定寄存器读取数据。
uint8_t MPU6050_ReadReg(uint8_t RegAddress)
{
	uint8_t Data;
	
	MyI2C_Start();
	MyI2C_SendByte(MPU6050_ADDRESS);
	MyI2C_ReceiveAck();
	MyI2C_SendByte(RegAddress);
	MyI2C_ReceiveAck();
	
	MyI2C_Start();
	MyI2C_SendByte(MPU6050_ADDRESS | 0x01);
	MyI2C_ReceiveAck();
	Data = MyI2C_ReceiveByte();
	MyI2C_SendAck(1);
	MyI2C_Stop();
	
	return Data;
}

//初始化 MPU6050 模块的函数。
void MPU6050_Init(void)
{
	//初始化 I2C 总线
	MyI2C_Init();
	//向 MPU6050_PWR_MGMT_1 寄存器写入值 0x01，电源管理寄存器1
	MPU6050_WriteReg(MPU6050_PWR_MGMT_1, 0x01);
	//向 MPU6050_PWR_MGMT_2 寄存器写入值 0x00，电源管理寄存器2
	MPU6050_WriteReg(MPU6050_PWR_MGMT_2, 0x00);
	MPU6050_WriteReg(MPU6050_SMPLRT_DIV, 0x09);
	MPU6050_WriteReg(MPU6050_CONFIG, 0x06);
	MPU6050_WriteReg(MPU6050_GYRO_CONFIG, 0x18);
	MPU6050_WriteReg(MPU6050_ACCEL_CONFIG, 0x18);
}
//具体寄存器的配置参考数据手册

//获取 MPU6050 设备的ID。通过读取 "Who Am I" 寄存器，可以确定设备是否正常连接。
uint8_t MPU6050_GetID(void)
{
	return MPU6050_ReadReg(MPU6050_WHO_AM_I);
}

//获取 MPU6050 的数据。该函数读取加速度计和陀螺仪的数据，并将其保存在传入的指针变量中
void MPU6050_GetData(int16_t *AccX, int16_t *AccY, int16_t *AccZ, 
						int16_t *GyroX, int16_t *GyroY, int16_t *GyroZ)
{
	uint8_t DataH, DataL;
	
	DataH = MPU6050_ReadReg(MPU6050_ACCEL_XOUT_H);
	DataL = MPU6050_ReadReg(MPU6050_ACCEL_XOUT_L);
	*AccX = (DataH << 8) | DataL;
	
	DataH = MPU6050_ReadReg(MPU6050_ACCEL_YOUT_H);
	DataL = MPU6050_ReadReg(MPU6050_ACCEL_YOUT_L);
	*AccY = (DataH << 8) | DataL;
	
	DataH = MPU6050_ReadReg(MPU6050_ACCEL_ZOUT_H);
	DataL = MPU6050_ReadReg(MPU6050_ACCEL_ZOUT_L);
	*AccZ = (DataH << 8) | DataL;
	
	DataH = MPU6050_ReadReg(MPU6050_GYRO_XOUT_H);
	DataL = MPU6050_ReadReg(MPU6050_GYRO_XOUT_L);
	*GyroX = (DataH << 8) | DataL;
	
	DataH = MPU6050_ReadReg(MPU6050_GYRO_YOUT_H);
	DataL = MPU6050_ReadReg(MPU6050_GYRO_YOUT_L);
	*GyroY = (DataH << 8) | DataL;
	
	DataH = MPU6050_ReadReg(MPU6050_GYRO_ZOUT_H);
	DataL = MPU6050_ReadReg(MPU6050_GYRO_ZOUT_L);
	*GyroZ = (DataH << 8) | DataL;
}

MPU6050.h文件

#ifndef __MPU6050_H
#define __MPU6050_H

void MPU6050_WriteReg(uint8_t RegAddress, uint8_t Data);
uint8_t MPU6050_ReadReg(uint8_t RegAddress);

void MPU6050_Init(void);
uint8_t MPU6050_GetID(void);
void MPU6050_GetData(int16_t *AccX, int16_t *AccY, int16_t *AccZ, 
						int16_t *GyroX, int16_t *GyroY, int16_t *GyroZ);

#endif

MPU6050_Reg.h文件

#ifndef __MPU6050_REG_H
#define __MPU6050_REG_H

#define	MPU6050_SMPLRT_DIV		0x19
#define	MPU6050_CONFIG			0x1A
#define	MPU6050_GYRO_CONFIG		0x1B
#define	MPU6050_ACCEL_CONFIG	0x1C

#define	MPU6050_ACCEL_XOUT_H	0x3B
#define	MPU6050_ACCEL_XOUT_L	0x3C
#define	MPU6050_ACCEL_YOUT_H	0x3D
#define	MPU6050_ACCEL_YOUT_L	0x3E
#define	MPU6050_ACCEL_ZOUT_H	0x3F
#define	MPU6050_ACCEL_ZOUT_L	0x40
#define	MPU6050_TEMP_OUT_H		0x41
#define	MPU6050_TEMP_OUT_L		0x42
#define	MPU6050_GYRO_XOUT_H		0x43
#define	MPU6050_GYRO_XOUT_L		0x44
#define	MPU6050_GYRO_YOUT_H		0x45
#define	MPU6050_GYRO_YOUT_L		0x46
#define	MPU6050_GYRO_ZOUT_H		0x47
#define	MPU6050_GYRO_ZOUT_L		0x48

#define	MPU6050_PWR_MGMT_1		0x6B
#define	MPU6050_PWR_MGMT_2		0x6C
#define	MPU6050_WHO_AM_I		0x75

#endif

/*
#ifndef __MPU6050_REG_H 和 #define __MPU6050_REG_H：这是条件编译指令，用于防止头文件被重复包含。
这样的写法确保在同一编译单元（源文件）中只会包含一次这个头文件。

MPU6050_SMPLRT_DIV、MPU6050_CONFIG、MPU6050_GYRO_CONFIG、MPU6050_ACCEL_CONFIG：这些宏定义了一些
用于配置 MPU6050 的寄存器地址。它们表示采样率分频、配置寄存器、陀螺仪配置寄存器和加速度计配置寄
存器的地址。

MPU6050_ACCEL_XOUT_H 到 MPU6050_GYRO_ZOUT_L：这些宏定义了加速度计和陀螺仪数据的寄存器地址。用于
从 MPU6050 中读取传感器数据。

MPU6050_TEMP_OUT_H 和 MPU6050_TEMP_OUT_L：这两个宏定义了温度数据的寄存器地址。

MPU6050_PWR_MGMT_1 和 MPU6050_PWR_MGMT_2：这两个宏定义了电源管理寄存器的地址，用于配置 MPU6050 的
电源管理设置。

MPU6050_WHO_AM_I：这个宏定义了 "Who Am I" 寄存器的地址，用于验证设备的身份，通常用于确认与设备的通
信是否正常。

#endif：结束条件编译的指令。
*/

I2C通信外设

I2C外设简介

I2C框图

I2C基本结构

主机发送

主机接收

软件/硬件波形对比

硬件I2C读写MPU6050

第一步：连接线路

第二步：编写程序

#include "stm32f10x.h"                  // Device header
#include "Delay.h"
#include "OLED.h"
#include "MPU6050.h"

uint8_t ID;
int16_t AX, AY, AZ, GX, GY, GZ;

int main(void)
{
	OLED_Init();
	MPU6050_Init();
	
	OLED_ShowString(1, 1, "ID:");
	ID = MPU6050_GetID();
	OLED_ShowHexNum(1, 4, ID, 2);
	
	while (1)
	{
		MPU6050_GetData(&AX, &AY, &AZ, &GX, &GY, &GZ);
		OLED_ShowSignedNum(2, 1, AX, 5);
		OLED_ShowSignedNum(3, 1, AY, 5);
		OLED_ShowSignedNum(4, 1, AZ, 5);
		OLED_ShowSignedNum(2, 8, GX, 5);
		OLED_ShowSignedNum(3, 8, GY, 5);
		OLED_ShowSignedNum(4, 8, GZ, 5);
	}
}

MPU6050.c文件

#include "stm32f10x.h"                  // Device header
#include "MPU6050_Reg.h"

#define MPU6050_ADDRESS		0xD0

//等待指定的 I2C 事件发生
//它采用两个参数，第一个是 I2C 外设的指针（比如 I2C1 或 I2C2），第二个是要等待的 I2C 事件（比如 I2C_EVENT_MASTER_MODE_SELECT）
//使用了一个超时计数器，如果在一定的时间内没有检测到指定的 I2C 事件，则会退出等待
void MPU6050_WaitEvent(I2C_TypeDef* I2Cx, uint32_t I2C_EVENT)
{
	uint32_t Timeout;
	Timeout = 10000;
	while (I2C_CheckEvent(I2Cx, I2C_EVENT) != SUCCESS)
	{
		Timeout --;
		if (Timeout == 0)
		{
			break;
		}
	}
}

//用于向 MPU6050 的寄存器写入数据
//它采用两个参数，第一个是要写入数据的寄存器地址，第二个是要写入的数据
//
void MPU6050_WriteReg(uint8_t RegAddress, uint8_t Data)
{
	//生成 I2Cx 通信的起始条件
	I2C_GenerateSTART(I2C2, ENABLE);
	//等待主模式选择事件（MASTER MODE SELECT）。这个函数会一直等待，直到 I2C2 外设进入主模式
	MPU6050_WaitEvent(I2C2, I2C_EVENT_MASTER_MODE_SELECT);
	
	//发送地址字节以选择从设备，指示是写入操作（I2C_Direction_Transmitter）
	I2C_Send7bitAddress(I2C2, MPU6050_ADDRESS, I2C_Direction_Transmitter);
	//等待主模式的发送模式选择事件（MASTER TRANSMITTER MODE SELECTED）。这个函数会一直等待，直到 I2C2 进入主模式的发送模式
	MPU6050_WaitEvent(I2C2, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED);
	
	//通过 I2Cx 外设发送一个数据字节。
	I2C_SendData(I2C2, RegAddress);
	//等待主模式的字节发送事件（MASTER BYTE TRANSMITTING）。这个函数会一直等待，直到当前字节被发送
	MPU6050_WaitEvent(I2C2, I2C_EVENT_MASTER_BYTE_TRANSMITTING);
	
	I2C_SendData(I2C2, Data);
	//等待主模式的字节发送完成事件（MASTER BYTE TRANSMITTED）。这个函数会一直等待，直到当前字节发送完成
	MPU6050_WaitEvent(I2C2, I2C_EVENT_MASTER_BYTE_TRANSMITTED);
	
	//生成 I2Cx 通信的停止条件
	I2C_GenerateSTOP(I2C2, ENABLE);
}

//从 MPU6050 的寄存器读取数据
uint8_t MPU6050_ReadReg(uint8_t RegAddress)
{
	uint8_t Data;
	
	//生成 I2C2 通信的起始条件（START condition），启动通信
	I2C_GenerateSTART(I2C2, ENABLE);
	//等待主模式选择事件（MASTER MODE SELECT）。这个函数会一直等待，直到 I2C2 外设进入主模式
	MPU6050_WaitEvent(I2C2, I2C_EVENT_MASTER_MODE_SELECT);
	
	//发送 7 位的从设备地址，并指示是写入操作（I2C_Direction_Transmitter）。这里的 MPU6050_ADDRESS 是设备地址，低位是写入操作位
	I2C_Send7bitAddress(I2C2, MPU6050_ADDRESS, I2C_Direction_Transmitter);
	//等待主模式的发送模式选择事件（MASTER TRANSMITTER MODE SELECTED）。这个函数会一直等待，直到 I2C2 进入主模式的发送模式
	MPU6050_WaitEvent(I2C2, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED);
	
	//通过 I2C2 外设发送要读取的寄存器地址
	I2C_SendData(I2C2, RegAddress);
	//等待主模式的字节发送事件（MASTER BYTE TRANSMITTED）。这个函数会一直等待，直到当前字节被发送
	MPU6050_WaitEvent(I2C2, I2C_EVENT_MASTER_BYTE_TRANSMITTED);
	
	//生成 I2C2 通信的起始条件（START condition），重新启动通信
	I2C_GenerateSTART(I2C2, ENABLE);
	//等待主模式选择事件（MASTER MODE SELECT）。这个函数会一直等待，直到 I2C2 外设重新进入主模式
	MPU6050_WaitEvent(I2C2, I2C_EVENT_MASTER_MODE_SELECT);
	
	//发送 7 位的从设备地址，并指示是读取操作（I2C_Direction_Receiver）。这里的 MPU6050_ADDRESS 是设备地址，低位是读取操作位
	I2C_Send7bitAddress(I2C2, MPU6050_ADDRESS, I2C_Direction_Receiver);
	//等待主模式的接收模式选择事件（MASTER RECEIVER MODE SELECTED）。这个函数会一直等待，直到 I2C2 进入主模式的接收模式
	MPU6050_WaitEvent(I2C2, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED);
	
	//禁用应答位，表示这是最后一个要接收的字节
	I2C_AcknowledgeConfig(I2C2, DISABLE);
	//生成 I2C2 通信的停止条件（STOP condition），结束通信
	I2C_GenerateSTOP(I2C2, ENABLE);
	
	//等待主模式的字节接收事件（MASTER BYTE RECEIVED）。这个函数会一直等待，直到当前字节被接收
	MPU6050_WaitEvent(I2C2, I2C_EVENT_MASTER_BYTE_RECEIVED);
	//将从 I2C2 外设接收到的数据存储在 Data 变量中
	Data = I2C_ReceiveData(I2C2);
	
	//启用应答位，为将来的通信准备
	I2C_AcknowledgeConfig(I2C2, ENABLE);
	
	return Data;
}

//初始化 MPU6050 模块
void MPU6050_Init(void)
{
	//启用了 I2C2 和 GPIOB 的时钟
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C2, ENABLE);
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
	
	//初始化 GPIOB 引脚
	GPIO_InitTypeDef GPIO_InitStructure;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_OD;//复用开漏模式
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10 | GPIO_Pin_11;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOB, &GPIO_InitStructure);
	
	//初始化 I2C2 外设
	I2C_InitTypeDef I2C_InitStructure;
	I2C_InitStructure.I2C_Mode = I2C_Mode_I2C ;//将 I2C2 配置为 I2C 模式
	I2C_InitStructure.I2C_ClockSpeed = 50000;//设置 I2C2 的通信速率为 50000Hz
	I2C_InitStructure.I2C_DutyCycle = I2C_DutyCycle_2 ;//设置 I2C2 的时钟占空比为 2
	I2C_InitStructure.I2C_Ack = I2C_Ack_Enable;//启用 I2C2 的应答功能
	I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;//设置 I2C2 从设备地址的长度为 7 位
	I2C_InitStructure.I2C_OwnAddress1 = 0x00;//设置 I2C2 主设备自身的地址为 0x00（主设备不用于接收）
	I2C_Init(I2C2, &I2C_InitStructure);
	
	//使能 I2C2 外设
	I2C_Cmd(I2C2, ENABLE);
	
	//将 MPU6050 的电源管理寄存器1配置为唤醒状态。这意味着传感器会从休眠模式中唤醒，开始正常工作
	MPU6050_WriteReg(MPU6050_PWR_MGMT_1, 0x01);
	//将 MPU6050 的电源管理寄存器2配置为正常工作模式，不应用任何自动休眠或唤醒功能
	MPU6050_WriteReg(MPU6050_PWR_MGMT_2, 0x00);
	//将采样率分频器寄存器配置为将采样率从默认的 1kHz 降低到约 100Hz，因为 0x09 对应的分频系数是 10
	MPU6050_WriteReg(MPU6050_SMPLRT_DIV, 0x09);
	/*
	将配置寄存器配置为以下设置：
		低通滤波器带宽为 5 Hz。
		外部同步禁用。
	*/
	MPU6050_WriteReg(MPU6050_CONFIG, 0x06);
	/*
	这会将陀螺仪配置寄存器配置为以下设置：
		量程范围为 ±2000°/s。即陀螺仪的最大测量范围为 ±2000°/s。
		不应用自检功能。
	*/
	MPU6050_WriteReg(MPU6050_GYRO_CONFIG, 0x18);
	/*
	将加速度计配置寄存器配置为以下设置：
		量程范围为 ±16g。即加速度计的最大测量范围为 ±16g。
		不应用自检功能。
	*/
	MPU6050_WriteReg(MPU6050_ACCEL_CONFIG, 0x18);
}

//获取 MPU6050 的器件 ID
//调用了 MPU6050_ReadReg() 函数，读取了 MPU6050 的 MPU6050_WHO_AM_I 寄存器，该寄存器存储了 MPU6050 的唯一 ID
uint8_t MPU6050_GetID(void)
{
	return MPU6050_ReadReg(MPU6050_WHO_AM_I);
}

//这个函数用于获取 MPU6050 的加速度和陀螺仪数据
//通过一系列的 MPU6050_ReadReg() 函数来读取对应的寄存器数据，然后将高位和低位数据合并成一个 16 位的数据，最终得到加速度和陀螺仪的数据
void MPU6050_GetData(int16_t *AccX, int16_t *AccY, int16_t *AccZ, 
						int16_t *GyroX, int16_t *GyroY, int16_t *GyroZ)
{
	uint8_t DataH, DataL;
	
	//从寄存器 MPU6050_ACCEL_XOUT_H 读取加速度计 X 轴的高字节数据，并将其存储在 DataH 中
	DataH = MPU6050_ReadReg(MPU6050_ACCEL_XOUT_H);
	//从寄存器 MPU6050_ACCEL_XOUT_L 读取加速度计 X 轴的低字节数据，并将其存储在 DataL 中
	DataL = MPU6050_ReadReg(MPU6050_ACCEL_XOUT_L);
	//将 DataH 左移 8 位，然后与 DataL 进行按位或操作，得到一个 16 位的加速度计 X 轴数据，将结果存储在 *AccX 指向的变量中
	*AccX = (DataH << 8) | DataL;
	
	DataH = MPU6050_ReadReg(MPU6050_ACCEL_YOUT_H);
	DataL = MPU6050_ReadReg(MPU6050_ACCEL_YOUT_L);
	*AccY = (DataH << 8) | DataL;
	
	DataH = MPU6050_ReadReg(MPU6050_ACCEL_ZOUT_H);
	DataL = MPU6050_ReadReg(MPU6050_ACCEL_ZOUT_L);
	*AccZ = (DataH << 8) | DataL;
	
	//从寄存器 MPU6050_GYRO_XOUT_H 读取陀螺仪 X 轴的高字节数据，并将其存储在 DataH 中
	DataH = MPU6050_ReadReg(MPU6050_GYRO_XOUT_H);
	//从寄存器 MPU6050_GYRO_XOUT_L 读取陀螺仪 X 轴的低字节数据，并将其存储在 DataL 中
	DataL = MPU6050_ReadReg(MPU6050_GYRO_XOUT_L);
	//将 DataH 左移 8 位，然后与 DataL 进行按位或操作，得到一个 16 位的陀螺仪 X 轴数据，将结果存储在 *GyroX 指向的变量中
	*GyroX = (DataH << 8) | DataL;
	
	DataH = MPU6050_ReadReg(MPU6050_GYRO_YOUT_H);
	DataL = MPU6050_ReadReg(MPU6050_GYRO_YOUT_L);
	*GyroY = (DataH << 8) | DataL;
	
	DataH = MPU6050_ReadReg(MPU6050_GYRO_ZOUT_H);
	DataL = MPU6050_ReadReg(MPU6050_GYRO_ZOUT_L);
	*GyroZ = (DataH << 8) | DataL;
}

MPU6050.h文件

#ifndef __MPU6050_H
#define __MPU6050_H

void MPU6050_WriteReg(uint8_t RegAddress, uint8_t Data);
uint8_t MPU6050_ReadReg(uint8_t RegAddress);

void MPU6050_Init(void);
uint8_t MPU6050_GetID(void);
void MPU6050_GetData(int16_t *AccX, int16_t *AccY, int16_t *AccZ, 
						int16_t *GyroX, int16_t *GyroY, int16_t *GyroZ);

#endif

SPI通信协议

SPI通信

I2C（内部集成电路）和 SPI（串行外设接口）都是嵌入式系统（包括 STM32 微控制器）中使用的流行串行通信协议。它们服务于不同的目的并具有不同的特征。以下是STM32上I2C和SPI的异同：

相似之处：

串行通信： I2C和SPI都是串行通信协议，用于微控制器和各种外设之间交换数据。
主从架构： 两种协议都支持主从架构，其中微控制器（主）控制一个或多个外围设备（从）。
同步通信： 两种协议都是同步的，这意味着它们使用时钟信号来同步主设备和从设备之间的数据传输。
寻址： 两种协议都有寻址机制。 I2C 设备使用 7 位或 10 位地址进行寻址，而 SPI 通常使用片选 (CS) 信号来选择目标设备。
硬件支持： STM32 微控制器具有对 I2C 和 SPI 的内置硬件支持，无需大量软件开销即可实现高效通信。

差异：

总线配置：
- I2C：I2C 使用 2 线总线（SCL 用于时钟，SDA 用于数据），多个设备连接到同一总线。它需要在总线上有上拉电阻。
- SPI：SPI 使用单独的线来传输数据（MOSI 和 MISO）、时钟（SCK）和片选（CS）。它支持与多个设备通信，但每个设备都需要专用的CS线。
数据传输：
- I2C：I2C支持多主多从通信。数据以具有开始和停止条件的帧形式传输，使其适合较慢的数据速率和更简单的设置。
- SPI：SPI 通常比 I2C 更快，并且支持全双工通信。它适用于更高的数据速率和需要更多带宽的应用。
时钟信号：
- I2C：I2C 使用在总线上的所有设备之间共享的单个时钟信号。
- SPI：SPI 对连接到总线的每个从设备使用单独的时钟信号。
比特率：
- I2C：I2C支持各种比特率，不同时钟速度的设备可以在同一总线上共存。
- SPI：SPI的时钟速度由主机决定，总线上的所有设备都以相同的速度运行。
电线数量：
- I2C：与 SPI 相比，I2C 需要更少的电线 (2)。
- SPI：由于数据线和时钟线是分开的，SPI 通常需要更多线（4 条或更多）。
协议开销：
- I2C：由于启动和停止条件，I2C 具有更多的协议开销，使其比 SPI 稍慢。
- SPI：SPI 的协议开销较少，并且通常比 I2C 更快。

综上所述，I2C和SPI都是STM32生态系统中有价值的通信协议，它们之间的选择取决于数据速率、设备数量和硬件复杂性等因素。 I2C 适用于较慢的数据速率和可以共享总线的设备，而 SPI 提供更高的数据速率和更灵活的配置选项，但需要更多的电线（SS）。

硬件电路

移位示意图

SPI时序基本单元

SPI 模式 0：

CPOL（时钟极性）： 时钟线的空闲状态为低电平。
CPHA（时钟相位）： 数据在时钟的第一个边沿（上升沿）捕获，并在第二个边沿（下降沿）传播。

STM32 SPI 交换一个字节的过程（模式0）：

配置：
- 配置 SPI 外设：设置通信模式（模式 0）、时钟极性、时钟相位、数据顺序（MSB 或 LSB 在前）以及数据帧格式（8 或 16 位）。
片选（CS）激活：
- 如果多个从设备连接到 SPI 总线，则通过将其 CS 线驱动为低电平来选择目标从设备。
数据传输：
- 准备要传输的数据字节。
开始计时：
- 时钟线（SCK）从低电平（CPOL = 0）开始。
数据交换 - 上升沿 (CPHA = 0):
- 在时钟的第一个上升沿，主机输出数据字节的最高有效位 (MSB)。
- 从机在时钟的上升沿采样数据。
时钟转换 - 下降沿：
- 时钟从低电平转换为高电平 (CPHA = 0)。
数据移位 - 下降沿：
- 在时钟的下降沿，主器件移位数据字节的剩余位（从 MSB 到 LSB），同时从器件移入接收到的数据。
时钟转换 - 上升沿：
- 时钟从高电平转换为低电平。
数据接收 - 上升沿：
- 在时钟的下一个上升沿，主机从从机接收数据字节的最低有效位 (LSB)。
时钟转换 - 下降沿：
- 时钟从低电平转换为高电平。
数据移位和完成 - 下降沿：
- 时钟继续切换，主设备和从设备都会移位剩余的位。
- 当时钟再次达到低电平时，完整的数据字节被交换。
芯片选择停用：
- 如有必要，通过将 CS 线驱动为高电平来停用 CS 线，以结束与所选从机的通信。
完成：
- 当前数据字节的 SPI 通信已完成。

在 SPI 模式 0（CPOL = 0，CPHA = 0）下，数据在时钟的第一个边沿（上升沿）移入，数据在第二个边沿（下降沿）移出。此模式可确保数据在主设备和从设备之间正确采样和传播，同时遵守指定的时钟极性和相位。

SPI 模式 1：

CPOL（时钟极性）： 时钟线的空闲状态为低电平。
CPHA（时钟相位）： 数据在时钟的上升沿捕获并在下降沿传播。

STM32 SPI 交换一个字节的过程（模式1）：

配置：
- 配置 SPI 外设：设置通信模式（模式 1）、时钟极性、时钟相位、数据顺序（MSB 或 LSB 在前）以及数据帧格式（8 或 16 位）。
片选（CS）激活：
- 如果多个从设备连接到 SPI 总线，则通过将其 CS 线驱动为低电平来选择目标从设备。
数据传输：
- 准备要传输的数据字节。
开始计时：
- 时钟线（SCK）从低电平（CPOL = 0）开始。
数据交换：
- 在时钟的上升沿（CPHA = 0），主机输出数据字节的最高有效位（MSB）。
- 从机在时钟的上升沿采样数据。
时钟转换：
- 时钟从低电平转换为高电平 (CPHA = 0)。
数据转移：
- 在时钟的下降沿，主器件移位数据字节的剩余位（从 MSB 到 LSB），同时从器件移入接收到的数据。
时钟转换：
- 时钟从高电平转换为低电平。
数据接收：
- 在时钟的下一个上升沿，主机从从机接收数据字节的最低有效位 (LSB)。
时钟转换：
- 时钟从低电平转换为高电平。
数据转移和完成：
- 时钟继续切换，主设备和从设备都会移位剩余的位。
- 当时钟再次达到高电平时，完整的数据字节被交换。
芯片选择停用：
- 如有必要，通过将 CS 线驱动为高电平来停用 CS 线，以结束与所选从机的通信。
完成：
- 当前数据字节的 SPI 通信已完成。

在 SPI 模式 1 中，数据在时钟的上升沿捕获并在下降沿传播。该模式常用于各种应用，并且在数据同步方面提供了灵活性。

SPI 模式 2：

CPOL（时钟极性）： 时钟线的空闲状态为高电平。
CPHA（时钟相位）： 数据在时钟的第一个边沿（上升沿）捕获，并在第二个边沿（下降沿）传播。

STM32 SPI 交换一个字节的过程（模式2）：

配置：
- 配置 SPI 外设：设置通信模式（模式 2）、时钟极性、时钟相位、数据顺序（MSB 或 LSB 在前）以及数据帧格式（8 或 16 位）。
片选（CS）激活：
- 如果多个从设备连接到 SPI 总线，则通过将其 CS 线驱动为低电平来选择目标从设备。
数据传输：
- 准备要传输的数据字节。
开始计时：
- 时钟线（SCK）从高电平（CPOL = 1）开始。
数据交换 - 上升沿 (CPHA = 0):
- 在时钟的第一个上升沿，主机输出数据字节的最高有效位 (MSB)。
- 从机在时钟的上升沿采样数据。
时钟转换 - 下降沿：
- 时钟从高电平转换为低电平 (CPHA = 0)。
数据移位 - 下降沿：
- 在时钟的下降沿，主器件移位数据字节的剩余位（从 MSB 到 LSB），同时从器件移入接收到的数据。
时钟转换 - 上升沿：
- 时钟从低电平转换为高电平。
数据接收 - 上升沿：
- 在时钟的下一个上升沿，主机从从机接收数据字节的最低有效位 (LSB)。
时钟转换 - 下降沿：
- 时钟从高电平转换为低电平。
数据移位和完成 - 下降沿：
- 时钟继续切换，主设备和从设备都会移位剩余的位。
- 当时钟再次达到低电平时，完整的数据字节被交换。
芯片选择停用：
- 如有必要，通过将 CS 线驱动为高电平来停用 CS 线，以结束与所选从机的通信。
完成：
- 当前数据字节的 SPI 通信已完成。

在 SPI 模式 2（CPOL = 1，CPHA = 0）下，时钟线在空闲状态期间处于高电平状态，数据在时钟上升沿（CPHA = 0）移入。然后，数据在时钟的下降沿移出，确保正确的数据采样和传播，同时遵守指定的时钟极性和相位。

SPI 模式 3：

CPOL（时钟极性）： 时钟线的空闲状态为高电平。
CPHA（时钟相位）： 数据在时钟的第二个边沿（下降沿）捕获并在第一个边沿（上升沿）传播。

STM32 SPI 交换一个字节的过程（模式3）：

配置：
- 配置 SPI 外设：设置通信模式（模式 3）、时钟极性、时钟相位、数据顺序（MSB 或 LSB 在前）以及数据帧格式（8 或 16 位）。
片选（CS）激活：
- 如果多个从设备连接到 SPI 总线，则通过将其 CS 线驱动为低电平来选择目标从设备。
数据传输：
- 准备要传输的数据字节。
开始计时：
- 时钟线（SCK）从高电平（CPOL = 1）开始。
数据移位 - 下降沿 (CPHA = 1)：
- 在时钟的第一个下降沿，主机移出数据字节的最高有效位 (MSB)。
- 从机在时钟的下降沿采样数据。
时钟转换 - 上升沿：
- 时钟从低电平转换为高电平 (CPHA = 1)。
数据交换 - 上升沿：
- 在时钟的上升沿，主机输出数据字节的剩余位（从 MSB 到 LSB）。
- 从机在时钟的上升沿移入接收到的数据。
时钟转换 - 下降沿：
- 时钟从高电平转换为低电平。
数据接收 - 下降沿：
- 在时钟的下降沿，主机从从机接收数据字节的最低有效位 (LSB)。
时钟转换 - 上升沿：
- 时钟从低电平转换为高电平。
数据移位和完成 - 上升沿：
- 时钟继续切换，主设备和从设备都会移位剩余的位。
- 当时钟再次达到高电平时，完整的数据字节被交换。
芯片选择停用：
- 如有必要，通过将 CS 线驱动为高电平来停用 CS 线，以结束与所选从机的通信。
完成：
- 当前数据字节的 SPI 通信已完成。

在 SPI 模式 3（CPOL = 1，CPHA = 1）下，时钟线在空闲状态期间处于高电平状态，数据在时钟的第一个沿（下降沿）移出，而数据在时钟的第一个沿（下降沿）移入。时钟的第二个沿（上升沿）。此模式可确保正确的数据采样和传播，同时遵守指定的时钟极性和相位。

SPI时序

W25Q64

W25Q64简介

硬件电路

W25Q64框图

Flash操作注意事项

软件SPI读写W25Q64

软件SPI是通过GPIO引脚模拟SPI协议来进行通信的方法。以下是使用软件SPI读写W25Q64 Flash存储器的步骤：

初始化GPIO引脚：配置用于模拟SPI通信的GPIO引脚，包括SCK、MISO、MOSI和CS。

编写SPI函数：编写函数来模拟SPI通信协议，包括发送和接收数据的逻辑。这些函数可能包括发送一个位、发送一个字节、接收一个字节等。

编写W25Q64函数：使用编写的SPI函数，实现W25Q64 Flash存储器的读写函数，包括写使能、擦除、编程等操作。

硬件SPI读写W25Q64

硬件SPI是使用STM32的硬件SPI外设来进行通信的方法。以下是使用硬件SPI读写W25Q64 Flash存储器的步骤：

初始化SPI外设：配置SPI外设，包括SCK、MISO、MOSI引脚，以及SPI通信模式、数据速率等。

编写SPI读写函数：使用HAL库或直接操作寄存器，编写SPI读写函数来发送和接收数据。

编写W25Q64函数：使用编写的SPI函数，实现W25Q64 Flash存储器的读写函数，包括写使能、擦除、编程等操作。

软件SPI读写W25Q64

第一步：连接线路

第二步：编写程序

实验现象：在OLED屏幕上，第一行显示为制造商ID和设备ID，第二行为W：写入数据，第三行为R：读取数据
main.c文件

#include "stm32f10x.h"                  // Device header
#include "Delay.h"
#include "OLED.h"
#include "W25Q64.h"

//定义了全局变量MID和DID，用于存储从W25Q64 Flash存储器读取的制造商ID和设备ID
uint8_t MID;
uint16_t DID;

uint8_t ArrayWrite[] = {0x01, 0x02, 0x03, 0x04};
uint8_t ArrayRead[4];

int main(void)
{
	OLED_Init();
	W25Q64_Init();
	
	OLED_ShowString(1, 1, "MID:   DID:");
	OLED_ShowString(2, 1, "W:");
	OLED_ShowString(3, 1, "R:");
	
	//调用W25Q64_ReadID函数从W25Q64中读取制造商ID和设备ID
	W25Q64_ReadID(&MID, &DID);
	OLED_ShowHexNum(1, 5, MID, 2);
	OLED_ShowHexNum(1, 12, DID, 4);
	
	/*
	擦除扇区并编程数据：首先，调用W25Q64_SectorErase函数擦除W25Q64的一个扇区（地址为0x000000）。
	然后，调用W25Q64_PageProgram函数将写入数组ArrayWrite中的数据编程到W25Q64的相同扇区中（地址为0x000000）
	*/
	W25Q64_SectorErase(0x000000);
	W25Q64_PageProgram(0x000000, ArrayWrite, 4);
	
	//调用W25Q64_ReadData函数从W25Q64的相同扇区中（地址为0x000000）读取数据，并将读取的数据存储在数组ArrayRead中
	W25Q64_ReadData(0x000000, ArrayRead, 4);
	
	OLED_ShowHexNum(2, 3, ArrayWrite[0], 2);
	OLED_ShowHexNum(2, 6, ArrayWrite[1], 2);
	OLED_ShowHexNum(2, 9, ArrayWrite[2], 2);
	OLED_ShowHexNum(2, 12, ArrayWrite[3], 2);
	
	OLED_ShowHexNum(3, 3, ArrayRead[0], 2);
	OLED_ShowHexNum(3, 6, ArrayRead[1], 2);
	OLED_ShowHexNum(3, 9, ArrayRead[2], 2);
	OLED_ShowHexNum(3, 12, ArrayRead[3], 2);
	
	while (1)
	{
		
	}
}

MySPI.c文件

#include "stm32f10x.h"                  // Device header

//用于设置片选信号（SS）。当SS为高电平时，MOSI线会被拉低，从而选择从设备
void MySPI_W_SS(uint8_t BitValue)
{
	GPIO_WriteBit (GPIOA,GPIO_Pin_4 ,(BitAction )BitValue );
}

//用于设置时钟信号（SCK）。当SCK为高电平时，每个时钟周期都会传输一个位
void MySPI_W_SCK(uint8_t BitValue)
{
	GPIO_WriteBit (GPIOA,GPIO_Pin_5 ,(BitAction )BitValue );
}

//用于设置主设备输出从设备输入（MOSI）线。当MOSI线被拉低时，它会将数据位发送到从设备
void MySPI_W_MOSI(uint8_t BitValue)
{
	GPIO_WriteBit (GPIOA,GPIO_Pin_7 ,(BitAction )BitValue );
}

//用于读取从设备的MISO线。如果MISO线为高电平，那么从设备已经成功接收了一个位
uint8_t MySPI_R_MISO(void)
{
	return GPIO_ReadInputDataBit (GPIOA ,GPIO_Pin_6);
}

//初始化SPI
void MySPI_Init(void)
{
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
	
	GPIO_InitTypeDef GPIO_InitStructure;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP ;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_7; 
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz ;
	GPIO_Init(GPIOA ,&GPIO_InitStructure );	
	
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU  ;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6; 
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz ;
	GPIO_Init(GPIOA ,&GPIO_InitStructure );	
	
	MySPI_W_SS(1);
	MySPI_W_SCK(0);
}

//用于开始SPI通信。它通过将片选信号设置为高电平来启动SPI
void MySPI_Start(void)
{
	MySPI_W_SS(0);
}

//用于停止SPI通信。它通过将片选信号设置为低电平来停止SPI
void MySPI_Stop(void)
{
	MySPI_W_SS(1);
}

//用于通过SPI交换一个字（8位）。它通过循环发送和接收数据来实现字的交换
uint8_t MySPI_SwapByte(uint8_t ByteSend)
{
	uint8_t i, ByteReceive = 0x00;
	
	for(i = 0; i < 8; i ++)
	{
		MySPI_W_MOSI(ByteSend & (0x80 >>i));
		MySPI_W_SCK(1);
		if ( MySPI_R_MISO() == 1){ByteReceive |= (0x80 >>i);}
		MySPI_W_SCK(0);
	}
	
	return ByteReceive;
}

MySPI.h文件

#ifndef __MYSPI_H
#define __MYSPI_H

void MySPI_Init(void);
void MySPI_Start(void);
void MySPI_Stop(void);
uint8_t MySPI_SwapByte(uint8_t ByteSend);

#endif

W25Q64.c文件

#include "stm32f10x.h"                  // Device header
#include "MySPI.h"
#include "W25Q64_Ins.h"

//用于初始化与W25Q64 Flash存储器通信所需要的SPI接口,调用了MySPI_Init()函数来初始化SPI通信
void W25Q64_Init(void)
{
	MySPI_Init();
}

/*
这个函数用于读取W25Q64 Flash存储器的制造商ID（MID）和设备ID（DID）。
函数首先启动SPI通信，发送命令来获取ID信息，然后读取制造商ID和设备ID，
	将设备ID左移8位并与另一个字节合并，最终获取完整的设备ID。
函数结束后关闭SPI通信。
*/
void W25Q64_ReadID(uint8_t *MID, uint16_t *DID)
{
	MySPI_Start();
	MySPI_SwapByte(W25Q64_JEDEC_ID);
	*MID = MySPI_SwapByte(W25Q64_DUMMY_BYTE);
	*DID = MySPI_SwapByte(W25Q64_DUMMY_BYTE);
	*DID <<= 8;
	*DID |= MySPI_SwapByte(W25Q64_DUMMY_BYTE);
	MySPI_Stop();
}

/*
这个函数发送命令给W25Q64 Flash存储器，使其允许写入操作。
函数启动SPI通信，发送写使能命令，然后关闭SPI通信。
*/
void W25Q64_WriteEnable(void)
{
	MySPI_Start();
	MySPI_SwapByte(W25Q64_WRITE_ENABLE);
	MySPI_Stop();
}

/*
这个函数用于等待W25Q64 Flash存储器完成其内部操作，例如擦除、编程等。
函数发送读取状态寄存器命令，然后循环读取状态寄存器的忙标志位，直到标志位为0或达到超时限制。
函数结束后关闭SPI通信。
*/
void W25Q64_WaitBusy(void)
{
	uint32_t Timeout;
	MySPI_Start();
	MySPI_SwapByte(W25Q64_READ_STATUS_REGISTER_1);
	Timeout = 100000;
	while ((MySPI_SwapByte(W25Q64_DUMMY_BYTE) & 0x01) == 0x01)
	{
		Timeout --;
		if (Timeout == 0)
		{
			break;
		}
	}
	MySPI_Stop();
}

/*
这个函数用于向W25Q64 Flash存储器的指定页写入数据。
函数首先发送写使能命令，然后启动SPI通信，发送页编程命令和地址，然后循环发送数据数组中的数据。
函数结束后关闭SPI通信，并调用W25Q64_WaitBusy()等待存储器完成操作。
*/
void W25Q64_PageProgram(uint32_t Address, uint8_t *DataArray, uint16_t Count)
{
	uint16_t i;
	
	W25Q64_WriteEnable();
	
	MySPI_Start();
	MySPI_SwapByte(W25Q64_PAGE_PROGRAM);
	MySPI_SwapByte(Address >> 16);
	MySPI_SwapByte(Address >> 8);
	MySPI_SwapByte(Address);
	for (i = 0; i < Count; i ++)
	{
		MySPI_SwapByte(DataArray[i]);
	}
	MySPI_Stop();
	
	W25Q64_WaitBusy();
}

/*
这个函数用于擦除W25Q64 Flash存储器的指定扇区。
函数首先发送写使能命令，然后启动SPI通信，发送扇区擦除命令和地址。
函数结束后关闭SPI通信，并调用W25Q64_WaitBusy()等待存储器完成擦除。
*/
void W25Q64_SectorErase(uint32_t Address)
{
	W25Q64_WriteEnable();
	
	MySPI_Start();
	MySPI_SwapByte(W25Q64_SECTOR_ERASE_4KB);
	MySPI_SwapByte(Address >> 16);
	MySPI_SwapByte(Address >> 8);
	MySPI_SwapByte(Address);
	MySPI_Stop();
	
	W25Q64_WaitBusy();
}

/*
这个函数用于从W25Q64 Flash存储器的指定地址开始读取一定数量的数据。
函数首先启动SPI通信，发送读取数据命令和地址，然后循环接收数据并存储到数据数组中。
函数结束后关闭SPI通信。
*/
void W25Q64_ReadData(uint32_t Address, uint8_t *DataArray, uint32_t Count)
{
	uint32_t i;
	MySPI_Start();
	MySPI_SwapByte(W25Q64_READ_DATA);
	MySPI_SwapByte(Address >> 16);
	MySPI_SwapByte(Address >> 8);
	MySPI_SwapByte(Address);
	for (i = 0; i < Count; i ++)
	{
		DataArray[i] = MySPI_SwapByte(W25Q64_DUMMY_BYTE);
	}
	MySPI_Stop();
}

W25Q64.h文件

#ifndef __W25Q64_H
#define __W25Q64_H

void W25Q64_Init(void);
void W25Q64_ReadID(uint8_t *MID, uint16_t *DID);
void W25Q64_PageProgram(uint32_t Address, uint8_t *DataArray, uint16_t Count);
void W25Q64_SectorErase(uint32_t Address);
void W25Q64_ReadData(uint32_t Address, uint8_t *DataArray, uint32_t Count);

#endif

W25Q64_Ins.h文件

#ifndef __W25Q64_INS_H
#define __W25Q64_INS_H

#define W25Q64_WRITE_ENABLE							0x06
#define W25Q64_WRITE_DISABLE						0x04
#define W25Q64_READ_STATUS_REGISTER_1				0x05
#define W25Q64_READ_STATUS_REGISTER_2				0x35
#define W25Q64_WRITE_STATUS_REGISTER				0x01
#define W25Q64_PAGE_PROGRAM							0x02
#define W25Q64_QUAD_PAGE_PROGRAM					0x32
#define W25Q64_BLOCK_ERASE_64KB						0xD8
#define W25Q64_BLOCK_ERASE_32KB						0x52
#define W25Q64_SECTOR_ERASE_4KB						0x20
#define W25Q64_CHIP_ERASE							0xC7
#define W25Q64_ERASE_SUSPEND						0x75
#define W25Q64_ERASE_RESUME							0x7A
#define W25Q64_POWER_DOWN							0xB9
#define W25Q64_HIGH_PERFORMANCE_MODE				0xA3
#define W25Q64_CONTINUOUS_READ_MODE_RESET			0xFF
#define W25Q64_RELEASE_POWER_DOWN_HPM_DEVICE_ID		0xAB
#define W25Q64_MANUFACTURER_DEVICE_ID				0x90
#define W25Q64_READ_UNIQUE_ID						0x4B
#define W25Q64_JEDEC_ID								0x9F
#define W25Q64_READ_DATA							0x03
#define W25Q64_FAST_READ							0x0B
#define W25Q64_FAST_READ_DUAL_OUTPUT				0x3B
#define W25Q64_FAST_READ_DUAL_IO					0xBB
#define W25Q64_FAST_READ_QUAD_OUTPUT				0x6B
#define W25Q64_FAST_READ_QUAD_IO					0xEB
#define W25Q64_OCTAL_WORD_READ_QUAD_IO				0xE3

#define W25Q64_DUMMY_BYTE							0xFF

#endif


/*
W25Q64_WRITE_ENABLE：启用写操作使能命令。
W25Q64_WRITE_DISABLE：禁用写操作使能命令。
W25Q64_READ_STATUS_REGISTER_1：读取状态寄存器1命令。
W25Q64_READ_STATUS_REGISTER_2：读取状态寄存器2命令。
W25Q64_WRITE_STATUS_REGISTER：写入状态寄存器命令。
W25Q64_PAGE_PROGRAM：页编程命令。
W25Q64_QUAD_PAGE_PROGRAM：四线编程命令。
W25Q64_BLOCK_ERASE_64KB：64KB块擦除命令。
W25Q64_BLOCK_ERASE_32KB：32KB块擦除命令。
W25Q64_SECTOR_ERASE_4KB：4KB扇区擦除命令。
W25Q64_CHIP_ERASE：整片擦除命令。
W25Q64_ERASE_SUSPEND：擦除暂停命令。
W25Q64_ERASE_RESUME：擦除恢复命令。
W25Q64_POWER_DOWN：进入掉电模式命令。
W25Q64_HIGH_PERFORMANCE_MODE：高性能模式命令。
W25Q64_CONTINUOUS_READ_MODE_RESET：连续读模式复位命令。
W25Q64_RELEASE_POWER_DOWN_HPM_DEVICE_ID：释放掉电和高性能模式下设备ID读取命令。
W25Q64_MANUFACTURER_DEVICE_ID：制造商设备ID读取命令。
W25Q64_READ_UNIQUE_ID：读取唯一ID命令。
W25Q64_JEDEC_ID：JEDEC ID读取命令。
W25Q64_READ_DATA：读取数据命令。
W25Q64_FAST_READ：快速读取命令。
W25Q64_FAST_READ_DUAL_OUTPUT：快速双输出读取命令。
W25Q64_FAST_READ_DUAL_IO：快速双输入输出读取命令。
W25Q64_FAST_READ_QUAD_OUTPUT：快速四输出读取命令。
W25Q64_FAST_READ_QUAD_IO：快速四输入输出读取命令。
W25Q64_OCTAL_WORD_READ_QUAD_IO：八线字节读取四输入输出读取命令。
W25Q64_DUMMY_BYTE：虚拟的填充字节，用于在读取操作中填充空位。
*/

SPI通信外设

SPI外设简介

I2S也是一种3引脚的同步串行接口通讯协议。它支持四种音频标准，包括飞利浦I2S标准，MSB和LSB对齐标准，以及PCM标准。它在半双工通讯中，可以工作在主和从2种模式下。当它作为主设备时，通过接口向外部的从设备提供时钟信号。

SPI框图

通常SPI通过4个引脚与外部器件相连：
● MISO：主设备输入/从设备输出引脚。该引脚在从模式下发送数据，在主模式下接收数据。
● MOSI：主设备输出/从设备输入引脚。该引脚在主模式下发送数据，在从模式下接收数据。
● SCK：串口时钟，作为主设备的输出，从设备的输入
● NSS：从设备选择。这是一个可选的引脚，用来选择主/从设备。它的功能是用来作为“片选引脚”，让主设备可以单独地与特定从设备通讯，避免数据线上的冲突。从设备的NSS引脚可以由主设备的一个标准I/O引脚来驱动。一旦被使能(SSOE位)，NSS引脚也可以作为输出引脚，并在SPI处于主模式时拉低；此时，所有的SPI设备，如果它们的NSS引脚连接到主设备的NSS引脚，则会检测到低电平，如果它们被设置为NSS硬件模式，就会自动进入从设备状态。当配置为主设备、NSS配置为输入引脚(MSTR=1，SSOE=0)时，如果NSS被拉低，则这个SPI设备进入主模式失败状态：即MSTR位被自动清除，此设备进入从模式。

具体可以参考STM32参考手册23 串行外设接口(SPI)

SPI基本结构

主模式全双工连续传输

非连续传输

软件/硬件波形对比

硬件SPI读写W25Q64

第一步：连接线路

第二步：编写程序

实验现象：在OLED屏幕上，第一行显示为制造商ID和设备ID，第二行为W：写入数据，第三行为R：读取数据
main.c文件

#include "stm32f10x.h"                  // Device header
#include "Delay.h"
#include "OLED.h"
#include "W25Q64.h"

//定义了全局变量MID和DID，用于存储从W25Q64 Flash存储器读取的制造商ID和设备ID
uint8_t MID;
uint16_t DID;

uint8_t ArrayWrite[] = {0x01, 0x02, 0x03, 0x04};
uint8_t ArrayRead[4];

int main(void)
{
	OLED_Init();
	W25Q64_Init();
	
	OLED_ShowString(1, 1, "MID:   DID:");
	OLED_ShowString(2, 1, "W:");
	OLED_ShowString(3, 1, "R:");
	
	//调用W25Q64_ReadID函数从W25Q64中读取制造商ID和设备ID
	W25Q64_ReadID(&MID, &DID);
	OLED_ShowHexNum(1, 5, MID, 2);
	OLED_ShowHexNum(1, 12, DID, 4);
	
	/*
	擦除扇区并编程数据：首先，调用W25Q64_SectorErase函数擦除W25Q64的一个扇区（地址为0x000000）。
	然后，调用W25Q64_PageProgram函数将写入数组ArrayWrite中的数据编程到W25Q64的相同扇区中（地址为0x000000）
	*/
	W25Q64_SectorErase(0x000000);
	W25Q64_PageProgram(0x000000, ArrayWrite, 4);
	
	//调用W25Q64_ReadData函数从W25Q64的相同扇区中（地址为0x000000）读取数据，并将读取的数据存储在数组ArrayRead中
	W25Q64_ReadData(0x000000, ArrayRead, 4);
	
	OLED_ShowHexNum(2, 3, ArrayWrite[0], 2);
	OLED_ShowHexNum(2, 6, ArrayWrite[1], 2);
	OLED_ShowHexNum(2, 9, ArrayWrite[2], 2);
	OLED_ShowHexNum(2, 12, ArrayWrite[3], 2);
	
	OLED_ShowHexNum(3, 3, ArrayRead[0], 2);
	OLED_ShowHexNum(3, 6, ArrayRead[1], 2);
	OLED_ShowHexNum(3, 9, ArrayRead[2], 2);
	OLED_ShowHexNum(3, 12, ArrayRead[3], 2);
	
	while (1)
	{
		
	}
}

MySPI.c文件

#include "stm32f10x.h"                  // Device header

void MySPI_W_SS(uint8_t BitValue)
{
	GPIO_WriteBit (GPIOA,GPIO_Pin_4 ,(BitAction )BitValue );
}

void MySPI_Init(void)
{
	//开启GPIOA和SPI1的时钟，以使能这两个外设
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1 ,ENABLE);
	
	GPIO_InitTypeDef GPIO_InitStructure;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP ;//推挽输出
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4; 
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz ;
	GPIO_Init(GPIOA ,&GPIO_InitStructure );	
	
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP ;//复用推挽输出
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5 | GPIO_Pin_7; 
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz ;
	GPIO_Init(GPIOA ,&GPIO_InitStructure );	
	
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU ;//上拉输入
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6; 
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz ;
	GPIO_Init(GPIOA ,&GPIO_InitStructure );	
	
	SPI_InitTypeDef SPI_InitStructure;
	SPI_InitStructure.SPI_Mode = SPI_Mode_Master ;//配置SPI工作在主模式（主设备）
	SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex ;//配置SPI为双线全双工通信
	SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b ;//配置SPI的数据大小为8位
	SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB ;//配置SPI的数据传输方式为高位优先
	SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_128 ;//配置SPI的波特率预分频器为128，用于设定SPI通信速率
	SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge ;//配置SPI的时钟极性和相位，这里为第一个边沿（上升沿）采样，CPHA=1
	SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low ;//配置SPI的时钟极性，这里为低电平时钟，CPOL=1
	SPI_InitStructure.SPI_NSS = SPI_NSS_Soft ;//配置SPI的NSS信号为软件控制
	SPI_InitStructure.SPI_CRCPolynomial = 7 ;//配置SPI的CRC多项式
	SPI_Init (SPI1 ,&SPI_InitStructure);
	
	//使能SPI1外设
	SPI_Cmd (SPI1 ,ENABLE );
	
	//将从片选信号（Slave Select，NSS）置高，通常在初始化时将其置高，表示没有选择从设备进行通信
	MySPI_W_SS(1);
}

void MySPI_Start(void)
{
	MySPI_W_SS(0);
}

void MySPI_Stop(void)
{
	MySPI_W_SS(1);
}

uint8_t MySPI_SwapByte(uint8_t ByteSend)
{
	// 等待直到发送缓冲区为空，表示可以发送数据
	while (SPI_I2S_GetFlagStatus (SPI1 ,SPI_I2S_FLAG_TXE ) != SET );
	/*
	在这一步中，代码等待直到发送缓冲区为空，这意味着可以将新的数据发送到SPI总线上。
	当发送缓冲区为空时，标志位 SPI_I2S_FLAG_TXE 将被设置为1。这一步确保在发送新数据之前，
	之前的数据已经被完整地发送出去。
	*/
	
	// 向SPI发送数据
	SPI_I2S_SendData (SPI1 ,ByteSend);
	
	// 等待直到接收缓冲区有数据，表示已接收到数据
	while (SPI_I2S_GetFlagStatus (SPI1 ,SPI_I2S_FLAG_RXNE ) != SET );
	/*
	这一步等待直到接收缓冲区有数据，这表示从SPI总线上接收到了数据。当接收缓冲区有数据时，
	标志位 SPI_I2S_FLAG_RXNE 将被设置为1。
	*/
	
	// 返回从SPI接收到的数据
	return SPI_I2S_ReceiveData (SPI1);
}

MySPI.h文件

#ifndef __MYSPI_H
#define __MYSPI_H

void MySPI_Init(void);
void MySPI_Start(void);
void MySPI_Stop(void);
uint8_t MySPI_SwapByte(uint8_t ByteSend);

#endif

W25Q64.c文件

#include "stm32f10x.h"                  // Device header
#include "MySPI.h"
#include "W25Q64_Ins.h"

//用于初始化与W25Q64 Flash存储器通信所需要的SPI接口,调用了MySPI_Init()函数来初始化SPI通信
void W25Q64_Init(void)
{
	MySPI_Init();
}

/*
这个函数用于读取W25Q64 Flash存储器的制造商ID（MID）和设备ID（DID）。
函数首先启动SPI通信，发送命令来获取ID信息，然后读取制造商ID和设备ID，
	将设备ID左移8位并与另一个字节合并，最终获取完整的设备ID。
函数结束后关闭SPI通信。
*/
void W25Q64_ReadID(uint8_t *MID, uint16_t *DID)
{
	MySPI_Start();
	MySPI_SwapByte(W25Q64_JEDEC_ID);
	*MID = MySPI_SwapByte(W25Q64_DUMMY_BYTE);
	*DID = MySPI_SwapByte(W25Q64_DUMMY_BYTE);
	*DID <<= 8;
	*DID |= MySPI_SwapByte(W25Q64_DUMMY_BYTE);
	MySPI_Stop();
}

/*
这个函数发送命令给W25Q64 Flash存储器，使其允许写入操作。
函数启动SPI通信，发送写使能命令，然后关闭SPI通信。
*/
void W25Q64_WriteEnable(void)
{
	MySPI_Start();
	MySPI_SwapByte(W25Q64_WRITE_ENABLE);
	MySPI_Stop();
}

/*
这个函数用于等待W25Q64 Flash存储器完成其内部操作，例如擦除、编程等。
函数发送读取状态寄存器命令，然后循环读取状态寄存器的忙标志位，直到标志位为0或达到超时限制。
函数结束后关闭SPI通信。
*/
void W25Q64_WaitBusy(void)
{
	uint32_t Timeout;
	MySPI_Start();
	MySPI_SwapByte(W25Q64_READ_STATUS_REGISTER_1);
	Timeout = 100000;
	while ((MySPI_SwapByte(W25Q64_DUMMY_BYTE) & 0x01) == 0x01)
	{
		Timeout --;
		if (Timeout == 0)
		{
			break;
		}
	}
	MySPI_Stop();
}

/*
这个函数用于向W25Q64 Flash存储器的指定页写入数据。
函数首先发送写使能命令，然后启动SPI通信，发送页编程命令和地址，然后循环发送数据数组中的数据。
函数结束后关闭SPI通信，并调用W25Q64_WaitBusy()等待存储器完成操作。
*/
void W25Q64_PageProgram(uint32_t Address, uint8_t *DataArray, uint16_t Count)
{
	uint16_t i;
	
	W25Q64_WriteEnable();
	
	MySPI_Start();
	MySPI_SwapByte(W25Q64_PAGE_PROGRAM);
	MySPI_SwapByte(Address >> 16);
	MySPI_SwapByte(Address >> 8);
	MySPI_SwapByte(Address);
	for (i = 0; i < Count; i ++)
	{
		MySPI_SwapByte(DataArray[i]);
	}
	MySPI_Stop();
	
	W25Q64_WaitBusy();
}

/*
这个函数用于擦除W25Q64 Flash存储器的指定扇区。
函数首先发送写使能命令，然后启动SPI通信，发送扇区擦除命令和地址。
函数结束后关闭SPI通信，并调用W25Q64_WaitBusy()等待存储器完成擦除。
*/
void W25Q64_SectorErase(uint32_t Address)
{
	W25Q64_WriteEnable();
	
	MySPI_Start();
	MySPI_SwapByte(W25Q64_SECTOR_ERASE_4KB);
	MySPI_SwapByte(Address >> 16);
	MySPI_SwapByte(Address >> 8);
	MySPI_SwapByte(Address);
	MySPI_Stop();
	
	W25Q64_WaitBusy();
}

/*
这个函数用于从W25Q64 Flash存储器的指定地址开始读取一定数量的数据。
函数首先启动SPI通信，发送读取数据命令和地址，然后循环接收数据并存储到数据数组中。
函数结束后关闭SPI通信。
*/
void W25Q64_ReadData(uint32_t Address, uint8_t *DataArray, uint32_t Count)
{
	uint32_t i;
	MySPI_Start();
	MySPI_SwapByte(W25Q64_READ_DATA);
	MySPI_SwapByte(Address >> 16);
	MySPI_SwapByte(Address >> 8);
	MySPI_SwapByte(Address);
	for (i = 0; i < Count; i ++)
	{
		DataArray[i] = MySPI_SwapByte(W25Q64_DUMMY_BYTE);
	}
	MySPI_Stop();
}

W25Q64.h文件

#ifndef __W25Q64_H
#define __W25Q64_H

void W25Q64_Init(void);
void W25Q64_ReadID(uint8_t *MID, uint16_t *DID);
void W25Q64_PageProgram(uint32_t Address, uint8_t *DataArray, uint16_t Count);
void W25Q64_SectorErase(uint32_t Address);
void W25Q64_ReadData(uint32_t Address, uint8_t *DataArray, uint32_t Count);

#endif

W25Q64_Ins.h文件

#ifndef __W25Q64_INS_H
#define __W25Q64_INS_H

#define W25Q64_WRITE_ENABLE							0x06
#define W25Q64_WRITE_DISABLE						0x04
#define W25Q64_READ_STATUS_REGISTER_1				0x05
#define W25Q64_READ_STATUS_REGISTER_2				0x35
#define W25Q64_WRITE_STATUS_REGISTER				0x01
#define W25Q64_PAGE_PROGRAM							0x02
#define W25Q64_QUAD_PAGE_PROGRAM					0x32
#define W25Q64_BLOCK_ERASE_64KB						0xD8
#define W25Q64_BLOCK_ERASE_32KB						0x52
#define W25Q64_SECTOR_ERASE_4KB						0x20
#define W25Q64_CHIP_ERASE							0xC7
#define W25Q64_ERASE_SUSPEND						0x75
#define W25Q64_ERASE_RESUME							0x7A
#define W25Q64_POWER_DOWN							0xB9
#define W25Q64_HIGH_PERFORMANCE_MODE				0xA3
#define W25Q64_CONTINUOUS_READ_MODE_RESET			0xFF
#define W25Q64_RELEASE_POWER_DOWN_HPM_DEVICE_ID		0xAB
#define W25Q64_MANUFACTURER_DEVICE_ID				0x90
#define W25Q64_READ_UNIQUE_ID						0x4B
#define W25Q64_JEDEC_ID								0x9F
#define W25Q64_READ_DATA							0x03
#define W25Q64_FAST_READ							0x0B
#define W25Q64_FAST_READ_DUAL_OUTPUT				0x3B
#define W25Q64_FAST_READ_DUAL_IO					0xBB
#define W25Q64_FAST_READ_QUAD_OUTPUT				0x6B
#define W25Q64_FAST_READ_QUAD_IO					0xEB
#define W25Q64_OCTAL_WORD_READ_QUAD_IO				0xE3

#define W25Q64_DUMMY_BYTE							0xFF

#endif

你可能感兴趣的:(stm32,学习,笔记)

情绪觉察日记第37天露露_e800
今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习 python
一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
铭刻于星（四十二）随风至
69夜晚，绍敏同学做完功课后，看了眼房外，没听到动静才敢从书包的夹层里拿出那个心形纸团。折痕压得很深，都有些旧了，想来是已经写好很久了。绍敏同学慢慢地、轻轻地捏开折叠处，待到全部拆开后，又反复抚平纸张，然后仔细地一字字默看。只是开头的三个字是第一次看到，让她心漏跳了几拍。“亲爱的绍敏：从四年级的时候，我就喜欢你了，但是我一直不敢说，怕影响你学习。六年级的时候听说有人跟你表白，你接受了，我很难过，但
UI学习——cell的复用和自定义cell Magnetic_h ui 学习
目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
10月|愿你的青春不负梦想-读书笔记-01 Tracy的小书斋
本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
学点心理知识，呵护孩子健康静候花开_7090
昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
《投行人生》读书笔记小蘑菇的树洞
《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
ArcGIS栅格计算器常见公式（赋值、0和空值的转换、补充栅格空值）研学随笔 arcgis 经验分享
我们在使用ArcGIS时通常经常用到栅格计算器，今天主要给大家介绍我日常中经常用到的几个公式，供大家参考学习。将特定值（-9999）赋值为0，例如-9999.Con("raster"==-9999,0,"raster")2.给空值赋予特定的值（如0）Con(IsNull("raster"),0,"raster")3.将特定的栅格值(如1)赋值为空值，其他保留原值SetNull("raster"==
【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数广龙宇一起学Rust #Rust设计模式 rust 设计模式开发语言
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
回溯 Leetcode 332 重新安排行程 mmaerd Leetcode刷题学习记录 leetcode 算法职场和发展
重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
Python数据分析与可视化实战指南 William数据分析 python python 数据
在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
git常用命令笔记咩酱-小羊 git 笔记
###用习惯了idea总是不记得git的一些常见命令，需要用到的时候总是担心旁边站了人~~~记个笔记@_@，告诉自己看笔记不丢人初始化初始化一个新的Git仓库gitinit配置配置用户信息gitconfig--globaluser.name"YourName"gitconfig--globaluser.email"[email protected]"基本操作克隆远程仓库gitclone查看
2019-12-22-22:30 涓涓1016
今天是冬至，写下我的日更，是因为这两天的学习真的是能量的满满，让我看到了自己，未来另外一种可能性，也让我看到了这两年这几年的过程中我所接受那些痛苦的来源。一切的根源和痛苦都来自于人生，家庭，而你的原生家庭，你的爸爸和妈妈，是因为你这个灵魂在那一刻选择他们作为你的爸爸和妈妈来的，所以你得接受他，你得接纳他，他就是因为他的存在而给你的学习和成长带来这些痛苦，那其实是你必然要经历的这个过程，当你去接纳的
将cmd中命令输出保存为txt文本文件落难Coder Windows cmd window
最近深度学习本地的训练中我们常常要在命令行中运行自己的代码，无可厚非，我们有必要保存我们的炼丹结果，但是复制命令行输出到txt是非常麻烦的，其实Windows下的命令行为我们提供了相应的操作。其基本的调用格式就是：运行指令>输出到的文件名称或者具体保存路径测试下，我打开cmd并且ping一下百度：pingwww.baidu.com>./data.txt看下相同目录下data.txt的输出：如果你再
509. 斐波那契数(每日一题) lzyprime
lzyprime博客(github)创建时间：2021.01.04qq及邮箱：2383518170leetcode笔记题目描述斐波那契数，通常用F(n)表示，形成的序列称为斐波那契数列。该数列由0和1开始，后面的每一项数字都是前面两项数字的和。也就是：F(0)=0，F(1)=1F(n)=F(n-1)+F(n-2)，其中n>1给你n，请计算F(n)。示例1：输入：2输出：1解释：F(2)=F(1)+
拥有断舍离的心态，过精简生活--《断舍离》读书笔记爱吃丸子的小樱桃
不知不觉间房间里的东西越来越多，虽然摆放整齐，但也时常会觉得空间逼仄，令人心生烦闷。抱着断舍离的态度，我开始阅读《断舍离》这本书，希望从书中能找到一些有效的方法，帮助我实现空间、物品上的断舍离。《断舍离》是日本作家山下英子通过自己的经历、思考和实践总结而成的，整体内涵也从刚开始的私人生活哲学的“断舍离”升华成了“人生实践哲学”，接着又成为每个人都能实行的“改变人生的断舍离”，从“哲学”逐渐升华成“
四章-32-点要素的聚合彩云飘过
本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
高端密码学院笔记285 柚子_b4b4
高端幸福密码学院（高级班）幸福使者：李华第（598）期《幸福》之回归内在深层生命原动力基础篇——揭秘“激励”成长的喜悦心理案例分析主讲：刘莉一，知识扩充:成功=艰苦劳动+正确方法+少说空话。贪图省力的船夫，目标永远下游。智者的梦再美，也不如愚人实干的脚印。幸福早课堂2020.10.16星期五一笔记:1，重视和珍惜的前提是知道它的价值非常重要，当你珍惜了，你就真正定下来，真正的学到身上。2，大家需要
GitHub上克隆项目 bigbig猩猩 github
从GitHub上克隆项目是一个简单且直接的过程，它允许你将远程仓库中的项目复制到你的本地计算机上，以便进行进一步的开发、测试或学习。以下是一个详细的步骤指南，帮助你从GitHub上克隆项目。一、准备工作1.安装Git在克隆GitHub项目之前，你需要在你的计算机上安装Git工具。Git是一个开源的分布式版本控制系统，用于跟踪和管理代码变更。你可以从Git的官方网站（https://git-scm.
HTML网页设计制作大作业（div+css）云南我的家乡旅游景点带文字滚动二挡起步 web前端期末大作业 web设计网页规划与设计 html css javascript dreamweaver 前端
Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
Day17笔记-高阶函数 ~在杰难逃~ Python 笔记 python 开发语言 pycharm 数据分析
高阶函数【重点掌握】函数的本质：函数是一个变量，函数名是一个变量名，一个函数可以作为另一个函数的参数或返回值使用如果A函数作为B函数的参数，B函数调用完成之后，会得到一个结果，则B函数被称为高阶函数常用的高阶函数：map(),reduce(),filter(),sorted()1.map()map(func,iterable)，返回值是一个iterator【容器，迭代器】func:函数iterab
Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Python python 开发语言大数据数据分析数据挖掘
大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
人工智能时代，程序员如何保持核心竞争力？ jmoych 人工智能
随着AIGC（如chatgpt、midjourney、claude等）大语言模型接二连三的涌现，AI辅助编程工具日益普及，程序员的工作方式正在发生深刻变革。有人担心AI可能取代部分编程工作，也有人认为AI是提高效率的得力助手。面对这一趋势,程序员应该如何应对?是专注于某个领域深耕细作，还是广泛学习以适应快速变化的技术环境?又或者，我们是否应该将重点转向AI无法轻易替代的软技能？让我们一起探讨程序员
node.js学习小猿L node.js node.js 学习 vim
node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
阶段总结反思轻争
马上就要进入10月份了，今天做一下前段时间的总结和反思。前段时间，日更、英语、健身、护肤坚持的比较好。阅读、书法坚持的不好。1.中间被迫停更半个多月，其余时间一直在坚持日更挑战。偶尔也有不想写的时候，就做一下摘抄。因为阅读（输入）没跟上来，所以写作（输出）质量有待进一步加强。2.英语做到了一周至少学习5天，每次不少于30分钟，但是小班课没有跟上更新速度，下一步要争取利用零碎时间补听小班课。3.减肥
数据仓库——维度表一致性墨染丶eye 背诵数据仓库
数据仓库基础笔记思维导图已经整理完毕，完整连接为：数据仓库基础知识笔记思维导图维度一致性问题从逻辑层面来看，当一系列星型模型共享一组公共维度时，所涉及的维度称为一致性维度。当维度表存在不一致时，短期的成功难以弥补长期的错误。维度时确保不同过程中信息集成起来实现横向钻取货活动的关键。造成横向钻取失败的原因维度结构的差别，因为维度的差别，分析工作涉及的领域从简单到复杂，但是都是通过复杂的报表来弥补设计
ARM驱动学习之基础小知识 JT灬新一 ARM 嵌入式 arm开发学习
ARM驱动学习之基础小知识•sch原理图工程师工作内容–方案–元器件选型–采购（能不能买到，价格）–原理图（涉及到稳定性）•layout画板工程师–layout（封装、布局，布线，log）（涉及到稳定性）–焊接的一部分工作（调试阶段板子的焊接）•驱动工程师–驱动，原理图，layout三部分的交集容易发生矛盾•PCB研发流程介绍–方案，原理图(网表)–layout工程师（gerber文件）–PCB板
ARM驱动学习之5 LEDS驱动 JT灬新一嵌入式 C 底层 arm开发学习单片机
ARM驱动学习之5LEDS驱动知识点：•linuxGPIO申请函数和赋值函数–gpio_request–gpio_set_value•三星平台配置GPIO函数–s3c_gpio_cfgpin•GPIO配置输出模式的宏变量–S3C_GPIO_OUTPUT注意点：DRIVER_NAME和DEVICE_NAME匹配。实现步骤：1.加入需要的头文件：//Linux平台的gpio头文件#include//三
ARM驱动学习之4小结 JT灬新一嵌入式 C++arm开发学习 linux
ARM驱动学习之4小结#include#include#include#include#include#defineDEVICE_NAME"hello_ctl123"MODULE_LICENSE("DualBSD/GPL");MODULE_AUTHOR("TOPEET");staticlonghello_ioctl(structfile*file,unsignedintcmd,unsignedlo
展现思维导图魅力，不断挖掘人生宝藏思维导图讲师Mandy
第13期最强思维导图训练营已经结束一周了，但是我依旧是感觉所有学员还在努力的学习，这些学员中有教师、学生、白领、公务员、宝妈等等，只要你努力，只要你想改变自己，任何行业，任何岗位都可以参与进来，28天足以让你见成效，在这28天中，我们的学员不仅仅是收获了一枚毕业证，最重要的是让自己的思维方式得到升级，今天的你为自己投资，明天的你就会感谢你今天的付出，我们来听一听来自13期最强思维导图训练营优秀学员
SAX解析xml文件小猪猪08 xml
1.创建SAXParserFactory实例 2.通过SAXParserFactory对象获取SAXParser实例 3.创建一个类SAXParserHander继续DefaultHandler，并且实例化这个类 4.SAXParser实例的parse来获取文件 public static void main(String[] args) { //
为什么mysql里的ibdata1文件不断的增长？ brotherlamp linux linux运维 linux资料 linux视频 linux运维自学
我们在 Percona 支持栏目经常收到关于 MySQL 的 ibdata1 文件的这个问题。当监控服务器发送一个关于 MySQL 服务器存储的报警时，恐慌就开始了 —— 就是说磁盘快要满了。一番调查后你意识到大多数地盘空间被 InnoDB 的共享表空间 ibdata1 使用。而你已经启用了 innodbfileper_table，所以问题是： ibdata1存了什么？当你启用了 i
Quartz-quartz.properties配置 eksliang quartz
其实Quartz JAR文件的org.quartz包下就包含了一个quartz.properties属性配置文件并提供了默认设置。如果需要调整默认配置，可以在类路径下建立一个新的quartz.properties，它将自动被Quartz加载并覆盖默认的设置。下面是这些默认值的解释 #-----集群的配置 org.quartz.scheduler.instanceName =
informatica session的使用 18289753290 workflow session log Informatica
如果希望workflow存储最近20次的log，在session里的Config Object设置，log options做配置，save session log :sessions run ;savesessio log for these runs:20 session下面的source 里面有个tracing
Scrapy抓取网页时出现CRC check failed 0x471e6e9a != 0x7c07b839L的错误酷的飞上天空 scrapy
Scrapy版本0.14.4 出现问题现象： ERROR: Error downloading <GET http://xxxxx CRC check failed 解决方法 1.设置网络请求时的header中的属性'Accept-Encoding': '*;q=0' 明确表示不支持任何形式的压缩格式，避免程序的解压
java Swing小集锦永夜-极光 java swing
1.关闭窗体弹出确认对话框 1.1 this.setDefaultCloseOperation (JFrame.DO_NOTHING_ON_CLOSE); 1.2 this.addWindowListener ( new WindowAdapter () { public void windo
强制删除.svn文件夹随便小屋 java
在windows上，从别处复制的项目中可能带有.svn文件夹，手动删除太麻烦，并且每个文件夹下都有。所以写了个程序进行删除。因为.svn文件夹在windows上是只读的，所以用File中的delete()和deleteOnExist()方法都不能将其删除，所以只能采用windows命令方式进行删除
GET和POST有什么区别？及为什么网上的多数答案都是错的。 aijuans get post
如果有人问你，GET和POST，有什么区别？你会如何回答？我的经历前几天有人问我这个问题。我说GET是用于获取数据的，POST，一般用于将数据发给服务器之用。这个答案好像并不是他想要的。于是他继续追问有没有别的区别？我说这就是个名字而已，如果服务器支持，他完全可以把G
谈谈新浪微博背后的那些算法 aoyouzi 谈谈新浪微博背后的那些算法
本文对微博中常见的问题的对应算法进行了简单的介绍，在实际应用中的算法比介绍的要复杂的多。当然，本文覆盖的主题并不全，比如好友推荐、热点跟踪等就没有涉及到。但古人云“窥一斑而见全豹”，希望本文的介绍能帮助大家更好的理解微博这样的社交网络应用。微博是一个很多人都在用的社交应用。天天刷微博的人每天都会进行着这样几个操作：原创、转发、回复、阅读、关注、@等。其中，前四个是针对短博文，最后的关注和@则针
Connection reset 连接被重置的解决方法百合不是茶 java 字符流连接被重置
流是java的核心部分,,昨天在做android服务器连接服务器的时候出了问题,就将代码放到java中执行,结果还是一样连接被重置被重置的代码如下; 客户端代码; package 通信软件服务器; import java.io.BufferedWriter; import java.io.OutputStream; import java.io.O
web.xml配置详解之filter bijian1013 java web.xml filter
一.定义 <filter> <filter-name>encodingfilter</filter-name> <filter-class>com.my.app.EncodingFilter</filter-class> <init-param> <param-name>encoding<
Heritrix Bill_chen 多线程 xml 算法制造配置管理
作为纯Java语言开发的、功能强大的网络爬虫Heritrix，其功能极其强大，且扩展性良好，深受热爱搜索技术的盆友们的喜爱，但它配置较为复杂，且源码不好理解，最近又使劲看了下，结合自己的学习和理解，跟大家分享Heritrix的点点滴滴。 Heritrix的下载（http://sourceforge.net/projects/archive-crawler/）安装、配置，就不罗嗦了，可以自己找找资
【Zookeeper】FAQ bit1129 zookeeper
1.脱离IDE，运行简单的Java客户端程序 #ZkClient是简单的Zookeeper~$ java -cp "./:zookeeper-3.4.6.jar:./lib/*" ZKClient 1. Zookeeper是的Watcher回调是同步操作，需要添加异步处理的代码 2. 如果Zookeeper集群跨越多个机房，那么Leader/
The user specified as a definer ('aaa'@'localhost') does not exist 白糖_ localhost
今天遇到一个客户BUG，当前的jdbc连接用户是root，然后部分删除操作都会报下面这个错误：The user specified as a definer ('aaa'@'localhost') does not exist 最后找原因发现删除操作做了触发器，而触发器里面有这样一句 /*!50017 DEFINER = ''aaa@'localhost' */ 原来最初
javascript中showModelDialog刷新父页面 bozch JavaScript 刷新父页面 showModalDialog
在页面中使用showModalDialog打开模式子页面窗口的时候，如果想在子页面中操作父页面中的某个节点，可以通过如下的进行： window.showModalDialog('url',self,‘status...’); // 首先中间参数使用self 在子页面使用w
编程之美-买书折扣 bylijinnan 编程之美
import java.util.Arrays; public class BookDiscount { /**编程之美买书折扣书上的贪心算法的分析很有意思，我看了半天看不懂，结果作者说，贪心算法在这个问题上是不适用的。。下面用动态规划实现。哈利波特这本书一共有五卷，每卷都是8欧元，如果读者一次购买不同的两卷可扣除5%的折扣，三卷10%，四卷20%，五卷
关于struts2.3.4项目跨站执行脚本以及远程执行漏洞修复概要 chenbowen00 struts WEB安全
因为近期负责的几个银行系统软件，需要交付客户，因此客户专门请了安全公司对系统进行了安全评测，结果发现了诸如跨站执行脚本，远程执行漏洞以及弱口令等问题。下面记录下本次解决的过程以便后续 1、首先从最简单的开始处理，服务器的弱口令问题，首先根据安全工具提供的测试描述中发现应用服务器中存在一个匿名用户，默认是不需要密码的，经过分析发现服务器使用了FTP协议，而使用ftp协议默认会产生一个匿名用
[电力与暖气]煤炭燃烧与电力加温 comsci
在宇宙中,用贝塔射线观测地球某个部分,看上去,好像一个个马蜂窝,又像珊瑚礁一样,原来是某个国家的采煤区..... 不过,这个采煤区的煤炭看来是要用完了.....那么依赖将起燃烧并取暖的城市,在极度严寒的季节中...该怎么办呢? &nbs
oracle O7_DICTIONARY_ACCESSIBILITY参数 daizj oracle
O7_DICTIONARY_ACCESSIBILITY参数控制对数据字典的访问.设置为true,如果用户被授予了如select any table等any table权限,用户即使不是dba或sysdba用户也可以访问数据字典.在9i及以上版本默认为false,8i及以前版本默认为true.如果设置为true就可能会带来安全上的一些问题.这也就为什么O7_DICTIONARY_ACCESSIBIL
比较全面的MySQL优化参考 dengkane mysql
本文整理了一些MySQL的通用优化方法，做个简单的总结分享，旨在帮助那些没有专职MySQL DBA的企业做好基本的优化工作，至于具体的SQL优化，大部分通过加适当的索引即可达到效果，更复杂的就需要具体分析了，可以参考本站的一些优化案例或者联系我，下方有我的联系方式。这是上篇。 1、硬件层相关优化 1.1、CPU相关在服务器的BIOS设置中，可
C语言homework2，有一个逆序打印数字的小算法 dcj3sjt126com c
#h1# 0、完成课堂例子 1、将一个四位数逆序打印 1234 ==> 4321 实现方法一： # include <stdio.h> int main(void) { int i = 1234; int one = i%10; int two = i / 10 % 10; int three = i / 100 % 10;
apacheBench对网站进行压力测试 dcj3sjt126com apachebench
ab 的全称是 ApacheBench ，是 Apache 附带的一个小工具，专门用于 HTTP Server 的 benchmark testing ，可以同时模拟多个并发请求。前段时间看到公司的开发人员也在用它作一些测试，看起来也不错，很简单，也很容易使用，所以今天花一点时间看了一下。通过下面的一个简单的例子和注释，相信大家可以更容易理解这个工具的使用。
2种办法让HashMap线程安全 flyfoxs java jdk jni
多线程之--2种办法让HashMap线程安全多线程之--synchronized 和reentrantlock的优缺点多线程之--2种JAVA乐观锁的比较( NonfairSync VS. FairSync) HashMap不是线程安全的,往往在写程序时需要通过一些方法来回避.其实JDK原生的提供了2种方法让HashMap支持线程安全.
Spring Security（04）——认证简介 234390216 Spring Security 认证过程
认证简介目录 1.1 认证过程 1.2 Web应用的认证过程 1.2.1 ExceptionTranslationFilter 1.2.2 在request之间共享SecurityContext 1
Java 位运算 Javahuhui java 位运算
// 左移( << ) 低位补0 // 0000 0000 0000 0000 0000 0000 0000 0110 然后左移2位后，低位补0： // 0000 0000 0000 0000 0000 0000 0001 1000 System.out.println(6 << 2);// 运行结果是24 // 右移( >> ) 高位补"
mysql免安装版配置 ldzyz007 mysql
1、my-small.ini是为了小型数据库而设计的。不应该把这个模型用于含有一些常用项目的数据库。 2、my-medium.ini是为中等规模的数据库而设计的。如果你正在企业中使用RHEL,可能会比这个操作系统的最小RAM需求(256MB)明显多得多的物理内存。由此可见，如果有那么多RAM内存可以使用，自然可以在同一台机器上运行其它服务。 3、my-large.ini是为专用于一个SQL数据
MFC和ado数据库使用时遇到的问题你不认识的休道人 sql C++mfc
=================================================================== 第一个 =================================================================== try{ CString sql; sql.Format("select * from p
表单重复提交Double Submits rensanning double
可能发生的场景： *多次点击提交按钮 *刷新页面 *点击浏览器回退按钮 *直接访问收藏夹中的地址 *重复发送HTTP请求（Ajax）（1）点击按钮后disable该按钮一会儿，这样能避免急躁的用户频繁点击按钮。这种方法确实有些粗暴，友好一点的可以把按钮的文字变一下做个提示，比如Bootstrap的做法： http://getbootstrap.co
Java String 十大常见问题 tomcat_oracle java 正则表达式
　1.字符串比较，使用“==”还是equals()? 　　"=="判断两个引用的是不是同一个内存地址(同一个物理对象)。　　equals()判断两个字符串的值是否相等。　　除非你想判断两个string引用是否同一个对象，否则应该总是使用equals()方法。　　如果你了解字符串的驻留(String Interning)则会更好地理解这个问题。　　
SpringMVC 登陆拦截器实现登陆控制 xp9802 springMVC
思路，先登陆后，将登陆信息存储在session中，然后通过拦截器，对系统中的页面和资源进行访问拦截，同时对于登陆本身相关的页面和资源不拦截。实现方法： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23