# 静态库

**Repository Path**: magic77elva/static-library

## Basic Information

- **Project Name**: 静态库
- **Description**: No description available
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2023-12-15
- **Last Updated**: 2025-08-01

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# serial库使用方法

## 头文件

        #ifndef __MAIN_H__
        #define __MAIN_H__

        #define DEVICE_NUM 2

        typedef struct
        {
            char* serial_devices[10];
            int num_devices;
            int fds[10];
        }Serial_Struct;

        extern Serial_Struct serial;
        #endif

## 实现

        #include <stdio.h>
        #include <stdint.h>
        #include "serial.h"
        #include "main.h"
        #include "string.h" //strlen
        #include <unistd.h> //read write
        #include <termios.h> //B9600

        Serial_Struct serial;

        void handle_timerfd(int timer_fd) {
            uint64_t expirations;

            read(timer_fd, &expirations, sizeof(expirations)); // 清空事件
            if (expirations > 0) {
                write(serial.fds[1], "remo_send", 12);
            }
        }

        // 处理EPOLLIN事件的函数
        void handle_epollin(int fd) {
            char buffer[1024];

            if(fd == serial.fds[0])
            {
                printf("serial1 received data\n");
            }
            if(fd == serial.fds[1])
            {
                printf("serial2 received data\n");
            }

        }

        //1、先将各个串口赋值serial.serial_devices[0]
        //2、动态计算出串口熟练
        //3、初始化串口，调用serial_init(serial.num_devices, serial.serial_devices, serial.fds);
        //4、设置串口参数set_serial_attributes(fd, B115200, 0);
        //5、开启串口监控monitor_serial_epoll(serial.num_devices, serial.fds, 2, handle_epollin, handle_timerfd);
        //6、两个回调函数参考上面两个函数
        int main() {
            serial.serial_devices[0] = "/dev/ttymxc1";
            serial.serial_devices[1] = "/dev/ttymxc2";
            serial.num_devices = 2; // 串口设备数量,数量不对有可能会导致调试串口被占用，所以最好手动赋值***

            // 调用串口初始化函数
            int result = serial_init(serial.num_devices, serial.serial_devices, serial.fds);
            if (result == 0) {
                printf("Serial port initialization successful.\n");
                //设置串口参数
                for(int i=0;i<serial.num_devices;i++)
                {
                    set_serial_attributes(serial.fds[i], B115200, 0)
                }

                // 循环读取串口并并定时发送数据
                monitor_serial_epoll(serial.num_devices, serial.fds, 2, handle_epollin, handle_timerfd);
            } else {
                printf("Serial port initialization failed.\n");
            }
            return 0;
        }

# TCP库使用方法

## 功能概述

TCP客户端库提供了一个可靠的TCP连接管理机制，具有以下特点：

- 自动重连机制，支持指数退避算法
- 基于epoll的高效I/O多路复用
- 定时发送数据功能
- 异步接收数据处理
- 完善的错误处理和状态通知

## 头文件

        #include "tcp_client.h"

## API函数

### 启动TCP客户端

        int start_tcp_client(const char *ip, int port, int send_interval,
                            send_callback message, recv_callback recv,
                            error_callback error_cb);

**参数说明：**
- `ip`: 服务器IP地址
- `port`: 服务器端口号(1-65535)
- `send_interval`: 定时发送数据的间隔时间(秒)
- `message`: 获取要发送数据的回调函数，不能为NULL
- `recv`: 接收数据的回调函数，不能为NULL
- `error_cb`: 错误处理回调函数，不能为NULL

**返回值：**
- 成功返回`TCP_OK`(0)
- 失败返回对应的错误码(负值)

## 回调函数类型

### 发送数据回调函数

        typedef const char* (*send_callback)(void);

此函数由用户实现，用于提供要发送的数据。**注意：返回的字符串必须在函数返回后仍然有效**。

### 接收数据回调函数

        typedef void (*recv_callback)(const char* data, size_t length);

此函数由用户实现，用于处理接收到的数据。

### 错误处理回调函数

        typedef void (*error_callback)(tcp_error_t error_code, const char* error_msg);

此函数由用户实现，用于处理错误和状态通知。

## 错误码说明

### 成功/信息码（非负值）
- `TCP_OK = 0`: 操作成功
- `TCP_INFO_CONNECTED = 1`: 连接建立
- `TCP_INFO_RECONNECTING = 2`: 正在重连
- `TCP_INFO_RETRY_RESET = 3`: 重试计数重置

### 错误码（负值）
- `TCP_ERR_INVALID_IP = -1`: 无效IP地址
- `TCP_ERR_INVALID_PORT = -2`: 无效端口号
- `TCP_ERR_INVALID_INTERVAL = -3`: 无效发送间隔
- `TCP_ERR_NULL_CALLBACK = -4`: 回调函数为NULL
- `TCP_ERR_MEMORY = -5`: 内存分配失败
- `TCP_ERR_MUTEX_INIT = -6`: 互斥锁初始化失败
- `TCP_ERR_SOCKET_CREATE = -7`: 套接字创建失败
- `TCP_ERR_SOCKET_CONNECT = -8`: 套接字连接失败
- `TCP_ERR_EPOLL_CREATE = -9`: epoll创建失败
- `TCP_ERR_TIMER_CREATE = -10`: 定时器创建失败
- `TCP_ERR_EPOLL_ADD = -11`: epoll添加失败
- `TCP_ERR_SOCKET_READ = -12`: 套接字读取失败
- `TCP_ERR_SOCKET_WRITE = -13`: 套接字写入失败
- `TCP_ERR_SOCKET_SETUP = -14`: 套接字设置失败
- `TCP_ERR_RECONNECT = -15`: 重连失败

## 重连机制

TCP客户端库实现了指数退避算法进行重连：
- 初始重连间隔为1秒
- 每次连接失败后，间隔时间翻倍，直到达到最大值32秒
- 达到最大值后，保持32秒间隔继续重连
- 当重连次数达到1000次时，计数器重置为0，继续尝试重连
- 成功建立连接后，重连计数器重置为初始值1秒

## 使用示例

        #include "tcp_client.h"
        #include <stdio.h>
        #include <string.h>
        #include <time.h>

        // 全局缓冲区，确保返回的字符串在函数返回后仍然有效
        static char g_send_buf[1024];

        // 用户提供的回调函数，用于处理接收到的数据
        void recv_handler(const char *data, size_t data_length)
        {
            printf("收到数据: %.*s\n", (int)data_length, data);
        }

        // 更新发送数据 - 正确实现方式
        const char *update_message(void) {
            // 使用静态或全局缓冲区
            memset(g_send_buf, 0, sizeof(g_send_buf));
            snprintf(g_send_buf, sizeof(g_send_buf), "Hello, Server! Time: %ld", time(NULL));
            return g_send_buf;
        }

        // 错误处理回调
        void error_handler(tcp_error_t code, const char* msg) {
            if (code >= 0) {
                printf("信息: %s\n", msg);
            } else {
                printf("错误: %s (代码: %d)\n", msg, code);
            }
        }

        int main() {
            const char *ip = "192.168.0.101";
            int port = 8080;
            int interval = 1; // 间隔时间(秒)

            // 启动TCP客户端
            int ret = start_tcp_client(ip, port, interval, update_message, recv_handler, error_handler);

            if (ret != TCP_OK) {
                printf("TCP客户端启动失败，错误码: %d\n", ret);
            }

            return ret;
        }

## 常见问题及解决方案

1. **发送回调返回的字符串无效**
   - 问题：使用局部变量作为返回值会导致内存访问错误
   - 解决：使用静态或全局缓冲区，或动态分配内存（需要管理内存释放）

2. **连接频繁断开**
   - 问题：网络不稳定或服务器问题
   - 解决：检查网络连接和服务器状态，库会自动尝试重连

3. **内存泄漏**
   - 问题：长时间运行可能导致内存泄漏
   - 解决：确保回调函数中不存在内存泄漏，特别是在处理接收数据时

4. **CPU占用高**
   - 问题：在某些情况下可能导致CPU占用率高
   - 解决：增加发送间隔时间，减少不必要的数据发送

## 编译和链接

将TCP库链接到您的项目中：

        # 编译您的程序并链接TCP库
        $(CC) your_program.c -o your_program -I/path/to/include -L/path/to/lib -ltcpclient

在Makefile中：

        CFLAGS += -I/path/to/include
        LDFLAGS += -L/path/to/lib -ltcpclient

        your_program: your_program.c
            $(CC) $(CFLAGS) $^ -o $@ $(LDFLAGS)

# shared-memory 共享内存API使用方法

## 功能简介
shared-memory模块实现了基于POSIX共享内存的进程间高效数据共享，支持多进程安全的读写，适合实时数据采集与上层应用解耦。

- 支持结构体数据直接共享
- 采用读写锁+互斥锁，保证多进程并发安全
- 结构体内容和内存大小可配置
- 支持动态添加/删除共享内存

## 主要结构体和接口

头文件：`#include "shared_memory.h"`

```c
// 共享内存配置
typedef struct {
    char name[64];      // 共享内存名称
    size_t size;        // 共享内存大小
} shm_config_t;

// 共享内存句柄
typedef struct {
    int shm_fd;
    void *addr;
    size_t size;
    pthread_rwlock_t *rwlock;
    pthread_mutex_t *mutex;
    char name[64];
} shm_handle_t;

// 主要API
int shm_create(const shm_config_t *config, shm_handle_t *handle); // 创建/打开
int shm_destroy(shm_handle_t *handle); // 关闭/销毁
int shm_write(shm_handle_t *handle, const void *data, size_t offset, size_t len); // 写入
int shm_read(shm_handle_t *handle, void *buf, size_t offset, size_t len); // 读取
int shm_add(const shm_config_t *config); // 动态添加
int shm_remove(const char *name); // 删除
```

## 典型使用流程

### 1. 采集进程写入数据
```c
sensor_data_t data = {25.5, 60.2, 101.3, 5.8};
shm_config_t config = {"/test_shm", 1024};
shm_handle_t handle;
shm_create(&config, &handle);
shm_write(&handle, &data, 0, sizeof(sensor_data_t));
// ...
shm_destroy(&handle);
```

### 2. 应用进程读取数据
```c
sensor_data_t data;
shm_config_t config = {"/test_shm", 1024};
shm_handle_t handle;
shm_create(&config, &handle);
shm_read(&handle, &data, 0, sizeof(sensor_data_t));
// printf("温度=%.2f, 湿度=%.2f, 压力=%.2f, 液位=%.2f\n", data.temperature, data.humidity, data.pressure, data.level);
shm_destroy(&handle);
```

### 3. 结构体定义示例
```c
typedef struct {
    float temperature;
    float humidity;
    float pressure;
    float level;
} sensor_data_t;
```

## 逻辑说明
- 采集进程定时采集数据，写入共享内存
- 其他进程可任意频率读取共享内存，获取最新数据
- 共享内存只负责数据同步，不做持久化，如需存数据库请另行实现

## 交叉编译说明
- 支持通过CC变量指定交叉编译器
- 示例：
```sh
make -C shared-memory CC=arm-poky-linux-gnueabi-gcc
```
- 或在根目录直接指定CC：
```sh
make CC=arm-poky-linux-gnueabi-gcc
```

更多细节请参考shared-memory目录下的源码和测试用例。