general.c

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

unsigned int ChkSum(unsigned char *Ptr,int Len)
{
  unsigned int Sum=0x55;
   while(Len>0)
   {
      Sum += *Ptr;
      Ptr++;
      Len--;
   }
   return(Sum);
}


//**********************************************************************
// Memory block copy
//**********************************************************************
void MemCopy( unsigned char *Dest, unsigned char *Src, int Len )
{
   while ( Len>0 )
   {
      *Dest = *Src;
      Dest++;
      Src++;
      Len--;
   }
}


void MemFill( unsigned char *Data_Ptr, unsigned int Len, unsigned char byte )
{
   while ( Len>0 )
   {
      *Data_Ptr = byte;
      Data_Ptr++;
      Len--;
   }
}

//**********************************************************************
// turn BCD data to byte data
//**********************************************************************
unsigned char BCD2Byte(unsigned char Data)
{
   return(((Data>>4)&0x0f)*10+(Data&0x0f));
}

//**********************************************************************
// turn byte data to BCD data
//**********************************************************************
unsigned char Byte2BCD(unsigned char Data)
{
   unsigned char Rslt=0;
   if (Data>=99) return 0x99;
   while(Data>9)
   {
      Data-=10;
      Rslt+=0x10;
   }
   return(Rslt+Data);
}

void Word2BCD0(unsigned char *Ptr, unsigned int Data)
{  
   *(Ptr+2)= 0;
   *(Ptr+1)= 0;
   *Ptr= 0;
   while(Data>=10000)
   {
      Data-=10000;
      *(Ptr+2) += 0x01;
   }
    while(Data>=1000)
   {
      Data-=1000;
      *(Ptr+1) += 0x10;
   }
   while(Data>=100)
   {
      Data-=100;
      *(Ptr+1) += 0x1;
   }
   *Ptr = Byte2BCD( (char)Data );
}

void Word2BCD2(unsigned char *Ptr, unsigned long Data)
{  
   *(Ptr+2)= 0;
   *(Ptr+1)= 0;
   *Ptr= 0;
   while(Data>=100000)
   {
      Data-=100000;
      *(Ptr+2) += 0x10;
   } 
   while(Data>=10000)
   {
      Data-=10000;
      *(Ptr+2) += 0x01;
   }
    while(Data>=1000)
   {
      Data-=1000;
      *(Ptr+1) += 0x10;
   }
   while(Data>=100)
   {
      Data-=100;
      *(Ptr+1) += 0x1;
   }
   *Ptr = Byte2BCD( (char)Data );
}

void Word2BCD_P(unsigned char *Ptr, unsigned long Data)
{  
   *(Ptr+2)= 0;
   *(Ptr+1)= 0;
   *Ptr= 0;
   while(Data>=1000000000)
   {
      Data-=1000000000;
      *(Ptr+2) += 0x10;
   }  
   
   while(Data>=100000000)
   {
      Data-=100000000;
      *(Ptr+2) += 0x01;
   }
   while(Data>=10000000)
   {
      Data-=10000000;
      *(Ptr+1) += 0x10;
   }
   while(Data>=1000000)
   {
      Data-=1000000;
      *(Ptr+1) += 0x01;
   }
   while(Data>=100000)
   {
      Data-=100000;
      *Ptr += 0x10;
   }
   while(Data>=10000)
   {
      Data-=10000;
      *Ptr += 0x1;
   }
}


//**********************************************************************
// turn word data to BCD data
//**********************************************************************
void Word2BCD1(unsigned char *Ptr, unsigned int Data)
{
   if (Data>=9999)
   {
      *(Ptr+1) = 0x99;
      *Ptr = 0x99;
      return;
   }

   *(Ptr+1)= 0;
   while(Data>=1000)
   {
      Data-=1000;
      *(Ptr+1) += 0x10;
   }
   while(Data>=100)
   {
      Data-=100;
      *(Ptr+1) += 0x1;
   }
   *Ptr = Byte2BCD( (char)Data );
}


//**********************************************************************
// Clear 1 segment of Flash
//**********************************************************************
void FlashClear( unsigned char *Data_ptr )
{
	//_DINT();
	FCTL1 = FWKEY + ERASE;  /* ERASE = 1 */
	FCTL3 = FWKEY;          /* Lock = 0 */
	*Data_ptr=0;            /* erase Flash segment */
	//_EINT();
}

//**********************************************************************
// Write 1 byte into Flash Memory
//**********************************************************************
void FlashWtByte( unsigned char *Data_ptr, unsigned char byte )
{
	_DINT();
	FCTL3 = FWKEY;           /* Lock = 0 */
	FCTL1 = 0x0A540;          /* WRT = 1 */
	*Data_ptr=byte;           /* program Flash word */
}

//**********************************************************************
// Write 1 word into Flash Memory
//**********************************************************************
void FlashWtWord( unsigned int *Data_ptr, unsigned int word )
{
	_DINT();
	FCTL3 = 0x0A500;          /* Lock = 0 */
	FCTL1 = 0x0A540;          /* WRT = 1 */
	*Data_ptr=word;           /* program Flash word */
}

//**********************************************************************
// Write n byte into blank Flash Memory
//**********************************************************************
void FlashWtBlock( unsigned char *Data_ptr, unsigned char *Src, unsigned int Len )
{
  //_DINT();
  
  if(MeterRunState & MAIN_VOLTAGE_ON)
  {
    FCTL2 = FWKEY+FSSEL1+FN4+FN3+FN2+FN1+FN0;
  }
  else
  {
    FCTL2 = FWKEY+FSSEL1+FN1;
  }	
	FCTL1 = FWKEY + ERASE;          
  FCTL3 = FWKEY;          
  *Data_ptr = 0;
  
  FCTL1 = FWKEY + WRT; 
  FCTL3 = FWKEY;
  for(unsigned char i=0;i<2;i++)
  {
    *Data_ptr = 0x55;
    Data_ptr++;
    Len--;
  }
  
  while ( Len>0 ) 
  {
    *Data_ptr = *Src;
    Data_ptr++;
    Src++;
    Len--;
  }
  
  FCTL1 = FWKEY;
  FCTL3 = FWKEY + LOCK;
  //_EINT();
}

/*
// **********************************************************************
// Write n byte into blank Flash Memory
// **********************************************************************
void FlashWtBlock( unsigned char *Data_ptr, unsigned char *Src, unsigned int Len )
{
   while ( Len>0 )
   {
      FlashWtByte( Data_ptr, *Src );
      Data_ptr++;
      Src++;
      Len--;
   }
}
*/
/***********************************************************************/
/*                         Flash_memcpy                                */
/* programs nLen memory data into the flash memory                     */
/***********************************************************************/
void Flash_byte_memcpy( unsigned char *Data_ptr, unsigned char *memaddr, unsigned int nLen )
{
	_DINT();
	FCTL3 = 0x0A500;          /* Lock = 0 */
	FCTL1 = 0x0A540;          /* WRT = 1 */
	for(; nLen > 0; nLen--)
	{
		*Data_ptr=*memaddr;           /* program Flash word */
		Data_ptr++;
		memaddr++;
	}
	_EINT();
}

/***********************************************************************/
/*                         Flash_memcpy                                */
/* programs nLen memory data into the flash memory                     */
/***********************************************************************/
void Flash_word_memcpy( unsigned int *Data_ptr, unsigned int *memaddr, unsigned int nLen )
{
	_DINT();
	FCTL3 = 0x0A500;          /* Lock = 0 */
	FCTL1 = 0x0A540;          /* WRT = 1 */
	for(; nLen > 0; nLen--)
	{
		*Data_ptr=*memaddr;           /* program Flash word */
		Data_ptr++;
		memaddr++;
	}
	_EINT();
}


//**********************************************************************
// Write n byte into blank Flash Memory
//**********************************************************************
void FlashFill( unsigned char *Data_ptr, unsigned int Len, unsigned char byte )
{
	_DINT();
	while ( Len>0 )
	{
		FlashWtByte( Data_ptr, byte );
		Data_ptr++;
		Len--;
	}
	_EINT();
}




/***********************************************************************/
/* secure all flash                                                    */
/***********************************************************************/
void FlashSecure(void)
{
	_DINT();
	FCTL1 = 0x0A500;          /* ERASE,WRITE = 0 */
	FCTL3 = 0x0A510;          /* Lock = 1 */
}






void DataFromFlash(unsigned char * Source_Ptr,unsigned char * Des_Ptr,int Lenth)
{
  while ( Lenth>0 ) 
  {
    *Des_Ptr = *Source_Ptr;
    Des_Ptr++;
    Source_Ptr++;
    Lenth--;
  }
}




#if PCB_VERSION == 0
void Update_HC595_Port(unsigned char POUT_HC595)
{
	unsigned char i = 8;
#ifdef HC595COM
  HC595_COM_SEL &= ~(HC595_SER_BIT+HC595_RCLK_BIT+HC595_SRCLK_BIT);
  HC595_COM_DIR |= (HC595_SER_BIT+HC595_RCLK_BIT+HC595_SRCLK_BIT);
  HC595_COM_OUT &= ~(HC595_RCLK_BIT+HC595_SRCLK_BIT);
#else
  HC595_SER_SEL &= ~HC595_SER_BIT;
  HC595_RCLK_SEL &= ~HC595_RCLK_BIT;
  HC595_SRCLK_SEL &= ~HC595_SRCLK_BIT;
  HC595_SER_DIR |= HC595_SER_BIT;
  HC595_RCLK_DIR |= HC595_RCLK_BIT;
  HC595_SRCLK_DIR |= HC595_SRCLK_BIT;
  HC595_RCLK_OUT &= ~HC595_RCLK_BIT;
  HC595_SRCLK_OUT &= ~HC595_SRCLK_BIT;  
#endif
	while(i--)
	{
		HC595_SRCLK_OUT &= ~HC595_SRCLK_BIT;
    if((POUT_HC595 & HC595_SER_BIT) == HC595_SER_BIT)
      HC595_SER_OUT |= HC595_SER_BIT;
    else
      HC595_SER_OUT &= ~HC595_SER_BIT;
    HC595_SRCLK_OUT |= HC595_SRCLK_BIT;
    POUT_HC595 <<= 1;
	}
	HC595_RCLK_OUT |= HC595_RCLK_BIT;  // 存储上升沿脉冲
	_NOP();
	
#ifdef HC595COM  
  HC595_COM_OUT &= ~(HC595_SER_BIT+HC595_RCLK_BIT+HC595_SRCLK_BIT);
#else
  HC595_RCLK_OUT &= ~HC595_RCLK_BIT;
  HC595_SRCLK_OUT &= ~HC595_SRCLK_BIT
  HC595_SER_OUT  &= ~HC595_SER_BIT
#endif
  
}
#endif