嵌入式 C 编程必备(5)：位运算在嵌入式系统开发中的应用

uint16_t data = (temp_int << 14) | (temp_frac << 10) | humidity;

uint16_t temp_int_extracted = (data >> 14) & 0x3FF; // 0x3FF是10位1的二进制数，用于掩码

uint16_t temp_frac_extracted = (data >> 10) & 0xF; // 0xF是4位1的二进制数，用于掩码

uint16_t humidity_extracted = data & 0x3; // 0x3是2位1的二进制数，用于掩码

#define MOTOR_REG_ADDR 0x40  // 电机驱动芯片寄存器地址
#define MOTOR_SPEED_BIT_POS 0  // 转速模式位起始位置
#define MOTOR_DIRECTION_BIT_POS 2  // 转向位位置

// 假设我们有一个函数用于读写寄存器
// uint8_t read_register(uint16_t address);
// void write_register(uint16_t address, uint8_t value);

// 设置电机转速模式和转向的函数
void set_motor_speed_and_direction(uint8_t speed_mode, uint8_t direction) {
    uint8_t reg_value;
    
    // 读取当前寄存器值
    reg_value = read_register(MOTOR_REG_ADDR);
    
    // 清除转速模式和转向位（将它们设置为0）
    // 创建一个掩码，其中转速模式和转向位为0，其他位为1
    uint8_t speed_mask = ~(0x03 << MOTOR_SPEED_BIT_POS);  // 0x03 = 00000011，左移后覆盖0-1位
    uint8_t direction_mask = ~(1 << MOTOR_DIRECTION_BIT_POS);  // 覆盖第2位
    reg_value = (reg_value & speed_mask) & direction_mask;
    
    // 设置新的转速模式和转向位
    // 创建一个值，其中只有转速模式和转向位被设置
    uint8_t new_speed_value = (speed_mode & 0x03) << MOTOR_SPEED_BIT_POS;  // 确保speed_mode为00, 01, 10之一
    uint8_t new_direction_value = (direction & 0x01) << MOTOR_DIRECTION_BIT_POS;  // 确保direction为0或1
    reg_value = (reg_value | new_speed_value) | new_direction_value;
    
    // 写入新的寄存器值
    write_register(MOTOR_REG_ADDR, reg_value);
}

// 示例：将电机设置为高速正转
void motor_high_speed_forward() {
    set_motor_speed_and_direction(0x02, 0x00);  // 0x02表示高速模式，0x00表示正转
}

// 示例：将电机设置为中速反转
void motor_medium_speed_reverse() {
    set_motor_speed_and_direction(0x01, 0x01);  // 0x01表示中速模式，0x01表示反转
}

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

// 示例：将数据打包并添加异或校验位
uint8_t pack_data_with_xor_checksum(uint8_t data1, uint8_t data2, uint8_t data3) {
    uint8_t packed_data[3] = {data1, data2, data3};
    uint8_t checksum = 0;

    // 计算异或校验位
    for (int i = 0; i < 3; i++) {
        checksum ^= packed_data[i];
    }

    // 假设我们在这里使用第4个字节作为校验位（实际应用中可能打包成更大的帧）
    uint8_t frame[4] = {packed_data[0], packed_data[1], packed_data[2], checksum};

    // 这里只是打印输出，实际情况下可能会通过SPI接口发送
    for (int i = 0; i < 4; i++) {
        printf("%02X ", frame[i]);
    }
    printf("\n");

    // 为了简单起见，这里只返回校验位（实际应用中可能返回整个帧）
    return checksum;
}

int main() {
    uint8_t data1 = 0xAA;
    uint8_t data2 = 0xBB;
    uint8_t data3 = 0xCC;
    pack_data_with_xor_checksum(data1, data2, data3);
    return 0;
}

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

// 示例：接收数据并验证异或校验位
bool verify_xor_checksum(uint8_t *frame, size_t length) {
    uint8_t received_checksum = frame[length - 1];
    uint8_t calculated_checksum = 0;

    // 计算异或校验位
    for (size_t i = 0; i < length - 1; i++) {
        calculated_checksum ^= frame[i];
    }

    // 验证校验位
    return (received_checksum == calculated_checksum);
}

int main() {
    uint8_t received_frame[4] = {0xAA, 0xBB, 0xCC, 0x0F}; // 假设0x0F是接收到的校验位

    if (verify_xor_checksum(received_frame, 4)) {
        printf("Data received correctly.\n");
    } else {
        printf("Data error detected.\n");
    }

    return 0;
}

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

// 示例：使用位掩码筛选CAN消息标识符
bool is_message_for_me(uint32_t message_id, uint32_t my_id_mask, uint32_t my_id_value) {
    // 使用位掩码屏蔽不关心的位
    uint32_t filtered_id = message_id & my_id_mask;

    // 检查是否匹配我的ID
    return (filtered_id == my_id_value);
}

int main() {
    uint32_t message_id = 0x12345678; // 示例消息ID
    uint32_t my_id_mask = 0xFFFFFF00; // 假设我们只关心高8位
    uint32_t my_id_value = 0x12000000; // 假设我们的ID是高8位为0x12

    if (is_message_for_me(message_id, my_id_mask, my_id_value)) {
        printf("Message is for me.\n");
    } else {
        printf("Message is not for me.\n");
    }

    return 0;
}

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

// 假设我们有8个硬件模块，每个模块都有一个对应的电源状态位
#define NUM_MODULES 8
#define MODULE_POWER_STATE_REG 0x01  // 假设状态寄存器地址（仅为示例）

// 模拟写入状态寄存器（在实际硬件中，这将通过特定的IO操作完成）
void write_power_state_reg(uint8_t value) {
    // 在实际硬件中，这里应该写入到实际的寄存器地址
    // 例如：*(volatile uint8_t *)MODULE_POWER_STATE_REG = value;
    printf("Writing power state register: 0x%02X\n", value);
}

// 模拟读取状态寄存器（在实际硬件中，这将通过特定的IO操作完成）
uint8_t read_power_state_reg(void) {
    // 在实际硬件中，这里应该从实际的寄存器地址读取
    // 例如：return *(volatile uint8_t *)MODULE_POWER_STATE_REG;
    return 0x00; // 仅为示例，返回全0表示所有模块均休眠
}

// 设置指定模块的电源状态
void set_module_power_state(int module_index, bool power_on) {
    uint8_t current_state = read_power_state_reg();
    if (power_on) {
        current_state |= (1 << module_index); // 使用位或运算开启模块电源
    } else {
        current_state &= ~(1 << module_index); // 使用位与和位非运算关闭模块电源
    }
    write_power_state_reg(current_state);
}

// 检查指定模块是否已开启
bool is_module_powered_on(int module_index) {
    uint8_t current_state = read_power_state_reg();
    return (current_state & (1 << module_index)) != 0;
}

// 示例：使用位运算进行数据运算处理（此处以简单的位计数为例）
int bit_count(uint8_t value) {
    int count = 0;
    while (value) {
        count += value & 1; // 检查最低位是否为1
        value >>= 1;        // 右移一位继续检查
    }
    return count;
}

int main(void) {
    // 示例：设置模块0和模块3的电源为开启状态
    set_module_power_state(0, true);
    set_module_power_state(3, true);

    // 示例：检查模块状态
    for (int i = 0; i < NUM_MODULES; i++) {
        printf("Module %d is powered %s\n", i, is_module_powered_on(i) ? "on" : "off");
    }

    // 示例：使用位运算进行数据处理（此处仅为演示，实际可能更复杂）
    uint8_t data = 0b10101100; // 示例数据
    int count = bit_count(data);
    printf("Number of set bits in data: %d\n", count);

    // 在实际应用中，这里可能会包含更多的逻辑来处理休眠、唤醒和数据运算等任务
    return 0;
}

a = a ^ b;
b = a ^ b; // 相当于 b = (a ^ b) ^ b = a
a = a ^ b; // 相当于 a = (a ^ b) ^ a = b（因为此时b已经是原来的a）

#include <stdio.h>

// 计算2的幂次
unsigned int power_of_two(int n) {
    return 1 << n; // 左移操作计算2的幂次
}

// 交换两个变量的值（不使用临时变量）
void swap(int *a, int *b) {
    if (a != b) { // 防止指针相同导致的无效操作
        *a = *a ^ *b;
        *b = *a ^ *b;
        *a = *a ^ *b;
    }
}

// 快速乘法（乘数为2的幂次）
int fast_multiply(int a, int power) {
    // 假设power是2的幂次，且已经通过某种方式验证或保证
    return a << (power - 1); // 例如，power为3时，计算a*2^2，即a*4
}

// 快速除法（除以2的幂次）
int fast_divide(int a, int power) {
    // 假设power是2的幂次，且已经通过某种方式验证或保证
    return a >> (power - 1); // 例如，power为3时，计算a/2^2，即a/4
}

// 紧凑存储示例：使用位字段存储一组布尔值
typedef struct {
    unsigned int flag1 : 1;
    unsigned int flag2 : 1;
    unsigned int flag3 : 1;
    unsigned int flag4 : 1;
    // 可以继续添加更多标志位
} BitFlags;

int main() {
    // 计算2的幂次示例
    int n = 5;
    printf("2^%d = %u\n", n, power_of_two(n));

    // 交换变量值示例
    int x = 10, y = 20;
    printf("Before swap: x = %d, y = %d\n", x, y);
    swap(&x, &y);
    printf("After swap: x = %d, y = %d\n", x, y);

    // 快速乘法示例
    int a = 7;
    int power = 3; // 2的幂次，这里为2^2=4
    printf("%d * 2^%d = %d\n", a, power - 1, fast_multiply(a, power));

    // 快速除法示例
    int b = 32;
    printf("%d / 2^%d = %d\n", b, power - 1, fast_divide(b, power));

    // 紧凑存储示例
    BitFlags flags;
    flags.flag1 = 1;
    flags.flag2 = 0;
    flags.flag3 = 1;
    flags.flag4 = 0;

    printf("BitFlags: flag1 = %u, flag2 = %u, flag3 = %u, flag4 = %u\n",
           flags.flag1, flags.flag2, flags.flag3, flags.flag4);

    return 0;
}

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

// 假设温度传感器ADC转换后的数据范围为0-255，使用uint8_t存储
typedef uint8_t temp_sensor_data_t;

// 假设系统有4个温控设备，每个设备用一个位来表示其状态（0：关闭，1：开启）
#define NUM_DEVICES 4
typedef uint8_t device_status_t;

// 模拟温度传感器读数（在实际应用中，这将通过ADC接口获取）
temp_sensor_data_t read_temperature_sensor(void) {
    // 此处返回模拟温度读数，实际应用中应替换为真实的ADC读取函数
    return 128; // 假设当前温度为128（仅为示例）
}

// 使用位运算压缩存储温度数据（此处为简化示例，实际上可能不需要压缩）
// 但假设我们需要将温度数据与其他信息打包传输
uint16_t pack_temperature_data(temp_sensor_data_t temp, device_status_t status) {
    // 将温度数据放在高8位，设备状态放在低4位（假设只需4位即可表示所有设备状态）
    return ((uint16_t)temp << 8) | (status & ((1 << NUM_DEVICES) - 1));
}

// 解包温度数据和设备状态
void unpack_temperature_data(uint16_t packed_data, temp_sensor_data_t *temp, device_status_t *status) {
    *temp = (packed_data >> 8) & 0xFF; // 提取高8位作为温度数据
    *status = packed_data & ((1 << NUM_DEVICES) - 1); // 提取低4位作为设备状态
}

// 模拟设置设备状态（在实际应用中，这将通过GPIO或I2C等接口与继电器控制板通信）
void set_device_status(device_status_t new_status) {
    // 此处仅为模拟，实际应用中应替换为真实的设备控制函数
    printf("Setting device status to: 0x%02X\n", new_status);
}

// 根据温度阈值控制设备（简化示例，未考虑实际温控逻辑）
void control_devices_based_on_temperature(temp_sensor_data_t current_temp, temp_sensor_data_t threshold) {
    device_status_t new_status = 0;
    
    // 假设温度高于阈值则开启设备0（制冷），低于阈值则开启设备1（加热）
    // 注意：此逻辑仅为示例，实际应用中需根据具体需求设计
    if (current_temp > threshold) {
        new_status |= (1 << 0); // 开启设备0
    } else {
        new_status |= (1 << 1); // 开启设备1
    }
    
    set_device_status(new_status);
}

int main(void) {
    temp_sensor_data_t current_temp;
    device_status_t device_status;
    uint16_t packed_data;
    
    // 读取当前温度
    current_temp = read_temperature_sensor();
    printf("Current temperature: %d\n", current_temp);
    
    // 假设温度阈值为150
    temp_sensor_data_t threshold = 150;
    
    // 根据温度阈值控制设备
    control_devices_based_on_temperature(current_temp, threshold);
    
    // 假设当前设备状态为控制后的状态（实际应用中应从设备获取或维护状态）
    device_status = (1 << 0) | (1 << 2); // 假设设备0和设备2已开启（仅为示例）
    
    // 打包温度数据和设备状态
    packed_data = pack_temperature_data(current_temp, device_status);
    printf("Packed data for transmission: 0x%04X\n", packed_data);
    
    // 解包以验证（在实际应用中，解包通常在接收端进行）
    unpack_temperature_data(packed_data, &current_temp, &device_status);
    printf("Unpacked temperature: %d, Device status: 0x%02X\n", current_temp, device_status);
    
    // 注意：在实际应用中，打包后的数据将通过网络发送到智能网关或云端
    
    return 0;
}