开源软件列表_lib文件是干嘛的[通俗易懂]

glib 里的定时器

GLib 的跨平台支持

你开发过跨硬件平台的软件吗？是不是常常为硬件平台的差异而苦恼呢？字节顺序是常见的问题之一，大端格式，小端格式，还是PDP格式的？这样差异造成的BUG会浪费不少时间，同时让代码晦涩难读。glib提供了一套完整的宏，利用这些宏编写程序，问题大大简化了。

你开发过跨操作系统的软件吗？在不同的平台下，很多函数有相同的功能，但函数原型，返回值差异巨大，也有的貌合神离，相同的名称有着不同的意义，请看下面这张清单
动态库加载函数

   线程函数

   信号量函数

   互斥锁函数

   事件函数

   字符集转换函数

   原子操作函数

   创建进程函数

   时间格式

   IO函数

GLib 词法分析

你写过读取配置文件的模块吧，像读取 ini 这样简单格式的文件，当然不在话下，要读 markup 语言格式的配置文件，难度可能大了点，虽然不是不可能，但除非是为了学习，何必自己找麻烦呢。 glib 里提供了词法分析、markup 语言解析、ini 文件存取等功能，你完全不用为此担忧。

不管是命令行程序，还是 GUI 程序，或者后台服务进程，通过命令参数来控制程序的行为，都是开发人员惯用的手法。从命令行参数取到有用的信息，不难，遍历一遍不就行了吗？但在每个程序中都来遍一次，你不觉得很单调吗？我们的时间很宝贵，浪费时间做这种事情，不值得吧。glib 的作者们早考虑到了，它提供了这样的功能，你调用的它的函数，可能轻松的取得所要的命令行参数。

对于正则表达式，Win32 下的开发人员可能用得少一点，而在 Linux 下的 Shell 里，它却是不可或缺之物。有没有想到在自己的程序中使用的它呢，在有的情况下，使用正则表达式，可能会大大降低开发的难度，提高易用性。glib也想到了这一点，它提供了简单的正则表达式功能，当然，用与不用完全取决于你自己。

GLib 错误追踪

在程序里，如果程序出错了，特别是调了不该调用的函数，你是不是很想知道是谁调了它？大多数时候用 debuger 是最好的选择，在某些情况下，没有 debuger 可用，或者在 debuger 里重现不了这个问题，你会不会觉得很无助？别怕，glib 提供了一套跨平台的 backtrace 函数，有了它，你可以很容易找到元凶了。

Glib 日志功能

如果读过一些大型的开源项目，你会发现，差不多每个项目都有一套自己的log函数，用于记录程序运行的调试或者审计信息。也有可能，你自己都曾在不同的项目里实现过好几次这个功能，第一次实现会觉得很好玩，会学到了一些东西，后来就会发现自己在做无用功。重复就是浪费，重复就是犯罪，glib想到了这一点，它实现了一套完整的log机制，供大家在不同的项目中使用。

GLib 数学计算

产生质数的算法不难，在我们的程序里也像是星外来客，很少使用，常常忽略了它。所谓书到用时方恨少，有这样的东东，说不定就有用得到它的时候。glib提供了这样的功能，同时还提供了一个较好的随机数算法。

Glib Shell 功能

Linux Shell 里的自动补完功能很好用吧，从 Linux 转移到 Win32 下工作的开发人员，常常抱怨Win32 的 Shell 里没有这个功能，其实 Win32 下也是有的，把注册表里的一个选项打开就行了。不管怎么样，总之这个功能太有用了，没有它，你都会觉得少了点什么，全身不自在，glib里连这个功能都提供了，是不是很人性化呢？

Glib 内存管理

内存问题！还是内存问题！如果你没有为内存问题而苦恼过，我都怀疑你是不是一个真正的C语言程序员。内存泄露、访问越界、空指针、野指针和内存优化等问题，是不是都曾让你夜不能昧？有些工具可以帮助你，但这不是万能的良药，好好写你的程序才是第一要义。glib提供了一些的手段，也可以在一定程度上减轻你的痛苦。

libevent通讯处理

Libevent 是一个用C语言编写的、轻量级的开源高性能事件通知库，主要有以下几个亮点：事件驱动（ event-driven），高性能;轻量级，专注于网络，不如 ACE 那么臃肿庞大；源代码相当精炼、易读；跨平台，支持 Windows、 Linux、 *BSD 和 Mac Os；支持多种 I/O 多路复用技术， epoll、 poll、 dev/poll、 select 和 kqueue 等；支持 I/O，定时器和信号等事件；注册事件优先级。
Libevent 已经被广泛的应用，作为底层的网络库；比如 memcached、 Vomit、 Nylon、 Netchat等等。
链接: Libevent

#include <stdio.h>
#include <event.h>
#include <time.h>

struct event ev;
struct timeval tv;

void timer_cb(int fd, short event, void *arg)    //回调函数
{
        printf("timer_cb\n");
        event_add(&ev, &tv);    //重新注册
}

int main()
{
        struct event_base *base = event_init();  //初始化libevent库
        tv.tv_sec = 1;
        tv.tv_usec = 0;

        event_set(&ev, -1, 0, timer_cb, NULL);  //初始化event结构中成员
        event_base_set(base, &ev);
        event_add(&ev, &tv);  //将event添加到events事件链表，注册事件
        event_base_dispatch(base);  //循环、分发事件

        return 0;
}

获取待监听的内容的fd；
创建一个event_base；
创建一个event,指定待监听的fd，待监听事件的类型，以及事件放生时的回调函数及传给回调函数的参数；
将event添加到event_base的事件管理器中；
开启event_base的事件处理循环；
（异步）当事件发生的时候，调用前面设置的回调函数。

/**
You need libevent2 to compile this piece of code
Please see: http://libevent.org/
Or you can simply run this command to install on Mac: brew install libevent
Cmd to compile this piece of code: g++ LibeventQuickStartServer.c  -o  LibeventQuickStartServer /usr/local/lib/libevent.a
**/
#include<stdio.h>  
#include<string.h>  
#include<errno.h>  
  
#include<unistd.h>  
#include<event.h>

void accept_cb(int fd, short events, void* arg);
void socket_read_cb(int fd, short events, void* arg);

int tcp_server_init(int port, int listen_num);

int main(int argc, char const *argv[])
{
    /* code */
    int listener = tcp_server_init(9999, 10);
    if (listener == -1)
    {
        perror("tcp_server_init error");
        return -1;
    }

    struct event_base* base = event_base_new();

    // 监听客户端请求链接事件
    struct event* ev_listen = event_new(base, listener, EV_READ | EV_PERSIST, accept_cb, base);

    event_add(ev_listen, NULL);

    event_base_dispatch(base);

    return 0;
}

void accept_cb(int fd, short events, void* arg)
{
    evutil_socket_t sockfd;

    struct sockaddr_in client;
    socklen_t len = sizeof(client);

    sockfd = ::accept(fd, (struct sockaddr*)&client, &len);
    evutil_make_socket_nonblocking(sockfd);

    printf("accept a client %d\n", sockfd);

    struct event_base* base = (event_base*)arg;

    //动态创建一个event结构体，并将其作为回调参数传递给
    struct event* ev = event_new(NULL, -1, 0, NULL, NULL);
    event_assign(ev, base, sockfd, EV_READ | EV_PERSIST, socket_read_cb, (void*)ev);

    event_add(ev, NULL);
}


void socket_read_cb(int fd, short events, void* arg)
{
    char msg[4096];
    struct event* ev = (struct event*)arg;
    int len = read(fd, msg, sizeof(msg) - 1);

    if(len <= 0)
    {
        printf("some error happen when read\n");
        event_free(ev);
        close(fd);
        return;
    }

    msg[len] = '\0';
    printf("recv the client msg : %s\n", msg);

    char reply_msg[4096] = "I have received the msg: ";
    strcat(reply_msg + strlen(reply_msg), msg);

    write(fd, reply_msg, strlen(reply_msg));
}

typedef struct sockaddr SA;  
int tcp_server_init(int port, int listen_num)  
{  
    int errno_save;  
    evutil_socket_t listener;  
  
    listener = ::socket(AF_INET, SOCK_STREAM, 0);  
    if( listener == -1 )  
        return -1;  
  
    //允许多次绑定同一个地址。要用在socket和bind之间  
    evutil_make_listen_socket_reuseable(listener);  
  
    struct sockaddr_in sin;  
    sin.sin_family = AF_INET;  
    sin.sin_addr.s_addr = 0;  
    sin.sin_port = htons(port);  
  
    if( ::bind(listener, (SA*)&sin, sizeof(sin)) < 0 )  
        goto error;  
  
    if( ::listen(listener, listen_num) < 0)  
        goto error;  
  
  
    //跨平台统一接口，将套接字设置为非阻塞状态  
    evutil_make_socket_nonblocking(listener);  
  
    return listener;  
  
    error:  
        errno_save = errno;  
        evutil_closesocket(listener);  
        errno = errno_save;  
  
        return -1;  
}  

/**
You need libevent2 to compile this piece of code
Please see: http://libevent.org/
Or you can simply run this command to install on Mac: brew install libevent
Cmd to compile this piece of code: g++ LibeventQuickStartClient.c -o LibeventQuickStartClient /usr/local/lib/libevent.a
**/
#include<sys/types.h>  
#include<sys/socket.h>  
#include<netinet/in.h>  
#include<arpa/inet.h>  
#include<errno.h>  
#include<unistd.h>  
  
#include<stdio.h>  
#include<string.h>  
#include<stdlib.h>  
  
#include<event.h>  
#include<event2/util.h>  
  
  
  
  
int tcp_connect_server(const char* server_ip, int port);  
  
  
void cmd_msg_cb(int fd, short events, void* arg);  
void socket_read_cb(int fd, short events, void *arg);  
  
int main(int argc, char** argv)  
{  
    if( argc < 3 )  
    {  
        printf("please input 2 parameter\n");  
        return -1;  
    }  
  
  
    //两个参数依次是服务器端的IP地址、端口号  
    int sockfd = tcp_connect_server(argv[1], atoi(argv[2]));  
    if( sockfd == -1)  
    {  
        perror("tcp_connect error ");  
        return -1;  
    }  
  
    printf("connect to server successful\n");  
  
    struct event_base* base = event_base_new();  
  
    struct event *ev_sockfd = event_new(base, sockfd,  
                                        EV_READ | EV_PERSIST,  
                                        socket_read_cb, NULL);  
    event_add(ev_sockfd, NULL);  
  
    //监听终端输入事件  
    struct event* ev_cmd = event_new(base, STDIN_FILENO,  
                                      EV_READ | EV_PERSIST, cmd_msg_cb,  
                                      (void*)&sockfd);  
  
  
    event_add(ev_cmd, NULL);  
  
    event_base_dispatch(base);  
  
    printf("finished \n");  
    return 0;  
}  
  
  
  
  
  
  
void cmd_msg_cb(int fd, short events, void* arg)  
{  
    char msg[1024];  
  
    int ret = read(fd, msg, sizeof(msg));  
    if( ret <= 0 )  
    {  
        perror("read fail ");  
        exit(1);  
    }  
  
    int sockfd = *((int*)arg);  
  
    //把终端的消息发送给服务器端  
    //为了简单起见，不考虑写一半数据的情况  
    write(sockfd, msg, ret);  
}  
  
  
void socket_read_cb(int fd, short events, void *arg)  
{  
    char msg[1024];  
  
    //为了简单起见，不考虑读一半数据的情况  
    int len = read(fd, msg, sizeof(msg)-1);  
    if( len <= 0 )  
    {  
        perror("read fail ");  
        exit(1);  
    }  
  
    msg[len] = '\0';  
  
    printf("recv %s from server\n", msg);  
}  
  
  
  
typedef struct sockaddr SA;  
int tcp_connect_server(const char* server_ip, int port)  
{  
    int sockfd, status, save_errno;  
    struct sockaddr_in server_addr;  
  
    memset(&server_addr, 0, sizeof(server_addr) );  
  
    server_addr.sin_family = AF_INET;  
    server_addr.sin_port = htons(port);  
    status = inet_aton(server_ip, &server_addr.sin_addr);  
  
    if( status == 0 ) //the server_ip is not valid value  
    {  
        errno = EINVAL;  
        return -1;  
    }  
  
    sockfd = ::socket(PF_INET, SOCK_STREAM, 0);  
    if( sockfd == -1 )  
        return sockfd;  
  
  
    status = ::connect(sockfd, (SA*)&server_addr, sizeof(server_addr) );  
  
    if( status == -1 )  
    {  
        save_errno = errno;  
        ::close(sockfd);  
        errno = save_errno; //the close may be error  
        return -1;  
    }  
  
    evutil_make_socket_nonblocking(sockfd);  
  
    return sockfd;  
}  

libmodbus 里的数据处理

libmodbus 是支持Linux，Mac OS X，QNX和win32 的一个modbus库，支持modbus TCP和RTU 两种模式。

libmodbus 的官网：
链接: libmodbus

ctx = modbus_new_tcp("127.0.0.1", 1502);

if (ctx == NULL) {

    fprintf(stderr, "Unable to allocate libmodbus context\n");

    return -1;

}

 

if (modbus_connect(ctx) == -1) {

    fprintf(stderr, "Connection failed: %s\n", modbus_strerror(errno));

    modbus_free(ctx);

    return -1;

}

显然，这是一种优雅的程序设计方式。

读比特位

rc = modbus_write_bit(ctx, addr, tab_rq_bits[0]);

 

写比特位

rc = modbus_read_bits(ctx, addr, 1, tab_rp_bits);
读寄存器

int modbus_read_registers(modbus_t *ctx, int addr, int nb, uint16_t *dest);

写寄存器

int modbus_write_register(modbus_t *ctx, int addr, const uint16_t value);

读写寄存器

int modbus_write_and_read_registers(modbus_t *ctx, int write_addr, int write_nb, const uint16_t *src, int read_addr, int read_nb, const uint16_t *dest);

今天的文章开源软件列表_lib文件是干嘛的[通俗易懂]分享到此就结束了，感谢您的阅读。