import ctypes
import platform

# Detectar plataforma y cargar librería apropiada
system = platform.system().lower()
if system == "linux":
    lib = ctypes.CDLL("./libsysmon.so")
elif system == "windows":
    lib = ctypes.CDLL("./sysmon.dll")
elif system == "darwin":  # macOS
    lib = ctypes.CDLL("./libsysmon.dylib")

# Configurar tipos de retorno
lib.sysmon_get_cpu_usage_percent.restype = ctypes.c_float
lib.sysmon_get_ram_usage_percent.restype = ctypes.c_float
lib.sysmon_get_cpu_temperature.restype = ctypes.c_float

# Inicializar
lib.sysmon_init()

# Obtener información (funciona en todas las plataformas)
cpu_usage = lib.sysmon_get_cpu_usage_percent()
ram_usage = lib.sysmon_get_ram_usage_percent()
cpu_temp = lib.sysmon_get_cpu_temperature()

print(f"CPU: {cpu_usage:.1f}%")
print(f"RAM: {ram_usage:.1f}%") 
print(f"Temp: {cpu_temp:.1f}°C")

lib.sysmon_cleanup()

import time
import threading

class HardwareMonitor:
    def __init__(self):
        self.lib = ctypes.CDLL('./libsysmon.so')
        self.lib.sysmon_init()
        self.running = False
        
    def start_monitoring(self, callback, interval=1.0):
        """Inicia monitoreo en tiempo real
        callback: función que recibe los datos
        interval: intervalo en segundos (1.0 = 1Hz perfecto para gráficos)
        """
        self.running = True
        
        def monitor_loop():
            while self.running:
                data = {
                    'timestamp': time.time(),
                    'cpu_usage': self.lib.sysmon_get_cpu_usage_percent(),
                    'ram_usage': self.lib.sysmon_get_ram_usage_percent(),
                    'cpu_temp': self.lib.sysmon_get_cpu_temperature(),
                    'gpu_usage': self.lib.sysmon_get_gpu_usage_percent(),
                    'cpu_freq': self.lib.sysmon_get_cpu_frequency()
                }
                callback(data)
                time.sleep(interval)
        
        thread = threading.Thread(target=monitor_loop)
        thread.daemon = True
        thread.start()
        return thread
    
    def stop_monitoring(self):
        self.running = False

# Usar en tu aplicación de escritorio
def update_charts(data):
    # Actualizar tus gráficos aquí
    print(f"CPU: {data['cpu_usage']:.1f}% | RAM: {data['ram_usage']:.1f}% | Temp: {data['cpu_temp']:.1f}°C")

monitor = HardwareMonitor()
monitor.start_monitoring(update_charts, interval=1.0)  # 1Hz

# Configurar tipos de retorno para mejor rendimiento
lib.sysmon_get_cpu_usage_percent.restype = ctypes.c_float
lib.sysmon_get_ram_usage_percent.restype = ctypes.c_float
lib.sysmon_get_cpu_temperature.restype = ctypes.c_float
lib.sysmon_get_gpu_count.restype = ctypes.c_int
lib.sysmon_battery_is_present.restype = ctypes.c_int

import ctypes
import tkinter as tk
from tkinter import ttk

class SystemDashboard:
    def __init__(self):
        # Cargar librería
        self.lib = ctypes.CDLL('./libsysmon.so')
        self.lib.sysmon_init()
        
        # Configurar tipos
        self.lib.sysmon_get_cpu_model.restype = ctypes.c_char_p
        self.lib.sysmon_get_cpu_cores.restype = ctypes.c_int
        self.lib.sysmon_get_ram_total_kb.restype = ctypes.c_ulong
        
        # Crear interfaz
        self.root = tk.Tk()
        self.root.title("System Dashboard")
        self.create_widgets()
        self.update_info()
    
    def create_widgets(self):
        # CPU Info
        ttk.Label(self.root, text="CPU:").grid(row=0, column=0, sticky="w")
        self.cpu_label = ttk.Label(self.root, text="Loading...")
        self.cpu_label.grid(row=0, column=1, sticky="w")
        
        # RAM Info
        ttk.Label(self.root, text="RAM:").grid(row=1, column=0, sticky="w")
        self.ram_label = ttk.Label(self.root, text="Loading...")
        self.ram_label.grid(row=1, column=1, sticky="w")
    
    def update_info(self):
        # Obtener información del sistema
        cpu_model = self.lib.sysmon_get_cpu_model().decode()
        cpu_cores = self.lib.sysmon_get_cpu_cores()
        ram_total = self.lib.sysmon_get_ram_total_kb() / (1024*1024)
        
        # Actualizar interfaz
        self.cpu_label.config(text=f"{cpu_model} ({cpu_cores} cores)")
        self.ram_label.config(text=f"{ram_total:.1f} GB")

# Usar
dashboard = SystemDashboard()
dashboard.root.mainloop()

import ctypes
import time
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
import threading
from collections import deque

class RealtimeMonitor:
    def __init__(self):
        # Cargar librería
        self.lib = ctypes.CDLL('./libsysmon.so')
        self.lib.sysmon_init()
        
        # Configurar tipos
        self.lib.sysmon_get_cpu_usage_percent.restype = ctypes.c_float
        self.lib.sysmon_get_ram_usage_percent.restype = ctypes.c_float
        self.lib.sysmon_get_cpu_temperature.restype = ctypes.c_float
        
        # Datos para gráficos
        self.cpu_data = deque(maxlen=60)  # 60 segundos
        self.ram_data = deque(maxlen=60)
        self.temp_data = deque(maxlen=60)
        self.time_data = deque(maxlen=60)
        
        # Iniciar monitoreo
        self.running = True
        self.monitor_thread = threading.Thread(target=self.monitor_loop)
        self.monitor_thread.daemon = True
        self.monitor_thread.start()
    
    def monitor_loop(self):
        """Bucle de monitoreo en tiempo real - 1Hz"""
        start_time = time.time()
        
        while self.running:
            # Obtener métricas actuales
            cpu_usage = self.lib.sysmon_get_cpu_usage_percent()
            ram_usage = self.lib.sysmon_get_ram_usage_percent()
            cpu_temp = self.lib.sysmon_get_cpu_temperature()
            
            # Agregar a datos
            current_time = time.time() - start_time
            self.cpu_data.append(cpu_usage)
            self.ram_data.append(ram_usage)
            self.temp_data.append(cpu_temp if cpu_temp > 0 else 0)
            self.time_data.append(current_time)
            
            # Esperar 1 segundo (1Hz - perfecto para gráficos)
            time.sleep(1.0)
    
    def create_realtime_plot(self):
        """Crear gráfico en tiempo real"""
        fig, (ax1, ax2, ax3) = plt.subplots(3, 1, figsize=(10, 8))
        
        def animate(frame):
            if len(self.time_data) > 0:
                # CPU Usage
                ax1.clear()
                ax1.plot(list(self.time_data), list(self.cpu_data), 'b-', label='CPU %')
                ax1.set_ylabel('CPU Usage (%)')
                ax1.set_ylim(0, 100)
                ax1.legend()
                ax1.grid(True)
                
                # RAM Usage
                ax2.clear()
                ax2.plot(list(self.time_data), list(self.ram_data), 'g-', label='RAM %')
                ax2.set_ylabel('RAM Usage (%)')
                ax2.set_ylim(0, 100)
                ax2.legend()
                ax2.grid(True)
                
                # Temperature
                ax3.clear()
                ax3.plot(list(self.time_data), list(self.temp_data), 'r-', label='CPU Temp')
                ax3.set_ylabel('Temperature (°C)')
                ax3.set_xlabel('Time (seconds)')
                ax3.legend()
                ax3.grid(True)
        
        ani = FuncAnimation(fig, animate, interval=1000, blit=False)
        plt.tight_layout()
        plt.show()

# Usar en tu aplicación
monitor = RealtimeMonitor()
monitor.create_realtime_plot()  # Gráfico en tiempo real

import sys
import ctypes
from PyQt5.QtWidgets import QApplication, QMainWindow, QVBoxLayout, QWidget, QLabel
from PyQt5.QtCore import QTimer

class HardwareMonitorApp(QMainWindow):
    def __init__(self):
        super().__init__()
        
        # Cargar librería
        self.lib = ctypes.CDLL('./libsysmon.so')
        self.lib.sysmon_init()
        
        # Configurar tipos
        self.lib.sysmon_get_cpu_usage_percent.restype = ctypes.c_float
        self.lib.sysmon_get_ram_usage_percent.restype = ctypes.c_float
        self.lib.sysmon_get_cpu_temperature.restype = ctypes.c_float
        
        self.init_ui()
        
        # Timer para actualización en tiempo real
        self.timer = QTimer()
        self.timer.timeout.connect(self.update_metrics)
        self.timer.start(1000)  # 1Hz
    
    def init_ui(self):
        self.setWindowTitle('Hardware Monitor')
        self.setGeometry(100, 100, 400, 200)
        
        central_widget = QWidget()
        self.setCentralWidget(central_widget)
        
        layout = QVBoxLayout()
        
        self.cpu_label = QLabel('CPU: Loading...')
        self.ram_label = QLabel('RAM: Loading...')
        self.temp_label = QLabel('Temperature: Loading...')
        
        layout.addWidget(self.cpu_label)
        layout.addWidget(self.ram_label)
        layout.addWidget(self.temp_label)
        
        central_widget.setLayout(layout)
    
    def update_metrics(self):
        """Actualizar métricas cada segundo"""
        cpu_usage = self.lib.sysmon_get_cpu_usage_percent()
        ram_usage = self.lib.sysmon_get_ram_usage_percent()
        cpu_temp = self.lib.sysmon_get_cpu_temperature()
        
        self.cpu_label.setText(f'CPU: {cpu_usage:.1f}%')
        self.ram_label.setText(f'RAM: {ram_usage:.1f}%')
        self.temp_label.setText(f'Temperature: {cpu_temp:.1f}°C')

# Usar
app = QApplication(sys.argv)
window = HardwareMonitorApp()
window.show()
sys.exit(app.exec_())