07.1AT24C02存储器

最新推荐文章于 2024-07-14 15:37:30 发布
最新推荐文章于 2024-07-14 15:37:30 发布
阅读量76 收藏
点赞数
文章标签： 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_69779423/article/details/132482451
版权

 1.

解读：第一个函数void AT24C02_write(unsigned char add, unsigned char dat)用于向AT24C02存储器写入数据。它接受两个参数：add表示要写入数据的地址，dat表示要写入的数据。函数首先调用IIC_Start()函数启动I2C总线，然后发送地址字节0XA0，等待接收应答信号。接着发送要写入的数据字节，再次等待接收应答信号，最后调用IIC_Stop()函数停止I2C总线。

第二个函数unsigned char AT24C02_read(unsigned char add)用于从AT24C02存储器读取数据。它接受一个参数：add表示要读取数据的地址。函数首先声明一个变量dat用于存储读取的数据，然后调用IIC_Start()函数启动I2C总线，发送地址字节0XA0，等待接收应答信号。接着发送读取数据的地址字节，再次等待接收应答信号。最后调用IIC_Stop()函数停止I2C总线，接着发送地址字节0XA1，等待接收应答信号，并从I2C总线上读取一个字节的数据，将其赋值给变量dat，最后返回读取的数据。

void AT24C02_write(unsigned char add,unsigned char dat)
{
	IIC_Start();
	IIC_SendByte(0XA0);
	IIC_WaitAck();
	IIC_SendByte(add);
	IIC_WaitAck();
	IIC_SendByte(dat);
	IIC_WaitAck();
	IIC_Stop();
}

unsigned char AT24C02_read(unsigned char add)
{
	unsigned char dat;
	
	IIC_Start();
	IIC_SendByte(0XA0);
	IIC_WaitAck();
	IIC_SendByte(add);
	IIC_WaitAck();
	IIC_Stop();
	
	IIC_Start();
	IIC_SendByte(0XA1);
	IIC_WaitAck();
	dat = IIC_RecByte();
	IIC_SendAck(1);
	IIC_Stop();
	
	return dat ;
}

2.AT24C02应用（开关机次数+部分蓝桥杯模板）

main.c文件

#include<STC15.H>
#include<intrins.H>
#include<IIC.H>

#define uchar unsigned char
#define uint unsigned int
	
unsigned char LED_Bit=0XFF;
unsigned char Actuator_Bit=0X00;

#define LEDx_ON(n) 	{ LED_Bit&=_crol_(0XFE,n-1); P0=LED_Bit; P2|=0X80;	P2&=0X9F;	P2&=0X1F;}
#define LEDx_OFF(n) { LED_Bit|=_crol_(0X01,n-1); P0=LED_Bit; P2|=0X80;	P2&=0X9F;	P2&=0X1F;}

#define Buzzer_ON 	Actuator_Bit|=0x40; P0=Actuator_Bit;	P2|=0XA0;	P2&=0XBF; P2&=0X1F;		
#define Buzzer_OFF 	Actuator_Bit&=0XBF; P0=Actuator_Bit;	P2|=0XA0;	P2&=0XBF;	P2&=0X1F;
#define Relay_ON 		Actuator_Bit|=0x10; P0=Actuator_Bit;	P2|=0XA0;	P2&=0XBF;	P2&=0X1F;
#define Relay_OFF 	Actuator_Bit&=0XEF; P0=Actuator_Bit;	P2|=0XA0;	P2&=0XBF;	P2&=0X1F;

unsigned char tab[]={0XC0,0XF9,0XA4,0XB0,0X99,0X92,0X82,0XF8,0X80,0X90,0XBF,0XFF};
unsigned char KEY_Value = 0 ;
unsigned char DigCom=0;
unsigned char DigBuf[8] = {10,10,10,10,10,10,10,10};

unsigned char LED = 1 ;
unsigned int LED_tt =0;
bit LED_Ref = 0 ;

unsigned int SEG_tt =0;		//定义一个数码管计数时间标识位
bit SEG_Ref = 0 ;					//定义一个数码管刷新标识位
bit SEG_Run = 0 ;					//定义一个控制数码管运行标识位
unsigned int Num = 999 ;

unsigned char Open;
unsigned char EEPROM_Write[8] = {2,3,4,5,6,7,8,9};
unsigned char EEPROM_Read[8] = {0,0,0,0,0,0,0,0};//将EEPROM_Write数组中的数据写入EEPROM中，
																								//并将其中的数据读取到EEPROM_Read数组中

unsigned int XXX_tt =0;
bit XXX_Ref =0;

void IO_Init(void);
void ALL_Init(void);
void Delay_MS(unsigned int MS);
void KeyScan(void);
void ArrKeyScan(void);
void Timer0Init(void);		//1毫秒@11.0592MHz

void main(void)
{
	IO_Init();
	ALL_Init();
	Timer0Init();
	EA=1;ET0=1;
	
//AT24C02_write(0X15,0);Delay_MS(1);     //对AT24C02芯片进行写操作,向地址为0x15的存储单元写入值为0的数据
																				   //在写操作完成后，通过Delay_MS(1)函数延时1毫秒，
																					//以确保数据稳定地被写入芯片中
	
	Open = AT24C02_read(0X15); Delay_MS(5); //从AT24C02芯片的地址0X15处读取数据,读取的数据存储在变量Open中
	AT24C02_write(0X15,++Open);Delay_MS(5); //将一个数据写入AT24C02芯片的地址0X15处,数据通过递增后的变量Open传递给函数
	DigBuf[0]=Open/10;DigBuf[1]=Open%10;   
	
//	AT24C02_Write_Page(0X00);Delay_MS(5);//将数据写入AT24C02芯片的0X00地址处的一页中;延时5毫秒，等待数据写入完成
//	AT24C02_Read_Page(0X00);Delay_MS(5);//从AT24C02芯片的0X00地址处读取一页数据;延时5毫秒，等待数据读取完成
//	DigBuf[0]=EEPROM_Read[0];DigBuf[1]=EEPROM_Read[1];DigBuf[2]=EEPROM_Read[2];DigBuf[3]=EEPROM_Read[3];
//	DigBuf[4]=EEPROM_Read[4];DigBuf[5]=EEPROM_Read[5];DigBuf[6]=EEPROM_Read[6];DigBuf[7]=EEPROM_Read[7];
//将EEPROM_Read数组中的数据从从AT24C02芯片读取到DigBuf数组中（分别对应的索引为0-7）

	while(1)
	{
		KeyScan();
		if(KEY_Value==7){KEY_Value=0;SEG_Run = 1 ;}
		if(KEY_Value==6){KEY_Value=0;SEG_Run = 0 ;}
		if(KEY_Value==5){KEY_Value=0;LEDx_ON(1);Buzzer_ON;}
		if(KEY_Value==4){KEY_Value=0;LEDx_OFF(1);Buzzer_OFF;}	
	}
}

void KeyScan(void)
{
	if(P30==0)
	{
		Delay_MS(10);
		if(P30==0)KEY_Value = 7 ;		
		while(!P30);
	}
	else if(P31==0)
	{
		Delay_MS(10);
		if(P31==0)KEY_Value = 6 ;		
		while(!P31);
	}	
	else if(P32==0)
	{
		Delay_MS(10);
		if(P32==0)KEY_Value = 5 ;		
		while(!P32);
	}	
	else if(P33==0)
	{
		Delay_MS(10);
		if(P33==0)KEY_Value = 4 ;		
		while(!P33);
	}	
}

void Timer0(void) interrupt 1
{
	P0=0X00;
	P2|=0XC0;  // P2=P2|0XC0;   XXXX XXXX | 1100 0000 = 11XX XXXX
	P2&=0XDF;	 // P2=P2&0XDF;   11XX XXXX & 1101 1111 = 110X XXXX	
	P2&=0X1F;		//关闭所有的74HC573锁存器	
	
	P0=tab[DigBuf[DigCom]];	
	P2|=0XE0;			//	P2=P2|0XE0;   XXXX XXXX | 1110 0000 = 111X XXXX
	P2&=0XFF;		 	// P2=P2&0XDF;   11XX XXXX & 1101 1111 = 110X XXXX	
	P2&=0X1F;			//关闭所有的74HC573锁存器
	
	P0=(0X01<<DigCom); 	//然后选中第一个数码管
	P2|=0XC0;  // P2=P2|0XC0;   XXXX XXXX | 1100 0000 = 11XX XXXX
	P2&=0XDF;	 // P2=P2&0XDF;   11XX XXXX & 1101 1111 = 110X XXXX	
	P2&=0X1F;		//关闭所有的74HC573锁存器

	if(++DigCom == 8)DigCom = 0 ;
	
	LED_tt++;
	if(LED_tt == 999) {LED_tt = 0 ; LED_Ref = 1 ;}

	if(++SEG_tt==1000){SEG_tt=0;SEG_Ref=1;}
//	XXX_tt++;
//	if(++XXX_tt==NNN){XXX_tt=0;XXX_Ref=1;}	
}

void Timer0Init(void)		//1毫秒@11.0592MHz
{
	AUXR |= 0x80;		//定时器时钟1T模式
	TMOD &= 0xF0;		//设置定时器模式
	TL0 = 0xCD;		//设置定时初始值
	TH0 = 0xD4;		//设置定时初始值
	TF0 = 0;		//清除TF0标志
	TR0 = 1;		//定时器0开始计时
}



void Delay_MS(unsigned int MS)
{
	unsigned i,j;
	for(i=0;i<MS;i++)
		for(j=853;j>0;j--); //STC15单片机设置为853; STC8H单片机修改为1109；STC32G单片机修改为427;
}

void ALL_Init(void)
{
	P0 =0X00;		//先设置关闭蜂鸣器继电器的P0输出值（全关）
	P2|=0XA0;		// 将P27 P25 设置为1 其他位保持不变
	P2&=0XBF; 	// 将P26设置为0 其他位保持不变
	P2&=0X1F;		//关闭所有的74HC573锁存器

	P0 =0XFF;		//先设置关闭所有的LED的P0输出值（全关）
	P2|=0X80;		// 将P27设置为1 其他位保持不变
	P2&=0X9F;		// 将P26 P25设置为0 其他位保持不变
	P2&=0X1F;		//关闭所有的74HC573锁存器
	
	P0 =0X00;		//先设置选择数码管位选的P0输出值（全不选）
	P2|=0XC0;		// 将P27 P26 设置为1 其他位保持不变
	P2&=0XDF;		// 将P26设置为0 其他位保持不变
	P2&=0X1F;		//关闭所有的74HC573锁存器
}

void IO_Init(void)
{
	P0M0 = 0x00; 	P0M1 = 0x00; 			//IO初始化为准双向I/O模式，STC15F系列可以写
	P1M0 = 0x00; 	P1M1 = 0x00;			//IO初始化为准双向I/O模式，STC15F系列可不写
	P2M0 = 0x00; 	P2M1 = 0x00;			//IO初始化为准双向I/O模式，STC15F系列可不写
	P3M0 = 0x00; 	P3M1 = 0x00;			//IO初始化为准双向I/O模式，STC15F系列可不写
	P4M0 = 0x00; 	P4M1 = 0x00;			//IO初始化为准双向I/O模式，STC15F系列可不写
	P0=0XFF; P1=0XFF; P2=0XFF; P3=0XFF; P4=0XFF; P5=0XFF; //P0、P1、P2、P3、P4、P5输出为高电平	 STC15系列单片机可不写
}

/*
void ArrKeyScan(void)
{
	unsigned char temp;				//定义局部变量用来存储从P3口读出的数值? 
	P44=0; P42=1; P3=0X7F; 		// //0111 1111 扫描第一列
	temp = P3 ;								//将P3口读出的数字赋值给temp 
	temp = temp & 0X0F ; 			// 0111 XXXX & 0000 1111 = 0000 XXXX 
	if(temp != 0X0F)
	{
		Delay_MS(5);
		temp = P3 ;								//将P3口读出的数字赋值给temp 
		temp = temp & 0X0F ; 			// 0111 XXXX & 0000 1111 = 0000 XXXX 
		if(temp != 0X0F)
		{
			temp = P3 ;
			switch(temp)  //1110  1101 1011 0111 
			{
				case 0X7E: KEY_Value = 7 ; break;
				case 0X7D: KEY_Value = 6 ; break;
				case 0X7B: KEY_Value = 5 ; break;
				case 0X77: KEY_Value = 4 ; break;
				default :  break;
			}
			while(temp != 0X0F)
			{
				temp = P3 ;								//将P3口读出的数字赋值给temp 
				temp = temp & 0X0F ; 			// 0111 XXXX & 0000 1111 = 0000 XXXX 
			}
		}
	}
	
	P44=1; P42=0; P3=0XBF; 		// //0111 1111 扫描第一列
	temp = P3 ;								//将P3口读出的数字赋值给temp 
	temp = temp & 0X0F ; 			// 0111 XXXX & 0000 1111 = 0000 XXXX 
	if(temp != 0X0F)
	{
		Delay_MS(5);
		temp = P3 ;								//将P3口读出的数字赋值给temp 
		temp = temp & 0X0F ; 			// 0111 XXXX & 0000 1111 = 0000 XXXX 
		if(temp != 0X0F)
		{
			temp = P3 ;
			switch(temp)  //1110  1101 1011 0111 
			{
				case 0XBE: KEY_Value = 11 ; break;
				case 0XBD: KEY_Value = 10 ; break;
				case 0XBB: KEY_Value = 9 ; break;
				case 0XB7: KEY_Value = 8 ; break;
				default :  break;
			}
			while(temp != 0X0F)
			{
				temp = P3 ;								//将P3口读出的数字赋值给temp 
				temp = temp & 0X0F ; 			// 0111 XXXX & 0000 1111 = 0000 XXXX 
			}
		}
	}

	P44=1; P42=1; P3=0XDF; 		// //1101 1111 扫描第一列
	temp = P3 ;								//将P3口读出的数字赋值给temp 
	temp = temp & 0X0F ; 			// 0111 XXXX & 0000 1111 = 0000 XXXX 
	if(temp != 0X0F)
	{
		Delay_MS(5);
		temp = P3 ;								//将P3口读出的数字赋值给temp 
		temp = temp & 0X0F ; 			// 0111 XXXX & 0000 1111 = 0000 XXXX 
		if(temp != 0X0F)
		{
			temp = P3 ;
			switch(temp)  //1110  1101 1011 0111 
			{
				case 0XDE: KEY_Value = 15 ; break;
				case 0XDD: KEY_Value = 14 ; break;
				case 0XDB: KEY_Value = 13 ; break;
				case 0XD7: KEY_Value = 12 ; break;
				default :  break;
			}
			while(temp != 0X0F)
			{
				temp = P3 ;								//将P3口读出的数字赋值给temp 
				temp = temp & 0X0F ; 			// 0111 XXXX & 0000 1111 = 0000 XXXX 
			}
		}
	}
	
	P44=1; P42=1; P3=0XEF; 		// //0111 1111 扫描第一列
	temp = P3 ;								//将P3口读出的数字赋值给temp 
	temp = temp & 0X0F ; 			// 0111 XXXX & 0000 1111 = 0000 XXXX 
	if(temp != 0X0F)
	{
		Delay_MS(5);
		temp = P3 ;								//将P3口读出的数字赋值给temp 
		temp = temp & 0X0F ; 			// 0111 XXXX & 0000 1111 = 0000 XXXX 
		if(temp != 0X0F)
		{
			temp = P3 ;
			switch(temp)  //1110  1101 1011 0111 
			{
				case 0XEE: KEY_Value = 19 ; break;
				case 0XED: KEY_Value = 18 ; break;
				case 0XEB: KEY_Value = 17; break;
				case 0XE7: KEY_Value = 16; break;
				default :  break;
			}
			while(temp != 0X0F)
			{
				temp = P3 ;								//将P3口读出的数字赋值给temp 
				temp = temp & 0X0F ; 			// 0111 XXXX & 0000 1111 = 0000 XXXX 
			}
		}
	}
}
*/

2.iic.c文件


/*
#include "reg52.h"
#include "intrins.h"

#define DELAY_TIME 50    //STC32G单片机   #define DELAY_TIME 3 

#define SlaveAddrW 0xA0
#define SlaveAddrR 0xA1

extern unsigned char EEPROM_Write[8];
extern unsigned char EEPROM_Read[8];


//总线引脚定义
sbit SDA = P2^1;     //数据线 
sbit SCL = P2^0;    //时钟线 

void IIC_Delay(unsigned char i)
{
    do{_nop_();}
    while(i--);        
}
//总线启动条件
void IIC_Start(void)
{
    SDA = 1;
    SCL = 1;
    IIC_Delay(DELAY_TIME);
    SDA = 0;
    IIC_Delay(DELAY_TIME);
    SCL = 0;	
}

//总线停止条件
void IIC_Stop(void)
{
    SDA = 0;
    SCL = 1;
    IIC_Delay(DELAY_TIME);
    SDA = 1;
    IIC_Delay(DELAY_TIME);
}

//发送应答
void IIC_SendAck(bit ackbit)
{
    SCL = 0;
    SDA = ackbit;  					// 0：应答，1：非应答
    IIC_Delay(DELAY_TIME);
    SCL = 1;
    IIC_Delay(DELAY_TIME);
    SCL = 0; 
    SDA = 1;
    IIC_Delay(DELAY_TIME);
}

//等待应答
bit IIC_WaitAck(void)
{
    bit ackbit;
	
    SCL  = 1;
    IIC_Delay(DELAY_TIME);
    ackbit = SDA;
    SCL = 0;
    IIC_Delay(DELAY_TIME);
    return ackbit;
}

//通过I2C总线发送数据
void IIC_SendByte(unsigned char byt)
{
    unsigned char i;

    for(i=0; i<8; i++)
    {
        SCL  = 0;
        IIC_Delay(DELAY_TIME);
        if(byt & 0x80) SDA  = 1;
        else SDA  = 0;
        IIC_Delay(DELAY_TIME);
        SCL = 1;
        byt <<= 1;
        IIC_Delay(DELAY_TIME);
    }
    SCL  = 0;  
}

//从I2C总线上接收数据
unsigned char IIC_RecByte(void)
{
    unsigned char i, da;
    for(i=0; i<8; i++)
    {   
    	SCL = 1;
	IIC_Delay(DELAY_TIME);
	da <<= 1;
	if(SDA) da |= 1;
	SCL = 0;
	IIC_Delay(DELAY_TIME);
    }
    return da;    
}
void AT24C02_write(unsigned char add,unsigned char dat)
{
	IIC_Start();
	IIC_SendByte(0XA0);
	IIC_WaitAck();
	IIC_SendByte(add);
	IIC_WaitAck();
	IIC_SendByte(dat);
	IIC_WaitAck();
	IIC_Stop();
}
unsigned char AT24C02_read(unsigned add)
{
	unsigned char dat;
	
	IIC_Start();
	IIC_SendByte(0XA0);
	IIC_WaitAck();
	IIC_SendByte(add);
	IIC_WaitAck();
	IIC_Stop();
	
	IIC_Start();
	IIC_SendByte(0XA1);
	IIC_WaitAck();
	dat=IIC_RecByte();
	IIC_SendAck(1);
	IIC_Stop();
	
	return dat;
}

void AT24C02_Write_Page(unsigned char add)
{
	unsigned char i = 0 ;
	
	IIC_Start();
	IIC_SendByte(0xA0);
	IIC_WaitAck();
	IIC_SendByte(add);
	IIC_WaitAck();
	for(i=0;i<8;i++)
	{
		IIC_SendByte(EEPROM_Write[i]);
		IIC_WaitAck();
	}
	IIC_Stop();
}

void AT24C02_Read_Page(unsigned char add)
{
	unsigned char i = 0 ;

	IIC_Start();
	IIC_SendByte(0XA0);
	IIC_WaitAck();
	IIC_SendByte(add);
	IIC_WaitAck();
	IIC_Stop();

	IIC_Start();
	IIC_SendByte(0XA1);
	IIC_WaitAck();
	for(i=0;i<8;i++)
	{
		EEPROM_Read[i] = IIC_RecByte();
		IIC_SendAck(0);
	}	
	IIC_Stop();
}
*/






#include "stc15.h"
#include "intrins.h"

extern unsigned char EEPROM_Write[8];
extern unsigned char EEPROM_Read[8];

//总线引脚定义
sbit SDA = P2^1; 
sbit SCL = P2^0; 

void Delay5us()		//@11.0592MHz
{
	unsigned char i;

	_nop_();
	i = 11;
	while (--i);
}

void IIC_Start()
{
	SDA = 1;
	SCL = 1;
	Delay5us();
	SDA = 0;
	Delay5us();
	
}

void IIC_Stop()
{
	SDA = 0;
	SCL = 1;
	Delay5us();
	SDA = 1;
	Delay5us();
}

void IIC_SendByte(unsigned char dat)
{
	unsigned char i;
	
	for(i=0;i<8;i++)
	{
		SCL = 0 ;
		Delay5us();
		if(dat & 0x80)SDA=1;
    else SDA =0;
		Delay5us();
		SCL = 1 ;
		dat <<= 1;
		Delay5us();
	}
	SCL = 0 ;
}

unsigned char IIC_RecByte(void)
{
	unsigned char dat;
	unsigned char i;
	
	for(i=0;i<8;i++)
	{
		SCL = 1 ;
		Delay5us();
		dat<<=1;
		if(SDA) dat |= 0x01;
		SCL = 0 ;
		Delay5us();
	}
	return dat;
}

bit IIC_WaitAck(void)
{
	bit ackbit;
	
	SCL = 1 ;
	Delay5us();
	ackbit = SDA ;
	SCL = 0 ;
	Delay5us();
	
	return ackbit;
}

void IIC_SendAck(bit ackbit)
{
	SCL = 0 ;
	SDA = ackbit;
	Delay5us();
	SCL = 1 ;
	Delay5us();	
	SCL = 0 ;
	SDA = 1 ;
	Delay5us();
}

void AT24C02_write(unsigned char add,unsigned char dat)
{
	IIC_Start();
	IIC_SendByte(0XA0);
	IIC_WaitAck();
	IIC_SendByte(add);
	IIC_WaitAck();
	IIC_SendByte(dat);
	IIC_WaitAck();
	IIC_Stop();
}

unsigned char AT24C02_read(unsigned char add)
{
	unsigned char dat;
	
	IIC_Start();
	IIC_SendByte(0XA0);
	IIC_WaitAck();
	IIC_SendByte(add);
	IIC_WaitAck();
	IIC_Stop();
	
	IIC_Start();
	IIC_SendByte(0XA1);
	IIC_WaitAck();
	dat = IIC_RecByte();
	IIC_SendAck(1);
	IIC_Stop();
	
	return dat ;
}

void AT24C02_Write_Page(unsigned char add)
{
	unsigned char i = 0 ;
	
	IIC_Start();
	IIC_SendByte(0xA0);
	IIC_WaitAck();
	IIC_SendByte(add);
	IIC_WaitAck();
	for(i=0;i<8;i++)
	{
		IIC_SendByte(EEPROM_Write[i]);
		IIC_WaitAck();
	}
	IIC_Stop();
}

void AT24C02_Read_Page(unsigned char add)
{
	unsigned char i = 0 ;

	IIC_Start();
	IIC_SendByte(0XA0);
	IIC_WaitAck();
	IIC_SendByte(add);
	IIC_WaitAck();
	IIC_Stop();

	IIC_Start();
	IIC_SendByte(0XA1);
	IIC_WaitAck();
	for(i=0;i<8;i++)
	{
		EEPROM_Read[i] = IIC_RecByte();
		IIC_SendAck(0);
	}	
	IIC_Stop();
}

3.IIC.H文件

#ifndef _IIC_H
#define _IIC_H

void IIC_Start(void); 
void IIC_Stop(void);  
bit IIC_WaitAck(void);  
void IIC_SendAck(bit ackbit); 
void IIC_SendByte(unsigned char byt); 
unsigned char IIC_RecByte(void);


void AT24C02_write(unsigned char add,unsigned char dat);
unsigned char AT24C02_read(unsigned add);
void AT24C02_Write_Page(unsigned char add);
void AT24C02_Read_Page(unsigned char add);

#endif

 

 

吸尘器的灰
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
CodeLab：Android fundamentals 07.1:AsyncTask
qq_39040714的博客
04-12 445
Android fundamentals 07.1:AsyncTask Tutorial source : Google CodeLab Date : 2021/04/06 Complete course : 教程目录 (java). Note : The link in this article requires Google access 1、Welcome This practical codelab is part of Unit 3: Working in the background in
库伯勒 SHK 07.1系列计时器.rar
10-13
库伯勒 SHK 07.1 系列计时器是工业自动化领域中常见的一种时间控制设备，主要用于实现各种时间间隔、周期性操作或延迟动作。这一系列计时器以其精准度高、稳定性好、操作简便等特点，在众多工业应用中得到了广泛应用...
IIC的使用
qq_54215896的博客
11-22 1563
总线空闲：SDA = 1,SCL = 1;启动信号：SCL = 1,SDA 1 -> 0;停止信号：SCL = 1,SDA 0 -> 1;数据传输：SCL为1时，SDA必须保持稳定，即为0或1（停止时相反，所以在停止前要改变SDA都要先把SCL置为0）；SCL为0时，才允许改变SDA状态；SCL在上升沿时写入数据，在下降沿时读出数据；应答信号：为0时，是有效应答，为1时，是无效应答；传输到最后一个字节后，要发送一个无效应答，再发送停止信号；
（9）AT24C02存储器
Falling_Asteroid的博客
05-17 857
AT24C02
07.1 双向链表
m0_47017197的博客
05-08 186
/任意位置进行插入，先绑定后面，再绑定前面。
07.1 类的的补充
纸境止境的博客
05-23 137
文章目录1、对象的初始化2、类的隐式转换3、explicit4、成员函数末尾的const5、mutable6、cosnt成员变量的初始化7、=default8、=delete 1、对象的初始化   可以注意一下这些初始化的方式方法。 class Time{ private: int Hour, Minute, Second; public: Time(int Hour, int Minute, int Second){ this->Hour = Hour; this->Minute
07.1 python基础-类和对象
qq_25672165的博客
05-10 165
文章目录1. 基础语法1.1 类基础语法1.2 初始化函数2. 继承2.1 单继承2.2 多继承2.3 超继承3. 多态3.1 重写3.2 拓展4. 总结 1. 基础语法 1.1 类基础语法 关键字class 类名规范：数字字母下划线组成,不能数字开头,首字母大写,不需要隔开 # 类命名是不带括号，调用时需要带括号，否则视为赋值 class TestEngineer: degree = ...
dart 07.1Dart执行模型
Applicaton的专栏
06-19 537
Dart 是一种单线程语言 首先我们需要记住 ​ Dart 是单线程的并且Flutter依赖于Dart 重点 Dart 同一时刻只执行一个操作，其他操作在该操作之后执行，这表示只要一个操作正在执行它就不会被其他代码中断 同样的如果该操作需要消耗一段时间，那么在操作执行期间应用将被阻塞 Dart 执行模型 那么，Dart 是如何管理事件执行呢 看下dart的 事件循环机制 当启动一个Flutter/Dart 程序时 将创建启动一个新的线程或者进程Dart中叫Isolate这个Iolate 将作
07.1. 深度卷积神经网络（AlexNet）
weixin_45063703的博客
10-09 321
通过标准的特征提取算法，如SIFT（尺度不变特征变换）和SURF（加速鲁棒特征）或其他手动调整的流水线来输入数据。AlexNet的架构与LeNet相似，但使用了更多的卷积层和更多的参数来拟合大规模的ImageNet数据集。网络中的网络（NiN）。AlexNet的更高层建立在这些底层表示的基础上，以表示更大的特征，如眼睛、鼻子、草叶等等。使用更小的学习速率训练，这是因为网络更深更广、图像分辨率更高，训练卷积神经网络就更昂贵。今天，AlexNet已经被更有效的架构所超越，但它是从浅层网络到深层网络的关键一步。
滴水三期：day07.1-函数堆栈图2
Edimade的博客
02-12 246
一、函数>二、windows堆栈（1.特点>2.堆栈平衡）>三、嵌套函数堆栈图
IPQ4029 AP.DK07.1 DAKOTA schematic
01-15
"IPQ4029 AP.DK07.1 DAKOTA 模式图" 本资源是 Qualcomm Atheros INC. 公司的一份设计文档，主要介绍了 IPQ4029 AP.DK07.1 DAKOTA 模式图的设计细节。下面是该文档中涉及的一些重要知识点： 1. 模式图设计：文档中...
Lab07.1-webpack-y-babel
03-06
在这个"Lab07.1-webpack-y-babel"实验中，我们将深入探讨这两个工具如何协同工作，帮助开发者构建复杂的前端应用。 首先，Webpack 的核心概念是模块化。在 JavaScript 开发中，模块化允许我们把代码分解成小块，...
SSD2116_0.31 07.1.11.pdf
03-01
SSD2116_0.31 07.1.11.pdf
ILI9222DS_V04-07.1.29
02-16
ILI9222DS_V04-07.1.29
hmallox勒索病毒科普：了解其威胁与防御策略
最新发布
safe130_的博客
07-14 944
halo，.360，.faust，.2700, .eking，elbie, .wis，.mkp，.malox，.rmallox，.mallox，.hmallox, .anony, .ma1x0，.live，.carver，.locked，_locked，.locked1，.svh , lockbit, .src, .secret , .datah, .BEAST,.DevicData-P, .kat6.l6st6r 等等，：用户从非官方或不受信任的源下载软件时，可能会无意中安装带有勒索病毒的软件包。
vue2 实现原生 WebSocket
weixin_38797742的博客
07-11 402
原生WebSocket： new WebSocket。
Mac虚拟机跑Windows流畅吗 Mac虚拟机连不上网络怎么解决 mac虚拟机网速慢怎么解决
2401_82916694的博客
07-10 671
选择Shared模式，你的Mac会当作虚拟机的路由器。一般来说，拥有更高性能的Cpu（如Apple M2或M3芯片）、更大的内存（建议16GB以上）、以及足够的存储空间可以显著提升虚拟机中Windows的运行流畅度。Mac的防火墙或其他安全设置可能阻止虚拟机访问网络，如果你的Mac主机可以访问网络，并且排查了上文介绍的情况，那么可以尝试关闭Mac电脑防火墙，再检查虚拟机是否可以连接网络。使用Mac虚拟机运行Windows是否流畅，取决于几个关键因素：硬件配置、虚拟机软件的选择以及虚拟机的设置。
访问控制的定义与原理
SafePloy_SH的博客
07-11 329
访问控制(Access Control)是一种重要的安全机制，用于限制对程序中的数据、函数、类以及计算机系统中资源(如文件、数据库、网络设备等)的访问权限。其主要目的是保护系统中的敏感信息和资源，防止未经授权的访问和操作，确保系统的安全性、完整性和可靠性。综上所述，访问控制是保障系统安全的重要手段之一，它通过限制用户对资源的访问权限来防止未经授权的访问和操作。允许用户对自身所创建的访问对象(如文件、数据表等)进行访问，并可将对这些对象的访问权授予其他用户或收回其访问权限。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值