STM32基于I2C协议的AHT20温湿度测量

其他 2020-12-24 02:10:52 阅读次数: 0

文章目录

任务要求

  1. 学习I2C总线通信协议，完成基于I2C硬件协议的AHT20温湿度传感器的数据采集，并将采集的温度-湿度值通过串口输出。
    1）解释什么是“软件I2C”和“硬件I2C”；
    2）编程实现：每隔2秒钟采集一次温湿度数据，并通过串口发送到上位机（win10）。

软硬件I2C

I2C Bus(Inter-Integrated Circuit Bus) 最早是由Philips半导体（现被NXP收购）开发的两线时串行总线，常用于微控制器与外设之间的连接。

I2C协议规定，总线上数据的传输必须以一个起始信号作为开始条件，以一个结束信号作为传输的停止条件。起始和结束信号总是由主设备产生。
起始和结束信号产生条件：总线在空闲状态时，SCL和SDA都保持着高电平，当SCL为高电平而SDA由高到低的跳变，表示产生一个起始条件；当SCL为高而SDA由低到高的跳变，表示产生一个停止条件。

在起始条件产生后，总线处于忙状态，由本次数据传输的主从设备独占，其他I2C器件无法访问总线；而在停止条件产生后，本次数据传输的主从设备将释放总线，总线再次处于空闲状态。起始和结束如图所示：在这里插入图片描述

数据的传输的进行：
在这里插入图片描述

软件I2C：
软件I2C一般是用GPIO管脚，用软件控制管脚状态以模拟I2C通信波形。
软件I2C:
硬件I2C对应芯片上的I2C外设，有相应I2C驱动电路，其所使用的I2C管脚也是专用的

AHT20测温湿度

本工程改编自野火自带例程串口通信4口，如下：
在这里插入图片描述
测温湿度函数计算代码如下：

void read_AHT20(void)
{
    
    
	uint8_t   i;

	for(i=0; i<6; i++)
	{
    
    
		readByte[i]=0;
	}

	//-------------
	I2C_Start();

	I2C_WriteByte(0x71);
	ack_status = Receive_ACK();
	readByte[0]= I2C_ReadByte();
	Send_ACK();

	readByte[1]= I2C_ReadByte();
	Send_ACK();

	readByte[2]= I2C_ReadByte();
	Send_ACK();

	readByte[3]= I2C_ReadByte();
	Send_ACK();

	readByte[4]= I2C_ReadByte();
	Send_ACK();

	readByte[5]= I2C_ReadByte();
	SendNot_Ack();
	//Send_ACK();

	I2C_Stop();

	//--------------
	if( (readByte[0] & 0x68) == 0x08 )
	{
    
    
		H1 = readByte[1];
		H1 = (H1<<8) | readByte[2];
		H1 = (H1<<8) | readByte[3];
		H1 = H1>>4;

		H1 = (H1*1000)/1024/1024;

		T1 = readByte[3];
		T1 = T1 & 0x0000000F;
		T1 = (T1<<8) | readByte[4];
		T1 = (T1<<8) | readByte[5];

		T1 = (T1*2000)/1024/1024 - 500;

		AHT20_OutData[0] = (H1>>8) & 0x000000FF;
		AHT20_OutData[1] = H1 & 0x000000FF;

		AHT20_OutData[2] = (T1>>8) & 0x000000FF;
		AHT20_OutData[3] = T1 & 0x000000FF;
	}
	else
	{
    
    
		AHT20_OutData[0] = 0xFF;
		AHT20_OutData[1] = 0xFF;

		AHT20_OutData[2] = 0xFF;
		AHT20_OutData[3] = 0xFF;
		printf("失败了");

	}
	printf("\r\n");
	printf("当前温度为: %d%d.%d",T1/100,(T1/10)%10,T1%10);
	printf("\r\n");
	printf("µ±Ç°Êª¶ÈΪ: %d%d.%d",H1/100,(H1/10)%10,H1%10);
	printf("\r\n");
}

连接STM32开发板与AHT20的引脚为B6,B7,电源供电为5V.如下：在这里插入图片描述

具体文件需要main.c，delay.c，usart.c，i2c.c，sys.c
main.c文件源码：

#include "delay.h"
#include "usart.h"
#include "i2c.h"


int main(void)
{
    
    	
	delay_init();    
	uart_init(115200);	 
	IIC_Init();
		while(1)
	{
    
    
		printf("野火STM32指南者基于I2C协议的AHT20温湿度传感器开始测量：");
		read_AHT20_once();
		delay_ms(1500);
  }
}

delay.c文件源码：

#include "delay.h"
#include "sys.h"
#if SYSTEM_SUPPORT_UCOS
#include "includes.h"	  
#endif
static u8  fac_us=0;
static u16 fac_ms=0;
#ifdef OS_CRITICAL_METHOD 	
void SysTick_Handler(void)
{
    
    				   
	OSIntEnter();		
    OSTimeTick();      
    OSIntExit();      
#endif

void delay_init()	 
{
    
    

#ifdef OS_CRITICAL_METHOD 	
	u32 reload;
#endif
	SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);	
	fac_us=SystemCoreClock/8000000;	 
	 
#ifdef OS_CRITICAL_METHOD 	
	reload=SystemCoreClock/8000000;		  
	reload*=1000000/OS_TICKS_PER_SEC;
	fac_ms=1000/OS_TICKS_PER_SEC;	   
	SysTick->CTRL|=SysTick_CTRL_TICKINT_Msk;
	SysTick->LOAD=reload;
	SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk; 
#else
	fac_ms=(u16)fac_us*1000;
#endif
}								    

#ifdef OS_CRITICAL_METHOD		    								   
void delay_us(u32 nus)
{
    
    		
	u32 ticks;
	u32 told,tnow,tcnt=0;
	u32 reload=SysTick->LOAD;	    	 
	ticks=nus*fac_us;   		 
	tcnt=0;
	told=SysTick->VAL; 
	while(1)
	{
    
    
		tnow=SysTick->VAL;	
		if(tnow!=told)
		{
    
    	    
			if(tnow<told)tcnt+=told-tnow;
			else tcnt+=reload-tnow+told;	    
			told=tnow;
			if(tcnt>=ticks)break;
		}  
	}; 									    
}

void delay_ms(u16 nms)
{
    
    	
	if(OSRunning==TRUE)    
	{
    
    		  
		if(nms>=fac_ms)
		{
    
    
   			OSTimeDly(nms/fac_ms);
		}
		nms%=fac_ms;		
	}
	delay_us((u32)(nms*1000));	
}
#else	    								   
void delay_us(u32 nus)
{
    
    		
	u32 temp;	    	 
	SysTick->LOAD=nus*fac_us;   		 
	SysTick->VAL=0x00;        
	SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk ;    
	do
	{
    
    
		temp=SysTick->CTRL;
	}
	while(temp&0x01&&!(temp&(1<<16)));
	SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;   
	SysTick->VAL =0X00;    
}

void delay_ms(u16 nms)
{
    
    	 		  	  
	u32 temp;		   
	SysTick->LOAD=(u32)nms*fac_ms;
	SysTick->VAL =0x00;     
	SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk ;      
	do
	{
    
    
		temp=SysTick->CTRL;
	}
	while(temp&0x01&&!(temp&(1<<16))); 
	SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;   
	SysTick->VAL =0X00;       	  	    
} 
#endif

usart.c文件源码：

#include "sys.h"
#include "usart.h"


#if SYSTEM_SUPPORT_UCOS
#include "includes.h"			
#if 1
#pragma import(__use_no_semihosting)                            
struct __FILE 
{
    
     
	int handle; 

}; 

FILE __stdout;       
void _sys_exit(int x) 
{
    
     
	x = x; 
} 
int fputc(int ch, FILE *f)
{
    
          
	while((USART1->SR&0X40)==0);//Ñ­»··¢ËÍ,Ö±µ½·¢ËÍÍê±Ï   
    USART1->DR = (u8) ch;      
	return ch;
}
#endif 

#if EN_USART1_RX  	
u8 USART_RX_BUF[USART_REC_LEN];  
u16 USART_RX_STA=0;   
  
void uart_init(u32 bound){
    
    
  GPIO_InitTypeDef GPIO_InitStructure;
	USART_InitTypeDef USART_InitStructure;
	NVIC_InitTypeDef NVIC_InitStructure;
	 
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA, ENABLE);	
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; 
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;	
    GPIO_Init(GPIOA, &GPIO_InitStructure);
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_Init(GPIOA, &GPIO_InitStructure);  
    NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3 ;
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;	
	NVIC_Init(&NVIC_InitStructure);
	USART_InitStructure.USART_BaudRate = bound;
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;
	USART_InitStructure.USART_StopBits = USART_StopBits_1;
	USART_InitStructure.USART_Parity = USART_Parity_No;
	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
	USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;	

    USART_Init(USART1, &USART_InitStructure); 
    USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
    USART_Cmd(USART1, ENABLE); 

}
void USART1_IRQHandler(void)  
	{
    
    
	u8 Res;
#ifdef OS_TICKS_PER_SEC	
	OSIntEnter();    
#endif
	if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET) 
		{
    
    
		Res =USART_ReceiveData(USART1);//(USART1->DR);	
		
		if((USART_RX_STA&0x8000)==0)
			{
    
    
			if(USART_RX_STA&0x4000)
				{
    
    
				if(Res!=0x0a)USART_RX_STA=0;
				else USART_RX_STA|=0x8000;
				}
			else 
				{
    
    	
				if(Res==0x0d)USART_RX_STA|=0x4000;
				else
					{
    
    
					USART_RX_BUF[USART_RX_STA&0X3FFF]=Res ;
					USART_RX_STA++;
					if(USART_RX_STA>(USART_REC_LEN-1))USART_RX_STA=0;  
					}		 
				}
			}   		 
     } 
#ifdef OS_TICKS_PER_SEC	 
	OSIntExit();  											 
#endif
} 
#endif

i2c.c文件源码：

#include "i2c.h"
#include "delay.h"

uint8_t   ack_status=0;
uint8_t   readByte[6];
uint8_t   AHT20_status=0;

uint32_t  H1=0;  //Humility
uint32_t  T1=0;  //Temperature

uint8_t  AHT20_OutData[4];
uint8_t  AHT20sendOutData[10] = {
    
    0xFA, 0x06, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF};

void IIC_Init(void)
{
    
    					     
	GPIO_InitTypeDef GPIO_InitStructure;
	RCC_APB2PeriphClockCmd(	RCC_APB2Periph_GPIOB, ENABLE );	
	   
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_7;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP ;   //ÍÆÍìÊä³ö
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOB, &GPIO_InitStructure);
 
	IIC_SCL=1;
	IIC_SDA=1;
 
}
void IIC_Start(void)
{
    
    
	SDA_OUT();  
	IIC_SDA=1;	  	  
	IIC_SCL=1;
	delay_us(4);
 	IIC_SDA=0;//START:when CLK is high,DATA change form high to low 
	delay_us(4);
	IIC_SCL=0;
}	  

void IIC_Stop(void)
{
    
    
	SDA_OUT();
	IIC_SCL=0;
	IIC_SDA=0;//STOP:when CLK is high DATA change form low to high
 	delay_us(4);
	IIC_SCL=1; 
	IIC_SDA=1;
	delay_us(4);							   	
}
u8 IIC_Wait_Ack(void)
{
    
    
	u8 ucErrTime=0;
	SDA_IN();  
	IIC_SDA=1;delay_us(1);	   
	IIC_SCL=1;delay_us(1);	 
	while(READ_SDA)
	{
    
    
		ucErrTime++;
		if(ucErrTime>250)
		{
    
    
			IIC_Stop();
			return 1;
		}
	}
	IIC_SCL=0;
	return 0;  
} 
void IIC_Ack(void)
{
    
    
	IIC_SCL=0;
	SDA_OUT();
	IIC_SDA=0;
	delay_us(2);
	IIC_SCL=1;
	delay_us(2);
	IIC_SCL=0;
}
//²»²úÉúACKÓ¦´ð		    
void IIC_NAck(void)
{
    
    
	IIC_SCL=0;
	SDA_OUT();
	IIC_SDA=1;
	delay_us(2);
	IIC_SCL=1;
	delay_us(2);
	IIC_SCL=0;
}					 				     	  
void IIC_Send_Byte(u8 txd)
{
    
                            
    u8 t;   
		SDA_OUT(); 	    
    IIC_SCL=0;
    for(t=0;t<8;t++)
    {
    
                  
        IIC_SDA=(txd&0x80)>>7;
        txd<<=1; 	  
		delay_us(2); 
		IIC_SCL=1;
		delay_us(2); 
		IIC_SCL=0;	
		delay_us(2);
    }	 
} 	    
u8 IIC_Read_Byte(unsigned char ack)
{
    
    
	unsigned char i,receive=0;
	SDA_IN();
  for(i=0;i<8;i++ )
	{
    
    
    IIC_SCL=0; 
    delay_us(2);
		IIC_SCL=1;
    receive<<=1;
    if(READ_SDA)receive++;   
		delay_us(1); 
  }					 
	if (!ack)
			IIC_NAck();
	else
			IIC_Ack(); 
	return receive;
} 
void IIC_WriteByte(uint16_t addr,uint8_t data,uint8_t device_addr)
{
    
    
	IIC_Start();  
	if(device_addr==0xA0) 
		IIC_Send_Byte(0xA0 + ((addr/256)<<1));
	else
		IIC_Send_Byte(device_addr);	 
	IIC_Wait_Ack(); 
	IIC_Send_Byte(addr&0xFF); 
	IIC_Wait_Ack(); 
	IIC_Send_Byte(data); 					   
	IIC_Wait_Ack();  		    	   
  IIC_Stop();
	if(device_addr==0xA0)
		delay_ms(10);
	else
		delay_us(2);
}
uint16_t IIC_ReadByte(uint16_t addr,uint8_t device_addr,uint8_t ByteNumToRead)  
{
    
    	
		uint16_t data;
		IIC_Start();  
		if(device_addr==0xA0)
			IIC_Send_Byte(0xA0 + ((addr/256)<<1));
		else
			IIC_Send_Byte(device_addr);	
		IIC_Wait_Ack();
		IIC_Send_Byte(addr&0xFF); 
		IIC_Wait_Ack(); 
 
		IIC_Start();  	
		IIC_Send_Byte(device_addr+1);
		IIC_Wait_Ack();
		if(ByteNumToRead == 1)
		{
    
    
			data=IIC_Read_Byte(0);
		}
		else
			{
    
    
				data=IIC_Read_Byte(1);
				data=(data<<8)+IIC_Read_Byte(0);
			}
		IIC_Stop();//²úÉúÒ»¸öÍ£Ö¹Ìõ¼þ	    
		return data;
}
void  read_AHT20_once(void)
{
    
    
	delay_ms(10);
	startMeasure_AHT20();
	delay_ms(80);
    read_AHT20();
	delay_ms(5);
}
void  startMeasure_AHT20(void)
{
    
    
	I2C_Start();

	I2C_WriteByte(0x70);
	ack_status = Receive_ACK();
	if(ack_status);
	else printf("7-n-");
	I2C_WriteByte(0xAC);
	ack_status = Receive_ACK();
	if(ack_status);
	else printf("8-n-");
	I2C_WriteByte(0x33);
	ack_status = Receive_ACK();
	if(ack_status);
	else printf("9-n-");
	I2C_WriteByte(0x00);
	ack_status = Receive_ACK();
	if(ack_status);
	else printf("10-n-");
	I2C_Stop();
}
void read_AHT20(void)
{
    
    
	uint8_t   i;
	for(i=0; i<6; i++)
	{
    
    
		readByte[i]=0;
	}
	I2C_Start();
	I2C_WriteByte(0x71);
	ack_status = Receive_ACK();
	readByte[0]= I2C_ReadByte();
	Send_ACK();
	readByte[1]= I2C_ReadByte();
	Send_ACK();
	readByte[2]= I2C_ReadByte();
	Send_ACK();
	readByte[3]= I2C_ReadByte();
	Send_ACK();
	readByte[4]= I2C_ReadByte();
	Send_ACK();
	readByte[5]= I2C_ReadByte();
	SendNot_Ack();
	//Send_ACK();
	I2C_Stop();
	if( (readByte[0] & 0x68) == 0x08 )
	{
    
    
		H1 = readByte[1];
		H1 = (H1<<8) | readByte[2];
		H1 = (H1<<8) | readByte[3];
		H1 = H1>>4;

		H1 = (H1*1000)/1024/1024;

		T1 = readByte[3];
		T1 = T1 & 0x0000000F;
		T1 = (T1<<8) | readByte[4];
		T1 = (T1<<8) | readByte[5];

		T1 = (T1*2000)/1024/1024 - 500;

		AHT20_OutData[0] = (H1>>8) & 0x000000FF;
		AHT20_OutData[1] = H1 & 0x000000FF;

		AHT20_OutData[2] = (T1>>8) & 0x000000FF;
		AHT20_OutData[3] = T1 & 0x000000FF;
	}
	else
	{
    
    
		AHT20_OutData[0] = 0xFF;
		AHT20_OutData[1] = 0xFF;

		AHT20_OutData[2] = 0xFF;
		AHT20_OutData[3] = 0xFF;
		printf("失败了");

	}
	printf("\r\n");
	printf("当前温度为:  %d%d.%d",T1/100,(T1/10)%10,T1%10);
	printf("\r\n");
	printf("当前湿度为: %d%d.%d",H1/100,(H1/10)%10,H1%10);
	printf("\r\n");
}
uint8_t  Receive_ACK(void)
{
    
    
	uint8_t result=0;
	uint8_t cnt=0;

	IIC_SCL = 0;
	SDA_IN(); 
	delay_us(4);

	IIC_SCL = 1;
	delay_us(4);

	while(READ_SDA && (cnt<100))
	{
    
    
		cnt++;
	}

	IIC_SCL = 0;
	delay_us(4);

	if(cnt<100)
	{
    
    
		result=1;
	}
	return result;
}



void  Send_ACK(void)
{
    
    
	SDA_OUT();
	IIC_SCL = 0;
	delay_us(4);

	IIC_SDA = 0;
	delay_us(4);

	IIC_SCL = 1;
	delay_us(4);
	IIC_SCL = 0;
	delay_us(4);

	SDA_IN();
}



void  SendNot_Ack(void)
{
    
    
	SDA_OUT();
	IIC_SCL = 0;
	delay_us(4);

	IIC_SDA = 1;
	delay_us(4);

	IIC_SCL = 1;
	delay_us(4);

	IIC_SCL = 0;
	delay_us(4);

	IIC_SDA = 0;
	delay_us(4);
}


void I2C_WriteByte(uint8_t  input)
{
    
    
	uint8_t  i;
	SDA_OUT();
	for(i=0; i<8; i++)
	{
    
    
		IIC_SCL = 0;
		delay_ms(5);

		if(input & 0x80)
		{
    
    
			IIC_SDA = 1;
			//delaymm(10);
		}
		else
		{
    
    
			IIC_SDA = 0;
			//delaymm(10);
		}

		IIC_SCL = 1;
		delay_ms(5);

		input = (input<<1);
	}

	IIC_SCL = 0;
	delay_us(4);

	SDA_IN();
	delay_us(4);
}	


uint8_t I2C_ReadByte(void)
{
    
    
	uint8_t  resultByte=0;
	uint8_t  i=0, a=0;

	IIC_SCL = 0;
	SDA_IN();
	delay_ms(4);

	for(i=0; i<8; i++)
	{
    
    
		IIC_SCL = 1;
		delay_ms(3);

		a=0;
		if(READ_SDA)
		{
    
    
			a=1;
		}
		else
		{
    
    
			a=0;
		}

		//resultByte = resultByte | a;
		resultByte = (resultByte << 1) | a;

		IIC_SCL = 0;
		delay_ms(3);
	}

	SDA_IN();
	delay_ms(10);

	return   resultByte;
}


void  set_AHT20sendOutData(void)
{
    
    
	AHT20sendOutData[3] = AHT20_OutData[0];
	AHT20sendOutData[4] = AHT20_OutData[1];
	AHT20sendOutData[5] = AHT20_OutData[2];
	AHT20sendOutData[6] = AHT20_OutData[3];
}


void  I2C_Start(void)
{
    
    
	SDA_OUT();
	IIC_SCL = 1;
	delay_ms(4);

	IIC_SDA = 1;
	delay_ms(4);
	IIC_SDA = 0;
	delay_ms(4);

	IIC_SCL = 0;
	delay_ms(4);
}



void  I2C_Stop(void)
{
    
    
	SDA_OUT();
	IIC_SDA = 0;
	delay_ms(4);

	IIC_SCL = 1;
	delay_ms(4);

	IIC_SDA = 1;
	delay_ms(4);
}

sys.c文件源码：

#include "sys.h"
void NVIC_Configuration(void)
{
    
    
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);	
}

最后烧录进STM32后，打开串口助手，显示如下：在这里插入图片描述

当朝着AHT20呼气时，显然温度与湿度都上升了，说明测试正确。

总结

参考来源：
https://blog.csdn.net/weixin_43202477/article/details/84823920
https://www.cnblogs.com/aaronLinux/p/6218660.html
https://blog.csdn.net/hhhhhh277523/article/details/111397514

以上就是本此对于STM32基于I2C协议的AHT20温湿度测量的全部内容。

猜你喜欢

转载自blog.csdn.net/qq_44644740/article/details/111438651
今日推荐
“开源信徒”周鸿祎开源360智脑大模型
华为ensp中vrrp虚拟路由器冗余协议 原理及配置命令
基于Python爬虫广东广州水酒店宾馆数据可视化系统设计与实现(Django框架) 研究背景与意义、国内外研究现状
知识融合：知识图谱构建的关键技术
文心一言收费还是免费：全面解析其价格策略与服务价值
百万用户通话新风潮：仅需50秒，无界AI让彩铃变身短视频
【STM32项目】基于STM32多传感器融合的新型智能导盲杖设计（完整工程资料源码）
文生视频大模型Sora的复现经验
腾讯云函数计算技术：云原生架构下的Serverless与微服务新篇章
干货分享｜JumpServer 三种常见的文件传输方式效果对比
【榜单公布】2023年度征文活动已结束
微信小程序（一）域名备案及HTTPS访问
周排行
Android六大布局详解——RelativeLayout（相对布局）
div absolute 居中
dict字典练习题
Django的Models模型
rand和srand的用法
聊一聊你理解的多线程
基于python语言利用割线法原理求解函数最小值问题
贫富分化社会不平等相关10本书，好书7本
jQuery中的wrap()、unwrap()
Linux学习【1】： cat 命令详解
每日归档
更多
2024-04-14(0)
2024-04-13(119)
2024-04-12(38)
2024-04-11(14)
2024-04-10(68)
2024-04-09(5)
2024-04-08(60)
2024-04-07(4)
2024-04-06(65)
2024-04-05(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022