单片机通信技术：串口、SPI、I2C等常用通信接口的应用与调试

时光旅者 2020-08-30 ⋅ 20 阅读

单片机通信技术在现代嵌入式系统中起着至关重要的作用。通过可靠的通信接口，单片机可以与外部设备进行数据传输和交互。本文将重点介绍串口、SPI和I2C等常用通信接口的应用与调试方法。

串口通信

串口通信是一种广泛应用于单片机系统中的通信方式。通常使用UART（通用异步收发传输）协议进行数据传输。相比于其他通信接口，串口通信拥有易用、低成本和广泛兼容性的优势。

应用场景

串口通信常用于以下应用场景：

  1. 连接计算机：通过串口与计算机进行通信，实现数据的传输和控制指令的下发；
  2. 与其他设备通信：通过串口与其他外设（如传感器、无线模块等）进行通信，实现数据的采集和控制；
  3. 远程调试：使用串口作为调试接口，输出程序运行状态、调试信息等。

调试方法

为了成功进行串口通信，我们需要正确配置芯片的串口参数。常见的串口参数包括波特率、数据位、校验位和停止位等。以下是一个示例代码，展示了如何配置并使用串口进行数据的发送和接收。

// 引入串口库
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <termios.h>

// 打开串口
int open_serial(const char *device)
{
    int fd = open(device, O_RDWR | O_NOCTTY | O_NDELAY);
    if (fd == -1)
    {
        perror("open_serial: Unable to open serial port");
        return -1;
    }

    struct termios options;
    tcgetattr(fd, &options);
    cfmakeraw(&options);
    cfsetispeed(&options, B115200);
    cfsetospeed(&options, B115200);

    options.c_cflag |= (CLOCAL | CREAD);
    options.c_cflag &= ~PARENB;
    options.c_cflag &= ~CSTOPB;
    options.c_cflag &= ~CSIZE;
    options.c_cflag |= CS8;

    tcsetattr(fd, TCSANOW, &options);
    return fd;
}

// 发送数据
int write_serial(int fd, const uint8_t *data, size_t len)
{
    ssize_t ret = write(fd, data, len);
    if (ret != len)
    {
        perror("write_serial: Failed to write data");
        return -1;
    }
    return ret;
}

// 读取数据
int read_serial(int fd, uint8_t *data, size_t len)
{
    ssize_t ret = read(fd, data, len);
    if (ret == -1)
    {
        perror("read_serial: Failed to read data");
        return -1;
    }
    return ret;
}

int main()
{
    const char *device = "/dev/ttyS0";
    int fd = open_serial(device);
    if (fd == -1)
    {
        return -1;
    }

    // 发送数据
    uint8_t tx_data[] = "Hello, serial communication!";
    size_t tx_len = sizeof(tx_data) - 1;  // 减1是为了去除字符串末尾的'\0'
    write_serial(fd, tx_data, tx_len);

    // 读取数据
    uint8_t rx_data[256];
    size_t rx_len = read_serial(fd, rx_data, sizeof(rx_data));
    if (rx_len != -1)
    {
        printf("Received data: %.*s\n", (int)rx_len, rx_data);
    }

    // 关闭串口
    close(fd);
    return 0;
}

SPI通信

SPI（串行外设接口）是一种高速的全双工同步串行通信接口。它可以支持多个外设与单片机之间进行数据传输，并且具有较高的传输速度和灵活性。

应用场景

SPI通信常用于以下应用场景：

  1. 连接存储器：通过SPI接口连接Flash存储器，实现数据的读写操作；
  2. 驱动显示屏：通过SPI接口驱动液晶显示屏，实现图形和字符的显示；
  3. 连接传感器：通过SPI接口与传感器进行通信，实现数据的采集和控制。

调试方法

为了成功进行SPI通信，我们需要正确配置芯片的SPI参数。常见的SPI参数包括时钟频率、数据位、传输模式和硬件连接方式等。以下是一个示例代码，展示了如何配置并使用SPI进行数据的读写操作。

// 引入SPI库
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <linux/spi/spidev.h>

// 打开SPI设备
int open_spi(const char *device, uint8_t mode, uint32_t speed)
{
    int fd = open(device, O_RDWR);
    if (fd == -1)
    {
        perror("open_spi: Unable to open SPI device");
        return -1;
    }

    int ret;
    uint8_t bits = 8;
    ret = ioctl(fd, SPI_IOC_WR_MODE, &mode);
    if (ret == -1)
    {
        perror("open_spi: Failed to set SPI write mode");
        return -1;
    }
    ret = ioctl(fd, SPI_IOC_RD_MODE, &mode);
    if (ret == -1)
    {
        perror("open_spi: Failed to set SPI read mode");
        return -1;
    }

    ret = ioctl(fd, SPI_IOC_WR_BITS_PER_WORD, &bits);
    if (ret == -1)
    {
        perror("open_spi: Failed to set SPI write bits per word");
        return -1;
    }
    ret = ioctl(fd, SPI_IOC_RD_BITS_PER_WORD, &bits);
    if (ret == -1)
    {
        perror("open_spi: Failed to set SPI read bits per word");
        return -1;
    }

    ret = ioctl(fd, SPI_IOC_WR_MAX_SPEED_HZ, &speed);
    if (ret == -1)
    {
        perror("open_spi: Failed to set SPI write max speed");
        return -1;
    }
    ret = ioctl(fd, SPI_IOC_RD_MAX_SPEED_HZ, &speed);
    if (ret == -1)
    {
        perror("open_spi: Failed to set SPI read max speed");
        return -1;
    }

    return fd;
}

// 发送和接收数据
int transfer_spi(int fd, uint8_t *tx_data, uint8_t *rx_data, size_t len)
{
    struct spi_ioc_transfer tr = {
        .tx_buf = (unsigned long)tx_data,
        .rx_buf = (unsigned long)rx_data,
        .len = len,
        .delay_usecs = 0,
        .speed_hz = 1000000,
        .bits_per_word = 8,
    };

    int ret = ioctl(fd, SPI_IOC_MESSAGE(1), &tr);
    if (ret == -1)
    {
        perror("transfer_spi: SPI transfer error");
        return -1;
    }
    return ret;
}

int main()
{
    const char *device = "/dev/spidev0.0";
    uint8_t mode = SPI_MODE_0;
    uint32_t speed = 1000000;

    int fd = open_spi(device, mode, speed);
    if (fd == -1)
    {
        return -1;
    }

    // 发送和接收数据
    uint8_t tx_data[] = {0xAA, 0xBB, 0xCC, 0xDD};
    uint8_t rx_data[sizeof(tx_data)];
    size_t len = sizeof(tx_data);
    transfer_spi(fd, tx_data, rx_data, len);

    // 处理接收到的数据
    for (size_t i = 0; i < len; i++)
    {
        printf("Received data: 0x%02X\n", rx_data[i]);
    }

    // 关闭SPI设备
    close(fd);
    return 0;
}

I2C通信

I2C（Inter-Integrated Circuit）是一种串行通信总线，支持多个设备之间进行数据传输和控制指令的下发。它具有较低的电气层和物理大小开销，并且可以通过软件进行地址和数据寻址。

应用场景

I2C通信常用于以下应用场景：

  1. 连接传感器：通过I2C总线连接各种传感器（如温度传感器、加速度传感器等），实现数据的采集和控制；
  2. 驱动显示屏：通过I2C总线驱动液晶显示屏，实现图形和字符的显示；
  3. 扩展IO：通过I2C总线扩展IO端口，实现输入和输出的扩展。

调试方法

为了成功进行I2C通信，我们需要正确配置芯片的I2C参数，例如时钟频率和设备地址等。以下是一个示例代码，展示了如何配置并使用I2C进行数据的读写操作。

// 引入I2C库
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <linux/i2c-dev.h>

// 打开I2C设备
int open_i2c(const char *device)
{
    int fd = open(device, O_RDWR);
    if (fd == -1)
    {
        perror("open_i2c: Unable to open I2C device");
        return -1;
    }
    return fd;
}

// 发送数据
int write_i2c(int fd, uint8_t address, uint8_t *data, size_t len)
{
    if (ioctl(fd, I2C_SLAVE, address) == -1)
    {
        perror("write_i2c: Unable to set I2C device slave address");
        return -1;
    }

    ssize_t ret = write(fd, data, len);
    if (ret != len)
    {
        perror("write_i2c: Failed to write data");
        return -1;
    }
    return ret;
}

// 接收数据
int read_i2c(int fd, uint8_t address, uint8_t *data, size_t len)
{
    if (ioctl(fd, I2C_SLAVE, address) == -1)
    {
        perror("read_i2c: Unable to set I2C device slave address");
        return -1;
    }

    ssize_t ret = read(fd, data, len);
    if (ret != len)
    {
        perror("read_i2c: Failed to read data");
        return -1;
    }
    return ret;
}

int main()
{
    const char *device = "/dev/i2c-0";
    uint8_t address = 0x50;

    int fd = open_i2c(device);
    if (fd == -1)
    {
        return -1;
    }

    // 发送数据
    uint8_t tx_data[] = {0xAA, 0xBB, 0xCC, 0xDD};
    size_t tx_len = sizeof(tx_data);
    write_i2c(fd, address, tx_data, tx_len);

    // 接收数据
    uint8_t rx_data[sizeof(tx_data)];
    size_t rx_len = read_i2c(fd, address, rx_data, sizeof(rx_data));
    if (rx_len != -1)
    {
        printf("Received data: ");
        for (size_t i = 0; i < rx_len; i++)
        {
            printf("0x%02X ", rx_data[i]);
        }
        printf("\n");
    }

    // 关闭I2C设备
    close(fd);
    return 0;
}

总结

本文介绍了单片机通信技术中的串口、SPI和I2C等常用通信接口的应用与调试方法。通过灵活使用这些通信接口，我们可以实现与外部设备的通信和数据交换，从而构建功能丰富的嵌入式系统。希望本文对您的单片机通信技术学习和应用提供帮助。


本文来自极简博客，作者：时光旅者，转载请注明原文链接：单片机通信技术：串口、SPI、I2C等常用通信接口的应用与调试

#单片机通信技术
阅读全部

全部评论: 0 条

    我有话说: