嵌入式 C 编程必备(3)：进制转换基础全解析

本文链接：https://blog.csdn.net/weixin_37800531/article/details/144010160

1.4. 十六进制（Hexadecimal）

2.4. 二进制、八进制与十六进制之间的转换

在嵌入式开发领域，进制转换是一项基础且至关重要的技能。计算机内部采用二进制进行数据存储和运算，而开发者通常使用十进制、八进制或十六进制来表示和操作数据。因此，掌握进制转换对于理解和优化嵌入式系统至关重要。

一、常见进制介绍

进制是计算技术中用于表示数值的一种方式，不同的进制使用不同数量的符号来表示数值。

常见进制包括二进制（0和1）、八进制（0-7）、十六进制（0-9及A-F）和十进制（0-9），它们在计算机科学、数学和其他领域中有着广泛的应用。

1.1 十进制（Decimal）

十进制是我们日常生活中最常用的进制。它由 0、1、2、3、4、5、6、7、8、9 这十个数字组成。每相邻的两个计数单位之间的进率都为十。
例如，数字123在十进制中表示为1×10^2 + 2×10^1 + 3×10^0，即100 + 20 + 3 = 123。
十进制的特点在于它的直观性和人们对它的熟悉程度。在数学运算、商业交易、日常计数等方面，十进制都被广泛应用。

1.2. 二进制（Binary）

二进制是计算机系统中最基本的进制系统。它只有0和1两个数字，逢二进一。
在嵌入式开发中，硬件的控制信号、存储器中的数据等通常都是以二进制形式表示的。例如，数字101在二进制中表示为1×2^2 + 0×2^1 + 1×2^0，即4 + 0 + 1 = 5。
二进制的优势在于其简单性和可靠性，适合在数字电路中进行处理和传输。每一位二进制数只有两种可能的状态，对应于电路中的高电平和低电平，这使得计算机能够快速、准确地处理信息。

1.3. 八进制（Octal）

八进制是一种以8为基数的计数法，它采用0-7这八个数字，逢八进一。
在一些早期的计算机系统和特定的编程场景中，八进制曾被广泛使用，因为它与二进制有直接的对应关系（每三位二进制数可以转换为一个八进制数），从而简化了二进制数的读写。例如，八进制数234表示为2×8^2 + 3×8^1 + 4×8^0，即128 + 24 + 4 = 156。

1.4. 十六进制（Hexadecimal）

十六进制是一种以16为基数的计数法，它采用0-9和A-F（或其大写A-F）这十六个数字或字母表示，逢十六进一。
十六进制在表示数据时更加紧凑，因为每四位二进制数可以转换为一个十六进制数，从而大大减少了数字的位数，便于阅读和书写。
十六进制在表示内存地址、寄存器值等方面非常方便。例如，十六进制数0x1A（或1A，前面的0x是十六进制数的常见前缀）表示为1×160，其中A代表10，所以结果为16 + 10 = 26。
在嵌入式开发中，十六进制常常用于调试和分析硬件状态。它能够以简洁的方式表示大量的二进制数据，使得开发人员能够更快速地理解和处理复杂的系统信息。同时，十六进制也方便与其他进制进行转换，特别是与二进制和十进制之间的转换，为开发过程中的数据处理提供了便利。

二、进制转换方法

2.1. 二进制与十进制之间的转换

①二进制转十进制：二进制数由0和1组成，每一位的数值是其位置上的权值（2的幂次方）乘以该位上的数字（0或1）。将所有这些乘积相加，即可得到十进制数。

例如：二进制数 1101 转换为十进制数的计算过程为：
1×2^3 + 1×2^2 + 0×2^1 + 1×2^0 = 8 + 4 + 0 + 1 = 13

②十进制转二进制：将十进制数不断除以2，记录余数，直到商为0。将余数按从低位到高位的顺序排列，得到的数就是对应的二进制数。

例如：十进制数 23 转换为二进制数的过程为：
```
23 ÷ 2 = 11 余 1
11 ÷ 2 = 5 余 1
5 ÷ 2 = 2 余 1
2 ÷ 2 = 1 余 0
1 ÷ 2 = 0 余 1
```
从下往上读取余数，得到 23 的二进制表示为 10111。

2.2. 八进制与十进制之间的转换

①八进制转十进制：八进制数由0到7的数字组成，每一位的数值是其位置上的权值（8的幂次方）乘以该位上的数字。将所有这些乘积相加，即可得到十进制数。

例如: 八进制数 7654 转换为十进制数的计算过程为：
7×8^3 + 6×8^2 + 5×8^1 + 4×8^0 = 28672 + 3072 + 400 + 4 = 32148

②十进制转八进制：将十进制数不断除以8，记录余数，直到商为0。将余数按从低位到高位的顺序排列，得到的数就是对应的八进制数。

例如：将十进制数29转换为八进制的过程为：
29 ÷ 8 = 3 余 5
所以 29 的八进制表示为 35。

2.3. 十六进制与十进制之间的转换

①十六进制转十进制：十六进制数由0到9和A到F（或a到f）组成，其中A到F代表10到15。每一位的数值是其位置上的权值（16的幂次方）乘以该位上的数字（0-9或A-F）。将所有这些乘积相加，即可得到十进制数。

例如：十六进制数 3E 转换为十进制数的计算过程为：
3×16^1 + 14×16^0 = 48 + 14 = 62

②十进制转十六进制：将十进制数不断除以16，记录余数，直到商为0。对于余数大于9的情况，使用A-F的字母来代表数字10-15。将余数按从低位到高位的顺序排列，得到的数就是对应的十六进制数。

例如：十进制数 123 转换为十六进制数的过程为：
```
123 ÷ 16 = 7 余 11（B）
7 ÷ 16 = 0 余 7
```
所以 123 的十六进制表示为 7B。

2.4. 二进制、八进制与十六进制之间的转换

①二进制转八进制：从小数点开始，分别向左、右按3位分组转换成对应的八进制数字字符，最后不满3位的，则需补0。

例如，二进制数 110101 转换为八进制。
- 分组为 011 和 010 和 101。
- 011 对应八进制数 3，010 对应八进制数 2，101 对应八进制数 5。
- 所以，110101 的八进制表示为 65。

②八进制转二进制：将每位八进制数用3位二进制数表示即可。

例如：八进制数 35 转换为二进制：
3 转换为二进制为 011
5 转换为二进制为 101
所以 35 的二进制表示为 011101（注意：通常我们省略前导的0，但在这里为了保持位数一致，我保留了它）。

③二进制转十六进制：从小数点开始，分别向左、右按4位分组转换成对应的十六进制数字字符，最后不满4位的，则需补0。

例如：二进制数 110101 转换为十六进制：
分组为 0011 和 0101（注意：这里我添加了前导的0以保持4位一组）。
0011 对应十六进制数 3，0101 对应十六进制数 5。
所以 110101 的十六进制表示为 35。

④十六进制转二进制：将每位十六进制数用4位二进制数表示即可。

例如：十六进制数 35 转换为二进制：
3 转换为二进制为 0011
5 转换为二进制为 0101
所以 35 的二进制表示为 00110101（同样，为了保持位数一致，我保留了前导的0，但在实际应用中通常会省略它们）。

三、进制转换在嵌入式开发中的应用

进制转换在嵌入式开发中具有广泛的应用，不仅涉及数据存储、数据传输，还与代码优化等多个方面紧密相连。

3.1. 数据存储

在嵌入式系统中，数据通常以二进制形式存储在内存中。了解进制转换有助于开发者理解数据的存储方式，并进行有效的数据读写操作。

二进制存储的优势：计算机系统是基于二进制运算的，使用二进制可以直接与硬件交互，减少中间步骤，提高存储和读取的速度。因此，在存储器中，数据以二进制的形式存储，数据的读取和写入都非常快速。
不同进制的优化存储：虽然二进制是最基础的进制，但在某些情况下，使用其他进制（如十六进制）可以优化存储空间。例如，十六进制是二进制的简化表示形式，每个十六进制字符可以表示四个二进制位，这使得数据表示更加紧凑。

3.2. 数据传输

在嵌入式系统中，数据常常需要在不同的模块或设备之间进行传输。了解进制转换有助于开发者设计高效的数据传输协议，并确保数据的正确传输。具体来说：

进制转换与数据传输效率：通过选择合适的进制表示方式，可以优化数据传输的效率。例如，十六进制编码常用于网络数据包的表示和传输，因为它可以将二进制数据表示得更加紧凑，减少传输的字符数量。
数据安全性：在加密通信中，不同的进制表示可以用于加密算法和密钥的生成与传输。通过使用不同的进制，可以提高加密算法的复杂性和安全性，从而保护数据免受未授权访问。

3.3. 代码优化

在嵌入式开发中，代码的优化对于提高系统的性能和降低功耗至关重要。了解进制转换有助于开发者编写更加紧凑和高效的代码，减少不必要的资源消耗。具体来说：

减少代码量：通过合理使用进制转换，可以减少代码中的冗余部分，使代码更加简洁明了。例如，在处理二进制数据时，可以直接使用位操作来替代复杂的算术运算，从而减少代码量并提高执行效率。
优化数据结构：在选择数据结构时，可以考虑数据的存储和访问方式。通过选择合适的进制表示方式，可以优化数据结构的存储和访问效率。例如，在嵌入式系统中常用的链表、数组等数据结构，可以通过优化数据的存储顺序和访问方式来提高性能。

3.4. 其他应用

除了上述三个方面外，进制转换在嵌入式开发中还有其他重要的应用：

硬件编程与低级系统操作：在硬件编程和低级系统操作中，十六进制与二进制的转换非常常见。需要熟悉这些进制之间的转换规则，以便能够正确地与硬件进行交互。
硬件配置：在配置寄存器时，常常需要使用十六进制或二进制来设置特定的位。例如，设置一个 GPIO 引脚的输入输出模式，可能需要通过写入特定的十六进制值到寄存器中来实现。
调试与开发：在调试和开发过程中，使用十六进制表示数据可以方便地查看内存和数据结构的内容。这是因为十六进制比二进制更加简洁，同时比十进制更能直观地反映数据的二进制结构。

3.5. 示例代码

以下是一个C语言代码示例，展示进制转换在嵌入式开发中的一些基本应用。请注意，这个示例主要是为了教学目的，实际应用中可能需要更复杂的处理和优化。

#include <stdio.h>
#include <stdint.h>

// 将二进制字符串转换为十进制整数
uint32_t binaryToDecimal(const char *binaryStr) {
    uint32_t decimal = 0;
    while (*binaryStr) {
        decimal = decimal * 2 + (*binaryStr - '0');
        binaryStr++;
    }
    return decimal;
}

// 将十进制整数转换为二进制字符串（静态分配缓冲区，注意溢出风险）
void decimalToBinary(uint32_t decimal, char *binaryStr, size_t bufferSize) {
    binaryStr[bufferSize - 1] = '\0'; // 确保字符串以null结尾
    for (size_t i = bufferSize - 2; i >= 0; i--) {
        binaryStr[i] = (decimal % 2) ? '1' : '0';
        decimal /= 2;
    }
    // 移除前导零（除了最高位可能是0的情况）
    char *start = binaryStr;
    while (*start == '0' && *(start + 1) != '\0') {
        start++;
    }
    if (*start == '\0') { // 如果整个字符串都是0
        binaryStr[0] = '0';
    } else {
        // 将非零部分复制到缓冲区开头
        for (size_t j = 0; j < bufferSize - (start - binaryStr) - 1; j++) {
            binaryStr[j] = start[j];
        }
        binaryStr[bufferSize - (start - binaryStr) - 1] = '\0';
    }
    // 注意：这里为了简化，没有处理缓冲区溢出的情况。在实际应用中，应该添加额外的检查。
}

// 将十六进制字符串转换为十进制整数
uint32_t hexToDecimal(const char *hexStr) {
    uint32_t decimal = 0;
    while (*hexStr) {
        char ch = *hexStr;
        if (ch >= '0' && ch <= '9') {
            decimal = decimal * 16 + (ch - '0');
        } else if (ch >= 'A' && ch <= 'F') {
            decimal = decimal * 16 + (ch - 'A' + 10);
        } else if (ch >= 'a' && ch <= 'f') {
            decimal = decimal * 16 + (ch - 'a' + 10);
        }
        hexStr++;
    }
    return decimal;
}

// 将十进制整数转换为十六进制字符串（静态分配缓冲区，注意溢出风险）
void decimalToHex(uint32_t decimal, char *hexStr, size_t bufferSize) {
    static const char hexDigits[] = "0123456789ABCDEF";
    hexStr[bufferSize - 1] = '\0'; // 确保字符串以null结尾
    for (size_t i = bufferSize - 2; i >= 0; i--) {
        hexStr[i] = hexDigits[decimal % 16];
        decimal /= 16;
    }
    // 反转字符串，因为我们是从后往前填充的
    for (size_t j = 0; j < bufferSize / 2; j++) {
        char temp = hexStr[j];
        hexStr[j] = hexStr[bufferSize - j - 2];
        hexStr[bufferSize - j - 2] = temp;
    }
    // 如果最高位是0（即整个数都是0或者小于16），则需要在前面补0
    if (hexStr[0] == '\0') {
        hexStr[0] = '0';
    }
    // 注意：同样没有处理缓冲区溢出的情况。
}

int main() {
    // 示例使用
    const char *binaryStr = "1101";
    uint32_t decimal = binaryToDecimal(binaryStr);
    printf("Binary %s to Decimal: %u\n", binaryStr, decimal);

    char binaryBuffer[33]; // 32位二进制数 + null终止符
    decimalToBinary(decimal, binaryBuffer, sizeof(binaryBuffer));
    printf("Decimal %u to Binary: %s\n", decimal, binaryBuffer);

    const char *hexStr = "1A3F";
    decimal = hexToDecimal(hexStr);
    printf("Hex %s to Decimal: %u\n", hexStr, decimal);

    char hexBuffer[9]; // 8位十六进制数 + null终止符
    decimalToHex(decimal, hexBuffer, sizeof(hexBuffer));
    printf("Decimal %u to Hex: %s\n", decimal, hexBuffer);

    return 0;
}

decimalToBinary 和 decimalToHex 函数没有处理所有可能的边界情况，特别是当转换结果需要比提供的缓冲区更大时。在实际应用中，应该添加额外的检查来确保不会发生缓冲区溢出。此外，对于嵌入式系统，可能还需要考虑内存使用和性能优化。