C语言计算crc32的源码

CRC（Cyclic Redundancy Check，循环冗余校验）是一种常用的错误检测技术，C语言中可以使用标准库函数来计算CRC32值，比如`crc32()`函数。但是如果你想要自定义实现，这里是一个简单的CRC32算法的基本步骤：

#include <stdlib.h>

uint32_t crc32(uint32_t initial_crc, const uint8_t* buffer, size_t length) {
    static const uint32_t crc_table[256] = ...; // 这里需要预先填充好CRC表，一般通过多项式生成
    for (size_t i = 0; i < length; i++) {
        uint32_t index = (initial_crc ^ buffer[i]) & 0xff;
        initial_crc = (initial_crc >> 8) ^ crc_table[index];
    }
    return ~initial_crc + 1; // 取反加1得到最终结果，因为大多数库函数返回的是补码形式
}

其中，`crc_table`是用于查找表，你需要先根据CRC32算法的系数生成这个表。实际应用中，你可以使用如Zlib库提供的预计算好的CRC32表。

相关问题

4位crc计算源码 c语言版

以下是一个用C语言编写的4位CRC计算源码：

#include <stdio.h>

unsigned int crc4(unsigned char *data, unsigned int length)
{
    unsigned int crc = 0;
    int i, j;

    for (i = 0; i < length; i++)
    {
        crc ^= data[i];
        for (j = 0; j < 4; j++)
        {
            if ((crc & 0x08) != 0)
                crc = (crc << 1) ^ 0x03;
            else
                crc = crc << 1;
        }
    }

    return crc;
}

int main()
{
    unsigned char data[] = {0x01, 0x02, 0x03};
    unsigned int crc = crc4(data, sizeof(data) / sizeof(data[0]));

    printf("CRC: 0x%02X\n", crc);

    return 0;
}

这个4位CRC计算源码假定输入的数据是一个unsigned char类型的数组指针和数据长度。crc4函数使用标准的4位CRC算法来计算CRC校验值。函数首先初始化crc值为0，然后依次对每个数据字节进行计算。

在计算过程中，crc值与当前数据字节进行异或运算。然后，对crc值进行四次迭代，每次迭代检查当前crc值的最高位是否为1。如果最高位为1，则将crc值左移一位并执行一个异或运算（使用多项式0x03），否则仅将crc值左移一位。

最终crc值即为计算得到的CRC校验值。

在main函数中，我们定义一个unsigned char类型的数据数组并初始化它。然后调用crc4函数计算CRC校验值，并将结果打印到控制台上。

c语言modbus rtu协议源码

以下是一个简单的C语言Modbus RTU协议源码示例：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>
#include <termios.h>
#include <unistd.h>

#define DEVICE "/dev/ttyUSB0"
#define BAUDRATE B9600
#define SLAVE_ADDR 1

int fd;

void modbus_send(unsigned char *buf, int len)
{
    write(fd, buf, len);
}

int modbus_recv(unsigned char *buf, int max_len)
{
    int n = read(fd, buf, max_len);
    if (n < 0) {
        perror("read");
        exit(1);
    }
    return n;
}

int modbus_crc(unsigned char *buf, int len)
{
    unsigned short crc = 0xFFFF;
    for (int i = 0; i < len; i++) {
        crc ^= buf[i];
        for (int j = 0; j < 8; j++) {
            if (crc & 0x0001) {
                crc >>= 1;
                crc ^= 0xA001;
            } else {
                crc >>= 1;
            }
        }
    }
    return crc;
}

void modbus_read_input_registers(int addr, int reg, int count, unsigned char *buf)
{
    unsigned char req[] = {SLAVE_ADDR, 0x04, reg >> 8, reg & 0xFF, count >> 8, count & 0xFF};
    int req_len = sizeof(req);
    unsigned short crc = modbus_crc(req, req_len);
    unsigned char req_buf[256];
    memcpy(req_buf, req, req_len);
    req_buf[req_len] = crc & 0xFF;
    req_buf[req_len + 1] = crc >> 8;
    int req_buf_len = req_len + 2;
    modbus_send(req_buf, req_buf_len);

    int res_len = 5 + 2 * count;
    unsigned char res_buf[256];
    modbus_recv(res_buf, res_len);

    if (res_buf[0] != SLAVE_ADDR || res_buf[1] != 0x04 || res_buf[2] != res_len - 5) {
        printf("Error: invalid response\n");
        exit(1);
    }

    unsigned short crc1 = modbus_crc(res_buf, res_len - 2);
    unsigned short crc2 = res_buf[res_len - 2] | (res_buf[res_len - 1] << 8);
    if (crc1 != crc2) {
        printf("Error: CRC mismatch\n");
        exit(1);
    }

    memcpy(buf, res_buf + 3, 2 * count);
}

int main()
{
    fd = open(DEVICE, O_RDWR | O_NOCTTY);
    if (fd < 0) {
        perror(DEVICE);
        exit(1);
    }

    struct termios tty;
    memset(&tty, 0, sizeof(tty));
    if (tcgetattr(fd, &tty) < 0) {
        perror("tcgetattr");
        exit(1);
    }
    cfsetospeed(&tty, BAUDRATE);
    cfsetispeed(&tty, BAUDRATE);
    tty.c_cflag |= (CLOCAL | CREAD);
    tty.c_cflag &= ~CSIZE;
    tty.c_cflag |= CS8;
    tty.c_cflag &= ~PARENB;
    tty.c_cflag &= ~CSTOPB;
    tty.c_cflag &= ~CRTSCTS;
    tty.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);
    tty.c_iflag &= ~(IXON | IXOFF | IXANY);
    tty.c_iflag &= ~(INLCR | ICRNL | IGNCR);
    tty.c_oflag &= ~(ONLCR | OCRNL);
    if (tcsetattr(fd, TCSANOW, &tty) < 0) {
        perror("tcsetattr");
        exit(1);
    }

    unsigned char buf[256];
    modbus_read_input_registers(SLAVE_ADDR, 0x1000, 10, buf);
    for (int i = 0; i < 10; i++) {
        unsigned short val = (buf[i * 2] << 8) | buf[i * 2 + 1];
        printf("Reg[%d] = %d\n", i, val);
    }

    close(fd);
    return 0;
}

该示例使用Linux系统的串行端口驱动程序读取Modbus RTU从设备的输入寄存器。它使用了基本的Modbus RTU帧格式，并计算帧的CRC校验码。注意，该示例仅作为参考，实际应用中还需要进行更多的错误检查和处理。