ASCALII助记

最新推荐文章于 2022-02-25 23:45:16 发布

生命不息奋斗不止

最新推荐文章于 2022-02-25 23:45:16 发布

阅读量606

点赞数

分类专栏： STM32系列文章标签： hex c

本文链接：https://blog.csdn.net/mliubing2532/article/details/7872804

版权

STM32系列专栏收录该内容

1 篇文章 0 订阅

订阅专栏

二进制      十进制    十六进制    字符                              二进制      十进制    十六进制    字符
0000 0000    0          00                                                    0011 0000    48         30         0
0000 0001    1          01                                                    0011 0001    49         31         1
0000 0010    2          02                                                    0011 0010    50         32         2
0000 0011    3          03                                                    0011 0011    51         33         3
0000 0100    4          04                                                    0011 0100    52         34         4
0000 0101    5          05                                                    0011 0101    53         35         5
0000 0110    6          06                                                    0011 0110    54         36         6
0000 0111    7          07                                                    0011 0111    55         37         7
0000 1000    8          08                                                    0011 1000    56         38         8
0000 1001    9          09                                                    0011 1001    57         39         9

从上面对比可以看出：当左边的加上48或者0x30时，变成相应的字符，即可完成HEX码转变成ASCALII码

0000 1010    10         0A                                                   0100 0001    65        41          A
0000 1011    11         0B                                                   0100 0010    66        42          B
0000 1100    12         0C                                                   0100 0011    67        43          C
0000 1101    13         0D                                                   0100 0100    68        44          D
0000 1110    14         0E                                                   0100 0101    69        45          E
0000 1111    15         0F                                                    0100 0110    70        46          F

从上面对比可以看出：当左边的加上55或者0x37时，变成相应的字符，即可完成HEX码转变成ASCALII码

二进制          十进制十六进制字符                              二进制          十进制十六进制字符

0100 0001    65        41            A                                       0110 0001    97        61            a
0100 0010    66        42            B                                        0110 0010    98        62            b
0100 0011    67        43            C                                        0110 0011    99        63            c
0100 0100    68        44            D                                        0110 0100    100      64            d
0100 0101    69        45            E                                        0110 0101    101      65            e
0100 0110    70        46            F                                        0110 0110    102      66            f
0100 0111    71        47            G                                       0110 0111    103      67            g
0100 1000    72        48            H                                       0110 1000    104      68            h
0100 1001    73        49            I                                         0110 1001    105      69            i
0100 1010    74        4A            J                                        0110 1010    106      6A            j
0100 1011    75        4B            K                                       0110 1011    107      6B            k
0100 1100    76        4C            L                                       0110 1100    108      6C            l
0100 1101    77        4D            M                                      0110 1101    109      6D            m
0100 1110    78        4E            N                                       0110 1110    110      6E            n
0100 1111    79        4F            O                                        0110 1111    111      6F            o
0101 0000    80        50            P                                        0111 0000    112      70            p
0101 0001    81        51            Q                                        0111 0001    113      71            q
0101 0010    82        52            R                                        0111 0010    114      72            r
0101 0011    83        53            S                                         0111 0011    115      73            s
0101 0100    84        54            T                                         0111 0100    116      74            t
0101 0101    85        55            U                                        0111 0101    117      75            u
0101 0110    86        56            V                                         0111 0110    118      76           v
0101 0111    87        57            W                                        0111 0111    119      77            w
0101 1000    88        58            X                                          0111 1000    120      78            x
0101 1001    89        59            Y                                          0111 1001    121      79            y

0101 1010 90 5A Z 0111 1010 122 7A z

0101 1011 91 5B [ 0111 1011 123 7B {

0101 1100    92        5C            \                                           0111 1100    124      7C            |
0101 1101    93        5D            ]                                           0111 1101    125      7D            }
0101 1110    94        5E            ^                                           0111 1110    126      7E            ~
0101 1111    95        5F            _
0110 0000    96        60            `

方法一：

通过串口发送HEX

char HexTAB[]={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'}; //注意单引号

void USARTxSendByteHex(USART_TypeDef *USARTx,u8 data)
{
        uint16 usart;
        if (USARTx == USART1) usart = 1;
        else if (USARTx == USART2) usart = 2;
        else usart = 3;

      switch(usart)
      {
              case 1:
              FIFO_PUT_ONE(Uart1TxFifo,HexTAB[(data>>4)&0x0f]);
              FIFO_PUT_ONE(Uart1TxFifo,HexTAB[data&0x0f]);
             FIFO_PUT_ONE(Uart1TxFifo,' ');
             break;
              case 2:
              FIFO_PUT_ONE(Uart2TxFifo,HexTAB[(data>>4)&0x0f]);
              FIFO_PUT_ONE(Uart2TxFifo,HexTAB[data&0x0f]);
              FIFO_PUT_ONE(Uart2TxFifo,' ');
              break;
              case 3:
              FIFO_PUT_ONE(Uart3TxFifo,HexTAB[(data>>4)&0x0f]);
              FIFO_PUT_ONE(Uart3TxFifo,HexTAB[data&0x0f]);
              FIFO_PUT_ONE(Uart3TxFifo,' ');
              break;
               default : break;
       }
}

方法二：

void Hex_To_ASCII(uint8 *Buf,uint8 iBYTE)
{
        //先对高4位进行转换
        uint8 i= iBYTE >> 4;
        //数字0－－9
        if(i<0x0A)
       {
               //i加上48:
              *Buf = 0x30 +i;
         }
         //字母A－－F（大写）
        else
         {
               //i加上55
              *Buf = 0x37 +i;
         }

         //再对低4位进行转换
         i = iBYTE &0x0F;
         //数字0－－9
         if(i<0x0A)
        {
               *(Buf+1) = 0x30 +i;
         }
          //字母A－－F（大写）
         else
        {
               *(Buf+1) = 0x37 +i;
        }
}

//下面的函数将调用上面那个函数

void add_hex_to_uartbuff(USART_TypeDef* USARTx,uint32 data)
{
         uint8 buff[3];
         //buff[0]存储高4位，buff[1]存储低4位
         //取[31~24]---从01~ff
         if(data > 0xffffff)
        {
               Hex_To_ASCII(buff,(uint8)(data>>24));
                add_data_to_uartbuff(USARTx,buff[0]);
                add_data_to_uartbuff(USARTx,buff[1]);
                data &= 0xffffff;
         }
        //取[23~16]---从01~ff
         if(data > 0xffff)
        {
               Hex_To_ASCII(buff,(uint8)(data>>16));
                add_data_to_uartbuff(USARTx,buff[0]);
                add_data_to_uartbuff(USARTx,buff[1]);
                data &= 0xffff;
         }
         //取[15~8]---从01~ff
         if(data > 0xff)
        {
                Hex_To_ASCII(buff,(uint8)(data>>8));
                add_data_to_uartbuff(USARTx,buff[0]);
                add_data_to_uartbuff(USARTx,buff[1]);
                data &= 0xff;
        }
        //取[7~0]---从00~ff
        Hex_To_ASCII(buff,(uint8)data);
        add_data_to_uartbuff(USARTx,buff[0]);
        add_data_to_uartbuff(USARTx,buff[1]);
        add_data_to_uartbuff(USARTx,' ');
}