LoRaWAN网关源码分析（SPI篇）

于 2024-06-28 12:57:36 发布
阅读量919 收藏 8
点赞数 29
分类专栏： LoRaWAN源码 文章标签： LoRaWAN 源码分析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_65292176/article/details/140035530
版权

目录

一、前言

二、lgw_spi_open函数

三、lgw_spi_w函数

四、lgw_spi_r函数

五、lgw_spi_wb函数

六、lgw_spi_rb函数

一、前言

        本篇文章整理了LoRaWAN网关如何处理与 LoRa 前端设备之间的 SPI通信（在loralgw_spi.c文件中）。对SPI协议不了解的可以看这篇文章---《SPI总线协议》。

二、lgw_spi_open函数

        该函数通常用于初始化 SPI 接口并准备与 LoRa 网关的前端设备进行通信。我们需要打开指定的 SPI 设备文件，并配置必要的 SPI 参数（如模式、速度等）。

主要流程：

1、打开SPI设备文件

spi_fd = open(SPI_DEVICE, O_RDWR);
  • 调用 open 函数以读写模式 (O_RDWR) 打开指定的 SPI 设备文件（如 /dev/spidev0.0）。
  • 如果打开失败，open 将返回 -1，并且 spi_fd 将保持为 -1。
  • 错误处理：如果 open 失败，调用 perror 打印错误信息，然后返回 -1。

2、设置SPI模式

ret = ioctl(spi_fd, SPI_IOC_WR_MODE, &SPI_MODE);
  • 使用 ioctl 函数将 SPI 模式设置为指定的模式（这里是模式 0）。
  • SPI_MODE 变量的值决定了时钟相位和极性。
  • 错误处理：如果 ioctl 失败，调用 perror 打印错误信息，关闭 SPI 设备文件并返回 -1。

3、设置每个传输字的位数

ret = ioctl(spi_fd, SPI_IOC_WR_BITS_PER_WORD, &SPI_BITS);
  • 使用 ioctl 函数设置每个 SPI 传输字的位数（这里是 8 位）。
  • 错误处理：如果 ioctl 失败，调用 perror 打印错误信息，关闭 SPI 设备文件并返回 -1。

4、设置SPI总线速度

ret = ioctl(spi_fd, SPI_IOC_WR_MAX_SPEED_HZ, &SPI_SPEED);
  • 使用 ioctl 函数设置 SPI 总线的最大速度（这里是 500 kHz）。
  • 错误处理：如果 ioctl 失败，调用 perror 打印错误信息，关闭 SPI 设备文件并返回 -1。

5、返回0表示成功

         如果所有设置都成功，函数返回 0 表示 SPI 初始化成功。

int lgw_spi_open(const char * com_path, void **com_target_ptr) {
    int *spi_device = NULL;
    int dev;
    int a=0, b=0;
    int i;

    /* check input variables */
    CHECK_NULL(com_path);
    CHECK_NULL(com_target_ptr);

    /* allocate memory for the device descriptor */
    spi_device = malloc(sizeof(int));
    if (spi_device == NULL) {
        DEBUG_MSG("ERROR: MALLOC FAIL\n");
        return LGW_SPI_ERROR;
    }

    /* open SPI device */
    dev = open(com_path, O_RDWR);
    if (dev < 0) {
        DEBUG_PRINTF("ERROR: failed to open SPI device %s\n", com_path);
        return LGW_SPI_ERROR;
    }

    /* setting SPI mode to 'mode 0' */
    i = SPI_MODE_0;
    a = ioctl(dev, SPI_IOC_WR_MODE, &i);
    b = ioctl(dev, SPI_IOC_RD_MODE, &i);
    if ((a < 0) || (b < 0)) {
        DEBUG_MSG("ERROR: SPI PORT FAIL TO SET IN MODE 0\n");
        close(dev);
        free(spi_device);
        return LGW_SPI_ERROR;
    }

    /* setting SPI max clk (in Hz) */
    i = SPI_SPEED;
    a = ioctl(dev, SPI_IOC_WR_MAX_SPEED_HZ, &i);
    b = ioctl(dev, SPI_IOC_RD_MAX_SPEED_HZ, &i);
    if ((a < 0) || (b < 0)) {
        DEBUG_MSG("ERROR: SPI PORT FAIL TO SET MAX SPEED\n");
        close(dev);
        free(spi_device);
        return LGW_SPI_ERROR;
    }

    /* setting SPI to MSB first */
    i = 0;
    a = ioctl(dev, SPI_IOC_WR_LSB_FIRST, &i);
    b = ioctl(dev, SPI_IOC_RD_LSB_FIRST, &i);
    if ((a < 0) || (b < 0)) {
        DEBUG_MSG("ERROR: SPI PORT FAIL TO SET MSB FIRST\n");
        close(dev);
        free(spi_device);
        return LGW_SPI_ERROR;
    }

    /* setting SPI to 8 bits per word */
    i = 0;
    a = ioctl(dev, SPI_IOC_WR_BITS_PER_WORD, &i);
    b = ioctl(dev, SPI_IOC_RD_BITS_PER_WORD, &i);
    if ((a < 0) || (b < 0)) {
        DEBUG_MSG("ERROR: SPI PORT FAIL TO SET 8 BITS-PER-WORD\n");
        close(dev);
        return LGW_SPI_ERROR;
    }

    *spi_device = dev;
    *com_target_ptr = (void *)spi_device;
    DEBUG_MSG("Note: SPI port opened and configured ok\n");
    return LGW_SPI_SUCCESS;
}

        相对应的，竟然要打开，就要关闭，关闭相应的SPI文件我们要使用lgw_spi_close函数，代码如下：

int lgw_spi_close(void *com_target) {
    int spi_device;
    int a;

    /* check input variables */
    CHECK_NULL(com_target);

    /* close file & deallocate file descriptor */
    spi_device = *(int *)com_target; /* must check that spi_target is not null beforehand */
    a = close(spi_device);
    free(com_target);

    /* determine return code */
    if (a < 0) {
        DEBUG_MSG("ERROR: SPI PORT FAILED TO CLOSE\n");
        return LGW_SPI_ERROR;
    } else {
        DEBUG_MSG("Note: SPI port closed\n");
        return LGW_SPI_SUCCESS;
    }
}

三、lgw_spi_w函数

        该函数通过 SPI 接口向指定的目标设备（由 spi_mux_target 标识）写入一个字节的数据到指定的寄存器地址。

主要流程：

1、获取SPI设备文件描述符

spi_device = *(int *)com_target;

        将 com_target 解释为指向 int 的指针，并解引用以获取 SPI 设备文件描述符。

2、准备要发送的帧

out_buf[0] = spi_mux_target;
out_buf[1] = WRITE_ACCESS | ((address >> 8) & 0x7F);
out_buf[2] =                ((address >> 0) & 0xFF);
out_buf[3] = data;
command_size = 4;
  • 构建要发送的 SPI 帧：
    • out_buf[0]：目标设备选择（SPI 多路复用目标）。
    • out_buf[1]：写访问标志和地址的高位（写命令）。
    • out_buf[2]：地址的低位。
    • out_buf[3]：要写入的数据字节。
  • command_size：设置为 4，表示总共发送 4 个字节。

3、准备I/O传输结构体

memset(&k, 0, sizeof(k));
k.tx_buf = (unsigned long) out_buf;
k.len = command_size;
k.speed_hz = SPI_SPEED;
k.cs_change = 0;
k.bits_per_word = 8;

4、执行I/O传输

a = ioctl(spi_device, SPI_IOC_MESSAGE(1), &k);

5、判断返回值并处理错误

if (a != (int)k.len) {
    DEBUG_MSG("ERROR: SPI WRITE FAILURE\n");
    return LGW_SPI_ERROR;
} else {
    DEBUG_MSG("Note: SPI write success\n");
    return LGW_SPI_SUCCESS;
}

int lgw_spi_w(void *com_target, uint8_t spi_mux_target, uint16_t address, uint8_t data) {
    int spi_device;
    uint8_t out_buf[4];
    uint8_t command_size;
    struct spi_ioc_transfer k;
    int a;

    /* check input variables */
    CHECK_NULL(com_target);

    spi_device = *(int *)com_target; /* must check that spi_target is not null beforehand */

    /* prepare frame to be sent */
    out_buf[0] = spi_mux_target;
    out_buf[1] = WRITE_ACCESS | ((address >> 8) & 0x7F);
    out_buf[2] =                ((address >> 0) & 0xFF);
    out_buf[3] = data;
    command_size = 4;

    /* I/O transaction */
    memset(&k, 0, sizeof(k)); /* clear k */
    k.tx_buf = (unsigned long) out_buf;
    k.len = command_size;
    k.speed_hz = SPI_SPEED;
    k.cs_change = 0;
    k.bits_per_word = 8;
    a = ioctl(spi_device, SPI_IOC_MESSAGE(1), &k);

    /* determine return code */
    if (a != (int)k.len) {
        DEBUG_MSG("ERROR: SPI WRITE FAILURE\n");
        return LGW_SPI_ERROR;
    } else {
        DEBUG_MSG("Note: SPI write success\n");
        return LGW_SPI_SUCCESS;
    }
}

四、lgw_spi_r函数

        该函数通过 SPI 接口从指定的目标设备（由 spi_mux_target 标识）的指定寄存器地址读取一个字节的数据。

主要流程：

1、获取SPI设备文件描述符

spi_device = *(int *)com_target;

        将 com_target 解释为指向 int 的指针，并解引用以获取 SPI 设备文件描述符。

2、准备要发送的帧

out_buf[0] = spi_mux_target;
out_buf[1] = READ_ACCESS | ((address >> 8) & 0x7F);
out_buf[2] = ((address >> 0) & 0xFF);
out_buf[3] = 0x00;
out_buf[4] = 0x00;
command_size = 5;
  • out_buf[0]：目标设备选择（SPI 多路复用目标）。
  • out_buf[1]：读访问标志和地址的高位（读命令）。
  • out_buf[2]：地址的低位。
  • out_buf[3] 和 out_buf[4]：填充字节，用于接收数据时的占位符。

3、准备I/O传输结构体

memset(&k, 0, sizeof(k)); /* 清空 k */
k.tx_buf = (unsigned long) out_buf;
k.rx_buf = (unsigned long) in_buf;
k.len = command_size;
k.cs_change = 0;

4、执行I/O传输

a = ioctl(spi_device, SPI_IOC_MESSAGE(1), &k);

5、判断返回值并处理错误

if (a != (int)k.len) {
    DEBUG_MSG("ERROR: SPI READ FAILURE\n");
    return LGW_SPI_ERROR;
} else {
    DEBUG_MSG("Note: SPI read success\n");
    *data = in_buf[command_size - 1];
    return LGW_SPI_SUCCESS;
}

int lgw_spi_r(void *com_target, uint8_t spi_mux_target, uint16_t address, uint8_t *data) {
    int spi_device;
    uint8_t out_buf[5];
    uint8_t command_size;
    uint8_t in_buf[ARRAY_SIZE(out_buf)];
    struct spi_ioc_transfer k;
    int a;

    /* check input variables */
    CHECK_NULL(com_target);
    CHECK_NULL(data);

    spi_device = *(int *)com_target; /* must check that com_target is not null beforehand */

    /* prepare frame to be sent */
    out_buf[0] = spi_mux_target;
    out_buf[1] = READ_ACCESS | ((address >> 8) & 0x7F);
    out_buf[2] =               ((address >> 0) & 0xFF);
    out_buf[3] = 0x00;
    out_buf[4] = 0x00;
    command_size = 5;

    /* I/O transaction */
    memset(&k, 0, sizeof(k)); /* clear k */
    k.tx_buf = (unsigned long) out_buf;
    k.rx_buf = (unsigned long) in_buf;
    k.len = command_size;
    k.cs_change = 0;
    a = ioctl(spi_device, SPI_IOC_MESSAGE(1), &k);

    /* determine return code */
    if (a != (int)k.len) {
        DEBUG_MSG("ERROR: SPI READ FAILURE\n");
        return LGW_SPI_ERROR;
    } else {
        DEBUG_MSG("Note: SPI read success\n");
        *data = in_buf[command_size - 1];
        return LGW_SPI_SUCCESS;
    }
}

五、lgw_spi_wb函数

        该函数用于在 SPI 设备上执行一个批量写操作，可以一次性写入多个字节的数据到指定的寄存器地址。

主要流程：

1、SPI设备选择

spi_device = *(int *)com_target;

2、准备命令字节

    command[0] = spi_mux_target;
    command[1] = WRITE_ACCESS | ((address >> 8) & 0x7F);
    command[2] =                ((address >> 0) & 0xFF);
    command_size = 3;
    size_to_do = size;
  • command[0]：设备选择字节，设置为 spi_mux_target。
  • command[1] 和 command[2]：组合地址和写操作标志，其中 (address >> 8) & 0x7F 是地址的高 7 位，(address >> 0) & 0xFF 是地址的低 8 位。写操作标志由 WRITE_ACCESS 定义。

3、准备SPI传输结构体

    memset(&k, 0, sizeof(k)); /* clear k */
    k[0].tx_buf = (unsigned long) &command[0];
    k[0].len = command_size;
    k[0].cs_change = 0;
    k[1].cs_change = 0;
  • 使用 struct spi_ioc_transfer k[2] 数组来准备两个传输结构体，因为这是一个批量操作。
  • k[0] 结构体用于发送命令字节。
  • k[1] 结构体用于发送数据部分。

4、执行批量写操作

  for (i=0; size_to_do > 0; ++i) {
        chunk_size = (size_to_do < LGW_BURST_CHUNK) ? size_to_do : LGW_BURST_CHUNK;
        offset = i * LGW_BURST_CHUNK;
        k[1].tx_buf = (unsigned long)(data + offset);
        k[1].len = chunk_size;
        byte_transfered += (ioctl(spi_device, SPI_IOC_MESSAGE(2), &k) - k[0].len );
        DEBUG_PRINTF("BURST WRITE: to trans %d # chunk %d # transferred %d \n", size_to_do, chunk_size, byte_transfered);
        size_to_do -= chunk_size; /* subtract the quantity of data already transferred */
    }
  • 使用循环来处理数据的分块写入，每次写入不超过 LGW_BURST_CHUNK 大小的数据块。
  • chunk_size：计算每次实际写入的数据块大小。
  • offset：计算当前写入的数据在 data 数组中的偏移量。
  • 调用 ioctl 函数发送 k 数组中的两个结构体，分别发送命令和数据部分。
  • 累计 byte_transfered 变量记录实际传输的字节数。

5、返回状态

int lgw_spi_wb(void *com_target, uint8_t spi_mux_target, uint16_t address, const uint8_t *data, uint16_t size) {
    int spi_device;
    uint8_t command[3];
    uint8_t command_size;
    struct spi_ioc_transfer k[2];
    int size_to_do, chunk_size, offset;
    int byte_transfered = 0;
    int i;

    /* check input parameters */
    CHECK_NULL(com_target);
    CHECK_NULL(data);
    if (size == 0) {
        DEBUG_MSG("ERROR: BURST OF NULL LENGTH\n");
        return LGW_SPI_ERROR;
    }

    spi_device = *(int *)com_target; /* must check that com_target is not null beforehand */

    /* prepare command byte */
    command[0] = spi_mux_target;
    command[1] = WRITE_ACCESS | ((address >> 8) & 0x7F);
    command[2] =                ((address >> 0) & 0xFF);
    command_size = 3;
    size_to_do = size;

    /* I/O transaction */
    memset(&k, 0, sizeof(k)); /* clear k */
    k[0].tx_buf = (unsigned long) &command[0];
    k[0].len = command_size;
    k[0].cs_change = 0;
    k[1].cs_change = 0;
    for (i=0; size_to_do > 0; ++i) {
        chunk_size = (size_to_do < LGW_BURST_CHUNK) ? size_to_do : LGW_BURST_CHUNK;
        offset = i * LGW_BURST_CHUNK;
        k[1].tx_buf = (unsigned long)(data + offset);
        k[1].len = chunk_size;
        byte_transfered += (ioctl(spi_device, SPI_IOC_MESSAGE(2), &k) - k[0].len );
        DEBUG_PRINTF("BURST WRITE: to trans %d # chunk %d # transferred %d \n", size_to_do, chunk_size, byte_transfered);
        size_to_do -= chunk_size; /* subtract the quantity of data already transferred */
    }

    /* determine return code */
    if (byte_transfered != size) {
        DEBUG_MSG("ERROR: SPI BURST WRITE FAILURE\n");
        return LGW_SPI_ERROR;
    } else {
        DEBUG_MSG("Note: SPI burst write success\n");
        return LGW_SPI_SUCCESS;
    }
}

六、lgw_spi_rb函数

       该函数用于 在 SPI 设备上执行一个批量读取操作，将多个字节的数据从指定地址的寄存器中读取到给定的数据数组中。

主要流程：

1、SPI设备选择

spi_device = *(int *)com_target;

2、准备命令字节

    command[0] = spi_mux_target;
    command[1] = READ_ACCESS | ((address >> 8) & 0x7F);
    command[2] =               ((address >> 0) & 0xFF);
    command[3] = 0x00;
    command_size = 4;
    size_to_do = size;
    • command[0]：设备选择字节，设置为 spi_mux_target。
    • command[1]、command[2] 和 command[3]：组合地址和读操作标志，其中 (address >> 8) & 0x7F 是地址的高 7 位，(address >> 0) & 0xFF 是地址的低 8 位。读操作标志由 READ_ACCESS 定义，最后一个字节设为 0x00。

 3、准备SPI传输结构体

    memset(&k, 0, sizeof(k)); /* clear k */
    k[0].tx_buf = (unsigned long) &command[0];
    k[0].len = command_size;
    k[0].cs_change = 0;
    k[1].cs_change = 0;
  • 使用 struct spi_ioc_transfer k[2] 数组来准备两个传输结构体，因为这是一个批量操作。
  • k[0] 结构体用于发送命令字节。
  • k[1] 结构体用于接收数据部分。

4、执行批量读取操作

for (i=0; size_to_do > 0; ++i) {
        chunk_size = (size_to_do < LGW_BURST_CHUNK) ? size_to_do : LGW_BURST_CHUNK;
        offset = i * LGW_BURST_CHUNK;
        k[1].rx_buf = (unsigned long)(data + offset);
        k[1].len = chunk_size;
        byte_transfered += (ioctl(spi_device, SPI_IOC_MESSAGE(2), &k) - k[0].len );
        DEBUG_PRINTF("BURST READ: to trans %d # chunk %d # transferred %d \n", size_to_do, chunk_size, byte_transfered);
        size_to_do -= chunk_size;  /* subtract the quantity of data already transferred */
    }
  • 使用循环来处理数据的分块读取，每次读取不超过 LGW_BURST_CHUNK 大小的数据块。
  • chunk_size：计算每次实际读取的数据块大小。
  • offset：计算当前读取的数据在 data 数组中的偏移量。
  • 调用 ioctl 函数发送 k 数组中的两个结构体，分别发送命令和接收数据部分。
  • 累计 byte_transfered 变量记录实际传输的字节数。

5、返回状态

int lgw_spi_rb(void *com_target, uint8_t spi_mux_target, uint16_t address, uint8_t *data, uint16_t size) {
    int spi_device;
    uint8_t command[4];
    uint8_t command_size;
    struct spi_ioc_transfer k[2];
    int size_to_do, chunk_size, offset;
    int byte_transfered = 0;
    int i;

    /* check input parameters */
    CHECK_NULL(com_target);
    CHECK_NULL(data);
    if (size == 0) {
        DEBUG_MSG("ERROR: BURST OF NULL LENGTH\n");
        return LGW_SPI_ERROR;
    }

    spi_device = *(int *)com_target; /* must check that com_target is not null beforehand */

    /* prepare command byte */
    command[0] = spi_mux_target;
    command[1] = READ_ACCESS | ((address >> 8) & 0x7F);
    command[2] =               ((address >> 0) & 0xFF);
    command[3] = 0x00;
    command_size = 4;
    size_to_do = size;

    /* I/O transaction */
    memset(&k, 0, sizeof(k)); /* clear k */
    k[0].tx_buf = (unsigned long) &command[0];
    k[0].len = command_size;
    k[0].cs_change = 0;
    k[1].cs_change = 0;
    for (i=0; size_to_do > 0; ++i) {
        chunk_size = (size_to_do < LGW_BURST_CHUNK) ? size_to_do : LGW_BURST_CHUNK;
        offset = i * LGW_BURST_CHUNK;
        k[1].rx_buf = (unsigned long)(data + offset);
        k[1].len = chunk_size;
        byte_transfered += (ioctl(spi_device, SPI_IOC_MESSAGE(2), &k) - k[0].len );
        DEBUG_PRINTF("BURST READ: to trans %d # chunk %d # transferred %d \n", size_to_do, chunk_size, byte_transfered);
        size_to_do -= chunk_size;  /* subtract the quantity of data already transferred */
    }

    /* determine return code */
    if (byte_transfered != size) {
        DEBUG_MSG("ERROR: SPI BURST READ FAILURE\n");
        return LGW_SPI_ERROR;
    } else {
        DEBUG_MSG("Note: SPI burst read success\n");
        return LGW_SPI_SUCCESS;
    }
}

努力学代码的小信
关注
  • 29
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
LoRaWAN网关源码
09-07
此代码在官方源代码基础上修改了Makefile，其他的都未动，代码运行平台是树莓派。在运行测试程序前一定要，复位，复位，复位，运行\packet_forwarder\lora_pkt_fwd下的reset_lgw.sh复位脚本，运行完后运行lora_pkt_fwd
LoraWAN网关源码
08-01
LoraWAN网关源码，有需要的朋友可以下载看看
loraWAN网关源码V5.0.1
11-22
LoraWAN V5.0.1版本源码。有需要的朋友可以下载研究研究。
LoRaWan节点协议源代码
03-12
这个资源是LoRaWan节点协议栈的源代码，里面有STM32的实例，是Linux下的环境，如果要用到keil或IAR需要自行移植，移植也很简单，把需要的文件添加到项目里就行了 代码还是比较规范的，比起其它协议栈来说还是容易看懂的，这个最好配合LoRaWan协议说明看比较好，我也整理了中文版的协议说明可以去https://download.csdn.net/download/hxinstar/12235866下载
LoRa网关代码
05-24
LoRa测试代码，LoRa测试代码，LoRa测试代码，LoRa测试代码
LoraWAN STM32 工程源码+lorawan1.0.3规范
12-07
LoraWAN STM32 工程源码+lorawan1.0.3规范。
锐米LoRaWAN网关说明书
08-29
锐米LoRaWAN网关说明书可能包括以下内容： 产品概述：对锐米LoRaWAN网关进行简要介绍，包括其用途、功能和特点。 硬件规格：列出锐米LoRaWAN网关的硬件规格，如处理器型号、内存容量、存储容量、接口等。 设备...
单通道lorawan网关
03-01
LoRaWAN网络通常由终端节点、集中器（网关）和网络服务器三部分组成。在本场景中，我们关注的是"单通道LoRaWAN网关"。 单通道LoRaWAN网关，正如其名，是指只有一个接收通道的网关设备。相比于多通道网关，它的成本...
LoraWAN终端源码！
11-22
LoraWAN终端源码，有需要的朋友可以下载研究研究！！！
LoraWAN终端部分的源码
08-01
LoraWAN终端部分的源码，有需要的朋友可以作为参考
LoRaWAN终端ClassA源码
09-25
此源码是在ST的源码基础上修改而来，我自己用的是L051单片机，现在可以和支持ClassA上下同频的网关通信，此代码默认支持CN470模式，有些地方按自己的想法改吧，这只是一个初程序，通信没有任何问题，OTAA和ABP都可以入网。
LORAWAN_1.0.2协议及源码
09-25
LORAWAN_1.0.2协议文档，基于SX1278节点C语言源代码。
LoRaWAN终端应用示例工程源码！
11-22
基于小壁虎EFM32系列单片机的一个示例工程源码，包含LoraWAN终端源码。使用SiliconLabs的Simplicity Studio可以打开工程，需要根据开发环境修改路径配置等才可以正常编译！
LORA UDP 网关代码
11-02
LORA 网关代码 采用UDP 传输
LoRaWAN网关源码分析（基础概念篇）
最新发布
m0_65292176的博客
06-23 913
本文文章带你了解LoRaWAN网关源码基础概念。
LoRaWAN网关源码分析（V1.0.2）
qq_59580408的博客
07-29 1847
LoRaWAN网关源码分析（V1.0.2）
Lorawan源码程序编译和运行过程记录
weixin_39035140的博客
01-26 1205
一、源码获取解压 1、 解压源码 不同的LoRa模块提供商也会因为硬件结构不同而提供他们适配的源码总体符合smetech官方源码框架，解压源码：Sx1302LinuxDriver.zip 2、 修改顶层目录下的Makefile，修改架构和交叉编译工具 3、编译源码 Make 4、因为我们的lora模块是连接在spi总线之上，所以查看spi测试代码，修改核心库源码libloragw/tst/test_loragw_spi.c 5、重新Make以后在开发板运行执行spi测试程序test_loragw_spi
LoRaWAN网关设计图
05-25
LoRaWAN网关主要是用来连接LoRa终端节点和互联网的设备。以下是一个基本的LoRaWAN网关设计图： ![LoRaWAN网关设计图](https://img-blog.csdnimg.cn/20210827163740694.png) 该图中，LoRaWAN终端节点通过无线信号向网关发送数据，网关将数据传输到互联网上的服务器，服务器将数据解析后进行相应的处理，并将结果返回给网关，最后网关将结果传输回LoRaWAN终端节点。其中，LoRaWAN终端节点和网关之间的通信采用LoRa无线协议，网关和服务器之间的通信采用IP协议。 LoRaWAN网关通常由以下部分组成： 1. 接收机模块：用于接收LoRa终端节点发送的数据。 2. 处理器：用于处理接收到的数据，并将其传输到服务器。 3. 网络接口：用于连接互联网，将数据传输到服务器。 4. 电源模块：提供电源给网关，保证其正常工作。 除此之外，根据实际需求，LoRaWAN网关还可以添加其他模块，如GPS模块、存储模块等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

努力学代码的小信

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值