uart.c

CS5532的驱动程序

/****************************************Copyright (c)**************************************************
**                               	GaodeTailin
**                                   
**                                 
** 文   件   名: uart.c
** 最后修改日期: 2007-9-19 12:56
** 描        述: rs232通讯函数
** 版	     本: V1.0
** 主  控  芯 片:M8 晶振频率:4.00, 波特率9600
** IDE:ICCAVR 6.31
**********************************************************************************************************/
#include <iom8v.h>
#include <macros.h>

#include "DEFINE.H"
#include "UART.H"
#include "COMMAND.H"


uint08 uart_tx_buf[UART_BUF_SIZE];			//发送缓冲
uint08 uart_tx_wr_ptr,uart_tx_rd_ptr;		
uint08 uart_rx_counter,uart_tx_counter;
uint08 uart_rx_buf[UART_BUF_SIZE];			//接收缓冲，相当于消息体
uint08 seq_number;					//顺序数
uint08 check_sum;					//和校验
uint08 rx_stu_mac;					//接收状态机
uint08 msg_end_flag;					//消息体结束标志
uint16 msg_size;					//消息尺寸


/**********************************************************************
functionName:void uart_init(void)
description:uart初始化
**********************************************************************/	
void uart_init(void)
{
	SET_BIT(DDRD,PD1);	//IO初始化	
	CLR_BIT(DDRD,PD0);	//IO初始化

	UCSRB = 0x00; 		
 	UCSRA = 0x00;
 	UCSRC = 0x86;
	UBRRL = BAUD9600; 			//set baud rate lo
 	UBRRH = 0x00; 				//set baud rate hi
 	UCSRB = 0x98;				//使用中断
	uart_tx_wr_ptr=uart_tx_rd_ptr=0;
	//uart_rx_wr_ptr=uart_rx_rd_ptr=0;
	uart_rx_counter=uart_tx_counter=0;
	msg_end_flag=0;				//表示没有接收到数据
	rx_stu_mac=ST_START;
}




/**********************************************************************
functionName:void uart0_rx_isr(void)
description:串口接受中断函数
**********************************************************************/
#pragma interrupt_handler uart0_rx_isr:12
void uart0_rx_isr(void)
{
 	uint08 uart_data;
 	uart_data=UDR;
 	switch(rx_stu_mac)
 	{
 		case ST_START:
 		{
 			if(uart_data==MESSAGE_START)
			{
				rx_stu_mac = ST_GET_SEQ_NUM;	
				check_sum = MESSAGE_START;
			}
 			break;
 		}
 		case ST_GET_SEQ_NUM:
 		{
 			seq_number = uart_data;
			check_sum ^= uart_data; 
			rx_stu_mac = ST_MSG_SIZE_H;
 			break;
 		}
 		case ST_MSG_SIZE_H:
 		{
 			msg_size = uart_data;
			msg_size <<=8;
			check_sum ^= uart_data;
			rx_stu_mac = ST_MSG_SIZE_L;
 			break;
 		}
 		case ST_MSG_SIZE_L:
 		{
 			msg_size |= uart_data;
			check_sum ^= uart_data;
			rx_stu_mac = ST_GET_TOKEN;	
 			break;
 		}
 		case ST_GET_TOKEN:
 		{
 			if(uart_data==TOKEN)
			{
				check_sum ^= uart_data;
				rx_stu_mac = ST_GET_DATA;
				uart_rx_counter=0;
			}
			else
			{
				rx_stu_mac = ST_START;
			}
 			break;
 		}
 		case ST_GET_DATA:
 		{
 			uart_rx_buf[uart_rx_counter++]=uart_data;
			check_sum ^= uart_data;
			if(uart_rx_counter==msg_size)
			{
				rx_stu_mac = ST_GET_CHECK;
			}
 			break;
 		}
 		case ST_GET_CHECK:
 		{
 			if(uart_data == check_sum)
			{
				msg_end_flag=1;
			}		
			rx_stu_mac = ST_START;
 			break;
 		}
 		default:
 		{
 			rx_stu_mac=ST_START;
 			break;
 		}
 	}
}




/*void packageProcess(uint08 seqNum) 
{
	uint08 cmd;
	uint08 tmp=0;
	uint08 tmp2=0;
	uint08 tmp3=0;
	uint08 mode;
	uint16 block_size;
	uint16 i;
	uint16 tmp16;
	uint16 num_bytes=0;
	uint32 polling_address=0;
	uint32 start_address = address;
	cmd = msg_buffer[0];
	
	//命令CMD_SIGN_ON
	if(cmd==CMD_SIGN_ON)
	{
		num_bytes = 11;
		msg_buffer[0] = CMD_SIGN_ON;
		msg_buffer[1] = STATUS_CMD_OK;
		msg_buffer[2] = 8;
		memcpy(msg_buffer+3,"STK500_2",8);
	}
	//命令CMD_SET_PARAMETER
	else if(cmd==CMD_SET_PARAMETER)
	{
		switch(msg_buffer[1])
		{
			case PARAM_SCK_DURATION:
				
				if((msg_buffer[2]) >= 1  ) clockSpeed=SPI_SPEED_2MHZ;
				if((msg_buffer[2]) >= 2  ) clockSpeed=SPI_SPEED_1MHZ;
				if((msg_buffer[2]) >= 4  ) clockSpeed=SPI_SPEED_500KHZ;
				if((msg_buffer[2]) >= 8  ) clockSpeed=SPI_SPEED_250KHZ;
				if((msg_buffer[2]) >= 16 ) clockSpeed=SPI_SPEED_125KHZ;
				if((msg_buffer[2]) >= 32 ) clockSpeed=SPI_SPEED_62KHZ;
				if(EEPROMread(EEP_SCK_DURATION)!=clockSpeed) 
				EEPROMwrite(EEP_SCK_DURATION,clockSpeed);
				//spi_set_speed(clock_speed);		//因为我这里不用硬件SPI 
				break;
			case PARAM_RESET_POLARITY:			//区分51和AVR用的,1表示AVR 0表示AT89C
				if(resetPolarity != msg_buffer[2])
				{
					resetPolarity = msg_buffer[2];
					EEPROMwrite(EEP_RESET_POLARITY,resetPolarity);				
				}
				break;
			case PARAM_CONTROLLER_INIT:
				paramControllerInit = msg_buffer[2];
				break;
			case PARAM_VADJUST:
				vAdjust = msg_buffer[2];
				EEPROMwrite(EEP_VOL_ADJUST,vAdjust);
				break;
			case PARAM_VTARGET:
				vTarget = msg_buffer[2]; 
				EEPROMwrite(EEP_VOL_TARGET,vTarget);
				asm("jmp 0x17FF");
				break;	
			default:break; 		
		}
		num_bytes = 2;
		msg_buffer[0] = CMD_SET_PARAMETER;
		msg_buffer[1] = STATUS_CMD_OK;
	}
	//命令CMD_GET_PARAMETER
	else if(cmd==CMD_GET_PARAMETER)
	{
		switch(msg_buffer[1])
		{
			case PARAM_BUILD_NUMBER_LOW:
				tmp = CONFIG_PARAM_BUILD_NUMBER_LOW;
				break;
			case PARAM_BUILD_NUMBER_HIGH:
				tmp = CONFIG_PARAM_BUILD_NUMBER_HIGH;
				break;
			case PARAM_HW_VER:
				tmp = CONFIG_PARAM_HW_VER;
				break;
			case PARAM_SW_MAJOR:
				tmp = CONFIG_PARAM_SW_MAJOR;
				break;
			case PARAM_SW_MINOR:
				tmp = CONFIG_PARAM_SW_MINOR;
				break;
			case PARAM_SCK_DURATION:
				tmp = clockSpeed;
				break;
			case PARAM_RESET_POLARITY:
				tmp = resetPolarity;
				break;
			case PARAM_CONTROLLER_INIT:
				tmp = paramControllerInit;
				break;
			case PARAM_VTARGET:				//目标电压
				tmp = vTarget;
				break;	
			case PARAM_VADJUST:
				tmp = vAdjust;				//参考电压
				break;
			case PARAM_TOPCARD_DETECT:
				tmp = TOP_CARD_STK520;
				break;	
		}
		num_bytes = 3;
		msg_buffer[0] = CMD_GET_PARAMETER;
		msg_buffer[1] = STATUS_CMD_OK;
		msg_buffer[2] = tmp;
	}
	//命令CMD_OSCCAL
	else if(cmd==CMD_OSCCAL)
	{
		num_bytes = 2;
		msg_buffer[0] = CMD_OSCCAL;
		msg_buffer[1] = STATUS_CMD_OK;
	}	
	//命令CMD_LOAD_ADDRESS
	else if(cmd==CMD_LOAD_ADDRESS)
	{
		address =  ((unsigned long)msg_buffer[1])<<24;
		address |= ((unsigned long)msg_buffer[2])<<16;
		address |= ((unsigned long)msg_buffer[3])<<8;
		address |= ((unsigned long)msg_buffer[4]);
		num_bytes = 2;
		msg_buffer[0] = CMD_LOAD_ADDRESS;
		msg_buffer[1] = STATUS_CMD_OK;
	}
	//命令CMD_FIRMWARE_UPGRADE
	else if(cmd==CMD_FIRMWARE_UPGRADE)
	{
		num_bytes = 2;
		msg_buffer[0] = CMD_FIRMWARE_UPGRADE;
		//msg_buffer[1] = STATUS_CMD_OK;
		msg_buffer[1] = STATUS_CMD_FAILED;
		asm("jmp 0x17FF");
		//进入Firmware upgrade模式
	}
	//命令CMD_ENTER_PROGMODE_ISP
	else if(cmd == CMD_ENTER_PROGMODE_ISP)
	{
		prgMode=1;
		spiEnable();
		msDelay(msg_buffer[2]);	
		LED_ON2;
		for(i=0;i<msg_buffer[4];i++)
		{
			SPIWrite(msg_buffer[8]);
			msDelay(msg_buffer[5]);
			SPIWrite(msg_buffer[9]);
			msDelay(msg_buffer[5]);
			if(msg_buffer[7]==3)		//AVR
			{
				tmp=SPIWrite(msg_buffer[10]);
				msDelay(msg_buffer[5]);				
				SPIWrite(msg_buffer[11]);
				msDelay(msg_buffer[5]);				
			}
			else				//AT89S
			{
				SPIWrite(msg_buffer[10]);
				msDelay(msg_buffer[5]);				
				tmp=SPIWrite(msg_buffer[11]);
				msDelay(msg_buffer[5]);
			}
			if((tmp==msg_buffer[6])||(msg_buffer[7]==0))
			{
				i=0xFF;
				LED_OFF2;
				break;
			}
			else
			{
				spiEnable();
				msDelay(msg_buffer[2]);	
			}
		}
		num_bytes = 2;
		msg_buffer[0] = CMD_ENTER_PROGMODE_ISP;
		if(i==0xFF)
		{			
			msg_buffer[1] = STATUS_CMD_OK;			
		}
		else
		{			
			msg_buffer[1] = STATUS_CMD_FAILED;
		}		
	}
	//命令 CMD_LEAVE_PROGMODE_ISP
	else if(cmd==CMD_LEAVE_PROGMODE_ISP)
	{
		prgMode=0;		
		spiDisable();
		num_bytes = 2;
		msg_buffer[0] = CMD_LEAVE_PROGMODE_ISP;
		msg_buffer[1] = STATUS_CMD_OK;		
	}
	//命令CMD_CHIP_ERASE_ISP
	else if(cmd==CMD_CHIP_ERASE_ISP)
	{
		universalComm(msg_buffer[3],msg_buffer[4],msg_buffer[5],msg_buffer[6]);	
		//Newer AVR's seems to have a busy bit
		//cant test this because I don't have any of these new chips
		if(msg_buffer[2]==0)
		{
			msDelay(msg_buffer[1]);
		}
		else 	//if(msg_buffer[2]==1)
		{
			while(universalComm(0xF0,0x00,0x00,0x00)&1);
		}		
		num_bytes = 2;
		msg_buffer[0] = CMD_CHIP_ERASE_ISP;
		msg_buffer[1] = STATUS_CMD_OK;			
	}
	//命令CMD_PROGRAM_FLASH_ISP
	else if(cmd==CMD_PROGRAM_FLASH_ISP)
	{
		block_size = ((unsigned int)msg_buffer[1])<<8;
		block_size |= msg_buffer[2];
		mode = msg_buffer[3];
		LED_FLASH2;
		//如果是字写模式
		if((mode&1) == 0)
		{	
			for(i=0;i<block_size;i++)
			{	
				//If we have an uneven byte programm the
				//high byte			
				if(i&1)
				{
					SPIWrite(msg_buffer[5]|(1<<3));
				}
				else
				{
					SPIWrite(msg_buffer[5]);
				}
				SPIWrite16(address);
				SPIWrite(msg_buffer[i+10]);
				//Check if we can do polling
				if(msg_buffer[8]!=msg_buffer[i+10])
				{
					polling_address = address&0xFFFF;
				}
				//If not switch the mode hard waiting
				else
				{
					mode = (mode&(~0x0E)) | 0x02;
				}
				//Different polling methods
				//Hard waiting
				if((mode&0x0E) == 0x02)
				{
					msDelay(msg_buffer[4]);
				}
				//Data polling
				else if((mode&0x0E) == 0x04)
				{
					do{
						//If we have an uneven byte read the
						//high byte			
						if(i&1)
						{
							SPIWrite(msg_buffer[7]|(1<<3));
						}
						else
						{
							SPIWrite(msg_buffer[7]);
						}						
						SPIWrite16(polling_address);
						tmp=SPIWrite(0x00);
					}while(tmp==msg_buffer[8]);
				}
				//RDY/BSY polling
				else if((mode&0x0E) == 0x08)
				{
					while(universalComm(0xF0,0x00,0x00,0x00)&1);
				}
				//If something was not correct with the given mode do
				//hard waiting. Should never reach this point
				else
				{
					msDelay(msg_buffer[4]);					
				}		
				//increment (word) address only when we have an uneven (byte) address
				if(i&1) address++;
			}			
		}
		//Page Mode
		else
		{
			for(i=0;i<block_size;i++)
			{
				//If we have an uneven（奇数） byte programm the
				//high byte			
				if(i&1)
				{
					SPIWrite(msg_buffer[5]|(1<<3));  	//高字节
				}
				else
				{
					SPIWrite(msg_buffer[5]);		//低字节
				}
				SPIWrite16(address);
				SPIWrite(msg_buffer[i+10]);
				//Check if we can do polling//用于数据轮寻，随意找一个地址
				if(msg_buffer[8]!=msg_buffer[i+10])
				{
					//We have to check if we have an uneven byte. 
					//Set the polling address to a byte address
					//so that we can poll the right location
					polling_address = (address&0xFFFF)*2;
					if(i&1) polling_address++;
				}
				
				//increment (word) address only when we have an uneven (byte) address