rscomm.c

MSP430FE42X防窍电电表DEMO（编译器IAR3.42)

//*****************************************************************
// Config UART0
//*****************************************************************
void StartUART0(void)
{
//for ACK=32.768k
//			bps:	300		600		1200	2400	4800	9600	19200	38400
//	ACLK=32.768kHz
//			U0BR1:	00		00		00		00		00		00
//			U0BR0:	6D		36		1B		0D		06		03
//			U0MCTL:	22		D5		03		6B		6F		4A
//	SMCLK=1.048576MHz
//			U0BR1:	0D		06		03		01		00		00		00		00
//			U0BR0:	A7		D3		69		B4		DA		6D		36		1B
//			U0MCTL:	00		FF		FF		FF		55		03		6B		03
	//U0CTL  = 0xD0;	// 1101 0001
	//U0TCTL = 0x10;	// 0001 0000: ACLK, 0010 0000: SMCLK
	//U0RCTL = 0x00;	// 0000 0000
	//U0BR1  = 0x00;	// 0000 0000
	//U0BR0  = 0x1B;	// 0001 1011
	//U0MCTL = 0x03;	// 0000 0011
  UCTL0 |= PENA+PEV+CHAR;         //偶校验，8位数据位，1个停止位//UCTL0 = CHAR;
  UTCTL0 = SSEL0;                 //选择ACLK
  U0RCTL = 0x00;
  UBR00 = 0x1B;                   // 设置分频因子 32k/2400 - 13.65
  UBR10 = 0x00;                        
  UMCTL0 = 0x03;                  // Modulation
  UCTL0 &= ~SWRST;                // Initalize USART state machine  
}

void StopUART0(void)
{
	U0CTL  = 0x00;	// 1101 0001
	U0TCTL = 0x00;	// 0001 0000: ACLK, 0010 0000: SMCLK
	U0RCTL = 0x00;	// 0000 0000
	U0BR1  = 0x00;	// 0000 0000
	U0BR0  = 0x00;	// 0001 1011
	U0MCTL = 0x00;	// 0000 0011
}


void StartUR0(void)
{
#if PCB_VERSION==0
  DM.ucP595OUT &= ~RS485_CONTROL;
  Update_HC595_Port(DM.ucP595OUT);
#elif PCB_VERSION==1  
	COMM_CON485_OUT &=~COMM_CON485_BIT;
#endif   
	COMM_RXD0_DIR &=~COMM_RXD0_BIT;
	COMM_RXD0_SEL |= COMM_RXD0_BIT;
	
	COMM_RXD0_IE = COMM_RXD0M_BIT;
	COMM_RXD0_ME = COMM_RXD0M_BIT;
 
}

void StopUR0(void)
{
#if PCB_VERSION==0

#elif PCB_VERSION==1   
  
	COMM_RXD0_SEL &=~COMM_RXD0_BIT;
	
	COMM_RXD0_IE &=~COMM_RXD0M_BIT;
	COMM_RXD0_ME &=~COMM_RXD0M_BIT;
#endif  
}

void StartUT0(void)
{
#if PCB_VERSION==0
  DM.ucP595OUT |= RS485_CONTROL;
  Update_HC595_Port(DM.ucP595OUT);
#elif PCB_VERSION==1  
	COMM_CON485_OUT |= COMM_CON485_BIT;
#endif   
  
	
	COMM_ACLK_SEL |= COMM_ACLK_BIT;
  COMM_ACLK_DIR |= COMM_ACLK_BIT;
	
	COMM_TXD0_OUT |= COMM_TXD0_BIT;
	COMM_TXD0_DIR |= COMM_TXD0_BIT;
	COMM_TXD0_SEL |= COMM_TXD0_BIT;
	
	COMM_TXD0_IE = COMM_TXD0M_BIT;
	COMM_TXD0_ME = COMM_TXD0M_BIT;
}
void StopUT0(void)
{
//#if PCB_VERSION==0

//#elif PCB_VERSION==1 	
  
  COMM_ACLK_DIR &=~COMM_ACLK_BIT;
	COMM_ACLK_SEL &=~COMM_ACLK_BIT;
	
	COMM_TXD0_OUT &=~COMM_TXD0_BIT;
	COMM_TXD0_DIR &=~COMM_TXD0_BIT;
	COMM_TXD0_SEL &=~COMM_TXD0_BIT;
	
	COMM_TXD0_IE &=~COMM_TXD0M_BIT;
	COMM_TXD0_ME &=~COMM_TXD0M_BIT;
//#endif   
}


//*****************************************************************
// Program Led Trun On
//*****************************************************************
void ComLedOn( unsigned char byte )
{
	if( POWER_TEST_IN & POWER_TEST_BIT)
	{
		DM.ComLedTmr = byte;
		//SetComLed;
	}
}

//*****************************************************************
// Program Led Trun Off
//*****************************************************************
void ComLedOff( void )
{
	if( POWER_TEST_IN & POWER_TEST_BIT)
	{
		if( DM.ComLedTmr > 0 )
		{
			DM.ComLedTmr--;
			//if( DM.ComLedTmr == 0 ) ClrComLed;
		}
		else DM.ComLedTmr=0;
	}
}

//*****************************************************************
// Calculate the CRC
//*****************************************************************
unsigned char ComCRC( void )
{
	unsigned int iii;
	unsigned char Sum;

	Sum=0;
	iii=0;
	while( iii<(DM.ComBuf[RS_LenPtr]+RS_CmdPtr) )
	{
		Sum+=DM.ComBuf[iii];
		iii++;
	}
	return Sum;
}

//*****************************************************************
// Read Data
//*****************************************************************
int ComRead(void)
{
	unsigned int Cmd;
	unsigned int Ptr;
 // unsigned int tempPtr;
 // unsigned char * Buf;
	
	Cmd=((unsigned int)DM.ComBuf[RS_CmdHPtr]<<8)+(unsigned int)DM.ComBuf[RS_CmdLPtr];

	Ptr=0;
	for( Ptr=0;Ptr<ComInfoNum;Ptr++ )
	{
		if( ComInfo[Ptr].ComID==Cmd ) break;
	}
	if( Ptr>=ComInfoNum ) return -1;
	
  
	MemCopy( &DM.ComBuf[RS_DPtr], ComInfo[Ptr].Addr, ComInfo[Ptr].Info&0xFF);
 // MemCopy( &DM.ComBuf[RS_DPtr], ComInfo[Ptr].Addr, 4);
  {
   //DM.ComBuf[RS_DPtr+4]=0;
   //DM.ComBuf[RS_DPtr+4]=0x05; 
   //for(tempPtr=0,Buf=&RS_Data+5;tempPtr<5;tempPtr++,Buf++)*Buf=0;
   //Buf=&RS_Data+10;
   
   //MemCopy( Buf, DM.ubV1RMS+1, 2);
   //Buf=&RS_Data+12;
   //MemCopy( Buf, DM.ubIRMS, 2);
   //Buf=&RS_Data+14;
   //MemCopy( Buf, SM.ClkBcd.Sec, 7);
   //MemCopy(&RS_Data+21,&SM.Cfg.MetStatus[0],2);
  }
	DM.ComBuf[RS_LenPtr]=(ComInfo[Ptr].Info&0xFF)+2;
	
	return 0;
}


//*****************************************************************
// write data into meter
//*****************************************************************
int ComWrite(void)
{
	unsigned int Cmd;
	unsigned int Ptr;
	unsigned char Tmp;
  unsigned char *Buf;

	if(DM.ComBuf[RS_DPtr]>1)return -1;    //??????????????????????????
	
	for(Tmp=0,Buf=&DM.ComBuf[RS_DPtr]; Tmp<=3; Tmp++,Buf++)
  {
		if( (*Buf)!=SM.Cfg.Pswd[1][Tmp]) return -1;
  }
	
	Cmd=((unsigned int)DM.ComBuf[RS_CmdHPtr]<<8)+(unsigned int)DM.ComBuf[RS_CmdLPtr];

	Ptr=0;
	for( Ptr=0;Ptr<ComInfoNum;Ptr++ )
	{
		if( ComInfo[Ptr].ComID==Cmd ) break;
	}
	if( Ptr>=ComInfoNum || DM.ComBuf[RS_LenPtr]!=((ComInfo[Ptr].Info&0xFF)+6) ) 
  {
    return -1;
  }
	if( Ptr>=ComInfoNum || DM.ComBuf[RS_LenPtr]!=((ComInfo[Ptr].Info&0xFF)) ) 
  {
    return -1;
  }
	if( (ComInfo[Ptr].Info&RS_TP_wr)==0 ) 
  {
    return -1;
  }
	switch( ComInfo[Ptr].Info&RS_TP )
	{
		case RS_TP_Norm:
			MemCopy( ComInfo[Ptr].Addr, &DM.ComBuf[RS_DPtr]+4, ComInfo[Ptr].Info&0xFF);
			break;
						
		case RS_TP_Clk:
			MemCopy( ComInfo[Ptr].Addr, &DM.ComBuf[RS_DPtr], ComInfo[Ptr].Info&0xFF);
			SM.ClkBcd.Week[0] = GetWeek();
			SM.ClkBcdChk=ChkSum( SM.ClkBcd.Sec, sizeof(CLKDEF) );
			ClkBcd_ClkHex();
			return 0;
    case RS_TP_Tariff:
      for(Ptr=0,Tmp=0;Ptr<8;Ptr++,Tmp+=3)
					{
						SM.Cfg.TariList[Ptr].FeeNo=DM.ComBuf[Tmp+16]-1;
						SM.Cfg.TariList[Ptr].Tmr=(DM.ComBuf[Tmp+18]<<8)+DM.ComBuf[Tmp+17];
					}
      break;
		default:
			return -1;
	}
	

  SM.CfgChk=ChkSum((unsigned char *)&SM.Cfg, sizeof(SM.Cfg));
	
	DM.ComBuf[RS_LenPtr] = 0;
	return 0;
}




//*****************************************************************
// main communication program
//*****************************************************************
void ProcCom(void)
{
	unsigned int iii;
  //unsigned int Cmd;
  unsigned char Tmp;
	unsigned char *Buf;
	SystemEventFlag &= ~SYSTEM_COMM_FLAG;
	DM.ComFlg=0;
	if( DM.ComPtr<RS_MinSize ) return;

	if( DM.ComBuf[RS_HeadPtr]!=0x68
     || DM.ComBuf[RS_Head0Ptr]!=0x68
     || DM.ComBuf[RS_CmdPtr+DM.ComBuf[RS_LenPtr]+1]!=0x16 ) return;

	if( DM.ComBuf[RS_CmdPtr+DM.ComBuf[RS_LenPtr]]!=ComCRC() ) return;

	if(    DM.ComBuf[RS_CtlPtr]!=RS_CTL_Time 
      && DM.ComBuf[RS_CtlPtr]!=RS_CTL_MetID 
      && DM.ComBuf[RS_CtlPtr]!=RS_CTL_FRMetID  
    )
	{
		for( Tmp=0,Buf=&DM.ComBuf[RS_AddrPtr];Tmp<6;Tmp++,Buf++ )
		{
			//if( ((*Buf!=0xAA)||(Tmp==0)) ) return;            //?????????????????????
      //if( Ptr==0 && *Buf==0xAA ) goto LoopComExit;
      if( *Buf!=SM.Cfg.MetID[Tmp] && *Buf!=0xAA ) return;
      
		}
	}
	
	if( DM.ComBuf[RS_LenPtr]>120 ) return;
  
  for( Tmp=0,Buf=&DM.ComBuf[RS_CmdPtr];Tmp<DM.ComBuf[RS_LenPtr];Tmp++,Buf++ ) 
  {
    *Buf-=0x33;
  }

	switch ( DM.ComBuf[RS_CtlPtr] )
	{
		case RS_CTL_Read:
			if( ComRead()!=0 )
			{
				DM.ComBuf[RS_CtlPtr] |= 0x40;
        DM.ComBuf[RS_LenPtr]=1;
        //DM.ComBuf[11] = RS_SER;
        //DM.ComBuf[12] = SM.Cfg.MetStatus[1];
        //DM.ComBuf[13] = SM.Cfg.MetStatus[0];
				//DM.ComBuf[RS_LenPtr] = 1;
				//DM.ComBuf[RS_CmdPtr] = 1;
			}
			
			break;
		case RS_CTL_Write:
      if(ComWrite()!=0)
      {
        DM.ComBuf[RS_CtlPtr] |=0x40;
        DM.ComBuf[RS_LenPtr]=1;
      }			
			break;
		case RS_CTL_MetID:
      MemCopy( SM.Cfg.MetID, &DM.ComBuf[RS_CmdPtr], 6 );
			DM.ComBuf[RS_LenPtr]=0;
			
			break;
		case RS_CTL_Time:
			//if( (CHECK_AMM1_IFG&CHECK_AMM1_BIT)==0 )
			{
				MemCopy( SM.ClkBcd.Sec, &DM.ComBuf[RS_CmdPtr], 3 );
				MemCopy( SM.ClkBcd.Day, &DM.ComBuf[RS_CmdPtr]+3, 3 );
				SM.ClkBcd.Week[0]=GetWeek();
				SM.ClkBcdChk=ChkSum( SM.ClkBcd.Sec, sizeof(CLKDEF) );
				ClkBcd_ClkHex();
			}
			
			return;
		case RS_CTL_Pswd:
			//if( (CHECK_AMM1_IFG&CHECK_AMM1_BIT)==0 )
			{
				Tmp=DM.ComBuf[RS_CmdPtr+4];
				if( Tmp>1 ) return;
				
				//if(Tmp==0)
					//MemCopy( &SM.Cfg.Pswd[0][0], &DM.ComBuf[RS_CmdPtr+4], 4 );
				//else
					//MemCopy( &SM.Cfg.Pswd[1][0], &DM.ComBuf[RS_CmdPtr+4], 4 );
				
        SM.CfgChk=ChkSum( (unsigned char *)&SM.Cfg, sizeof(SM.Cfg) );
			}
			DM.ComBuf[RS_LenPtr]=4;
			
			break;
    case RS_CTL_FRMetID:  
      MemCopy( &DM.ComBuf[RS_AddrPtr],SM.Cfg.MetID,  6 );
      DM.ComBuf[RS_LenPtr]=6;
      MemCopy( &DM.ComBuf[RS_CmdPtr],SM.Cfg.MetID,  6 );
      break;
		case RS_CTL_RdMet:
			if( DM.ComBuf[RS_LenPtr]!=6 ) return;
			SM.ClkBcdChk=ChkSum( SM.ClkBcd.Sec, sizeof(CLKDEF) );
			ClkBcd_ClkHex();
			DM.ComBuf[RS_LenPtr]=0;
			
			break;
		default:
      //DM.ComBuf[RS_CtlPtr]= 0xff;
      //DM.ComBuf[RS_LenPtr]=3;
      //DM.ComBuf[11] = RS_SER;
      //DM.ComBuf[12] = SM.Cfg.MetStatus[1];
      //DM.ComBuf[13] = SM.Cfg.MetStatus[0];
      
			return;
	}
	
	DM.ComBuf[RS_CtlPtr] |= 0x80;
	if( DM.ComBuf[RS_LenPtr]>120 ) 
  {
    return;
  }
	for( Tmp=0,Buf=&DM.ComBuf[RS_CmdPtr];Tmp<DM.ComBuf[RS_LenPtr];Tmp++,Buf++ ) 
  {
    *Buf+=0x33;
  }
	DM.ComBuf[RS_CmdPtr+DM.ComBuf[RS_LenPtr]]=ComCRC();
	DM.ComBuf[RS_CmdPtr+DM.ComBuf[RS_LenPtr]+1]=0x16;
	
	DM.ComFlg |= F_Txing;
	DM.ComPtr=1;
	
	iii=TAR;
	while( (TAR-iii)<655 ) {};			// 655
	
	
	if( (DM.ComFlg & F_PortX )==P_UART0)
	{
		StartUT0();
    //COMM_ACLK_SEL |= COMM_ACLK_BIT;
		U0TXBUF=DM.ComBuf[RS_HeadPtr];
    DM.ComPtr=1;
    //SystemEventFlag &= ~SYSTEM_COMM_FLAG;
	}
	else if( (DM.ComFlg & F_PortX )==P_UART1)
	{
		StartUT0();
		//U1TXBUF=DM.ComBuf[RS_HeadPtr];
	}
	
	_NOP();
}