s3c2440 iic eeprom

最新推荐文章于 2021-05-15 18:47:15 发布
最新推荐文章于 2021-05-15 18:47:15 发布
阅读量679 收藏 1
点赞数
分类专栏： 中软培训
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/My_way_/article/details/48250047
版权
1、使用2440 iic 模块控制 

#include "2440addr.h"
#include "uart.h"


volatile int ackFlag = 0;

void delay()
{
	int i,j;
	for(i = 0; i < 500;i++)
		for(j = 0; j < 500; j++)
		;
}

/***********************************************
Function  name  :   Iic_ISR
Description     :   iic 中断处理函数
Input parameter :   none	
Return          :   none 	
Others		    :                   	                    
*************************************************/
static void __irq Iic_ISR()
{
	//清除中断
	rSRCPND |= (1 << 27);
	rINTPND |= (1 << 27);
	
	ackFlag = 1;
}



/***********************************************
Function  name  :   iic_init
Description     :   iic 通信初始化
Input parameter :   none	
Return          :   none 	
Others		    :                   	                    
*************************************************/
void iic_init(void)
{
	//配置GPE14\15 为 IICSCL 、IICSDA、不使能拉高电阻(GPE14\15没有对应的位)
	rGPECON &= ~(0xf << 28);
	rGPECON |= (0x2 << 30) | (0x2 << 28);
	
	//清除中断
	rSRCPND |= (1 << 27);
	rINTPND |= (1 << 27);
	//开启iic中断
	rINTMSK &= ~(1 << 27);
	
	//设置中断处理函数
	pISR_IIC = (unsigned)Iic_ISR;
	
	//配置IICCON寄存器：使能ACK，时钟源选择fPCLK /512
	//(从eeprom手册看出,其最大的传输频率为100kHZ)
	//使能中断，发送时钟值为0xf。
	//Tx clock = IICCLK/(IICCON[3:0]+1)=50000000/512=97kHz
	rIICCON = (1<<7)|(1<<6)|(1<<5);
	
	//设置CPU的从设备地址（未使用)
	rIICADD = 0x10;
	//IIC-bus data output enable
	rIICSTAT |= (1<<4);
	

}

/***********************************************
Function  name  :   iic_Tx
Description     :   iic 发送数据
Input parameter :   buffer 要发送的数据	
					size:数据大小
Return          :   none 	
Others		    :                   	                    
*************************************************/
void iic_Tx(unsigned char devAddr,unsigned char wordAddr,char buffer[],int size)
{
	int i = 0,j = 0;
	
	ackFlag = 0;
	
	//写从设备地址到IICDS寄存器
	rIICDS = devAddr;
	
	//配置为主发送模式
	//写0XF0到IICSTAT(主发送模式，并开始)
	rIICSTAT = 0xf0;
	for(i = 0; i < 100; i++);
	//清除挂起位
	rIICCON &= ~(1<<4);
	//等待ack中断响应
	//while(!ackFlag);
	//注意：这里等待挂起可以单独判断pending，但不能单独判断ack，防止数据丢失
	while(!ackFlag)
		delay();
	ackFlag = 0;
	
	//写起始地址到IICDS寄存器
	rIICDS = wordAddr;
	for(i = 0; i < 100; i++);
	//清除挂起位
	rIICCON &= ~(1<<4);
	//等待ack中断响应
	while(!ackFlag)
		delay();
	ackFlag = 0;
	
	//向IICDS写入发送数据直到发送结束
	for(j = 0; j < size; j++)
	{
		//写入新数据
		rIICDS = buffer[j];
		for(i = 0; i < 100; i++);
		//清除挂起位
		rIICCON &= ~(1<<4);
		//等待ack中断
		while(!ackFlag)
			delay();
		ackFlag = 0;
		
	}
	
	//发送结束，写0XD0到 IICSTAT
	rIICSTAT = 0xd0;
	rIICCON = 0xe0;
	
	//等待停止条件生效
	delay();
	
}



/***********************************************
Function  name  :   iic_Rx
Description     :   iic 接收数据
Input parameter :   buffer 接收buffer
Return          :   i: 接收到的数据大小 	
Others		    :                   	                    
*************************************************/
int iic_Rx(unsigned char devAddr,unsigned char wordAddr,char * buffer,int size)
{
	char ch;
	int i = 0,j = 0;
	ackFlag = 0;
	
	//写从设备地址到IICDS寄存器
	rIICDS = devAddr;
	for(i = 0; i < 100; i++);
	//配置为主发送模式
	//写0XF0到IICSTAT(主发送模式，并开始)
	rIICSTAT = 0xf0;
	//清除挂起位
	rIICCON &= ~0x10;
	//等待ack中断响应
	while(!ackFlag)
		delay();
	ackFlag = 0;
	
	
	//写起始地址到IICDS寄存器
	rIICDS = wordAddr;
	for(i = 0; i < 100; i++);
	//清除挂起位
	rIICCON &= ~0x10;
	//等待ack中断响应
	while(!ackFlag)
		delay();
	ackFlag = 0;
	
	
	//写从设备地址到IICDS寄存器
	rIICDS = devAddr;
	for(i = 0; i < 100; i++);
	//写0XB0到IICSTAT(主接收模式，并开始)
	rIICSTAT = 0xb0;
	//清除挂起位
	rIICCON &= ~0x10;
	//等待ack中断响应
	while(!ackFlag)
		delay();
	ackFlag = 0;
	
	//从IICDS读取第一个字节舍弃
	ch = rIICDS;
	//清除挂起位
	rIICCON &= ~0x10;
	//等待ack中断响应
	while(!ackFlag)
		delay();
	ackFlag = 0;
	
	//从IICDS读取数据直到接收结束
	for(j = 0; j < size; j++)
	{
		if(j == size-1)
		{
			rIICCON &= ~0x80;
		}
		//从IICDS读取数据
		buffer[j] = rIICDS;
		for(i=0;i<100;i++);
		//清除挂起位
		rIICCON &= ~0x10;
		//等待ack中断响应
		while(!ackFlag)
			delay();
		ackFlag = 0;
	}
	
	//接收结束，写0X90到 IICSTAT
	rIICSTAT = 0x90;
	rIICCON = 0xe0;
	
	//等待停止条件生效
	delay();
	
	return j;
}

/***********************************************
Function  name  :   iic_test
Description     :   iic 测试
Input parameter :   none
Return          :   none	
Others		    :                   	                    
*************************************************/
int iic_test(void)
{
	iic_init();
	int i = 998;
	int j = 0;
	
	iic_Tx(0xa0,0,(char*)&i,4);
	iic_Rx(0xa0,0,(char*)&j,4);
	
	uart_printf("\nj = %d\n",j);
}


2、使用 io 模拟 

/******************
iic.h
*******************/
#ifndef _IIC_H_
#define  _IIC_H_
#include "def.h"

void iic_init(void);

#define  AT24C08_ADDRDRESS    0xa0

#define  true  1
#define  false   0


#define PAGE1   0xa0
#define PAGE2   0xa2
#define PAGE3   0xa4
#define PAGE4   0xa6

#define  IIC_CLOCK_HIGH           rGPEDAT |= (1<<14)
#define  IIC_CLOCK_LOW            rGPEDAT &= ~(1<<14)

#define  IIC_DATA_HIGH            rGPEDAT |= (1<<15)
#define  IIC_DATA_LOW             rGPEDAT &= ~(1<<15)

#define  SET_IIC_DATA_INPUT       rGPECON &= ~(3<<30)
#define  SET_IIC_DATA_OUTPUT      rGPECON |= (1<<30)


U8  i2c_write(U8  device_address, U8  memory_address , U8 data);

U8  i2c_read(U8  device_address,  U8  memory_address, U8 *data);

U8  i2c_page_read(U8  device_address,  U8  memory_address, U8 *destination,U32 size);

U8  i2c_page_write(U8  device_address, U8 memory_address , U8 *source,U32 size);


U8  i2c_largepage_write(U8  device_address, U8 memory_address , U8 *source,U32 size);


void i2c_test(void);

#endif



/*****************************
iic.c
*****************************/

#include "2440addr.h"
#include "def.h"
#include "uart.h"
#include "iic.h"
//#include "timer.h"

#define   DELAY_DECIMUS_MS  100
extern void Delay_MS( unsigned int time);

void delayus( U32 time)
{
	U32 i,j;
	for ( i=0; i<time; i++)
	{
		  for(j=0;j<DELAY_DECIMUS_MS;j++)
		  {
		  }	
       }	
	    	  
}


void iic_init(void)
{
	 /* config  GPE14, GPE15 as output*/
	 rGPECON &=(~((3<<30)|(3<<28)));
	 rGPECON |=(1<<30)|(1<<28);
	
	/* SDA,SCL 默认为高电平 */
	 rGPEDAT |= ((1<<15)|(1<<14));
	 rGPEUP |= ((1<<15)|(1<<14));
	 delayus(1);
	 	
}	
	/* start */
void i2c_start(void)
{	

	IIC_DATA_HIGH; 
	delayus(1);
	IIC_CLOCK_HIGH;
	delayus(1);
	IIC_DATA_LOW;   
	delayus(1);
	IIC_CLOCK_LOW;
}

void  i2c_stop(void)
{	  
	SET_IIC_DATA_OUTPUT;
	delayus(1);
	IIC_DATA_LOW;	 	  
 	delayus(1);  
	IIC_CLOCK_HIGH;   
	delayus(1);  
	IIC_DATA_HIGH;  	
 	delayus(1);  	 
}	

U8  check_ack(void)
{
	 /* ack */	 
	  U8  ret;	

	 U8 ucErrTime=0; 
	 SET_IIC_DATA_INPUT;
	 delayus(1); 
	 IIC_CLOCK_HIGH; //negative edge clock data out of each device
	  delayus(1);
	
	 while(rGPEDAT&(1<<15))
	  {	
	  	ucErrTime++;      				//时间累加
		ret = false;             
		if(ucErrTime>250)                     //如果时间大于250
		{
			i2c_stop();                         //调用IIC停止子函数
			return ret;                         //程序返回值0
		}
        	
	  }
	 
	   ret = true;
	   
	IIC_CLOCK_LOW; 
	delayus(1);	 
	SET_IIC_DATA_OUTPUT; 
	delayus(1);
	return ret;
}	 

void send_no_ack(void)
{
	  delayus(1);   
	  IIC_CLOCK_LOW;  //positive edge clock data into eachEEPROM 
	  delayus(1); 
	  SET_IIC_DATA_OUTPUT;//发送数据时与上升沿同步
	  IIC_DATA_HIGH;           /* 发送高电平no ack */
	  delayus(2); 
	  IIC_CLOCK_HIGH;
	  delayus(1); 
   	  IIC_CLOCK_LOW;
	  delayus(1);
}	
	


void  data_write(U8 data)
{
	  U8 i;
	  SET_IIC_DATA_OUTPUT; 
	  delayus(1);
	    	  
	  /* data transmit */    
	  for (i = 0; i< 8; i++)
	  {
	  	
	  	if(data&(1<<(7-i)))//发送数据时与上升沿同步
	      {
           	 IIC_DATA_HIGH;
	      }
	      else
	      {
	   	      IIC_DATA_LOW;
	      }  
	       
	      delayus(1);
	      IIC_CLOCK_HIGH ;	  
	      delayus(1);	 
		  IIC_CLOCK_LOW ;
	    	delayus(1);
	  }
	  
	   IIC_DATA_HIGH;
	      delayus(1);	
	// UartPuts(" data write over!\n");
	    
}	


void  data_read(U8  *data )
{
	  U8 i;	
	  
	  IIC_DATA_HIGH;  // free
	  delayus(1); 
	  SET_IIC_DATA_INPUT;
	  delayus(1); 

	  
	  /* data reas */    
	  for (i = 0 ; i< 8; i++)
	  {
	  	
	  	 IIC_CLOCK_LOW;
	    	  delayus(1); 
		IIC_CLOCK_HIGH;	 
	  	 delayus(1);	

		  if(rGPEDAT&(1<<15))//接收数据时与下降沿同步
	  	  {   
	  	      (*data) |=(1<<(7-i)) ;
	  	  }   
		  else
		  {
			(*data) &=~(1<<(7-i)) ;
		  }

	    }
	  
	   IIC_CLOCK_LOW;
	     delayus(1); 
	 SET_IIC_DATA_OUTPUT; 
	//  Uart_Printf("----  %4x \n",*data); 
	  
}	





U8  i2c_write(U8  device_address, U8 memory_address , U8 data)
{
	  U8  write_addr;
	  U8  ack_flag;
	  U8  ret;
	  
	  /* start */
   	 i2c_start();
    	  
	  /* write address transmit */    
    	data_write(device_address);
	  
	  /* ack */	 
	  ack_flag = check_ack();
	  //ack_flag = 0;
	  
	  if(!ack_flag)
	  {
	  	 ret =  false;
	  	 UartPuts(" write  i2c  device address  no  ack!\n");
	  	 goto  i2c_stop;
	  }
	  
	   /* write address transmit */    
   	 data_write(memory_address);
	  
	  /* ack */	 
	  ack_flag = check_ack();
	  
	  if(!ack_flag)
	  {	    
	  	 ret =  false;
	  	 UartPuts(" write  memory  address  no  ack!\n");
	  	 while(1);
	  	 goto  i2c_stop;
	  }	  
	  /* write data transmit */  
	     
    	data_write(data);
	  
	  /* ack */	 
	  ack_flag = check_ack();
	  
	  if(!ack_flag)
	  {
	  	 ret =  false;
	  	 UartPuts(" write  data   no  ack!\n");
	  	 goto  i2c_stop;
	  }
	  else
	  {
	  	 ret =  true;
	  }	
	  	   
i2c_stop:
	 	 i2c_stop();
		  delayus(1000);  //延时等待STOP信号生效(10ms)
	 	 return ret;	
}

U8  i2c_dummy_write(U8  device_address, U8 memory_address )
{
	  U8  write_addr;
	  U8  ack_flag;
	  U8  ret;
	  
	  /* start */
   	 i2c_start();
    	  
	  /* write address transmit */    
   	 data_write(device_address);
	  
	  /* ack */	 
	  ack_flag = check_ack();
	  
	  if(!ack_flag)
	  {
	  	 ret =  false;
	  	 UartPuts(" dummy write  i2c  device address  no  ack!\n");
	  	 goto  i2c_stop;
	  }
	  
	   /* write address transmit */    
    	data_write(memory_address);
	  
	  /* ack */	 
	  ack_flag = check_ack();
	  
	  if(!ack_flag)
	  {	    
	  	 ret =  false;
	  	 UartPuts(" dummy write  memory  address  no  ack!\n");
	  	 goto  i2c_stop;
	  }	  
	  /* write data transmit */  
	    else
	  {
	  	 ret =  true;
		 return ret;	
	  }	
	  	   
i2c_stop:
	 	 i2c_stop();
	 	 return ret;	
}


U8  i2c_read(U8  device_address,  U8  memory_address, U8 *data)
{
	  U8  read_addr;	  	    
	  U8  ack_flag;	  
	  U8  ret;
	  
	  ret = i2c_dummy_write( device_address , memory_address);
	  
	  if(!ret)
	  {
	     ret =  false;
	     return ret; 	 
	  }	
	  
	  i2c_start();
	   
	  read_addr =  device_address |1;
   
   	 data_write(read_addr);
    
    	ack_flag = check_ack();
     
  	  if(!ack_flag)
	  {
	  	 ret =  false;
	  	 UartPuts(" i2c_read write  i2c  device address  no  ack!\n");
	  	 goto  i2c_read_stop;
	  }
	  
	  data_read(data);
	  
	  send_no_ack();	  
	  
	  ret =  true;
		  	  
i2c_read_stop:
	 	 i2c_stop();
	 	 return ret;    
     
}		

U8  i2c_page_read(U8  device_address,  U8  memory_address, U8 *destination,U32 size)
{
	int i;
	for(i=0;i<size;i++)
		i2c_read(device_address,memory_address+i,destination+i);

}
U8  i2c_page_write(U8  device_address, U8 memory_address , U8 *source,U32 size)
{
	int i;
	for(i=0;i<size;i++)
		{
		i2c_write(device_address,memory_address+i,source[i]);
		//Uart_Printf("write %d\n",i);
		}

}

U8  i2c_largepage_write(U8  device_address, U8 memory_address , U8 *source,U32 size)
{
	int i;
	int n,m;
	if(size>256)
		Uart_Printf("Size illegal\n");
	//assert(size<=256);//判断参数合法性
		
	n=size/16;		//写入的小页数
	m=size%16;	  //写入小页后剩余的个数
	for(i=0;i<n;i++)
			i2c_page_write(device_address,(memory_address+16*i),(source+16*i),16);
	for(i=0;i<m;i++)
			i2c_write(device_address,(memory_address+16*n+i),*(source+16*n+i));

}

void i2c_test(void)
{
	  U8 flag;
	  
	  U8  write_data;
	  U8  read_data;
	  U8 i,j;
	  i=1;
	  j=1;
	  
  	
	  UartPuts(" Begin to write!\n");
	
	  for(i=1;i<10;i++,j++)
	  {
	    flag = i2c_write(AT24C08_ADDRDRESS,i,j);
	    
	    if(flag)	
        UartPuts(" write i2c ok!\n");
      else
        UartPuts(" write i2c failed!\n");  
        
        Delay_MS(1000);
          
      flag = i2c_read(AT24C08_ADDRDRESS,i,&read_data);
    
       
       if(flag)
       {    
           Uart_Printf(" read  i2c ok! %4x \n",read_data); 
           //UartPutch(0x30+read_data); 
          //UartPuts(" \n");
          //Uart_Printf("%4x",read_data);
       }    
       else
       {
           UartPuts(" read  i2c failed!\n"); 
       } 
                    
       Delay_MS(500);     
    }    

}




My_way_
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
s3c2440 裸机 EEPROM存储
05-30
mini2440 裸机 EEPROM存储 查询和中断两种方式
I2C之知(六)--s3c2440用I2C接口访问EEPROM
weixin_30588729的博客
10-15 104
前面阅读理解了I2C的官方协议文档后,就拿s3c2440和EEPROM来验证一下. 本来是想用s3c2440的SDA和SCL管脚复用为GPIO来模拟的,但在没有示波器的情况下搞了一周,怎么都出不来,最后还是放弃了.甚至参考了linux下i2c-algo-bit.c和i2c-gpio.c,依然没调出来.如果有示波器,可能很快就能找到原因,现在完全不知道问题出在哪里.其实想用GPIO...
linux s3c2440 下i2c设备（EEPROM）操作
fz835304205的专栏
08-29 864
以前分析过i2c总线的构架但没写过i2c设备驱动，在platform下i2c实现比裸机复杂的多，由于内核中已加入i2c的实现且有虚拟设备i2c-0，因此借助内核，直接写应用程序就可以完成对i2c设备的操作。 root@FZ:/dev# ls apm_bios            ptyv1               ttyp9 audio               ptyv2    
S3C2440 Linux驱动移植——AT24C02（EEPROM）驱动
热门推荐
嵌入式Linux
01-11 1万+
开发板：TQ2440 内核：Linux 2.6.32 PC OS：Ubuntu 11.04 1.配置内核 打开I2C功能： 打开杂项设备，该选项打开后，EEPROM也就打开了。     2. 修改代码 修改文件: linux/arch/arm/mach-s3c2440/mach-smdk2440.c 增加如下代码片段： #include stat
iic裸机与linux通信,裸机系列——S3C2440IIC通信
weixin_35767180的博客
05-15 138
经过一周左右的时间终于是把IIC弄的个差不多了，我只能说对于每一个程序都要认真对待，每个程序的编写都是一种进步。对于IIC，给我的感觉是这个东西单片机的时候也知道，但是没有调出来，现在RAM裸机编程正好好好的学习的一下，但是虽然对于2440的IIC驱动只需要配置好寄存器和把握好时序就可以了，但是我还是经过了很多的一段痛苦的时期，不过现在回想看看，都是一种成长的经历，让人值得骄傲。因为我坚持过来了。...
S3C2440之IIC
爱笑运气就不会太差
01-15 368
IIC个人感觉驱动的中断步骤还是挺麻烦的， 要按照步骤流程来，程序如下： /****************************** *文件名：IIC.c * *功能: AT24C02底层驱动 * *创建者: 潘星宇 * *最后修改:2013.03.20 * *备注: * * * **********************...
s3c2440的IIC控制
weixin_34061555的博客
05-28 154
      在tq2440和mini2440上都连接着EEPROM 它们作用也不过測试I2C总线能否用。 当中在mini2440上EEPROM型号是 AT24C08，在tq2440上这个型号是 AT24C02A。 它们之间容量不同。地址线也不一样。       S3C2440A RISC 微处理器能够支持一个多主控 IIC 总线串行接口。一条串行数据线(SDA)和一条专用时钟线(SCL...
s3c2440 IIC控制器裸板程序
宁静以致远
06-13 635
        I2C总线只有两根双向信号线。一根是数据线SDA，另一根是时钟线SCL。要点：1、总线空闲：I2C总线空闲的时候，两条线SDA和SCL都是高电平。2、开始信号 S 信号：SCL 为高电平时，SDA由高电平向低电平跳变，开始传送数据。3、结束信号 P 信号：SCL 为高电平时，SDA由低电平向高电平跳变，结束传送数据。4、响应信号 ACK：接收器在接收到8位数据后，在第9个时钟周期，...
最完美的STM32读写I2C EEPROM驱动
08-16
目前网上能找到的最完美的STM32读写EEPROM驱动，硬件I2C中断加DMA方式！用24C16测试通过！
S3c2440-IIC.rar_s3c2440 ads1.2_s3c2440 iic
09-14
《S3C2440 IIC通讯协议详解与ADS1.2开发实践》 S3C2440是一款由Samsung公司推出的基于ARM920T内核的微处理器，广泛应用于嵌入式系统设计中。在这些系统中，IIC（Inter-Integrated Circuit）接口因其简单、低功耗的...
IIC.rar_IIC_linux iic_s3c2440 iic
最新发布
09-23
5. **实验步骤与示例**：提供在S3C2440开发板上实现IIC通信的实验步骤，可能包括配置IIC控制器，加载驱动，连接并测试IIC设备，如EEPROM、传感器等。 6. **调试技巧**：如何使用工具如`i2cdetect`、`i2cdump`等来...
IIC.rar_TE2440_s3c2440 iic_s3c2440 test
09-22
在实际应用中，S3C2440的IIC接口可以用来连接各种传感器，如温湿度传感器、陀螺仪、加速计等，或者控制LCD显示屏、EEPROM等。通过编写和测试IIC驱动程序，开发者可以确保其产品能够有效地与这些外部设备通信，从而...
s3c2440 IIC AT24C08
06-05
本篇文章将详细介绍如何在裸机环境下，使用S3C2440的IIC接口与AT24C08串行EEPROM进行通信。 AT24C08是一种8K位的串行EEPROM，常被用作存储小量非易失性数据，如配置参数、设备ID等。它通过IIC协议与主机进行交互，...
S3C2440 Linux下的I2C驱动以及I2C体系下对EEPROM进行读写操作。
07-08 4815
这篇文档算上期末复习这段时间其实拖了有好久了，因为从一开始接触linux的i2c驱动体系我就各种凌乱，经常性的在看内核代码时看着看着就把自己看飞了。结果就是无功而返，还使自己挫败感爆表，丧失信心。所以我决定当前阶段把结构体熟悉，知道大致的驱动体系框架。日后真正做到此类项目时再来深入理解，总结。
s3c2440中断总结+按键中断
My_way_的专栏
08-21 1712
一、启动代码之IRQ中断分析。 二、中断申请      60中断源，其中独立的中断和含有子中断的中断共32个。它们是位或共存。 1、 配置中断控制寄存器  SUB子  SRC源  PND--PENDING 挂起   1）SRCPND---申请中断   每一位对应一个总（独立）的中断源       手动写1---自动清0---有中断产生的那位就自动置1  -----在中断函

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值