uart.c

LPC213x系列启动代码,支持ADS1.2编译器,已成功运行

#include "config.h"

UCHAR ucUartFlag;

UCHAR Uart_ucReceBuff[UART_BUFF_LEN];
UCHAR Uart_ucSendBuff[UART_BUFF_LEN];
UCHAR Uart_ucReceLen;
UCHAR Uart_ucSendLen;
UCHAR Uart_ucAddr;

UCHAR Uart0_ucReceBuff[UART_BUFF_LEN];
UCHAR Uart0_ucSendBuff[UART_BUFF_LEN];
UCHAR Uart0_ucReceLen;
UCHAR Uart0_ucSendPosi;
UCHAR Uart0_ucSendLen;
UDWORD Uart0_udTimeOut;

UCHAR Uart1_ucReceBuff[UART_BUFF_LEN];
UCHAR Uart1_ucSendBuff[UART_BUFF_LEN];
UCHAR Uart1_ucReceLen;
UCHAR Uart1_ucSendPosi;
UCHAR Uart1_ucSendLen;
UDWORD Uart1_udTimeOut;

void __irq IRQ_UART0(void)
{
	UCHAR stat;
	
	switch(U0IIR & 0x0f)
	{
		case 0x06:	stat = U0LSR;
					break;
					
		case 0x04:	Uart0_ucReceLen = Uart0_ucReceLen & (UART_BUFF_LEN - 1);
					Uart0_ucReceBuff[Uart0_ucReceLen++] = U0RBR;
					Uart0_udTimeOut = udTickCount + 5;
					break;
					
		case 0x0c:	stat = U0RBR;
					break;
		
		case 0x02:	if(Uart0_ucSendPosi < Uart0_ucSendLen) U0THR = Uart0_ucSendBuff[Uart0_ucSendPosi++];
					else Uart0_udTimeOut = udTickCount + 5;
					break;
					
		default:	break;		
	}
	
	VICVectAddr = 0x00; 
}//void __irq IRQ_UART0(void)

void __irq IRQ_UART1(void)
{
	UCHAR stat;
	
	switch(U1IIR & 0x0f)
	{
		case 0x06:	stat = U1LSR;
					break;
					
		case 0x04:	Uart1_ucReceLen = Uart1_ucReceLen & (UART_BUFF_LEN - 1);
					Uart1_ucReceBuff[Uart1_ucReceLen++] = U1RBR;
					Uart1_udTimeOut = udTickCount + 5;
					break;
					
		case 0x0c:	stat = U1RBR;
					break;
		
		case 0x02:	if(Uart1_ucSendPosi < Uart1_ucSendLen) U1THR = Uart1_ucSendBuff[Uart1_ucSendPosi++];
					else Uart1_udTimeOut = udTickCount + 5;
					break;
					
		case 0x00:	stat = U1MSR;			
					break;
					
		default:		break;		
	}
	
	VICVectAddr = 0x00; 
}//void __irq IRQ_UART1(void)

void Uart0_Init(UWORD band)
{
	UWORD bak;
			
	U0LCR = 0x83;
	bak = (Fpclk >> 4) / band;
	U0DLL = bak & 0xff;
	U0DLM = (bak >> 8) & 0xff;
	U0LCR = 0x03;
	
	U0IER = 0x07;
	
	VICIntEnable = (1 << INT_UART0);
}//void Uart0_Init(void)

void Uart1_Init(UWORD band)
{
	UWORD bak;
		
	U1LCR = 0x83;
	bak = (Fpclk >> 4) / band;
	U1DLL = bak & 0xff;
	U1DLM = (bak >> 8) & 0xff;
	U1LCR = 0x03;
	
	U1IER = 0x0f;
	
	VICIntEnable = (1 << INT_UART1);	
}//void Uart1_Init(void)

void Uart0_SendByte(UCHAR dat)
{
	VICIntEnClr = 0x40;
	
	U0THR = dat;
	while((U0LSR & 0x40) == 0);
	
	VICIntEnable = 0x40;
}//void Uart0_SendByte(UCHAR dat)

void Uart1_SendByte(UCHAR dat)
{
	VICIntEnClr = 0x80;
	
	U1THR = dat;
	while((U1LSR & 0x40) == 0);
	
	VICIntEnable = 0x80;
}//void Uart1_SendByte(UCHAR dat)

UCHAR Uart_CheckSum(UCHAR *p, UCHAR n)
{
	UCHAR sum;
	UCHAR i;

	sum = 0;
	for(i = 0; i < n; i++) sum += *(p + i);

	return(sum);
}//UCHAR UartCheckSum(UCHAR *p, UCHAR n)

void Uart_FillData(void)
{
	Uart_ucSendBuff[0] = 2;
	Uart_ucSendBuff[1] = Uart_ucSendLen;
	Uart_ucSendBuff[2] = Uart_ucAddr;
	Uart_ucSendBuff[3] = Uart_ucReceBuff[3];
	Uart_ucSendBuff[Uart_ucSendLen - 1] = 256 - Uart_CheckSum(Uart_ucSendBuff,Uart_ucSendLen - 1);
}//void Uart_FillData(void)

void Td200_ReadMemory(void)
{
	WORD i,j;
	UCHAR n;
	WORD addr;
	
	Uart_ucSendLen = 4;
	n = (Uart_ucReceBuff[1] - 5) / 3;
	for(i = 0; i < n; i++)		// 多少对数据
	{
		addr = (Uart_ucReceBuff[4 + i * 3] << 8) + Uart_ucReceBuff[5 + i * 3];
		
		if(addr >= 0x2000 && (addr + Uart_ucReceBuff[6 + i * 3]) <= (0x2000 + TD200_M_BYTE_NUM))	//m
		{
			for(j = 0; j < Uart_ucReceBuff[6 + i * 3]; j++)
			{
				Uart_ucSendBuff[Uart_ucSendLen++] = (Coil[(addr - 0x2000 + j) / 2] >> (( (addr - 0x2000 + j) % 2 ) * 8)) & 0xff;
			}
		}
		else	if((addr + Uart_ucReceBuff[6 + i * 3]) <= TD200_D_BYTE_NUM)
		{
			for(j = 0; j < Uart_ucReceBuff[6 + i * 3]; j++)
			{
				Uart_ucSendBuff[Uart_ucReceBuff[6 + i * 3] - 1 - j - j + Uart_ucSendLen++] = (HoldingReg[(addr + j) / 2] >> (((addr + j) % 2) * 8)) & 0xff;
			}
		}
	}
	Uart_ucSendLen++;
	
	Uart_FillData();
}//void Td200_ReadMemory(void)

void Td200_WriteMemory(void)
{
	WORD addr;
	UCHAR posi, j;
	UCHAR len;
	UCHAR flag;
	
	flag = 0x55;
	
	posi = 4;
	while((posi + 4) < Uart_ucReceBuff[1])
	{
		addr = Uart_ucReceBuff[posi++] << 8;
		addr += Uart_ucReceBuff[posi++];
		
		if(addr >= 0x2000 && addr < (0x2000 + TD200_M_BYTE_NUM))		// m
		{
			if(Uart_ucReceBuff[posi++] == 2)
			{
				Coil[(addr - 0x2000) / 2] &= ~(WORD)(Uart_ucReceBuff[posi++] << (((addr - 0x2000) % 2) * 8));
				Coil[(addr - 0x2000) / 2] |= (WORD)(Uart_ucReceBuff[posi++] << (((addr - 0x2000) % 2) * 8));
			}
			else
			{
				flag = 0xaa;
				break;
			}
		}
		else
		{
			len = Uart_ucReceBuff[posi++];
			for(j = 0; j < len; j++)
			{
				if((addr + j) < TD200_D_BYTE_NUM) 
				{
					HoldingReg[(addr + len -1 - j) / 2] &= ~(WORD)(0xff << (((addr +len -1 - j) % 2) * 8));
					HoldingReg[(addr + len - 1 - j) / 2] |= (WORD)(Uart_ucReceBuff[posi++] << (((addr + len - 1 - j) % 2) * 8));
				}
				else 
				{
					flag = 0xaa;
					break;
				}
			}
		}
	}
	
	Uart_ucSendLen = 6;
	Uart_ucSendBuff[4] = flag;
	Uart_FillData();
}//void Td200_WriteMemory(void)

void Test_ReadUnique(void)
{
	UWORD i;
	
	for(i = 0; i < 8; i++) Uart_ucSendBuff[4 + i] = ucUnique[i];
	
	Uart_ucSendLen = 5 + 8;
	Uart_FillData();
}//void Test_ReadUnique(void)

void Test_WriteAo(void)
{
	uwAo[Uart_ucReceBuff[4]] = (Uart_ucReceBuff[5] << 0) | (Uart_ucReceBuff[6] << 8);
	
	Uart_ucSendLen = 6;
	Uart_ucSendBuff[4] = 0x55;
	Uart_FillData();
}//void Test_WriteAo(void)

void Test_ReadAiSamp(void)
{
	UCHAR i;
	
	for(i = 0; i < AI_SAMP_NUM; i++)
	{
		Uart_ucSendBuff[4 + i * 2] = wAiSamp[Uart_ucReceBuff[4]][i] & 0xff;
		Uart_ucSendBuff[5 + i * 2] = (wAiSamp[Uart_ucReceBuff[4]][i] >> 8) & 0xff;		
	}
	
	Uart_ucSendLen = 5 + AI_SAMP_NUM * 2;
	Uart_FillData();
}//void Test_ReadAiSamp(void)

void Test_ReadxAiSamp(void)
{
	UCHAR i;
	
	for(i = 0; i < xAI_SAMP_NUM; i++)
	{
		Uart_ucSendBuff[4 + i * 2] = wxAiSamp[Uart_ucReceBuff[4]][i] & 0xff;
		Uart_ucSendBuff[5 + i * 2] = (wxAiSamp[Uart_ucReceBuff[4]][i] >> 8) & 0xff;		
	}
	
	Uart_ucSendLen = 5 + xAI_SAMP_NUM * 2;
	Uart_FillData();
}//void Test_ReadxAiSamp(void)

void Test_ReadX5045(void)
{
	WORD addr;
	char i;
	
	addr = (Uart_ucReceBuff[4] << 0) + (Uart_ucReceBuff[5] << 8);
	for(i = 0; i < Uart_ucReceBuff[6]; i++) Uart_ucSendBuff[4 + i] = ReadUchar(addr + i);
	
	Uart_ucSendLen = 5 + Uart_ucReceBuff[6];
	Uart_FillData();
}//void Test_ReadX5045(void)

void Test_WriteX5045(void)
{
	WORD addr;
	char i;
	
	addr = (Uart_ucReceBuff[4] << 0) + (Uart_ucReceBuff[5] << 8);
	for(i = 0; i < Uart_ucReceBuff[6]; i++) WriteUchar(addr + i,Uart_ucReceBuff[7 + i]);
	
	Uart_ucSendBuff[4] = 0x55;	
	Uart_ucSendLen = 6;
	Uart_FillData();
}//void Test_WriteX5045(void)
/*
void Test_IAP(void)
{
	UDWORD addr,len;
	int i;
	
	switch(Uart_ucReceBuff[4])
	{
		case 128:	IAP_ReadPartID();	
			Uart_ucSendBuff[4] = (IAP_ParaOut[0] >> 0) & 0xff;
			Uart_ucSendBuff[5] = (IAP_ParaOut[0] >> 8) & 0xff;
			Uart_ucSendBuff[6] = (IAP_ParaOut[0] >> 16) & 0xff;
			Uart_ucSendBuff[7] = (IAP_ParaOut[0] >> 24) & 0xff;
			Uart_ucSendBuff[8] = (IAP_ParaOut[1] >> 0) & 0xff;
			Uart_ucSendBuff[9] = (IAP_ParaOut[1] >> 8) & 0xff;
			Uart_ucSendBuff[10] = (IAP_ParaOut[1] >> 16) & 0xff;
			Uart_ucSendBuff[11] = (IAP_ParaOut[1] >> 24) & 0xff;
			Uart_ucSendLen = 5 + 8;
			break;
					
		case 129:	IAP_BootCodeID();	
			Uart_ucSendBuff[4] = (IAP_ParaOut[0] >> 0) & 0xff;
			Uart_ucSendBuff[5] = (IAP_ParaOut[0] >> 8) & 0xff;
			Uart_ucSendBuff[6] = (IAP_ParaOut[0] >> 16) & 0xff;
			Uart_ucSendBuff[7] = (IAP_ParaOut[0] >> 24) & 0xff;
			Uart_ucSendBuff[8] = (IAP_ParaOut[1] >> 0) & 0xff;
			Uart_ucSendBuff[9] = (IAP_ParaOut[1] >> 8) & 0xff;
			Uart_ucSendBuff[10] = (IAP_ParaOut[1] >> 16) & 0xff;
			Uart_ucSendBuff[11] = (IAP_ParaOut[1] >> 24) & 0xff;
			Uart_ucSendLen = 5 + 8;
			break;
					
		case 130:	addr = (Uart_ucReceBuff[5] << 0) + (Uart_ucReceBuff[6] << 8) + (Uart_ucReceBuff[7] << 16) + (Uart_ucReceBuff[8] << 24);
					len = (Uart_ucReceBuff[9] << 0) + (Uart_ucReceBuff[10] << 8) + (Uart_ucReceBuff[11] << 16) + (Uart_ucReceBuff[12] << 24);
					IAP_ReadFlash(addr,IAP_RAM_BASE_ADDR,len);
					for(i = 0; i < len; i++) Uart_ucSendBuff[4 + i] = *(UCHAR *)(IAP_RAM_BASE_ADDR + i);
					Uart_ucSendLen = 5 + len;
					break;
					
		case 131:	addr = (Uart_ucReceBuff[5] << 0) + (Uart_ucReceBuff[6] << 8) + (Uart_ucReceBuff[7] << 16) + (Uart_ucReceBuff[8] << 24);
					len = (Uart_ucReceBuff[9] << 0) + (Uart_ucReceBuff[10] << 8) + (Uart_ucReceBuff[11] << 16) + (Uart_ucReceBuff[12] << 24);
					for(i = 0; i < len; i++) *(UCHAR *)(IAP_RAM_BASE_ADDR + i) = Uart_ucReceBuff[13 + i];
					Uart_ucSendBuff[4] = IAP_WriteFlash(addr,IAP_RAM_BASE_ADDR,len);
					Uart_ucSendLen = 5 + 1;
					break;					
	}
	
	Uart_FillData();
}//void Test_IAP(void)
*/
void Test_PWM2_Forward(void)
{
	UDWORD pulwidth;
	
	TruckForward();
	
	pulwidth =  Uart_ucReceBuff[4] + (Uart_ucReceBuff[5] << 8);
	Pwm2_Init(pulwidth);
	
	Uart_ucSendBuff[4] = Uart_ucReceBuff[4];
	Uart_ucSendBuff[5] = Uart_ucReceBuff[5];
	
	Uart_ucSendLen = 5 + 2;
	Uart_FillData();
}//void Test_PWM2_Forward(void)

void Test_PWM2_Backward(void)
{
	UDWORD pulwidth;
	
	TruckBackward();
	
	pulwidth =  Uart_ucReceBuff[4] + (Uart_ucReceBuff[5] << 8);
	Pwm2_Init(pulwidth);
	
	Uart_ucSendBuff[4] = Uart_ucReceBuff[4];
	Uart_ucSendBuff[5] = Uart_ucReceBuff[5];
	
	Uart_ucSendLen = 5 + 2;
	Uart_FillData();
}//void Test_PWM2_Backward(void)

void Test_Pwm2_Stop(void)
{
	Pwm2_Stop();

	Uart_ucSendBuff[4] = 0x55;
	
	Uart_ucSendLen = 5 + 1;
	Uart_FillData();
}//void Test_Pwm2_Stop(void)

void Test_DoingZero(void)
{
	wAiZero[wAiChann] = wAiZeroTemp[wAiChann];
	WriteWord(ZERO_ADDR + wAiChann * 2,wAiZero[wAiChann]);
	
	Uart_ucSendBuff[4] = wAiZero[wAiChann] & 0xff;
	Uart_ucSendBuff[5] = (wAiZero[wAiChann] >> 8) & 0xff;
	
	Uart_ucSendLen = 5 + 2;
	Uart_FillData();
}//void Test_DoingZero(void)

void Test_DoingAdjust(void)
{
	float temp;
	
	if(wAiAdjustTemp[wAiChann] > 0)
	{
		temp = Uart_ucReceBuff[4] + (Uart_ucReceBuff[5] << 8) - wxAiFact[wxAiChann];
		temp = temp * 1024 / wAiAdjustTemp[wAiChann];
		wAiAdjust[wAiChann] = temp;
		WriteWord(ADJUST_ADDR + wAiChann * 2,wAiAdjust[wAiChann]);
	}	
	
	Uart_ucSendBuff[4] = wAiAdjust[wAiChann] & 0xff;
	Uart_ucSendBuff[5] = (wAiAdjust[wAiChann] >> 8) & 0xff;
	
	Uart_ucSendLen = 5 + 2;
	Uart_FillData();
}//void Test_DoingAdjust(void)

void Test_DoingxAdjust(void)
{
	float temp;
	
	if(wxAiAdjustTemp[wxAiChann] > 0)
	{	
		temp = (15.0 * 1024.0) / ((1.0 + 5.1 + 5.0) * 3.3);
		temp = temp * 1024 / wxAiAdjustTemp[wxAiChann];
		wxAiAdjust[wxAiChann] = temp;
		WriteWord(xADJUST_ADDR + wxAiChann * 2,wxAiAdjust[wxAiChann]);
	}	
	
	Uart_ucSendBuff[4] = wxAiAdjust[wxAiChann] & 0xff;
	Uart_ucSendBuff[5] = (wxAiAdjust[wxAiChann] >> 8) & 0xff;
	
	Uart_ucSendLen = 5 + 2;
	Uart_FillData();
}//void Test_DoingxAdjust(void)

void Test_ReadFact(void)
{
	Uart_ucSendBuff[4] = wAiFact[wAiChann] & 0xff;
	Uart_ucSendBuff[5] = (wAiFact[wAiChann] >> 8) & 0xff;
	
	Uart_ucSendBuff[6] = wxAiFact[wxAiChann] & 0xff;
	Uart_ucSendBuff[7] = (wxAiFact[wxAiChann] >> 8) & 0xff;
	
	Uart_ucSendLen = 5 + 4;
	Uart_FillData();
}//void Test_ReadFact(void)

void Uart_CheckData(void)
{	
	if(Uart_ucReceBuff[2] == Uart_ucAddr || Uart_ucReceBuff[2] == 255)
	{       
		if(Uart_CheckSum(Uart_ucReceBuff,Uart_ucReceLen) == 0)
		{   
			switch(Uart_ucReceBuff[3])
			{
				case 130:	Td200_ReadMemory();
							break;
							
				case 131:	Td200_WriteMemory();
							break;
							
				case 142:	Test_ReadUnique();
							break;
							
				case 143:	Test_WriteAo();
							break;
							
				case 144:	Test_ReadAiSamp();
							break;
				
				case 145:	Test_ReadxAiSamp();
							break;
							
				case 146:	Test_ReadX5045();
							break;
				
				case 147:	Test_WriteX5045();
							break;
				
				//case 148:	Test_IAP();
				//			break;
				
				case 150:	Test_PWM2_Forward();
							break;
							
				case 151:	Test_PWM2_Backward();
							break;
				
				case 152:	Test_Pwm2_Stop();
							break;
				
				case 153:	Test_DoingZero();
							break;
				
				case 154:	Test_DoingAdjust();
							break;
				
				case 155:	Test_DoingxAdjust();
							break;
				
				case 156:	Test_ReadFact();
							break;
																	
				default:		break;
			}			
		}
	}
}//void Uart_CheckData(void)

void Uart0_CheckData(void)
{
	WORD i;
	
	if(Uart0_ucReceLen >= 5)
	{
		if(Uart0_ucReceBuff[0] == 0x02)
		{
			if(Uart0_ucReceLen == Uart0_ucReceBuff[1])
			{
				ucUartFlag = 0;
				Uart_ucReceLen = Uart0_ucReceLen;
				for(i = 0; i < Uart0_ucReceLen; i++) Uart_ucReceBuff[i] = Uart0_ucReceBuff[i];
				
				Uart_ucSendLen = 0;
				Uart_CheckData();
				
				if(Uart_ucSendLen > 0)
				{
					Uart0_ucSendLen = Uart_ucSendLen;
					for(i = 0; i < Uart_ucSendLen; i++) Uart0_ucSendBuff[i] = Uart_ucSendBuff[i];
					Uart0_ucSendPosi = 1;
					U0THR = Uart0_ucSendBuff[0];
				}
				
				Uart0_ucReceLen = 0;
				Uart0_udTimeOut = 0;
			}
		}
		else
		{
			Uart0_RTU984();
		}
	}
}//void Uart0_CheckData(void)


void Uart1_CheckData(void)
{
	WORD i;
	
	if(Uart1_ucReceLen >= 5)
	{
		if(Uart1_ucReceBuff[0] == 0x02)
		{
			if(Uart1_ucReceLen == Uart1_ucReceBuff[1])
			{
				ucUartFlag = 1;
				Uart_ucReceLen = Uart1_ucReceLen;
				for(i = 0; i < Uart1_ucReceLen; i++) Uart_ucReceBuff[i] = Uart1_ucReceBuff[i];
				
				Uart_ucSendLen = 0;
				Uart_CheckData();
				
				if(Uart_ucSendLen > 0)
				{
					Uart1_ucSendLen = Uart_ucSendLen;
					for(i = 0; i < Uart_ucSendLen; i++) Uart1_ucSendBuff[i] = Uart_ucSendBuff[i];
					Uart1_ucSendPosi = 1;
					U1THR = Uart1_ucSendBuff[0];
				}
				
				Uart1_ucReceLen = 0;
				Uart1_udTimeOut = 0;
			}
		}
		else
		{
			Uart1_RTU984();
		}
	}
}//void Uart1_CheckData(void)