SmartPDCode/485/src/common.c

#include "common.h"
#include "elog.h"
#include <unistd.h>
#include <sys/types.h>
#include <sys/sysinfo.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <net/if.h>
#include <arpa/inet.h>
#include <sys/vfs.h>
 #include <dirent.h>
 
//#define LOG_TAG    "main"

void printf_global_device_info(GlobalDeviceInfo* _globalDeviceInfo)
{
    log_d("******global device info********* ");
    log_d("product_id:%d ", _globalDeviceInfo->product_id);
    log_d("product_number:%s ", _globalDeviceInfo->product_number);
    log_d("product_name:%s ", _globalDeviceInfo->product_name);
    log_d("product_type:%d ", _globalDeviceInfo->product_type);
    log_d("product_pwr_type:%d ", _globalDeviceInfo->product_pwr_type);
    log_d("product_version:%s ", _globalDeviceInfo->product_version);
    log_d("product_count:%d ", _globalDeviceInfo->product_count);
    log_d("product_samp_time:%d ", _globalDeviceInfo->product_samp_time);
    log_d("product_save_time:%d ", _globalDeviceInfo->product_save_time);   

    log_d("product_modbus_type:%d ", _globalDeviceInfo->_modbus_info.product_modbus_type);
    log_d("product_modbus_baud:%d ", _globalDeviceInfo->_modbus_info.product_modbus_baud);
    log_d("product_modbus_addr:%d ", _globalDeviceInfo->_modbus_info.product_modbus_addr);
    log_d("product_relay_port:%s ",  _globalDeviceInfo->_modbus_info.product_relay_ctrl_port);
    log_d("******************************** ");
}

void printf_global_power_manage_info(GlobalPowerManger* _globalPowerManger)
{
    printf("******global power manage info********* ");
    printf("product_id:%d ", _globalPowerManger->product_id);
    printf("product_ch_id:%d ", _globalPowerManger->product_ch_id);
    printf("product_ch_name:%s ", _globalPowerManger->product_ch_name);
    printf("product_ch_type:%d ", _globalPowerManger->product_ch_type);
    printf("product_ch_status:%d ", _globalPowerManger->product_ch_status);
    printf("product_ch_start_delay:%d ", _globalPowerManger->product_ch_start_delay);
    printf("product_ch_stop_delay:%d ", _globalPowerManger->product_ch_stop_delay);

    printf("product_vol_upper_enable:%d ", _globalPowerManger->global_over_manager->product_vol_upper_enable);
    printf("product_vol_upper_threshold:%0.2f ", _globalPowerManger->global_over_manager->product_vol_upper_threshold);
    printf("product_vol_over_upper_threshold_ctrl:%d ", _globalPowerManger->global_over_manager->product_vol_over_upper_threshold_ctrl);
     printf("product_vol_over_upper_threshold_para:%d ", _globalPowerManger->global_over_manager->product_vol_over_upper_threshold_ctrl_para);

    printf("product_vol_lower_enable:%d ", _globalPowerManger->global_over_manager->product_vol_lower_enable);
    printf("product_vol_lower_threshold:%0.2f ", _globalPowerManger->global_over_manager->product_vol_lower_threshold);
    printf("product_vol_over_lower_threshold_ctrl:%d ", _globalPowerManger->global_over_manager->product_vol_over_lower_threshold_ctrl);
    printf("product_vol_over_lower_threshold_ctrl_para:%d ", _globalPowerManger->global_over_manager->product_vol_over_lower_threshold_ctrl_para);

    printf("product_cur_upper_enable:%d ", _globalPowerManger->global_over_manager->product_cur_upper_enable);
    printf("product_cur_upper_threshold:%0.2f ", _globalPowerManger->global_over_manager->product_cur_upper_threshold);
    printf("product_cur_over_upper_threshold_ctrl:%d ", _globalPowerManger->global_over_manager->product_cur_over_upper_threshold_ctrl);
        printf("product_cur_over_upper_threshold_ctrl_para:%d ", _globalPowerManger->global_over_manager->product_cur_over_upper_threshold_ctrl_para);

    printf("product_pwr_upper_enable:%d ", _globalPowerManger->global_over_manager->product_pwr_upper_enable);
    printf("product_pwr_upper_threshold:%0.2f ", _globalPowerManger->global_over_manager->product_pwr_upper_threshold);
    printf("product_pwr_over_upper_threshold_ctrl:%d ", _globalPowerManger->global_over_manager->product_pwr_over_upper_threshold_ctrl);
    printf("product_pwr_over_upper_threshold_ctrl_para:%d ", _globalPowerManger->global_over_manager->product_pwr_over_upper_threshold_ctrl_para);

    printf("product_pwrcon_upper_enable:%d ", _globalPowerManger->global_over_manager->product_pwrcon_upper_enable);
    printf("product_pwrcon_upper_threshold:%0.2f ", _globalPowerManger->global_over_manager->product_pwrcon_upper_threshold);
    printf("product_pwrcon_over_upper_threshold_ctrl:%d ", _globalPowerManger->global_over_manager->product_pwrcon_over_upper_threshold_ctrl);
    printf("product_pwrcon_over_upper_threshold_ctrl_para:%d ", _globalPowerManger->global_over_manager->product_pwrcon_over_upper_threshold_ctrl_para);
    printf("******************************** ");
}

//打印电源信息
void printf_power_info(GlobalPowerInfo* _globalPowerInfo)
{
    //struct list_head *pos;
    GlobalPowerInfo* _temp;
    int i = 0;
    list_for_each_entry(_temp, &_globalPowerInfo->list, list)
    {
        printf("i:%d ", i++);
        printf("samp_time:%s ", _temp->samp_time);
        printf("product_id:%d ", _temp->product_id);
    }
}


void INIT_LIST_HEAD(struct list_head *list)
{
    list->next = list->prev = list;
}


/**
 * EasyLogger demo
 */
// void test_elog(void) {
//     uint8_t buf[256]= {0};
//     int i = 0;

//     for (i = 0; i < sizeof(buf); i++)
//     {
//         buf[i] = i;
//     }
//     while(true) {
//         /* test log output for all level */
//         log_a("Hello EasyLogger!");
//         log_e("Hello EasyLogger!");
//         log_w("Hello EasyLogger!");
//         log_i("Hello EasyLogger!");
//         log_d("Hello EasyLogger!");
//         log_v("Hello EasyLogger!");
// //        elog_raw("Hello EasyLogger!");
//         elog_hexdump("test", 16, buf, sizeof(buf));
//         sleep(5);
//     }
// }


#if(1)
void initLogger(void)
{
    setbuf(stdout, NULL);
    elog_init();
    elog_set_fmt(ELOG_LVL_ASSERT, ELOG_FMT_ALL);
    elog_set_fmt(ELOG_LVL_ERROR, ELOG_FMT_LVL | ELOG_FMT_TAG | ELOG_FMT_TIME);
    elog_set_fmt(ELOG_LVL_WARN, ELOG_FMT_LVL | ELOG_FMT_TAG | ELOG_FMT_TIME);
    elog_set_fmt(ELOG_LVL_INFO, ELOG_FMT_LVL | ELOG_FMT_TAG | ELOG_FMT_TIME);
    elog_set_fmt(ELOG_LVL_DEBUG, ELOG_FMT_ALL & ~ELOG_FMT_FUNC);
    elog_set_fmt(ELOG_LVL_VERBOSE, ELOG_FMT_ALL & ~ELOG_FMT_FUNC);   
    elog_set_text_color_enabled(true);
    elog_start(); 

    log_i("Smart Pdu Application Running!");
}
#endif


/// @brief 获取系统mem大小
/// @param totalSize 
/// @return 
int getTotalMemorySize(unsigned int* totalSize)
{
    struct sysinfo memInfo;
    
    if (sysinfo(&memInfo) != -1) {
        *totalSize = memInfo.totalram;
        // printf("Total RAM size: %lu bytes\n", memInfo.totalram);
        // printf("Free RAM size: %lu bytes\n", memInfo.freeram);
    }
    else
    {
        *totalSize = 0 ;
        return -1;
    }    
    return 0;
}

/// @brief 返回设备IP地址
/// @param dev 网口名
/// @return 
char* getLocalIpAddress(char* dev)
{
    int fd;
    struct ifreq ifr;

    fd = socket(AF_INET, SOCK_DGRAM, 0);
    ifr.ifr_addr.sa_family = AF_INET;
    strncpy(ifr.ifr_name, dev, IFNAMSIZ-1);
 
    ioctl(fd, SIOCGIFADDR, &ifr);
    close(fd);

    return inet_ntoa(((struct sockaddr_in *)&ifr.ifr_addr)->sin_addr);
}

/// @brief 获取磁盘使用率
/// @param reused 
void get_disk_occupy(char ** reused)
{
    const unsigned short MAXBUFSIZE = 1024;
    char currentDirectoryPath[ MAXBUFSIZE ];
    getcwd(currentDirectoryPath, MAXBUFSIZE);
    //printf("当前目录：%s\n",currentDirectoryPath);
    char cmd[50] = "df ";
    strcat(cmd, currentDirectoryPath);
    //printf("%s\n",cmd);
 
    char buffer[MAXBUFSIZE];
    FILE* pipe = popen(cmd, "r");
    char fileSys[20];
    char blocks[20];
    char used[20];
    char free[20];
    char percent[10];
    char moment[20];
    if (!pipe)
    {
        return;
    }
    if (fgets(buffer, sizeof(buffer), pipe) != NULL)
    {
        sscanf(buffer, "%s %s %s %s %s %s", fileSys, blocks, used, free, percent, moment);
    }
    if (fgets(buffer, sizeof(buffer), pipe) != NULL)
    {
        sscanf(buffer, "%s %s %s %s %s %s", fileSys, blocks, used, free, percent, moment);
    }
    //printf("desk used:%s\n",percent);
    strcpy(*reused, percent);
    return;
}

char* getUserNamebyToken(char* Token)
{
    char* userName = NULL;

    if (Token==NULL)
    {
        return NULL;
    }
    
    _User_Log *_UserInfoTemp = NULL;
    list_for_each_entry(_UserInfoTemp, &_GlobalUserLoginInfo.list, list)
    {
        if (_UserInfoTemp == NULL)
            break;

        if (strcmp(_UserInfoTemp->user_token, Token) == 0)
        {
            userName=_UserInfoTemp->user_name;
        }
    }

    return userName;
}

int is_process_running(const char *process_name)
{  
    DIR *dir;  
    struct dirent *entry;  
    char path[1035]; // /proc/[pid]/cmdline 的最大路径长度（/proc/ + PID(最多5位) + /cmdline + \0）  
    char buffer[4096]; // 假设cmdline不会超过这个长度  
    FILE *file;  
  
    dir = opendir("/proc");  
    if (dir == NULL) {  
        perror("opendir");  
        return -1;  
    }  
  
    while ((entry = readdir(dir)) != NULL) {  
        // 忽略非数字目录（即非进程目录）  
        if (!isdigit(entry->d_name[0])) {  
            continue;  
        }  
  
        // 构造cmdline文件的完整路径  
        snprintf(path, sizeof(path), "/proc/%s/cmdline", entry->d_name);  
  
        // 打开cmdline文件  
        file = fopen(path, "r");  
        if (file == NULL) {  
            continue; // 忽略无法打开的文件  
        }  
  
        // 读取cmdline文件的内容  
        if (fgets(buffer, sizeof(buffer), file) != NULL) {  
            // 去除cmdline中的空字符（进程名与参数间用空字符分隔）  
            size_t len = strlen(buffer);  
            while (len > 0 && buffer[len - 1] == '\0') {  
                buffer[--len] = '\0';  
            }  
  
            // 比较进程名（这里假设process_name是完整的命令行，但你可以修改逻辑来仅比较进程名）  
            if (strstr(buffer, process_name) != NULL) {  
                fclose(file);  
                closedir(dir);  
                return 1; // 进程已启动  
            }  
        }  
  
        fclose(file);  
    }  
  
    closedir(dir);  
    return 0; // 进程未启动  
}