0201_APP/BSP/tools.c

#include "tools.h"
#include "includes.h"

#define CRC16_INIT_VALUE 0x0000
//CRC校验
//CRC16-IBM
uint16_t CRC16_get(uint8_t *_buff,uint32_t _len)
{
    uint32_t i,j;
    uint16_t crc;
    uint16_t temp;

    crc=(uint16_t)CRC16_INIT_VALUE;
    for(i=0;i<_len;i++) {
        temp=_buff[i];
        temp &=0x00FF;
        crc^=temp;

        for(j=0;j<8;j++) {
            if((crc&0x0001)!=0x00) {
                crc>>=1;
                crc^=0xA001;
            } else {
                crc>>=1;
            }
        }
    }
    return crc;
}

//数组比较
//返回，0：相同；1：不同
uint8_t buff_compare(uint8_t *buf1, uint8_t *buf2, uint16_t len)
{
	uint8_t ret = 0;
	uint16_t i;
	for(i = 0; i < len; i++)
	{
		if(buf1[i] != buf2[i])
		{
			ret = 1;
			break;
		}
	}
	return ret;
}

//异或和计算
uint8_t get_xor(uint8_t *buf, uint16_t len)
{
	uint16_t i;
	uint8_t data = 0;
	for(i = 0; i < len; i++)
	{
		data ^= buf[i];
	}
	return data;
}

//报税口明文协议校验
uint8_t _crc_get_gw(uint8_t *data, uint8_t size)
{
	uint8_t i, crc = 0;
	
	for(i = 0;i < size;i++){
		crc ^=data[i];
	}
 
	return crc;
}

//字符串转十六进制数
uint32_t strtohex(char *data, uint8_t len)
{
  uint32_t p_data = 0;
	uint8_t temp;
	uint8_t i = 0;;
	
	for(i = 0; i < len; i++)
	{
		temp = HexToChar(data[i]);
		if(temp == 0xff)
			break;
		p_data = (p_data<<4)|temp;
	}
	return p_data;
}

//flash内数据的crc16校验
uint16_t CRC16_get_flash(uint32_t addr, uint32_t len)
{
	uint32_t i,j;
    uint16_t crc;
    uint16_t temp;
    crc=(uint16_t)CRC16_INIT_VALUE;

	FLASH_Unlock();// Unlock the Flash to enable the flash control register access
	FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);	// Clear pending flags (if any)

    for(i=0;i<len;i++) {
        temp=*(__IO uint8_t *)(addr+i);
        temp &=0x00FF;
        crc^=temp;

        for(j=0;j<8;j++) {
            if((crc&0x0001)!=0x00) {
                crc>>=1;
                crc^=0xA001;
            } else {
                crc>>=1;
            }
        }
    }
	FLASH_Lock(); // Lock the Flash to disable the flash control register access
    return crc;
}

//显示屏升级校验
void GetCodeVerify(uint32 _start,uint32 _len,uint32 * _verify)
{/*{{{*/
    uint32 verifySum;
    uint32 verifyXor;

//    uint32 * pBuff;
    uint32 i;

//    pBuff=(uint32 *)_start;

    verifySum=0xAA555AA5;
    verifyXor=0x55AAA55A;
	FLASH_Unlock();// Unlock the Flash to enable the flash control register access
	FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);	// Clear pending flags (if any)

    for(i=0;i<_len/4;i++)
    {
		
		verifySum+=*(__IO uint32_t *)(_start+i*4);
        verifyXor^=*(__IO uint32_t *)(_start+i*4);
		
//        verifySum+=*pBuff;
//        verifyXor^=*pBuff;
//        pBuff++;
    }
    _verify[0]=verifyXor;
    _verify[1]=verifySum;
	FLASH_Lock(); // Lock the Flash to disable the flash control register access
//	printf("verifyxor=0x%08x,verifysum=0x%08x\n",verifyXor,verifySum);
}/*}}}*/

//显示屏升级校验
void GetCodeVerify_t(uint32 _start,uint32 _len,uint32 * _verify)
{/*{{{*/
    uint32 verifySum;
    uint32 verifyXor;

    uint32 * pBuff;
    uint32 i;

    pBuff=(uint32 *)_start;

    verifySum=0xAA555AA5;
    verifyXor=0x55AAA55A;

    for(i=0;i<_len/4;i++)
    {
        verifySum+=*pBuff;
        verifyXor^=*pBuff;
        pBuff++;
    }
    _verify[0]=verifyXor;
    _verify[1]=verifySum;
}/*}}}*/

/*转义*/
uint8_t Buff_Code[256];
int _ytsf_data_code(uint8_t *buff, uint8_t *len)
{
//	uint8_t buff_code[256];
	uint8_t i, tlen = 0;
	memset(Buff_Code,0,sizeof(Buff_Code));
	/* 帧中除了帧头为 BB 外，不再出现 BB，如果出现 BB 则转义为
BA 01；如果出现 BA 则转义为 BA 00；帧长度和校验码都按转义前
来计算。*/
	for(i = 0;i < *len; i ++){
		if(buff[i] == 0xba){
			Buff_Code[tlen++] = 0xba;
			Buff_Code[tlen++] = 0x00;
		} else if(i&&buff[i] == 0xbb){
			Buff_Code[tlen++] = 0xba;
			Buff_Code[tlen++] = 0x01;
		}
		else{
			Buff_Code[tlen++] = buff[i];
		}
	}
	memcpy(buff, Buff_Code, tlen);
	*len = tlen;
	return 0;
}
/*反转义*/
int _ytsf_data_decode(uint8_t *buff, uint8_t *len)
{
//	uint8_t buff_code[128];
	uint8_t i, tlen = 0;
	memset(Buff_Code,0,sizeof(Buff_Code));
	/* 帧中除了帧头为 BB 外，不再出现 BB，如果出现 BB 则转义为
BA 01；如果出现 BA 则转义为 BA 00；帧长度和校验码都按转义前
来计算。*/
	for(i = 0;i < *len; i ++){
		if((buff[i] == 0xba)&&(buff[i+1] == 0x00)) {
			Buff_Code[tlen++] = 0xba;
			i += 1;
		} else if((buff[i] == 0xba)&&(buff[i+1] == 0x01)){
			Buff_Code[tlen++] = 0xbb;
			i += 1;
		}
		else{
			Buff_Code[tlen++] = buff[i];
		}
	}
	memcpy(buff, Buff_Code, tlen);
	*len = tlen;

	return 0;
}

//十六进制字符串转十进制数
long  HextoDec(char *s)
{
   int i,t;
   long sum=0;
   for(i=0;s[i];i++)
   {
     if(s[i]<='9')
         t=s[i]-'0';
     else
         t=s[i]-'A'+10;
     sum=sum*16+t;
   }
   return sum;
}

unsigned char HexToChar(unsigned char bChar)
{
	if((bChar>=0x30)&&(bChar<=0x39))
	{
		bChar -= 0x30;
	}
	else if((bChar>=0x41)&&(bChar<=0x46)) // Capital
	{
		bChar -= 0x37;
	}
	else if((bChar>=0x61)&&(bChar<=0x66)) //littlecase
	{
		bChar -= 0x57;
	}
	else
	{
		bChar = 0xff;
	}
	return bChar;
}

//ascii转十六进制
int asciitohex(char *data, uint8_t *out_data, int len)
{
	int i,slen=0;
	uint8_t temp1,temp2;
	for(i = 0; i < len; i+=2)
	{
		temp1 = HexToChar(data[i]);
		temp2 = HexToChar(data[i+1]);
		out_data[slen] = (temp1<<4) | temp2;
		slen++;
	}
	return slen;
}

//十进制转BCD码
int decimal_bcd_code(int decimal)
{
	int sum = 0;  //sum返回的BCD码
	int i;
	for (i = 0; decimal > 0; i++)
	{
		sum |= ((decimal % 10 ) << ( 4*i));

		decimal /= 10;
	}

	return sum;
}


/**************************************************************************
	以下定时器均由滴答定时器驱动，systickCount
***************************************************************************/
/**
  * @brief 设置定时器
  * @par param[timeout_t] *tt
  * @par param[uint32_t] val，延时ms
  * @par param[uint8_t] flg。0:不使能；1单次使能；0xFF连续使能
  */
void timeout_setValue(timeout_t *tt,uint32_t val,uint8_t flg){
	tt->flag = flg;
	tt->count = TickCounter;
	tt->timeout = val;
};

/**
  * @brief 启动定时器
  * @par param[timeout_t] *tt
  * @par param[uint8_t] flg。0:不使能；1单次使能；0xFF连续使能
  */

/**
 * @brief 启动定时器
 * @param  tt               定时器指针
 * @param  flg              是否开启
 */
void timeout_start(timeout_t *tt,uint8_t flg){
	tt->flag = flg;
	if(flg){
		tt->count = TickCounter;
	}
};



/**
 * @brief 停止定时器
 * @param  tt               定时器指针
 */
void timeout_stop(timeout_t *tt){
	tt->flag = 0;
};


/**
 * @brief 返回定时器是否超时
 * @param  tt               定时器指针
 * @return uint8_t 1:超时，0:未超时
 */


uint8_t timeout_isOut(timeout_t *tt){
	if(tt->flag){
		if((TickCounter - tt->count) > tt->timeout){
			tt->count = TickCounter;
			if(tt->flag == 1){
				tt->flag = 0;
			}
			return 1;
		}
		else{
			return 0;
		}
	}
	else{
		return 0;
	}
};

/**************************************************************************
	以上定时器均由滴答定时器驱动，systickCount
***************************************************************************/



/**************************************************************************
	以下定时器均由timer定时器驱动，Tickcount_us
***************************************************************************/
/**
  * @brief 设置定时器
  * @par param[timeout_t] *tt
  * @par param[uint32_t] val，延时10us
  * @par param[uint8_t] flg。0:不使能；1单次使能；0xFF连续使能
  */
void timeout_setValue_us(timeout_t *tt,uint32_t val,uint8_t flg){
	tt->flag = flg;
	tt->count = Get_Time();
	tt->timeout = val;
};

/**
  * @brief 启动定时器
  * @par param[timeout_t] *tt
  * @par param[uint8_t] flg。0:不使能；1单次使能；0xFF连续使能
  */

/**
 * @brief 启动定时器
 * @param  tt               定时器指针
 * @param  flg              是否开启
 */
void timeout_start_us(timeout_t *tt,uint8_t flg){
	tt->flag = flg;
	if(flg){
		tt->count = Get_Time();
	}
};



/**
 * @brief 停止定时器
 * @param  tt               定时器指针
 */
void timeout_stop_us(timeout_t *tt){
	tt->flag = 0;
};


/**
 * @brief 返回定时器是否超时
 * @param  tt               定时器指针
 * @return uint8_t 1:超时，0:未超时
 */


uint8_t timeout_isOut_us(timeout_t *tt){
	if(tt->flag){
		if((Get_Time() - tt->count) > tt->timeout){
			tt->count = Get_Time();
			if(tt->flag == 1){
				tt->flag = 0;
			}
			return 1;
		}
		else{
			return 0;
		}
	}
	else{
		return 0;
	}
};

/**************************************************************************
	以上定时器均由timer定时器驱动，Tickcount_us
***************************************************************************/


//串口波特率判断
//返回值：1 数据正确，2 数据错误
uint8_t uart_baud_judge(uint32_t baud)
{
	//波特率范围1200到460800
	if(baud >= 1200 && baud <= 460800)
		return 1;
	else
		return 0;
		
}

//判断数组是否全部为0
//返回值：1 全为0，0 不全为0
uint8_t buf_is_zero(uint8_t *buf, uint16_t size)
{
	int i;
	for(i = 0; i < size; i++)
	{
		if(buf[i])
			break;
	}
	if(i == size)
		return 1;
	else
		return 0;
}


//printf打印函数
void printf_debug(uint8_t cmd1, const char *fmt, ...)
{
	va_list args;       //定义一个va_list类型的变量，用来储存单个参数  

	if(cmd1)
	{
		va_start(args, fmt); //使args指向可变参数的第一个参数  
		vprintf(fmt, args);  //必须用vprintf等带V的  
		va_end(args);       //结束可变参数的获取
	}
}

//十六进制打印
void data_dump_debug(uint8_t cmd1, const char *name, uint8_t *data, uint16_t len)
{
	if(cmd1)
	{
		data_dump(name, data, len);
	}
}