sio.c

bootloader

head	1.1;
access;
symbols;
locks
	ICCAVR:1.1; strict;
comment	@ * @;


1.1
date	2006.11.14.14.10.17;	author ICCAVR;	state Exp;
branches;
next	;


desc
@对方
@


1.1
log
@Initial revision
@
text
@

#include "config.h"

#if USEUART0
siocirqueue RTbuf_UART0;
#endif
#if USEUART1
siocirqueue RTbuf_UART1;
#endif



#if (CPU_TYPE == M32)||(CPU_TYPE == M16)||(CPU_TYPE == M8)
#define USEUART0  TRUE
#define USEUART1  FALSE
#define iv_USART0_RXC   iv_USART_RXC
#define iv_USART0_TXC   iv_USART_TXC
#define UDR0  	  UDR 
#define UCSR0A    UCSRA
#define UCSR0B    UCSRB
#define UCSR0C	  UCSRC
#define UBRR0H	  UBRRH
#define UBRR0L	  UBRRL
#define RXCIE0	  RXCIE
#define TXCIE0	  TXCIE
#endif


/*********************************************************************************************************
** 函数名称: Com_init
** 功能描述: 初始化串行口
** 输　入: 
** 全局变量: 无
** 调用模块: Com_baudrate
** 说明：
** 注意：
********************************************************************************************************/
void Com_init (void) {	
//WDR(); //喂狗 
//CLI();                     // 关中断
#if USEUART0
Tbuf_init(&RTbuf_UART0);              //初始化接收缓冲
Rbuf_init(&RTbuf_UART0);
UCSR0B = 0x00; //disable while setting baud rate
UCSR0A=0x00;

#if CPU_TYPE <= M32
UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0);
UCSR0B = (1<<RXCIE)|(1<<TXCIE)|(1<<RXEN)|(1<<TXEN);  // RXCIE=1;TXCIE=1;UDREIE=0;RXEN=1;TXEN=1
#else
UCSR0C=0x06;  //8 DATA ,1 STOP, NO PARITY
UCSR0B = (1<<RXCIE0)|(1<<TXCIE0)|(1<<RXEN0)|(1<<TXEN0);  // RXCIE=1;TXCIE=1;UDREIE=0;RXEN=1;TXEN=1
#endif

#endif


#if USEUART1
Tbuf_init(&RTbuf_B);              //初始化接收缓冲
Rbuf_init(&RTbuf_B);
UCSR1B = 0x00; //disable while setting baud rate
UCSR1A = 0x00;
UCSR1C = 0x06;
UCSR1B = 0xD8;
#endif
Com_baudrate (9600);		 // 

//SEI();                     // 开中断
}
/*********************************************************************************************************
** 函数名称: Com_baudrate
** 功能描述: 利用定时器T1产生由参数baudrate指定的波特率
** 输　入: baudrate指定的波特率
** 全局变量: 无
** 调用模块: 无
** 说明：
** 注意：
********************************************************************************************************/
void Com_baudrate (uint16 baudrate) {
uint16 tmp;
tmp= F_CPU/baudrate/16-1;
#if USEUART0
UBRR0H=(uint8)(tmp>>8);
UBRR0L=(uint8)tmp;
#endif
#if USEUART1
UBRR1H=(uint8)(tmp>>8);
UBRR1L=(uint8)tmp;
#endif
}
/*********************************************************************************************************
** 函数名称: Com_putchar
** 功能描述: 从串行口输出一个字符c
** 输　入: c:输出字符
** 输出	 : 0:失败 1:成功
** 全局变量: 无
** 调用模块: 
** 说明：
** 注意：
********************************************************************************************************/
uint8 Com_putchar (uint8 c,siocirqueue *RTbuf) {
//WDR(); //喂狗
if (Tbuf_full(RTbuf)) 
   return(0);
else{
	Tbuf_putchar(c,RTbuf);				// 将数据加入到发送缓冲区并开中断
	return(1);
	}
}
/*********************************************************************************************************
** 函数名称: Com_putstring
** 功能描述: 从串行口输出一个字符串
** 输　入: p:指向输出字符串 len:输出长度
** 输出	 : 
** 全局变量: 无
** 调用模块: 
** 说明：
** 注意：
********************************************************************************************************/
void Com_putstring (uint8 *p,uint8 len,siocirqueue *RTbuf) {
uint8 i;
//WDR(); //喂狗
if (len!=0 ){
	for(i=0;i<len;i++)
	while(Com_putchar(p[i],RTbuf)==0);//WDR(); //喂狗;
	}
	else {
		do{
			while(Com_putchar(*p,RTbuf)==0);//WDR(); //喂狗;
			}while(*p++!='\n');
	}
	
}
/*********************************************************************************************************
** 函数名称: Com_getchar
** 功能描述: 从串行口输入一个字符
** 输　入: mode：0不需等待，在调用函数前检测Com_R_count的值
**              1 等待数据到来
** 输出	 : 读入的字符
** 全局变量: 无
** 调用模块: 
** 说明：
** 注意：
********************************************************************************************************/

uint8 Com_getchar (uint8 mode,siocirqueue *RTbuf) {
//WDR(); //喂狗
//    Delay(Delay_Comget,MaxLimit_Comget_Delay);
//	if (mode>0) while(Com_R_count(RTbuf)==0 && !DelayOvf(Delay_Comget))//WDR(); //喂狗;
//	if (DelayOvf(Delay_Comget))
//	    return 0;    //时间超时
//	else 
	    
		while(!Com_R_count(RTbuf));
		return (Rbuf_getchar(RTbuf));// 串行口输入正确，返回输入的字符
}



void Com_Rbuf_Clear(siocirqueue *RTbuf){
	Rbuf_init(RTbuf);
}



uint8 Com_getstring (uint8 *p,uint8 len,siocirqueue *RTbuf) {
uint8 i=0;
//WDR(); //喂狗
if (len>0 ){
	for(i=0;i<len;i++){
		//WDR(); //喂狗
		*p++=Com_getchar(1,RTbuf);
		}
	return(len);
	}
	else{
		
		
		do{
				*p++=Com_getchar(1,RTbuf);
				i++;
				//WDR(); //喂狗
			}while(*(p-1)!='\n');
//			*p++=Com_getchar(1,RTbuf);
//			*(p)=0;
		return(i);
		}
	
}


/*********************************************************************************************************
** 函数名称: Com_R_count
** 功能描述: 返回接收缓冲区字符个数函数
** 输　入: 
** 输出	 : 字符个数
** 全局变量: 无
** 调用模块: 
** 说明：
** 注意：
********************************************************************************************************/
uint8 Com_R_count(siocirqueue *RTbuf){
return RTbuf->R_count;
}
/*********************************************************************************************************
** 函数名称: Rbuf_init
** 功能描述: 接收缓冲区初始化
** 输　入: 
** 输出	 : 
** 全局变量: 无
** 调用模块: 
** 说明：
** 注意：
********************************************************************************************************/
void Rbuf_init(siocirqueue *RTbuf){
	RTbuf->R_front=0;
	RTbuf->R_rear=0;
    RTbuf->R_count=0;
	RTbuf->R_overflow=0;
}
/*********************************************************************************************************
** 函数名称: Tbuf_init
** 功能描述: 发送缓冲区初始化
** 输　入: 
** 输出	 : 
** 全局变量: 无
** 调用模块: 
** 说明：
** 注意：
********************************************************************************************************/
void Tbuf_init(siocirqueue *RTbuf){
	RTbuf->T_front=0;
	RTbuf->T_rear=0;
    RTbuf->T_count=0;
	RTbuf->T_disabled=1;
	}
/*********************************************************************************************************
** 函数名称: Rbuf_empty
** 功能描述: 接收缓冲区判空
** 输　入: 
** 输出	 :  TRUE 空 FALSE 非空
** 全局变量: 无
** 调用模块: 
** 说明：
** 注意：
********************************************************************************************************/
uint8 Rbuf_empty(siocirqueue *RTbuf){
	return RTbuf->R_count==0;
	}
/*********************************************************************************************************
** 函数名称: Tbuf_empty
** 功能描述: 发送缓冲区判空
** 输　入: 
** 输出	 :  TRUE 空 FALSE 非空
** 全局变量: 无
** 调用模块: 
** 说明：
** 注意：
********************************************************************************************************
uint8 Tbuf_empty(void){
	return RTbuf->T_count==0;
	}
/*********************************************************************************************************
** 函数名称: Rbuf_full
** 功能描述: 接收缓冲区判满
** 输　入: 
** 输出	 :  TRUE 满 FALSE 非满
** 全局变量: 无
** 调用模块: 
** 说明：
** 注意：
********************************************************************************************************
uint8 Rbuf_full (void){
	return RTbuf->R_count==RBUF_SIZE;
	}
/*********************************************************************************************************
** 函数名称: Tbuf_full
** 功能描述: 发送缓冲区判满
** 输　入: 
** 输出	 :  TRUE 满 FALSE 非满
** 全局变量: 无
** 调用模块: 
** 说明：
** 注意：
********************************************************************************************************/
uint8 Tbuf_full(siocirqueue *RTbuf){
	return RTbuf->T_count==TBUF_SIZE;
	}
/*********************************************************************************************************
** 函数名称: Rbuf_putchar
** 功能描述: 把一个字符放入接收缓冲区
** 输　入: 
** 输出	 :  
** 全局变量: 无
** 调用模块: 
** 说明：
** 注意：
********************************************************************************************************
void  Rbuf_putchar (uint8 x){
	if(!Rbuf_full()){
		REV_DIS();
		RTbuf->R_count++;
		RTbuf->R_buf[RTbuf->R_rear]=x;
		RTbuf->R_rear=(RTbuf->R_rear+1) % RBUF_SIZE;
		REV_EN();
	}
}
/*********************************************************************************************************
** 函数名称: Tbuf_putchar
** 功能描述: 把一个字符放入发送缓冲区
** 输　入: 
** 输出	 :  
** 全局变量: 无
** 调用模块: 
** 说明：
** 注意：
********************************************************************************************************/
void Tbuf_putchar(uint8 x,siocirqueue *RTbuf){
	if(!Tbuf_full(RTbuf)){
		TXC_DIS();
		if (RTbuf->T_disabled)
			{
			UDR0=x;
			RTbuf->T_disabled=0;
			}
		else
			{
			RTbuf->T_count++;
			RTbuf->T_buf[RTbuf->T_rear]=x;
			RTbuf->T_rear=(RTbuf->T_rear+1) % TBUF_SIZE;
			}
		TXC_EN();
	}
}
/*********************************************************************************************************
** 函数名称: Rbuf_getstring
** 功能描述: 从接收缓冲区返回当前子串指针
** 输　入: 
** 输出	 :  当前子串指针
** 全局变量: 无
** 调用模块: 
** 说明：
** 注意：
********************************************************************************************************
uint8 * Rbuf_getstring(void){
	return (RTbuf->R_buf[RTbuf->R_front]);
}
/*********************************************************************************************************
** 函数名称: Tbuf_getstring
** 功能描述: 从发送缓冲区返回当前子串指针
** 输　入: 
** 输出	 :  当前子串指针
** 全局变量: 无
** 调用模块: 
** 说明：
** 注意：
********************************************************************************************************
uint8 * Tbuf_getstring(void){
	return (RTbuf->T_buf[RTbuf->T_front]);
}
/*********************************************************************************************************
** 函数名称: Rbuf_putchar
** 功能描述: 从接收缓冲区读一个字符
** 输　入: 
** 输出	 :  读字符
** 全局变量: 无
** 调用模块: 
** 说明：
** 注意：
********************************************************************************************************/
uint8 Rbuf_getchar(siocirqueue *RTbuf){
	uint8 Btemp=0;
	if (!Rbuf_empty(RTbuf)){
		Btemp=RTbuf->R_buf[RTbuf->R_front];
		REV_DIS();
		RTbuf->R_count--;
		RTbuf->R_front=(RTbuf->R_front+1) % RBUF_SIZE;
		REV_EN();
		}
	return (Btemp);
	
}
/*********************************************************************************************************
** 函数名称: Tbuf_getchar
** 功能描述: 从发送缓冲区读一个字符
** 输　入: 
** 输出	 :  读字符
** 全局变量: 无
** 调用模块: 
** 说明：
** 注意：
********************************************************************************************************
uint8 Tbuf_getchar(void){
	uint8 Btemp;
	if (!Tbuf_empty()){
		Btemp=RTbuf->T_buf[RTbuf->T_front];
		TXC_DIS();
		RTbuf->T_count--;
		RTbuf->T_front=(RTbuf->T_front+1) % TBUF_SIZE;
		TXC_EN();
		return (Btemp);
	}
}
*/

/******************************* 中断处理函数 ***************************
* 功能：完成数据得的接收和发送
***********************************************************************/
#if USEUART0
#pragma interrupt_handler uart0_rx_isr:iv_USART0_RXC 
void uart0_rx_isr(void)
{
 uint8 status,data;
 siocirqueue *RTbuf;
 RTbuf=&RTbuf_UART0;
// CLI();
 status=UCSR0A;
 data=UDR0;
 //WDR(); //喂狗
 if((status & (FRAMING_ERROR | DATA_OVERRUN))==0)
 	{
	if(RTbuf->R_count<RBUF_SIZE){
		RTbuf->R_count++;
		RTbuf->R_buf[RTbuf->R_rear]=data;
		RTbuf->R_rear=(RTbuf->R_rear+1) % RBUF_SIZE;
		}
	else 
	   {
	   RTbuf->R_overflow=1;
	   }
	}
//SEI();
}
	
#pragma interrupt_handler uart0_tx_isr: iv_USART0_TXC
void uart0_tx_isr(void)
{
//CLI();
 siocirqueue *RTbuf;
 //WDR(); //喂狗
 RTbuf=&RTbuf_UART0;
 if (RTbuf->T_count>0){
	UDR0=RTbuf->T_buf[RTbuf->T_front];
	RTbuf->T_count--;
	RTbuf->T_front=(RTbuf->T_front+1) % TBUF_SIZE;
	}
 else RTbuf->T_disabled=1;
//SEI();
}
#endif

#if USEUART1
#pragma interrupt_handler uart1_rx_isr:iv_USART1_RXC 
void uart1_rx_isr(void)
{
 uint8 status,data;
 siocirqueue *RTbuf;
 RTbuf=&RTbuf_B;
// CLI();
//WDR(); //喂狗
 status=UCSR1A;
 data=UDR1;
 if((status & (FRAMING_ERROR | DATA_OVERRUN))==0)
 	{
	if(RTbuf->R_count<RBUF_SIZE){
		RTbuf->R_count++;
		RTbuf->R_buf[RTbuf->R_rear]=data;
		RTbuf->R_rear=(RTbuf->R_rear+1) % RBUF_SIZE;
		}
	else 
	   {
	   RTbuf->R_overflow=1;
	   }
	}
//SEI();
}
	
#pragma interrupt_handler uart1_tx_isr: iv_USART1_TXC
void uart1_tx_isr(void)
{
//CLI();
 siocirqueue *RTbuf;
 //WDR(); //喂狗
 RTbuf=&RTbuf_B;
 if (RTbuf->T_count>0){
	UDR1=RTbuf->T_buf[RTbuf->T_front];
	RTbuf->T_count--;
	RTbuf->T_front=(RTbuf->T_front+1) % TBUF_SIZE;
	}
 else RTbuf->T_disabled=1;
//SEI();
}
#endif


@