uart._c

CS5532的驱动程序

					//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
				if(i&1) address++;
			}
			//If this page is complete the bit 7 of mode will be set and we programm the page
			if(mode&0x80)  //页编程，并且选择等待的方式
			{
				SPIWrite(msg_buffer[6]);	
				SPIWrite16(start_address);
				SPIWrite(0x00);
				//If we have no valid polling address switch to simple wait mode
				if(polling_address==0)
				{
					mode = (mode&(~0x70)) | 0x10;
				}
				//Different polling methods
				//Hard waiting
				if((mode&0x70) == 0x10)
				{
					msDelay(msg_buffer[4]);
				}
				//Data polling
				else if((mode&0x70) == 0x20)
				{
					do{
						//If we have an uneven byte read the
						//high byte			
						if(polling_address%2)
						{
							SPIWrite(msg_buffer[7]|(1<<3));
						}
						else
						{
							SPIWrite(msg_buffer[7]);
						}
						SPIWrite16(polling_address/2);
						tmp=SPIWrite(0x00);
					}while(tmp==msg_buffer[8]);
				}
				//RDY/BSY polling
				else if((mode&0x70) == 0x40)
				{
					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]);					
				}
			}
		}
		num_bytes = 2;
		msg_buffer[0] = CMD_PROGRAM_FLASH_ISP;
	}
	//命令CMD_READ_FLASH_ISP
	else if(cmd==CMD_READ_FLASH_ISP)
	{
		LED_FLASH2;	
		block_size = ((unsigned int)msg_buffer[1])<<8;
		block_size |= msg_buffer[2];
		tmp = msg_buffer[3];
		
		for(i=0;i<block_size;i++)
		{
			//Select Low or High-Byte
			if(i&1)
			{
				SPIWrite(tmp|(1<<3));
			}
			else
			{
				SPIWrite(tmp);
			}
			
			SPIWrite16(address&0xFFFF);
			msg_buffer[i+2] = SPIWrite(0);
			//increment (word) address only when we have an uneven (byte) address
			if(i&1) address++;
		}
		
		num_bytes = block_size+3;
		msg_buffer[0] = CMD_READ_FLASH_ISP;
		msg_buffer[1] = STATUS_CMD_OK;
		msg_buffer[block_size+2] = STATUS_CMD_OK;
	}
	//命令CMD_PROGRAM_EEPROM_ISP
	else if(cmd==CMD_PROGRAM_EEPROM_ISP)
	{
		block_size = ((unsigned int)msg_buffer[1])<<8;
		block_size |= msg_buffer[2];
		mode = msg_buffer[3];
		
		//Byte Mode
		if((mode&1) == 0)
		{		
			for(i=0;i<block_size;i++)
			{	
				LED_FLASH2;	
				SPIWrite(msg_buffer[5]);								
				SPIWrite16(address&0xFFFF);
				SPIWrite(msg_buffer[i+10]);
				
				//Check if we can do polling
				if((msg_buffer[i+10]!=msg_buffer[8])&&(msg_buffer[i+10]!=msg_buffer[9]))
				{
					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{
						SPIWrite(msg_buffer[7]);
						SPIWrite16(polling_address);
						tmp=SPIWrite(0x00);
					}while((tmp==msg_buffer[8])||(tmp==msg_buffer[9]));
				}
				//RDY/BSY polling
				else if((mode&0x0E) == 0x08)
				{
					while(universalComm(0xF0,0x00,0x00,0x00)&1);
					//while(spi_transfer_32(0xF0000000)&1);
				}
				//If something was not correct with the given mode do
				//hard waiting. Should never reach this point
				else
				{
					msDelay(msg_buffer[4]);					
				}
				
				//increment address
				address++;
			}			
		}
		//Page Mode
		else
		{
			
			for(i=0;i<block_size;i++)
			{
				LED_FLASH2;
				SPIWrite(msg_buffer[5]);
				SPIWrite16(address&0xFFFF);
				SPIWrite(msg_buffer[i+10]);
				//Check if we can do polling
				if((msg_buffer[i+10]!=msg_buffer[8])&&(msg_buffer[i+10]!=msg_buffer[9]))
				{
					polling_address = address&0xFFFF;
				}
				
				//increment (word) address only when we have an uneven (byte) address
				address++;
			}
			
			//If this page is complete the bit 7 of mode will be set and we programm the page
			if(mode&0x80)
			{
				SPIWrite(msg_buffer[6]);						
				SPIWrite16(start_address&0xFFFF);
				SPIWrite(0);
				
				//If we have no valid polling address switch to simple wait mode
				if(polling_address==0)
				{
					mode = (mode&(~0x70)) | 0x10;
				}
				
				//Different polling methods
				//Hard waiting
				if((mode&0x70) == 0x10)
				{
					msDelay(msg_buffer[4]);
				}
				//Data polling
				else if((mode&0x70) == 0x20)
				{
					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&0x70) == 0x40)
				{
					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]);					
				}
			}
		}
		
		num_bytes = 2;
		msg_buffer[0] = CMD_PROGRAM_EEPROM_ISP;
		msg_buffer[1] = STATUS_CMD_OK;
	}
	//命令CMD_READ_EEPROM_ISP
	else if(cmd==CMD_READ_EEPROM_ISP)
	{
		block_size = ((unsigned int)msg_buffer[1])<<8;
		block_size |= msg_buffer[2];
		tmp = msg_buffer[3];
		
		for(i=0;i<block_size;i++)
		{
			//Select Low or High-Byte
			SPIWrite(tmp);
			SPIWrite16(address&0xFFFF);
			msg_buffer[i+2] = SPIWrite(0);
			//increment address
			address++;
		}
		num_bytes = block_size+3;
		msg_buffer[0] = CMD_READ_EEPROM_ISP;
		msg_buffer[1] = STATUS_CMD_OK;
		msg_buffer[block_size+2] = STATUS_CMD_OK;
	}
	
	//命令CMD_PROGRAM_FUSE_ISP
	else if(cmd==CMD_PROGRAM_FUSE_ISP)
	{
		universalComm(msg_buffer[1],msg_buffer[2],msg_buffer[3],msg_buffer[4]);
		num_bytes = 3;
		msg_buffer[0] = CMD_PROGRAM_FUSE_ISP;
		msg_buffer[1] = STATUS_CMD_OK;		
		msg_buffer[2] = STATUS_CMD_OK;
	}

	//命令CMD_READ_FUSE_ISP
	else if(cmd==CMD_READ_FUSE_ISP)
	{	
		tmp = SPIWrite(msg_buffer[2]);
		if(msg_buffer[1] == 1) msg_buffer[2] = tmp;
		tmp = SPIWrite(msg_buffer[3]);
		if(msg_buffer[1] == 2) msg_buffer[2] = tmp;
		tmp = SPIWrite(msg_buffer[4]);
		if(msg_buffer[1] == 3) msg_buffer[2] = tmp;
		tmp = SPIWrite(msg_buffer[5]);
		if(msg_buffer[1] == 4) msg_buffer[2] = tmp;
		num_bytes = 4;
		msg_buffer[0] = CMD_READ_FUSE_ISP;
		msg_buffer[1] = STATUS_CMD_OK;		
		msg_buffer[3] = STATUS_CMD_OK;
	}
	
	//命令CMD_PROGRAM_LOCK_ISP
	else if(cmd==CMD_PROGRAM_LOCK_ISP)
	{
		universalComm(msg_buffer[1],msg_buffer[2],msg_buffer[3],msg_buffer[4]);
		
		num_bytes = 3;
		msg_buffer[0] = CMD_PROGRAM_LOCK_ISP;
		msg_buffer[1] = STATUS_CMD_OK;		
		msg_buffer[2] = STATUS_CMD_OK;
	}
	//命令CMD_READ_LOCK_ISP
	else if(cmd==CMD_READ_LOCK_ISP)
	{
		tmp = SPIWrite(msg_buffer[2]);
		if(msg_buffer[1] == 1) msg_buffer[2] = tmp;
		tmp = SPIWrite(msg_buffer[3]);
		if(msg_buffer[1] == 2) msg_buffer[2] = tmp;
		tmp = SPIWrite(msg_buffer[4]);
		if(msg_buffer[1] == 3) msg_buffer[2] = tmp;
		tmp = SPIWrite(msg_buffer[5]);
		if(msg_buffer[1] == 4) msg_buffer[2] = tmp;
		num_bytes = 4;
		msg_buffer[0] = CMD_READ_LOCK_ISP;
		msg_buffer[1] = STATUS_CMD_OK;		
		msg_buffer[3] = STATUS_CMD_OK;
	}
	
	//命令CMD_READ_SIGNATURE_ISP
	else if(cmd==CMD_READ_SIGNATURE_ISP)
	{
		tmp = SPIWrite(msg_buffer[2]);
		if(msg_buffer[1] == 1) msg_buffer[2] = tmp;
		tmp = SPIWrite(msg_buffer[3]);
		if(msg_buffer[1] == 2) msg_buffer[2] = tmp;
		tmp = SPIWrite(msg_buffer[4]);
		if(msg_buffer[1] == 3) msg_buffer[2] = tmp;
		tmp = SPIWrite(msg_buffer[5]);
		if(msg_buffer[1] == 4) msg_buffer[2] = tmp;
		num_bytes = 4;
		msg_buffer[0] = CMD_READ_SIGNATURE_ISP;
		msg_buffer[1] = STATUS_CMD_OK;		
		msg_buffer[3] = STATUS_CMD_OK;
	}
	
	//命令CMD_READ_OSCCAL_ISP
	else if(cmd==CMD_READ_OSCCAL_ISP)
	{
		tmp = SPIWrite(msg_buffer[2]);
		if(msg_buffer[1] == 1) msg_buffer[2] = tmp;
		tmp = SPIWrite(msg_buffer[3]);
		if(msg_buffer[1] == 2) msg_buffer[2] = tmp;
		tmp = SPIWrite(msg_buffer[4]);
		if(msg_buffer[1] == 3) msg_buffer[2] = tmp;
		tmp = SPIWrite(msg_buffer[5]);
		if(msg_buffer[1] == 4) msg_buffer[2] = tmp;
		num_bytes = 4;
		msg_buffer[0] = CMD_READ_OSCCAL_ISP;
		msg_buffer[1] = STATUS_CMD_OK;		
		msg_buffer[3] = STATUS_CMD_OK;
	}
	else
	{
		num_bytes = 1;
		msg_buffer[0] = STATUS_CMD_UNKNOWN;
	}
	//传送缓冲区数据
	if(num_bytes>0)
	{		
		putChar(MESSAGE_START);
		checkSum=MESSAGE_START;
		putChar(seqNum);
		checkSum^=seqNum;
		tmp=(num_bytes&0xFF00)>>8;
		putChar(tmp);
		checkSum^=tmp;
		tmp=num_bytes&0x00FF;
		putChar(tmp);
		checkSum^=tmp;
		putChar(TOKEN);
		checkSum^=TOKEN;
		for(i=0;i<num_bytes;i++)
		{
			putChar(msg_buffer[i]);
			checkSum^=msg_buffer[i];
		}		
		putChar(checkSum);
		checkSum=0x00;		
	}

}    
*/


/**********************************************************************
functionName:void rx_pkg_process(void)
description:串口接收包处理
**********************************************************************/
void rx_pkg_process(void)
{
	uint16 i;
	uint08 cmd;
	
	cmd = uart_tx_buf[0];
	
	if(msg_end_flag)
	{
		msg_end_flag=0;
		
		for(i=0;i<uart_rx_counter;i++)
		{
			put_char(uart_rx_buf[i]);
		}
		/*switch(cmd)
		{
			case 0:
			{
				break;
			}
			default:
			{
				break;
			}
		}*/
	}
}

/**********************************************************************
functionName:void uart0_tx_isr(void)
description:串口发送中断函数
**********************************************************************/
#pragma interrupt_handler uart0_tx_isr:14
void uart0_tx_isr(void)
{
 	uart_tx_counter--;
 	if(uart_tx_counter)		//如果还没有发送完成
 	{
 		UDR=uart_tx_buf[uart_tx_rd_ptr];
		uart_tx_rd_ptr++;
		if(uart_tx_rd_ptr==UART_BUF_SIZE)uart_tx_rd_ptr=0;
 	}
 	else
 	{
 		UCSRB&=~BIT(TXCIE);		//发送结束中断不使能
 		UART_TX_LED;
 	}
}


/**********************************************************************
functionName:uint08 write_uart(uint08 uart_data)
description:写串口数据
**********************************************************************/
uint08 put_char(uint08 uart_data)
{
	if(uart_tx_counter==UART_BUF_SIZE)
	{
		return(UART_FALSE);		//表示串口缓冲器溢出
	}
	uart_tx_buf[uart_tx_wr_ptr]=uart_data;
	uart_tx_wr_ptr++;
	if(uart_tx_wr_ptr>=UART_BUF_SIZE)uart_tx_wr_ptr=0;
	uart_tx_counter++;
	if(uart_tx_counter==1)
	{
		UDR=uart_tx_buf[uart_tx_rd_ptr];
		uart_tx_rd_ptr++;
		if(uart_tx_rd_ptr==UART_BUF_SIZE)uart_tx_rd_ptr=0;
		UCSRB|=BIT(TXCIE);		//发送结束中断使能
	}
	return(UART_TURE);
}


/**********************************************************************
functionName:putChars(BYTE *sentData)
description:通过串口发送数据字符串
**********************************************************************/
uint08 put_chars(uint08 *sentData)
{
 	while(*sentData)
 	{
 		if(put_char(*sentData)==UART_FALSE)
 		return(UART_FALSE);
 		sentData++;
 		
 	}
 	return(UART_TURE);
}