使用libmodbus库在相同IP地址和端口上实现多个从机

已于 2024-03-03 19:17:21 修改
阅读量1k 收藏 30
点赞数 23
分类专栏： C++ 文章标签： tcp/ip 驱动开发 网络协议
于 2024-03-03 19:16:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/QAZ600888/article/details/136436318
版权

文章目录

前言

之前用Python写过Modbus服务端，用的是pymodbus库，但这个库里面使用的是协程，小弟水平不够，有些hold不住，所以决定用C++把之前那块代码给重构了

使用libmodbus库

  1. 将源代码拉下来放到项目里面，源代码下载地址：https://github.com/stephane/libmodbus

  2. 编译源代码，先执行./autogen.sh，再执行./configure

    在这里插入图片描述

  3. 编写CMakeLists.txt，链接的时候加入modbus库，这里是我的一个例子

    set(TARGET modbus_tcp_server_test)

file(GLOB_RECURSE SRC *.cpp)

include_directories(${PROJECT_SOURCE_DIR}/src)

add_executable(${TARGET} ${SRC} ${PROJECT_SOURCE_DIR}/src/server/modbus_tcp_server.cpp)

target_include_directories(${TARGET} PUBLIC 
    ${GTEST_INCLUDE_DIRS})
message("project source dir: ${PROJECT_SOURCE_DIR}")
target_link_libraries(${TARGET} PUBLIC gtest gtest_main pthread modbus)

实现modbus服务端

  1. 先定义modbus_tcp_server.h文件，将modbus_server封装成类，定义以下这些接口

    #pragma once
#include <iostream>
#include <vector>
#include <mutex>
#include "libmodbus/src/modbus-tcp.h"

class ModbusTcpServer
{
public:
    ModbusTcpServer(int port, int slaveCount, bool debug);//端口号，从机个数，是否开启调试
    ~ModbusTcpServer();
    // 判断从机地址,寄存器地址是否合法
    bool isAddressValid(int slaveId, int address);
    // 线圈寄存器
    void setCoilValue(int slaveId, int address, uint8_t value);
    uint8_t getCoilValue(int slaveId, int address);
    // 离散输入寄存器
    void setDiscreteInputValue(int slaveId, int address, uint8_t value);
    uint8_t getDiscreteInputValue(int slaveId, int address);
    // 输入寄存器
    void setInputRegisterValue(int slaveId, int address, uint16_t value);
    uint16_t getInputRegisterValue(int slaveId, int address);
    // 保持寄存器
    void setHoldRegisterValue(int slaveId, int address, uint16_t value);
    uint16_t getHoldRegisterValue(int slaveId, int address);
    void recieveMessages();
    void start();

private:
    modbus_t *_ctx;
    uint16_t *_registers; // 假设所有寄存器的值都是0
    int _slaveCount;
    std::mutex _slavemutex;
    int _errCount{0};
    int _modbusSocket{-1};
    std::vector<modbus_mapping_t *> _mappingList;
    bool _initialized{false};
    /*Mapping*/
    int _numBits{65535};
    int _numInputBits{65535};
    int _numRegisters{65535};
    int _numInputRegisters{65535};
};

  2. 构造函数实现

    ModbusTcpServer::ModbusTcpServer(int port, int slaveCount, bool debug)
{
    this->_slaveCount = slaveCount;
    _ctx = modbus_new_tcp("10.8.0.126", port);	//ip地址+端口号
    modbus_set_debug(_ctx, debug);
    if (_ctx == nullptr)
    {
        LOG_DEBUG("初始化ModbusServer错误!");
        throw -1;
    }
    if (_modbusSocket < 0)
    {
        _modbusSocket = modbus_tcp_listen(_ctx, 1);
    }
    // 设置从机0-slaveCount的地址映射
    for (int i = 0; i <= slaveCount; ++i)
    {
        /*设置线圈, 离散输入, 输入寄存器, 保持寄存器个数(数组元素个数))*/
        modbus_mapping_t *_mapping = modbus_mapping_new(_numBits, _numInputBits, _numInputRegisters, _numRegisters);
        _mappingList.push_back(_mapping);
        if (_mapping == nullptr)
        {
            LOG_ERROR("初始化ModbusMap失败!");
            modbus_free(_ctx);
            _initialized = false;
            return;
        }
    }
    _initialized = true;
}

  3. 析构函数实现

    ModbusTcpServer::~ModbusTcpServer()
{
    // 清理资源
    modbus_close(_ctx);
    modbus_free(_ctx);
    for (auto &mapping : _mappingList)
    {
        modbus_mapping_free(mapping);
    }
}

  4. 接收消息处理函数（重点）

    之前我在网上搜遍资料，都没有找到一个ip和端口号设置多个从机的教程，后面又看了一整天libmodbus的源码，发现源码里根本就没有处理多个从机地址的情况。最后我发现是要自己手动处理接收到报文里的从机地址，否则所有回复的报文都是一台从机的情况。

    这里支持多个主站连接的代码参考了这篇博客：https://blog.csdn.net/qq_38158479/article/details/120928043

    void ModbusTcpServer::recieveMessages()
{
    // 初始化
    uint8_t query[MODBUS_TCP_MAX_ADU_LENGTH];
    fd_set reads, cpy_reads;
    FD_ZERO(&reads);
    FD_SET(_modbusSocket, &reads);
    int fdMax = _modbusSocket;
    while (true)
    {
        memset(query, 0, sizeof(query));
        cpy_reads = reads;
        int fdNum = select(fdMax + 1, &cpy_reads, 0, 0, 0);
        if (fdNum == -1)
            break;
        else if (fdNum == 0)
            continue;
        for (int i = 0; i < fdMax + 1; i++)
        {
            if (FD_ISSET(i, &cpy_reads))
            {
                if (i == _modbusSocket)
                {
                    int clntSock = modbus_tcp_accept(_ctx, &_modbusSocket);
                    if ((_modbusSocket == -1) || (clntSock == -1))
                    {
                        LOG_ERROR("accept error!");
                        std::cerr << modbus_strerror(errno) << std::endl;
                        continue;
                    }
                    FD_SET(clntSock, &reads);
                    if (fdMax < clntSock)
                        fdMax = clntSock;
                }
                else
                {
                    int ret = modbus_receive(_ctx, query);
                    if (ret == 0)
                    {
                        _errCount = 0;
                        continue;
                    }
                    else if (ret > 0)
                    {
                        _errCount = 0;
                        uint8_t slave = query[6]; // 获取收到问询的从机号
                        if (slave <= static_cast<uint8_t>(_slaveCount))
                        {
                            // 只回复当前从机的报文，从机号不符合就不回复
                            modbus_set_slave(_ctx, slave);
                            modbus_reply(_ctx, query, sizeof(query), _mappingList[slave]);
                        }
                    }
                    else
                    {
                        modbus_set_error_recovery(_ctx, MODBUS_ERROR_RECOVERY_NONE);
                        modbus_set_error_recovery(_ctx, MODBUS_ERROR_RECOVERY_LINK);
                        modbus_close(_ctx);
                        FD_CLR(i, &reads);
                        LOG_ERROR("报文错误,服务端断开连接!");
                        close(i);
                        _errCount++;
                    }
                    if (_errCount > 5)
                    {
                        _initialized = false;
                        break;
                    }
                }
            }
        }
    }
    _initialized = false;
}

  5. 启动服务

    void ModbusTcpServer::start()
{
    std::thread loop([this]()
                     {
        while (true)
        {
            if (_initialized)
            {
                recieveMessages();
            }
            else
            {
                _initialized = true;
            }
        } });
    // 将线程放在后台运行，防止阻塞主线程
    loop.detach();
}

  6. 判断从机地址和寄存器地址是否合法

    bool ModbusTcpServer::isAddressValid(int slaveId, int address)
{
    if (slaveId < 0 || slaveId > _slaveCount)
    {
        LOG_ERROR(fmt::format("从机号错误, 从机号: {}!", slaveId));
        return false;
    }
    if (address > (_numRegisters - 1))
    {
        LOG_ERROR(fmt::format("寄存器地址错误, 寄存器地址: {}!", address));
        return true;
    }
    return true;
}

  7. 读写线圈寄存器

    void ModbusTcpServer::setCoilValue(int slaveId, int address, uint8_t value)
{
    if (!isAddressValid(slaveId, address))
        return;
    _mappingList[slaveId]->tab_bits[address] = value;
}

uint8_t ModbusTcpServer::getCoilValue(int slaveId, int address)
{
    if (!isAddressValid(slaveId, address))
        return 0;
    return _mappingList[slaveId]->tab_bits[address];
}

  8. 读写离散输入寄存器

    void ModbusTcpServer::setDiscreteInputValue(int slaveId, int address, uint8_t value)
{
    if (!isAddressValid(slaveId, address))
        return;
    _mappingList[slaveId]->tab_input_bits[address] = value;
}

uint8_t ModbusTcpServer::getDiscreteInputValue(int slaveId, int address)
{
    if (!isAddressValid(slaveId, address))
        return 0;
    return _mappingList[slaveId]->tab_input_bits[address];
}

  9. 读写输入寄存器

    void ModbusTcpServer::setInputRegisterValue(int slaveId, int address, uint16_t value)
{
    if (!isAddressValid(slaveId, address))
        return;
    _mappingList[slaveId]->tab_registers[address] = value;
}

uint16_t ModbusTcpServer::getInputRegisterValue(int slaveId, int address)
{
    if (!isAddressValid(slaveId, address))

        return 0;
    return _mappingList[slaveId]->tab_registers[address];
}

  10. 读写保持寄存器

    void ModbusTcpServer::setHoldRegisterValue(int slaveId, int address, uint16_t value)
{
    if (!isAddressValid(slaveId, address))
        return;
    _slavemutex.lock();
    _mappingList[slaveId]->tab_registers[address] = value;
    _slavemutex.unlock();
}

uint16_t ModbusTcpServer::getHoldRegisterValue(int slaveId, int address)
{
    if (!isAddressValid(slaveId, address))
        return 0;
    return _mappingList[slaveId]->tab_registers[address];
}

  11. modbus_tcp_server.cpp所有代码

    #include "modbus_tcp_server.h"
#include <cstring>
#include "log.h"

ModbusTcpServer::ModbusTcpServer(int port, int slaveCount, bool debug)
{
    this->_slaveCount = slaveCount;
    _ctx = modbus_new_tcp("10.8.0.126", port);
    // 设置从机地址
    modbus_set_slave(_ctx, 1);
    modbus_set_debug(_ctx, debug);
    if (_ctx == nullptr)
    {
        LOG_DEBUG("初始化ModbusServer错误!");
        throw -1;
    }
    if (_modbusSocket < 0)
    {
        _modbusSocket = modbus_tcp_listen(_ctx, 1);
    }
    // 设置从机0-slaveCount的地址映射
    for (int i = 0; i <= slaveCount; ++i)
    {
        /*设置线圈, 离散输入, 输入寄存器, 保持寄存器个数(数组元素个数))*/
        modbus_mapping_t *_mapping = modbus_mapping_new(_numBits, _numInputBits, _numInputRegisters, _numRegisters);
        _mappingList.push_back(_mapping);
        if (_mapping == nullptr)
        {
            LOG_ERROR("初始化ModbusMap失败!");
            modbus_free(_ctx);
            _initialized = false;
            return;
        }
    }
    _initialized = true;
}

ModbusTcpServer::~ModbusTcpServer()
{
    // 清理资源
    modbus_close(_ctx);
    modbus_free(_ctx);
    for (auto &mapping : _mappingList)
    {
        modbus_mapping_free(mapping);
    }
}

bool ModbusTcpServer::isAddressValid(int slaveId, int address)
{
    if (slaveId < 0 || slaveId > _slaveCount)
    {
        LOG_ERROR(fmt::format("从机号错误, 从机号: {}!", slaveId));
        return false;
    }
    if (address > (_numRegisters - 1))
    {
        LOG_ERROR(fmt::format("寄存器地址错误, 寄存器地址: {}!", address));
        return true;
    }
    return true;
}

void ModbusTcpServer::setCoilValue(int slaveId, int address, uint8_t value)
{
    if (!isAddressValid(slaveId, address))
        return;
    _mappingList[slaveId]->tab_bits[address] = value;
}

uint8_t ModbusTcpServer::getCoilValue(int slaveId, int address)
{
    if (!isAddressValid(slaveId, address))
        return 0;
    return _mappingList[slaveId]->tab_bits[address];
}

void ModbusTcpServer::setDiscreteInputValue(int slaveId, int address, uint8_t value)
{
    if (!isAddressValid(slaveId, address))
        return;
    _mappingList[slaveId]->tab_input_bits[address] = value;
}

uint8_t ModbusTcpServer::getDiscreteInputValue(int slaveId, int address)
{
    if (!isAddressValid(slaveId, address))
        return 0;
    return _mappingList[slaveId]->tab_input_bits[address];
}

void ModbusTcpServer::setInputRegisterValue(int slaveId, int address, uint16_t value)
{
    if (!isAddressValid(slaveId, address))
        return;
    _mappingList[slaveId]->tab_registers[address] = value;
}

uint16_t ModbusTcpServer::getInputRegisterValue(int slaveId, int address)
{
    if (!isAddressValid(slaveId, address))

        return 0;
    return _mappingList[slaveId]->tab_registers[address];
}

void ModbusTcpServer::setHoldRegisterValue(int slaveId, int address, uint16_t value)
{
    if (!isAddressValid(slaveId, address))
        return;
    _slavemutex.lock();
    _mappingList[slaveId]->tab_registers[address] = value;
    _slavemutex.unlock();
}

uint16_t ModbusTcpServer::getHoldRegisterValue(int slaveId, int address)
{
    if (!isAddressValid(slaveId, address))
        return 0;
    return _mappingList[slaveId]->tab_registers[address];
}

void ModbusTcpServer::recieveMessages()
{
    // 初始化
    uint8_t query[MODBUS_TCP_MAX_ADU_LENGTH];
    fd_set reads, cpy_reads;
    FD_ZERO(&reads);
    FD_SET(_modbusSocket, &reads);
    int fdMax = _modbusSocket;
    while (true)
    {
        memset(query, 0, sizeof(query));
        cpy_reads = reads;
        int fdNum = select(fdMax + 1, &cpy_reads, 0, 0, 0);
        if (fdNum == -1)
            break;
        else if (fdNum == 0)
            continue;
        for (int i = 0; i < fdMax + 1; i++)
        {
            if (FD_ISSET(i, &cpy_reads))
            {
                if (i == _modbusSocket)
                {
                    int clntSock = modbus_tcp_accept(_ctx, &_modbusSocket);
                    if ((_modbusSocket == -1) || (clntSock == -1))
                    {
                        LOG_ERROR("accept error!");
                        std::cerr << modbus_strerror(errno) << std::endl;
                        continue;
                    }
                    FD_SET(clntSock, &reads);
                    if (fdMax < clntSock)
                        fdMax = clntSock;
                }
                else
                {
                    int ret = modbus_receive(_ctx, query);
                    if (ret == 0)
                    {
                        _errCount = 0;
                        continue;
                    }
                    else if (ret > 0)
                    {
                        _errCount = 0;
                        uint8_t slave = query[6]; // 获取收到问询的从机子号
                        if (slave <= static_cast<uint8_t>(_slaveCount))
                        {
                            modbus_set_slave(_ctx, slave);
                            modbus_reply(_ctx, query, sizeof(query), _mappingList[slave]);
                        }
                    }
                    else
                    {
                        modbus_set_error_recovery(_ctx, MODBUS_ERROR_RECOVERY_NONE);
                        modbus_set_error_recovery(_ctx, MODBUS_ERROR_RECOVERY_LINK);
                        modbus_close(_ctx);
                        FD_CLR(i, &reads);
                        LOG_ERROR("报文错误,服务端断开连接!");
                        close(i);
                        _errCount++;
                    }
                    if (_errCount > 5)
                    {
                        _initialized = false;
                        break;
                    }
                }
            }
        }
    }
    _initialized = false;
}
void ModbusTcpServer::start()
{
    std::thread loop([this]()
                     {
        while (true)
        {
            if (_initialized)
            {
                recieveMessages();
            }
            else
            {
                _initialized = true;
            }
        } });
    loop.detach();
}

单元测试

  1. 使用gtest进行单元测试，测试代码如下

    #include "server/modbus_tcp_server.h"
#include "gtest/gtest.h"

class ModbusTcpServerTest : public testing::Test
{
public:
    std::unique_ptr<ModbusTcpServer> server;

protected:
    virtual void SetUp()
    {
        try
        {
            server = std::make_unique<ModbusTcpServer>(5020, 10, true); // 创建Modbus服务器实例，监听端口5020，配置10台从机
            server->start();                                            // 启动服务器
        }
        catch (const std::exception &e)
        {
            std::cerr << "Exception: " << e.what() << std::endl;
        }
    }
};

TEST_F(ModbusTcpServerTest, TestSetRegisterValue)
{
    server->setHoldRegisterValue(1, 1, 100);
    ASSERT_EQ(100, server->getHoldRegisterValue(1, 1));
    
    server->setInputRegisterValue(1, 1, 200);
    ASSERT_EQ(200, server->getInputRegisterValue(1, 1));
    
    server->setCoilValue(1, 1, 1);
    ASSERT_TRUE(server->getCoilValue(1, 1));
    
    server->setDiscreteInputValue(1, 1, 1);
    ASSERT_TRUE(server->getDiscreteInputValue(1, 1));
}

int main()
{
    testing::InitGoogleTest();
    return RUN_ALL_TESTS();
}

  2. 测试结果
    在这里插入图片描述

使用网络调试助手测试

​ 为了判断我们多从机是否设置成功，我们可以用网络调试助手手发报文测试

  1. 为了让服务一直运行，我们可以把启动服务里的detach改成join，让其阻塞主线程
    在这里插入图片描述

  2. 用网络调试助手连接modbus服务端
    在这里插入图片描述

  3. 设置从机地址1，输入寄存器地址1的值为1

    报文格式：00 00 00 00 00 06 01 06 00 01 00 01

    重点看后面7位

    06：后面有6个值

    01：从机地址为1

    06：功能码，写输入寄存器

    00 01：输入寄存器的地址，4位16进制数，转换成10进制就是0-65535

    00 01：寄存器值，范围与上面寄存器地址范围相同
    在这里插入图片描述

    使用06功能码的时候，回复的值是一大串数据，这个没有影响

  4. 读取从机地址1，输入寄存器地址1的值，判断刚才手发的报文是否成功将值写入

    报文格式：00 00 00 00 00 06 01 03 00 01 00 01

    在这里插入图片描述

    报文回复的后四位为00 01，值为1，说明值被成功写入了

  5. 读取从机地址2，输入寄存器地址1的值，判断之前的写命令是否干扰了其他从机

    报文格式：00 00 00 00 00 06 02 03 00 01 00 01

    在这里插入图片描述

    报文回复的后四位为00 00，值为0，说明之前的写命令没有干扰其他从机

MC皮蛋侠客
关注
  • 23
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Libmodbus关于从站地址的问题
ROF
08-31 488
在嵌入式LINUX开发板上，基于libmodbus第三方库编程实现土壤水分及温度的读取，传感器采用大连祺峰科技有限公司的土壤水分温度传感器（型号：SMTS-II-485）。在程序运行过程中，遇到了一些问题，记录如下: 查看土壤水分温度传感器手册，若要读取水分温度，则需要发送如下RTU帧：FE 03 00 00 00 02 D0 04，这里FE是传感器modbus站地址，这是传...
基于libmodbus库实现modbus TCP/RTU通信
热门推荐
tutu_hu的博客
08-01 1万+
基于libmodbus实现modbus TCP/RTU通信基类封装，以及功能介绍，库安装等全面知识，关于modbus使用看此文足矣！
modbus 服务端（从站）C++小项目源码
08-07
因项目需要。自己实现的modbus服务器C++项目源码，和我上传的另一个资源是配套的，刚好实现0x03的接受和发送数据功能。其他功能码的接口也有几个。可以下载学习哦。
python实现读取串口数据-使用LibModbus库实现一个实时读取串口数据
像风一样自由的博客
05-15 676
准备硬件环境 要实现Modbus RTU通信，首先需要准备支持RS-485或RS-232接口的硬件设备，如串口适配器、从设备（如传感器、执行器等）以及连接线材。安装Python库 要实现Modbus RTU通信，我们可以使用Python的第三方库pymodbus。Modbus RTU是一种基于串行通信的Modbus协议，它使用RS-485或RS-232接口，以字节为单位进行数据传输。Modbus RTU协议定义了主从设备之间的通信规则，主设备负责发起请求，从设备则响应请求并返回数据。
使用libmodbus库开发modbusTcp从站(支持多个主站连接)
宁静致远的博客
10-05 2066
【代码】使用libmodbus库开发modbusTcp从站(支持多个主站连接)
modbus tcp server (slave)开源代码 - 基于libmodbus，支持多客户端同时访问
闲人的专栏
10-20 5442
当我们需要自己搞一个C/C++版的 modbus Server时，总想像C#里面借助个好用的库来实现，但是libmodbus这个库封装的并不好用，从官方的源码中连个example都没有，能抄着用的也就tests目录下有几个可以借鉴。本文借鉴这篇文章，进行了一点优化，实现了modbus tcp Server，可以拿到即用。如果需要自己实现逻辑可以直接在另一个线程函数中对modbus的变量进行修改。libmodbus是非常有名的modbus库，本身是用C语言写的。还是会阻塞的，单线程。
libmodbus使用手册中文版.docx
01-12
以上内容概述了libmodbus库的核心功能及其使用方法，通过这些API可以轻松地在各种平台上实现Modbus协议通信。对于具体的应用场景，开发者可以根据实际需求选择合适的方法进行调用，从而实现高效、可靠的设备间数据...
libmodbus编译完成的动态库
01-06
在使用libmodbus库时，首先需要包含必要的头文件，然后创建`modbus_t`类型的上下文对象，配置通信参数（如主机地址、端口、RTU的串口设置等），建立连接，最后调用对应的读写函数进行数据交换。当完成通信任务后，...
libmodbus接口函数以及动静态链接库.rar
04-23
这些函数接受配置参数，如IP地址、端口、波特率等，并返回一个`modbus_t`类型的指针。 2. `modbus_connect()`与`modbus_close()`：连接和断开与Modbus设备的连接。`modbus_connect()`尝试建立与指定设备的连接，而`...
通过C++编写程序与机器人通讯的libmodbus库
04-07
libmodbus库是一个开源项目，它实现了Modbus协议的客户端和服务器端功能。这个库不仅支持Modbus RTU和ASCII模式，还支持TCP/IP协议，因此可以用于各种网络环境下的设备通讯。利用libmodbus，C++开发者可以方便地读取...
modbus 从站从机程序标准库35
01-19
modbus 标准库 从机
libmodbus-3.1.6.tar.gz
10-18
// IP地址和端口 if (ctx == NULL) { fprintf(stderr, "Error creating context\n"); exit(1); } // 连接设备 if (modbus_connect(ctx) == -1) { fprintf(stderr, "Error connecting to device\n"); ...
Modbus通讯开发随记3——基于LibModbus库的简易Modbus主机类封装（C++版）
最新发布
ZW_finder的博客
05-30 1013
由于LibModbus库的直接使用为面向过程的，本文使用C++类和模板方法，将Modbus主机开发对象化，实现了Modbus通讯的关键功能，并定义数据缓存接口，以方便Modbus通讯数据的前后端分离。本文主要作为自己的开发随记文档，相关代码只考虑到了功能实现，健壮性和安全性有所欠缺，随着后续开发的推进会进行尽量补全，若对路过的您有所帮助也请指出文中的不足之处。另外，本文中的实现只进行了最简单的测试，很可能存在实现有误的情况，若您需要克隆使用请谨慎。
Java实现ModBus Poll端，读 写外连设备寄存器数据，COM3端口连接_java modbus usb(1)
2401_83704192的博客
04-05 328
你的支持，我的动力；祝各位前程似锦，offer不断，步步高升！！！你的支持，我的动力；祝各位前程似锦，offer不断，步步高升！！！更多资料点击此处获qu！！
libmodbus的python接口pylibmodbus简介
ethercat_i7的博客
02-27 1850
一、安装libmodbus 在ubuntu1404环境下安装libmodbus: #sudo apt-get install libmodbus-dev libmodbus源码下载地址为： https://libmodbus.org/download/ 二、下载pylibmodbus pylibmodbus下载地址为： https://pypi.org/project/pylibmodbus/#...
基于python的modbus协议编程_使用libmodbus C为OpenWRT路由器编写modbus程序（将Python应用程序重写为C）...
weixin_39914938的博客
12-15 850
我同情你。。。至于它支持的编程语言，看起来就像是你用C/C++或Lua。因为你想用你的个人电脑为你的路由器编译代码，你必须要研究交叉编译。这样做的原因(在你不知道的情况下)是因为你的电脑运行在一个(最有可能)x86u64或32位架构(arch)的CPU上，当你正常编译代码时，它会编译成只在这个架构上运行的机器码。你的路由器可能运行在ARM或MIPS32或类似的架构(你应该能够在DD wrt或开放w...
1.在xxx1上使用以下三种方式实现多个虚拟主机： a.相同IP地址，不同端口号； b.不同IP地址，相同端口号； c.相同IP地址，相同端口号，不同FQDN。 2.客户端分别测试效果。
09-16
不同IP地址，相同端口号：在xxx1上配置多个虚拟主机，每个虚拟主机使用不同的IP地址但相同的端口号。当客户端访问该端口号时，根据不同的IP地址访问不同的虚拟主机。 c. 相同IP地址，相同端口号，不同FQDN：在xxx1...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

MC皮蛋侠客

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

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

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

打赏作者

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

抵扣说明：

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

余额充值