monitor.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

// ----------------------------------------------------------------------
// Função para obter uso de CPU
// ----------------------------------------------------------------------
float get_cpu_usage() {
    static long prev_total = 0, prev_idle = 0;
    long user, nice, system, idle, iowait, irq, softirq, steal;
    long total, total_diff, idle_diff;

    FILE *f = fopen("/proc/stat", "r");
    if (!f) return -1;

    fscanf(f, "cpu %ld %ld %ld %ld %ld %ld %ld %ld",
           &user, &nice, &system, &idle, &iowait, &irq, &softirq, &steal);
    fclose(f);

    total = user + nice + system + idle + iowait + irq + softirq + steal;

    total_diff = total - prev_total;
    idle_diff  = idle - prev_idle;

    prev_total = total;
    prev_idle  = idle;

    if (total_diff == 0) return 0;

    return (100.0 * (total_diff - idle_diff) / total_diff);
}

// ----------------------------------------------------------------------
// Função para obter RAM total e livre
// ----------------------------------------------------------------------
void get_memory_usage(long *total, long *free) {
    char label[32], unit[8];
    long value;

    *total = *free = 0;

    FILE *f = fopen("/proc/meminfo", "r");
    if (!f) return;

    while (fscanf(f, "%31s %ld %7s", label, &value, unit) != EOF) {
        if (strcmp(label, "MemTotal:") == 0) *total = value;
        if (strcmp(label, "MemAvailable:") == 0) *free = value;

        if (*total > 0 && *free > 0) break;
    }

    fclose(f);
}

// ----------------------------------------------------------------------
// Função para obter I/O de disco
// ----------------------------------------------------------------------
void get_disk_io(long *read, long *write) {
    char device[32];
    long reads, read_sectors, writes, write_sectors;

    *read = *write = 0;

    FILE *f = fopen("/proc/diskstats", "r");
    if (!f) return;

    while (fscanf(f, "%*d %*d %31s %ld %*d %ld %*d %ld %*d %ld",
                  device, &reads, &read_sectors, &writes, &write_sectors) != EOF) {

        if (strcmp(device, "sda") == 0 || strcmp(device, "nvme0n1") == 0) {
            *read  = read_sectors * 512;
            *write = write_sectors * 512;
            break;
        }
    }

    fclose(f);
}

// ----------------------------------------------------------------------
// Número de núcleos
// ----------------------------------------------------------------------
int get_cpu_cores() {
    FILE *f = fopen("/proc/cpuinfo", "r");
    if (!f) return -1;

    char line[256];
    int cores = 0;

    while (fgets(line, sizeof(line), f)) {
        if (strncmp(line, "processor", 9) == 0) cores++;
    }

    fclose(f);
    return cores;
}

// ----------------------------------------------------------------------
// Uso da GPU NVIDIA (%)
// ----------------------------------------------------------------------
int get_gpu_usage() {
    FILE *fp = popen("nvidia-smi --query-gpu=utilization.gpu --format=csv,noheader,nounits", "r");
    if (!fp) return -1;

    int usage = 0;
    fscanf(fp, "%d", &usage);

    pclose(fp);
    return usage;
}

// ----------------------------------------------------------------------
// Temperatura da GPU NVIDIA (°C)
// ----------------------------------------------------------------------
int get_gpu_temp() {
    FILE *fp = popen("nvidia-smi --query-gpu=temperature.gpu --format=csv,noheader,nounits", "r");
    if (!fp) return -1;

    int temp = 0;
    fscanf(fp, "%d", &temp);

    pclose(fp);
    return temp;
}

// ----------------------------------------------------------------------
// Potência (Watts) da GPU NVIDIA
// ----------------------------------------------------------------------
float get_gpu_power() {
    FILE *fp = popen("nvidia-smi --query-gpu=power.draw --format=csv,noheader,nounits", "r");
    if (!fp) return -1;

    float watts = 0.0f;
    fscanf(fp, "%f", &watts);

    pclose(fp);
    return watts;
}

// ----------------------------------------------------------------------
// PROGRAMA PRINCIPAL
// ----------------------------------------------------------------------
int main() {
    printf("Monitor completo do sistema (CPU, RAM, Disco, Cores, GPU)\n");

    long mem_total, mem_free;
    long disk_read_prev = 0, disk_write_prev = 0;

    int cores = get_cpu_cores();

    while (1) {
        float cpu = get_cpu_usage();

        get_memory_usage(&mem_total, &mem_free);

        long disk_read, disk_write;
        get_disk_io(&disk_read, &disk_write);

        long read_diff  = disk_read - disk_read_prev;
        long write_diff = disk_write - disk_write_prev;

        disk_read_prev = disk_read;
        disk_write_prev = disk_write;

        // Comentar essas linhas se não tiver GPU NVIDIA ou nvidia-smi instalado
        int gpu = get_gpu_usage();
        int gpu_temp = get_gpu_temp();
        float gpu_power = get_gpu_power();

        system("clear");
        printf("=== MONITOR DE SISTEMA ===\n\n");

        printf("CPU: %.2f%%\n", cpu);
        printf("Núcleos: %d\n\n", cores);

        printf("RAM Total: %ld MB\n", mem_total / 1024);
        printf("RAM Livre: %ld MB\n", mem_free / 1024);
        printf("Uso da RAM: %.2f%%\n\n",
               100.0 * (mem_total - mem_free) / mem_total);

        printf("Disco (sda/nvme0n1):\n");
        printf("Leitura: %ld KB/s\n", read_diff / 1024);
        printf("Escrita: %ld KB/s\n\n", write_diff / 1024);
        
        // Comentar esse bloco se não tiver GPU NVIDIA ou nvidia-smi instalado
        printf("GPU (RTX):\n");
        printf("Uso: %d%%\n", gpu);
        printf("Temperatura: %d°C\n", gpu_temp);
        printf("Consumo: %.2f Watts\n", gpu_power);

        sleep(1);
    }

    return 0;
}