外设函数代码

已于 2023-04-15 16:42:26 修改
阅读量231 收藏
点赞数 2
分类专栏： 嵌入式开发 文章标签： 单片机 stm32 嵌入式硬件
于 2022-11-06 12:59:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45578181/article/details/127714739
版权

文章目录

按键扫描

KEY_Init(void);
while(t--)//延时,同时扫描按键
{
	delay_ms(1);
	key=KEY_Scan(0);
	if(key==KEY0_PRES)goto UPD;
}

KEY_Init 按键初始化

//按键初始化函数
void KEY_Init(void)
{
	
	GPIO_InitTypeDef  GPIO_InitStructure;

  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA|RCC_AHB1Periph_GPIOE, ENABLE);//使能GPIOA,GPIOE时钟
 
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2|GPIO_Pin_3|GPIO_Pin_4; //KEY0 KEY1 KEY2对应引脚
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;//普通输入模式
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100M
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
  GPIO_Init(GPIOE, &GPIO_InitStructure);//初始化GPIOE2,3,4
	
	 
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;//WK_UP对应引脚PA0
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_DOWN ;//下拉
  GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA0
 
}

在这里插入图片描述之所以0 1 2上拉是因为导通后变低。而WK_UP导通后是高。

KEY_Scan

//按键处理函数
//返回按键值
//mode:0,不支持连续按;1,支持连续按;
//0，没有任何按键按下
//1，KEY0按下
//2，KEY1按下
//3，KEY2按下 
//4，WKUP按下 WK_UP
//注意此函数有响应优先级,KEY0>KEY1>KEY2>WK_UP!!
u8 KEY_Scan(u8 mode)
{	 
	static u8 key_up=1;//按键按松开标志
	if(mode)key_up=1;  //支持连按		  
	if(key_up&&(KEY0==0||KEY1==0||KEY2==0||WK_UP==1))
	{
		delay_ms(10);//去抖动 
		key_up=0;
		if(KEY0==0)return 1;
		else if(KEY1==0)return 2;
		else if(KEY2==0)return 3;
		else if(WK_UP==1)return 4;
	}else if(KEY0==1&&KEY1==1&&KEY2==1&&WK_UP==0)key_up=1; 	    
 	return 0;// 无按键按下
}

LED闪烁

LED_Init(void);
LED0=!LED0;

LED_Init

//初始化PF9和PF10为输出口.并使能这两个口的时钟		    
//LED IO初始化
void LED_Init(void)
{    	 
  GPIO_InitTypeDef  GPIO_InitStructure;

  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOF, ENABLE);//使能GPIOF时钟

  //GPIOF9,F10初始化设置
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9 | GPIO_Pin_10;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;//普通输出模式
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;//推挽输出
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100MHz
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
  GPIO_Init(GPIOF, &GPIO_InitStructure);//初始化
	
	GPIO_SetBits(GPIOF,GPIO_Pin_9 | GPIO_Pin_10);//GPIOF9,F10设置高，灯灭

}

LED0

//LED端口定义
#define LED0 PFout(9)	// DS0
#define LED1 PFout(10)	// DS1

SPI

//W25 IC复位
void SpiFlash_Rest(void)
{
    unsigned int au32SourceData;
    unsigned int au32DestinationData;
    SPI_SET_SS_LOW(SPI1);
    //有些地方使用了 16 24 32 位模式 所以这里会重新设置一遍
    SPI_SET_DATA_WIDTH(SPI1, 8);//设置SPI为8位模式
    au32SourceData = 0xFF;//复位指令      
    SPI_WRITE_TX(SPI1, au32SourceData);while(SPI_IS_BUSY(SPI1));
    SPI_SET_SS_HIGH(SPI1);sys_delayms(2);
}
//选择模具 IChange == 0 或 1
void SpiFlash_IC_Change(u8 IChange)
{
   unsigned int au32SourceData;
    unsigned int au32DestinationData;
    SPI_SET_SS_LOW(SPI1);
   SPI_SET_DATA_WIDTH(SPI1, 8);//设置SPI为8位模式
    //选择模具指令 选择W25M02GV内的两片W25N01GV中的其中一片 然后进行操作
    au32SourceData = 0xC2;
    SPI_WRITE_TX(SPI1, au32SourceData);while(SPI_IS_BUSY(SPI1));
    au32SourceData = IChange;      
SPI_WRITE_TX(SPI1, au32SourceData);while(SPI_IS_BUSY(SPI1));
SPI_SET_SS_HIGH(SPI1);sys_delayms(2);
}
//读取IC ID值 一共24位
unsigned int SpiFlash_ReadMidDid(void)
{
    unsigned int au32SourceData;
    unsigned int au32DestinationData;
    SPI_SET_SS_LOW(SPI1);
      SPI_SET_DATA_WIDTH(SPI1, 8);
      au32SourceData = 0x9F;//读取ID指令  9F 00
    SPI_WRITE_TX(SPI1, au32SourceData);while(SPI_IS_BUSY(SPI1));
    au32SourceData = 0x0;
    SPI_WRITE_TX(SPI1, au32SourceData);while(SPI_IS_BUSY(SPI1));
//如果不想更改SPI设置 也可以拆成3个8位来操作     
SPI_SET_DATA_WIDTH(SPI1, 24);//设置SPI为24位模式
    I2S_CLR_RX_FIFO(SPI1);//清除SPI缓存
    // 接收
    au32SourceData = 0x0;
    SPI_WRITE_TX(SPI1, au32SourceData);while(SPI_IS_BUSY(SPI1));
    SPI_SET_SS_HIGH(SPI1);sys_delayms(2);
    //导出SPI缓存数据
    au32DestinationData = SPI_READ_RX(SPI1);
    return (au32DestinationData & 0xffffff);
}
//写寄存器1  
void SpiFlash_WriteStatusReg1(u8 SRData)
{    unsigned int au32SourceData;
    unsigned int au32DestinationData;
    SPI_SET_SS_LOW(SPI1);
    SPI_SET_DATA_WIDTH(SPI1, 8);
    au32SourceData = 0x01;//写寄存器1指令： 01 A0
    SPI_WRITE_TX(SPI1, au32SourceData);while(SPI_IS_BUSY(SPI1));
au32SourceData = 0xA0;
    SPI_WRITE_TX(SPI1, au32SourceData);while(SPI_IS_BUSY(SPI1));
au32SourceData = SRData;;//写寄存器1：数据
    SPI_WRITE_TX(SPI1, au32SourceData);while(SPI_IS_BUSY(SPI1));
SPI_SET_SS_HIGH(SPI1);sys_delayms(2);
}
//写状态寄存器2
void SpiFlash_WriteStatusReg2(u8 SRData)
{
    unsigned int au32SourceData;
    unsigned int au32DestinationData;
    SPI_SET_SS_LOW(SPI1);
    SPI_SET_DATA_WIDTH(SPI1, 8);
    au32SourceData = 0x01;//写寄存器2指令： 01 B0
    SPI_WRITE_TX(SPI1, au32SourceData);while(SPI_IS_BUSY(SPI1));
au32SourceData = 0xB0;
    SPI_WRITE_TX(SPI1, au32SourceData);while(SPI_IS_BUSY(SPI1));
au32SourceData = SRData;//写寄存器2：数据
   SPI_WRITE_TX(SPI1, au32SourceData);while(SPI_IS_BUSY(SPI1));
SPI_SET_SS_HIGH(SPI1);sys_delayms(2);
}
//读寄存器1
unsigned int SpiFlash_ReadStatusReg1(void)
{
    unsigned int au32SourceData;
    unsigned int au32DestinationData;
    SPI_SET_SS_LOW(SPI1);
    SPI_SET_DATA_WIDTH(SPI1, 8);
    au32SourceData = 0x05;//读寄存器1指令： 05 A0
    SPI_WRITE_TX(SPI1, au32SourceData);while(SPI_IS_BUSY(SPI1));
au32SourceData = 0xA0;
    SPI_WRITE_TX(SPI1, au32SourceData);while(SPI_IS_BUSY(SPI1));
I2S_CLR_RX_FIFO(SPI1);
au32SourceData = 0X0;
    SPI_WRITE_TX(SPI1, au32SourceData);while(SPI_IS_BUSY(SPI1));
au32DestinationData = SPI_READ_RX(SPI1);//导致寄存器1数据
SPI_SET_SS_HIGH(SPI1);sys_delayms(2);
    return (au32DestinationData & 0xFF);
}
//读寄存器2
unsigned int SpiFlash_ReadStatusReg2(void)
{
    unsigned int au32SourceData;
    unsigned int au32DestinationData;
    SPI_SET_SS_LOW(SPI1);    SPI_SET_DATA_WIDTH(SPI1, 8);
    au32SourceData = 0x05;//读寄存器2指令： 05 B0
    SPI_WRITE_TX(SPI1, au32SourceData);while(SPI_IS_BUSY(SPI1));
au32SourceData = 0xB0;
    SPI_WRITE_TX(SPI1, au32SourceData);while(SPI_IS_BUSY(SPI1));
I2S_CLR_RX_FIFO(SPI1);
au32SourceData = 0X0;
    SPI_WRITE_TX(SPI1, au32SourceData);while(SPI_IS_BUSY(SPI1));
au32DestinationData = SPI_READ_RX(SPI1);
SPI_SET_SS_HIGH(SPI1);sys_delayms(2);
    return (au32DestinationData & 0xFF);
}
//读寄存器3
unsigned int SpiFlash_ReadStatusReg3(void)
{
    unsigned int au32SourceData;
    unsigned int au32DestinationData;
   SPI_SET_SS_LOW(SPI1);
    SPI_SET_DATA_WIDTH(SPI1, 8);
    au32SourceData = 0x05;//读寄存器2指令： 05 C0
    SPI_WRITE_TX(SPI1, au32SourceData);while(SPI_IS_BUSY(SPI1));
au32SourceData = 0xC0;
    SPI_WRITE_TX(SPI1, au32SourceData);while(SPI_IS_BUSY(SPI1));
I2S_CLR_RX_FIFO(SPI1);
au32SourceData = 0X0;
    SPI_WRITE_TX(SPI1, au32SourceData);while(SPI_IS_BUSY(SPI1));
au32DestinationData = SPI_READ_RX(SPI1);
SPI_SET_SS_HIGH(SPI1);sys_delayms(2);
    return (au32DestinationData & 0xFF);
}
//等待ic空闲
void SpiFlash_WaitReady(void)
{
    unsigned int ReturnValue;
    do
{ ReturnValue = SpiFlash_ReadStatusReg3();
        ReturnValue = ReturnValue & 1;
    }while(ReturnValue != 0);
}
//判断是否正在写入IC
void SpiFlash_WaitWEL_1(void)
{
    unsigned int ReturnValue;
    do
{ ReturnValue = SpiFlash_ReadStatusReg3();
        ReturnValue = ReturnValue | 0XFD;
   }while(ReturnValue != 0XFF);
}
//擦除一块数据  64页 ：64*2048=128k 字节
void SpiFlash_PageErase(u32 StartAddress)
{    unsigned int au32SourceData;
    SPI_SET_SS_LOW(SPI1);
    SPI_SET_DATA_WIDTH(SPI1, 8);
    au32SourceData = 0x06;//写启用指令 06
    SPI_WRITE_TX(SPI1, au32SourceData);while(SPI_IS_BUSY(SPI1));
    SPI_SET_SS_HIGH(SPI1);sys_delayms(2);
SpiFlash_WaitReady();//等闲
SpiFlash_WaitWEL_1();
    SPI_SET_SS_LOW(SPI1);
    au32SourceData = 0xD8;//擦除块 指令 D8 00
    SPI_WRITE_TX(SPI1, au32SourceData);while(SPI_IS_BUSY(SPI1));
    au32SourceData = 0x0;
    SPI_WRITE_TX(SPI1, au32SourceData);while(SPI_IS_BUSY(SPI1));
SPI_SET_DATA_WIDTH(SPI1, 16);
//改块64页中任意一页地址
au32SourceData=ADDR_Row_PA15_PA0(StartAddress);
    SPI_WRITE_TX(SPI1, au32SourceData);while(SPI_IS_BUSY(SPI1));
    SPI_SET_SS_HIGH(SPI1);sys_delayms(2);
SpiFlash_WaitReady();//等闲
}
//擦除功能函数
void SpiFlash_ChipErase(u32 StartAddress)
{
SpiFlash_PageErase(StartAddress);
W25M_STR3=SpiFlash_ReadStatusReg3();//判断是否成功
if(W25M_STR3 & 0x04)//擦除失败
{
//printf("\r\nErase_Error\r\n");
SpiFlash_PageErase(StartAddress);
}
SpiFlash_WaitReady();
}
//写入数据功能函数
//StartAddress1 12~27位: 页地址
//StartAddress1 0~11位：页内数据位置
//ByteCount字节个数
void SpiFlash_WriteData(u8 *DataBuffer, u32 StartAddress1, unsigned int ByteCount)
{
    u32 au32SourceData;
    unsigned int Counter;
    SPI_SET_SS_LOW(SPI1);
    SPI_SET_DATA_WIDTH(SPI1, 8);
    au32SourceData = 0x06;//写启用指令 06
    SPI_WRITE_TX(SPI1, au32SourceData);while(SPI_IS_BUSY(SPI1));
    SPI_SET_SS_HIGH(SPI1);sys_delayms(2);
SpiFlash_WaitReady();//等闲
SpiFlash_WaitWEL_1();
    SPI_SET_SS_LOW(SPI1);
      au32SourceData = 0x02;//数据写入IC缓冲区指令 02
SPI_WRITE_TX(SPI1, au32SourceData);while(SPI_IS_BUSY(SPI1));
    SPI_SET_DATA_WIDTH(SPI1, 16);   au32SourceData=StartAddress1;
    au32SourceData = (u16)(au32SourceData&0x7ff);//页内位置
    SPI_WRITE_TX(SPI1, au32SourceData);while(SPI_IS_BUSY(SPI1));
    SPI_SET_DATA_WIDTH(SPI1, 8);
    for(Counter = 0; Counter < ByteCount; Counter++)//数据写入IC换冲执行过程
    {
      au32SourceData = DataBuffer[Counter];
SPI_WRITE_TX(SPI1, au32SourceData);while(SPI_IS_BUSY(SPI1));
    }
    SPI_SET_SS_HIGH(SPI1);sys_delayms(2);
SpiFlash_WaitReady();//等闲
SPI_SET_SS_LOW(SPI1);
au32SourceData = 0x10;//换冲导入存储区指令 10 00
    SPI_WRITE_TX(SPI1, au32SourceData);while(SPI_IS_BUSY(SPI1));
au32SourceData = 0x0;
    SPI_WRITE_TX(SPI1, au32SourceData);while(SPI_IS_BUSY(SPI1));
SPI_SET_DATA_WIDTH(SPI1, 16);
au32SourceData=StartAddress1;
au32SourceData = (u16)(au32SourceData>>12);//页地址
    SPI_WRITE_TX(SPI1, au32SourceData);while(SPI_IS_BUSY(SPI1));
SPI_SET_SS_HIGH(SPI1);sys_delayms(2);
SpiFlash_WaitReady();//等闲
W25M_STR3=SpiFlash_ReadStatusReg3();//判断是否成功
if(W25M_STR3 & 0x08)//写入失败
{
//printf("\r\nWrite_Error\r\n");
}
SpiFlash_WaitReady();
}
//一页数据导出到IC缓冲区
void SpiFlash_LoadData(u32 StartAddress1)
{
    u32 au32SourceData;
	SPI_SET_SS_LOW(SPI1);
	SPI_SET_DATA_WIDTH(SPI1, 8);
	au32SourceData = 0x13;//页数据读取到缓存指令 13 00
    SPI_WRITE_TX(SPI1, au32SourceData);while(SPI_IS_BUSY(SPI1));
    au32SourceData = 0x0;
    SPI_WRITE_TX(SPI1, au32SourceData);while(SPI_IS_BUSY(SPI1));
	SPI_SET_DATA_WIDTH(SPI1, 16);
	au32SourceData=(u16)(StartAddress1>>12);//页地址
	SPI_WRITE_TX(SPI1, au32SourceData);while(SPI_IS_BUSY(SPI1));
	SPI_SET_SS_HIGH(SPI1);
	sys_delayms(2);
	SpiFlash_WaitReady();//等闲

}
//读出数据功能函数
//StartAddress1 12~27位: 页地址
//StartAddress1 0~11位：页内数据位置
//ByteCount字节个数void SpiFlash_ReadData(u8 *DataBuffer, u32 StartAddress1, unsigned int ByteCount)
{
    u32 au32SourceData;
    unsigned int au32DestinationData;
    unsigned int Counter;
SpiFlash_LoadData(StartAddress1);
W25M_STR3=SpiFlash_ReadStatusReg3();//判断是否成功
if(W25M_STR3 & 0x20)//读取失败
{
//printf("\r\nRead_Load_Error\r\n");
SpiFlash_LoadData(StartAddress1);
W25M_STR3=SpiFlash_ReadStatusReg3();//判断是否成功
if(W25M_STR3 & 0x20)//读取失败
{
//UART1_PUTS(":读取失败\r\n");
}
}
   SPI_SET_SS_LOW(SPI1);
    SPI_SET_DATA_WIDTH(SPI1, 8);
    au32SourceData = 0x03;//读取IC缓冲区数据指令 03
    SPI_WRITE_TX(SPI1, au32SourceData);while(SPI_IS_BUSY(SPI1));
    SPI_SET_DATA_WIDTH(SPI1, 16);
au32SourceData=StartAddress1;
    au32SourceData = (u16)(au32SourceData&0x7ff);//页内位置
    SPI_WRITE_TX(SPI1, au32SourceData);while(SPI_IS_BUSY(SPI1));
    SPI_SET_DATA_WIDTH(SPI1, 8);
    au32SourceData = 0x0;
    SPI_WRITE_TX(SPI1, au32SourceData);while(SPI_IS_BUSY(SPI1));
    I2S_CLR_RX_FIFO(SPI1);//清空SPI缓冲区 准备接收IC缓冲区数据
    for(Counter = 0; Counter < ByteCount; Counter++)
    {
au32SourceData = 0x0;
SPI_WRITE_TX(SPI1, au32SourceData);while(SPI_IS_BUSY(SPI1));
au32DestinationData = SPI_READ_RX(SPI1);
DataBuffer[Counter] = (u8) au32DestinationData;
    }
    SPI_SET_SS_HIGH(SPI1);sys_delayms(2);
SpiFlash_WaitReady();
}
//以下是工程函数的案例
#defineW25PAGE(n)( 4096 * n )
//0 <= n < { 1024(块)*64（页）}
//注意：擦除操作时是擦除整块 SpiFlash_ChipErase(W25PAGE(n))
//拿第一块为例:n=0或n=63都是擦除第一块64个页的存储区
//参数写0并保存
void W25M_write_0(void)  
{
u16 i=0;
for(i=0;i<2048;i++)
{W25M_temp[i]=0;}
SpiFlash_ChipErase(W25PAGE(0));SpiFlash_WriteData(W25M_temp, W25PAGE(0),2048);
}
//保存工程参数
void W25M_write_GongChen(void)  
{
SpiFlash_ChipErase(W25PAGE(0));
SpiFlash_WriteData(W25M_temp, W25PAGE(0),500);
}
//读取工程参数
void W25M_read_GongChen(void)
{
SpiFlash_ReadData(W25M_temp,W25PAGE(0),500);
}

w25N01

/*-----------------------------------------------------------------------*/
/* Low level disk I/O module skeleton for FatFs     (C)ChaN, 2016        */
/*-----------------------------------------------------------------------*/
/* If a working storage control module is available, it should be        */
/* attached to the FatFs via a glue function rather than modifying it.   */
/* This is an example of glue functions to attach various exsisting      */
/* storage control modules to the FatFs module with a defined API.       */
/*-----------------------------------------------------------------------*/

#include "ff.h"            /* Obtains integer types */
#include "diskio.h"        /* Declarations of disk functions */
#include "flash_w25n01.h"


/* Definitions of physical drive number for each drive */
#define SPI_FLASH        0



/*-----------------------------------------------------------------------*/
/* Get Drive Status                                                      */
/*-----------------------------------------------------------------------*/

DSTATUS disk_status (
    BYTE pdrv        /* Physical drive nmuber to identify the drive */
)
{
    if(pdrv == SPI_FLASH)
    {
        return RES_OK;
    }
    else
    {
        return RES_PARERR;
    }
}

/*-----------------------------------------------------------------------*/
/* Inidialize a Drive                                                    */

DSTATUS disk_initialize (
    BYTE pdrv                /* Physical drive nmuber to identify the drive */
)
{
    if(pdrv == SPI_FLASH)
    {
        //flash_w25n01_init();
        if(flash_w25n01_readID() == 0xEFAA21)
            return RES_OK;
        else
            return RES_PARERR;
    }
    else
    {
        return RES_PARERR;
    }
}



/*-----------------------------------------------------------------------*/
/* Read Sector(s)                                                        */
/*-----------------------------------------------------------------------*/

DRESULT disk_read (
    BYTE pdrv,        /* Physical drive nmuber to identify the drive */
    BYTE *buff,        /* Data buffer to store read data */
    DWORD sector,    /* Start sector in LBA */
    UINT count        /* Number of sectors to read */
)
{
    unsigned short addr_block = 0, addr_page = 0;
    if(pdrv == SPI_FLASH)
    {
        addr_block = sector / 64;//每块有64页
        addr_page = sector % 64;
        flash_w25n01_buffer_read(buff, addr_block,addr_page,0, count * 2048);
        return RES_OK;
    }
    else
    {
        return RES_PARERR;
    }
}



/*-----------------------------------------------------------------------*/
/* Write Sector(s)                                                       */
/*-----------------------------------------------------------------------*/

#if FF_FS_READONLY == 0

DRESULT disk_write (
    BYTE pdrv,            /* Physical drive nmuber to identify the drive */
    const BYTE *buff,    /* Data to be written */
    DWORD sector,        /* Start sector in LBA */
    UINT count            /* Number of sectors to write */
)
{
    unsigned short addr_block = 0, addr_byte = 0;
    unsigned char addr_page = 0;
    if(pdrv == SPI_FLASH)
    {
        addr_block = sector / 64;//每块有64页
        addr_page = sector % 64;
        flash_w25n01_sector_write((unsigned char *)buff, addr_block,addr_page, count * 2048);
        return RES_OK;
    }
    else
    {
        return RES_PARERR;
    }
}

#endif


/*-----------------------------------------------------------------------*/
/* Miscellaneous Functions                                               */
/*-----------------------------------------------------------------------*/

DRESULT disk_ioctl (
    BYTE pdrv,        /* Physical drive nmuber (0..) */
    BYTE cmd,        /* Control code */
    void *buff        /* Buffer to send/receive control data */
)
{
    if (pdrv == SPI_FLASH)
    {
        switch (cmd)
        {
         case CTRL_SYNC:
             return RES_OK;

         /* 扇区数量 1024*1024*1024 =4 (MB) */

         case GET_SECTOR_COUNT:

             *(DWORD * )buff = 65536;//
             return RES_OK;

         /* 扇区大小 */

         case GET_SECTOR_SIZE :

             *(WORD * )buff = 2048;//spi flash的扇区大小是 2048Byte
             return RES_OK;

         /*块大小 */

         case GET_BLOCK_SIZE :
              *(DWORD * )buff = 64;//64页
             return RES_OK;

         default:
              return RES_PARERR;
         }
    }
    else
    {
        return RES_PARERR;
    }
}

DWORD get_fattime(void)
{
    return 0;
}
万码无虫
关注
专栏目录
python function at 0x00000_Python 自定义函数的特殊属性（收藏专用）
weixin_32147807的博客
02-09 6528
Python 中通过函数定义所创建的用户自定义函数对象均具有一些特殊属性，需要注意的是这里介绍的是自定义函数(function类型)的特殊属性，而非方法(method 类型)的特殊属性，函数和方法的特熟属性以及默认的返回值可能不尽相同。对于大多数特殊属性，可以通过下面这个例子示范一下：class Test():def func(self, v = 'dog'):'''这里演示一个闭包函数'''na...
python function at 0x00000_异常忽略于：＜function BaseMySQLSocket.\uuuuuat 0x000002C85CBADF70＞回溯（最新版本,Excep...
weixin_39835792的博客
12-11 905
今天使用Python实现模块化的功能，突然遇到的问题具体报错如下：Exception ignored in: Traceback (most recent call last):File "D:\software installation\AutoOperate\venv\lib\site-packages\mysql\connector\network.py", line 149, in __d...
python 输出 ＜function z at 0x000002CDB971F1C0＞
weixin_44070217的博客
08-04 1160
python 输出
STM32 CubeMX 生成的代码中外设初始化函数未被调用
Never give up!
06-08 2026
      在使用CUBE MX生成代码时，定时器2的初始化函数在主程序中没有被调用，其它的外设初始化语句都能够正常生成，多次尝试生成代码都不行，以为是CUBE MX的一个bug，最后偶然想起来，自己在摸索CUBE MX这个软件的功能时，勾选了下图所示的地方，导致定时器2的初始化函数没有在主程序中被调用。将其取消选中后，再次生成代码，定时器2的初始化函数就在主程序中被调用了。该设置在Project...
[Simulink] 从S函数到模块代码生成
qq_26915769的博客
03-30 1万+
文章目录S函数S函数类型S函数的组成及执行顺序编写S函数Level1 M S函数Level2 M S函数C Mex S函数mdlInitializeSizesC Mex S函数的实例 S函数 当Simulink默认提供的模块不能够满足用户的需求时，用户可以通过S函数打造自己的模块，实现自定义的算法或期望的动作。 S函数类型 S函数的类型，按照所支持的功能分类，可以分为 Level 1 —— 编写...
数据库的函数
demonXwire的博客
11-15 2929
一文了解数据库函数
vxWorks延时函数
dragon_cdut的博客
07-11 4627
原文地址：https://blog.csdn.net/juana1/article/details/6673762 在应用编程的时候，通常会碰到需要一个任务在特定的延时之后执行一个指定的动作，如等待外设以确保数据可靠，控制扬声器发声时间以及串口通信超时重发等。这就需要利用定时器机制来计量特定长度的时间段。 vxWorks作为实时嵌入式系统，提供多样的定时接口函数。下面结合我的项目经历和...
STM32标准库常用函数的使用和代码说明
m0_50562428的博客
11-04 1万+
在每次中断程序结束后，一定要再调用一下清除中断标志位的函数，因为只要中断标志位置1了，程序就会跳转到中断函数， 如果不清除中断标志位，那它就会一直申请中断，这样程序就会不断响应中断，执行中断函数，那程序就会卡死在中断函数中，所以每次中断程序结束后，都应该清除一下中断标志位。这里的结构体就是一个数据打包的过程，首先将参数写到结构体的三个变量里，然后统一打包，将结构体传递到初始化函数里，接着在初始化函数里面，再把这个结构体拆包出来，读取变量，这就是使用结构体的整个过程。
DMA外设详解
热门推荐
k666499436的博客
05-01 3万+
存储器到存储器，存储器到外设，外设到存储器以及串口空闲中断深入理解
stm32学习笔记---USART串口外设（代码部分）串口发送/串口发送+接收
xiaobaivera的博客
07-03 4194
第一步，开启时钟，把需要用的USART和GPIO的时钟打开。 第二步，GPIO初始化，把TX配置成复用输出，RX配置成输入。 第三步，配置USART，直接使用一个结构体，就可以把这里所有的参数都配置好了。 第四步，开关控制，如果只需要发送的功能，就直接开启USART初始化就结束了。如果需要接收的功能，可能还需要配置中断。那就在开启USART之前，再加上ITConfig和NVIC的代码就行了。 初始化完成之后，如果要发送数据，调用一个发送函数就行了。如果要接收数据，就调用接收的函数。如果要获取发送和接收的状态
STM32F0标准外设函数库手册
04-21
STM32F0标准外设函数库手册是STMicroelectronics为STM32F0系列微控制器提供的一份重要参考资料，该手册详细介绍了如何利用STM32F0芯片上的各种外设功能。STM32F0系列是基于ARM Cortex-M0内核的微控制器，适用于低...
STM8函数库代码生成器
08-08
STM8函数库代码生成器是一款专门针对STM8微控制器设计的工具，用于自动化生成与STM8芯片相关的函数库代码。STM8是意法半导体（STMicroelectronics）推出的一系列8位微控制器，广泛应用于各种嵌入式系统设计，如家用...
ADuC845各外设源代码
04-02
本资源包含的是ADuC845的各个外设功能模块的源代码，这对于开发者来说是宝贵的参考资料，能够帮助他们快速理解和实现ADuC845的硬件功能。 1. **内部主AD（ADC）**：ADuC845内置了一个高精度的12位ADC，可以用于采集...
STM32的基本外设代码.rar
06-23
在"STM32的基本外设代码"压缩包中，可能包含了以下代码示例： 1. 串口初始化和DMA配置的代码：这部分代码会设置串口的波特率、数据位、停止位和奇偶校验，然后配置DMA通道以启用空闲接收。 2. USB初始化和类驱动代码...
STM32各外设源代码
03-07
源代码通常包括初始化LCD控制器、设置显示区域、刷新屏幕以及处理字符和图像显示的函数。 4. RTC（实时时钟）：RTC提供精确的时间保持功能，即使在CPU关闭时也能工作。源代码可能包括RTC的初始化、设置日期和时间、...
STM32-- 串口发送数据
code_snow的博客
11-23 379
？答：的作用是等待串口的发送数据寄存器（TXE，Transmit Data Register Empty）变为空，确保可以向串口发送新的数据。这是 STM32 标准外设库（SPL，Standard Peripheral Library）提供的函数，用于检查 USART 的标志位状态。
PTC在电池中的作用
最新发布
weixin_42929997的博客
11-23 979
而在温度升高时，PTC材料中的半导体会发生相变，晶格结构从松散转为紧密，电子运动受阻，电阻值急剧上升，进而限制或中断电流的流动，从而防止电池过热或发生热失控。PTC热敏电阻是一种特殊的材料，其电阻值随温度升高而增加的特性，决定了其在电池安全保护中不可或缺的作用。该复合材料不仅提高了电池的安全性，还提升了电池的电性能，具有更好的过流保护能力和更高的温度适应性。此外，随着高能量密度电池的出现，研究人员也在尝试开发更高温度耐受性和更快速响应的PTC材料，以满足新能源领域、汽车电池及其他高性能应用的需求。
九、FOC原理详解
weixin_59334478的博客
11-20 686
想要磁场旋转就需要线电流做着正弦变化，而 3 组线圈绕组的角度差，就使得三相电流需要时刻做相位差为 120 度的正弦变化，这时可使定子构造最合适的旋转磁场，显然简单的 6 步换向无法控制三相电流做正弦变化，转矩在一定程度上会有跳变，这样无法输出稳定转矩，因此需要 FOC 来保持转子的扭矩时刻连续稳定可调。电流环、速度环、位置环都会经历完成了FOC流程，并在PID控制模块进行偏差计算，对前一个系统（外环）的输出进行偏差的计算，计算结果作为后一个系统（内环）的输入。将位置环的输出，作为速度环的输入；
STM32F103系统时钟配置
Graceful_scenery的博客
11-19 832
时钟是单片机运行的基础，时钟信号推动单片机内各个部分执行相应的指令。时钟系统就是CPU的脉搏，决定CPU速率，像人的心跳一样 只有有了心跳，人才能做其他的事情，而单片机有了时钟，才能够运行执行指令，才能够做其他的处理 (点灯，串口，ADC)，时钟的重要性不言而喻。 一、STM32F103时钟介绍 STM32F103本身十分复杂，外设非常多 但我们实际使用的时候只会用到有限的几个外设，使用任何外...
stm32恢复外设函数
08-22
在STM32的HAL库中，恢复外设函数通常指的是使能外设的时钟，并且复位外设相关的寄存器，以保证外设处于一个确定的、可用的状态。恢复外设的过程一般包括以下几个步骤： 1. 使能外设的时钟：这一步骤是通过调用相应...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

万码无虫

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值