宏实现大小端转换

#define BIG_LITTLE_SWAP16(x)        ( (((*(short int *)&x) & 0xff00) >> 8) | \
                                      (((*(short int *)&x) & 0x00ff) << 8) )

#define BIG_LITTLE_SWAP32(x)        ( (((*(long int *)&x) & 0xff000000) >> 24) | \
                                      (((*(long int *)&x) & 0x00ff0000) >> 8) | \
                                      (((*(long int *)&x) & 0x0000ff00) << 8) | \
                                      (((*(long int *)&x) & 0x000000ff) << 24) )

#define BIG_LITTLE_SWAP64(x)        ( (((*(long long int *)&x) & 0xff00000000000000) >> 56) | \
                                      (((*(long long int *)&x) & 0x00ff000000000000) >> 40) | \
                                      (((*(long long int *)&x) & 0x0000ff0000000000) >> 24) | \
                                      (((*(long long int *)&x) & 0x000000ff00000000) >> 8) | \
                                      (((*(long long int *)&x) & 0x00000000ff000000) << 8) | \
                                      (((*(long long int *)&x) & 0x0000000000ff0000) << 24) | \
                                      (((*(long long int *)&x) & 0x000000000000ff00) << 40) | \
                                      (((*(long long int *)&x) & 0x00000000000000ff) << 56) )

函数实现大小端转换

/**
  ******************************************************************************
  * @brief   大小端转换 函数
  * @param   *p     数据块指针
  * @param   size   字节数
  * @return  None
  * @note    
  ******************************************************************************
  */
void BigLittleEndianSwap(unsigned char *p, unsigned char size)
{
	unsigned char i;
	unsigned char tmp;
	unsigned char num = size/2;
	size--;
    for(i=0; i<num; i++)
    {
	    tmp = p[i];
	    p[i] = p[size-i];
		p[size-i] = tmp;
	}
}

测试、验证 大小端转换函数

#include <stdio.h> //库头文件

/**
  ******************************************************************************
  * @brief   主 函数
  * @param   None
  * @return  None
  * @note    测试验证上面的函数与宏
  ******************************************************************************
  */
void main(void)
{
	unsigned char i;
	short int tmp;
	long int ltmp;
	long long int lltmp;
    float ftmp;
    double fftmp;
    unsigned char *p;
//**判断CPU大小端模式 *************************************
	tmp = 0x1234;
    p = (unsigned char *)&tmp;    
    if(*p == 0x34)
    {
        printf("小端模式\r\n"); //最低字节，首先存储低地址。
    }
    else //(*p == 0x12)
    {
        printf("大端模式\r\n"); //最高字节，首先存储低地址。
    }
//**int 大小端转换 ****************************************
    printf("0x%04X \r\n", tmp); //转换前
    
    p = (unsigned char *)&tmp;
    for(i=0; i<2; i++)
    {
    	printf("0x%02hhX ", *p++);	
	}
    printf("\r\n");
    
    BigLittleEndianSwap((unsigned char *)&tmp, 2); //函数转换
    p = (unsigned char *)&tmp;
    for(i=0; i<2; i++)
    {
    	printf("0x%02hhX ", *p++);	
	}
    printf("\r\n");
    
    tmp = BIG_LITTLE_SWAP16(tmp); //宏转换
    p = (unsigned char *)&tmp;
    for(i=0; i<2; i++)
    {
    	printf("0x%02hhX ", *p++);	
	}
    printf("\r\n");
    
   	printf("0x%04X \r\n\r\n", tmp); //经过2次转换回来的值
//**long 大小端转换 ***************************************
	ltmp = 0x12345678;
   	printf("0x%08X \r\n", ltmp); //转换前
    
    p = (unsigned char *)&ltmp;
    for(i=0; i<4; i++)
    {
    	printf("0x%02hhX ", *p++);	
	}
    printf("\r\n");
    
    BigLittleEndianSwap((unsigned char *)&ltmp, 4); //函数转换
    p = (unsigned char *)&ltmp;
    for(i=0; i<4; i++)
    {
    	printf("0x%02hhX ", *p++);	
	}
    printf("\r\n");
    
   	ltmp = BIG_LITTLE_SWAP32(ltmp); //宏转换
    p = (unsigned char *)&ltmp;
    for(i=0; i<4; i++)
    {
    	printf("0x%02hhX ", *p++);	
	}
    printf("\r\n");
    
   	printf("0x%08X \r\n\r\n", ltmp); //经过2次转换回来的值
//**long long 大小端转换 **********************************
	lltmp = 0x1234567801234567;
   	printf("0x%016llX \r\n", lltmp); //转换前
    
    p = (unsigned char *)&lltmp;
    for(i=0; i<8; i++)
    {
    	printf("0x%02hhX ", *p++);	
	}
    printf("\r\n");
    
    BigLittleEndianSwap((unsigned char *)&lltmp, 8); //函数转换
    p = (unsigned char *)&lltmp;
    for(i=0; i<8; i++)
    {
    	printf("0x%02hhX ", *p++);	
	}
    printf("\r\n");
    
   	lltmp = BIG_LITTLE_SWAP64(lltmp); //宏转换
    p = (unsigned char *)&lltmp;
    for(i=0; i<8; i++)
    {
    	printf("0x%02hhX ", *p++);	
	}
    printf("\r\n");
    
   	printf("0x%016llX \r\n\r\n", lltmp); //经过2次转换回来的值
//**float 大小端转换 **************************************
	ftmp = 1.234568;
    printf("%f \r\n", ftmp); //转换前
    
    p = (unsigned char *)&ftmp;
    for(i=0; i<4; i++)
    {
    	printf("0x%02hhX ", *p++);	
	}
    printf("\r\n");
    
    BigLittleEndianSwap((unsigned char *)&ftmp, 4); //函数转换
    p = (unsigned char *)&ftmp;
    for(i=0; i<4; i++)
    {
    	printf("0x%02hhX ", *p++);	
	}
    printf("\r\n");
    
    *(long int *)&ftmp = BIG_LITTLE_SWAP32(ftmp); //宏转换
    p = (unsigned char *)&ftmp;
    for(i=0; i<4; i++)
    {
    	printf("0x%02hhX ", *p++);	
	}
    printf("\r\n");
    
    printf("%f \r\n\r\n", ftmp); //经过2次转换回来的值
//**double 大小端转换 **********************************
	fftmp =  1.234568901234;
    printf("%.12lf\r\n", fftmp); //转换前
    
    p = (unsigned char *)&fftmp;
    for(i=0; i<8; i++)
    {
    	printf("0x%02hhX ", *p++);	
	}
    printf("\r\n");
    
    BigLittleEndianSwap((unsigned char *)&fftmp, 8); //函数转换
    p = (unsigned char *)&fftmp;
    for(i=0; i<8; i++)
    {
    	printf("0x%02hhX ", *p++);	
	}
    printf("\r\n");
    
   	*(long long int *)&fftmp = BIG_LITTLE_SWAP64(fftmp); //宏转换
    p = (unsigned char *)&fftmp;
    for(i=0; i<8; i++)
    {
    	printf("0x%02hhX ", *p++);	
	}
    printf("\r\n");
    
    printf("%.12lf\r\n", fftmp); //经过2次转换回来的值
}

测试输出结果：