<repo_name>K4YO/SysInfo<file_sep>/README.md
# SysInfo
Sistema de informação e monitoramento Desktop inteligente
Developers                                       Version : 1.0.1
<NAME>                                    Date: 11/26/2017
<NAME>
<NAME>
<NAME>

PUC Minas - Sistemas de Informação 
Arquitetura de Computadores 
<file_sep>/TP_ARQUITETURA/Conversoes.cs
﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace TP_ARQUITETURA
{
    public class Conversoes
    {
        public static string ConverterUnMedida(string Num) 
        {
            double numero = 0;

            if (Num != string.Empty)
            {
                numero = Convert.ToDouble(Num);
            }
            if (numero <= 1024)
            {
                return numero + " Bits";
            }
            else if (numero >= 1024 && numero < 1048576)
            {
                return (numero / 1024).ToString("0.00") + " KB";
            }
            else if (numero >= 1048576 && numero < 1073741824)
            {
                return (numero / 1048576).ToString("0.00") + " MB";
            }
            else if (numero >= 1073741824 && numero < 1099511627776)
            {
                return (numero / 1073741824).ToString("0.00") + " GB";
            }
            else if (numero >= 1099511627776 && numero <= 1125899906842624)
            {
                return (numero / 1099511627776).ToString("0.00") + " TB";
            }
            else
            {
                return numero.ToString();
            }
        }
    }
}
<file_sep>/TP_ARQUITETURA/Memoria.cs
﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Management;
using System.Diagnostics;
using System.Text;
using System.Threading.Tasks;

namespace TP_ARQUITETURA
{
    public class Memoria
    {
        private PerformanceCounter memoryAvailable = new PerformanceCounter("Memory", "Available Bytes");
        private PerformanceCounter memoryInUse = new PerformanceCounter("Memory", "% Committed Bytes In Use"); //porcentagem

        //VARIAVEIS COM GETSET
        public string Nome { get; set; }
        public string CapacidadeTotal { get; set; } 
        public string Frequecia { get; set; }
        public string FrequeciaClock { get; set; }
        public string TipoMemoria { get; set; }
        public string MaxVoltage { get; set; }
        
        private double BitsTotal;

      
        //CONSTRUTOR
        public Memoria()
        { 
        this.IniciaMemoria(); 
        }

        private void IniciaMemoria()
        {
            double aux;
            ManagementObjectSearcher InfoMemory = new ManagementObjectSearcher("root\\CIMV2", "SELECT * FROM Win32_PhysicalMemory");
            foreach (ManagementObject memory in InfoMemory.Get()) 
            { 
                this.Nome = memory["Name"].ToString();
                this.BitsTotal = Convert.ToDouble(memory["Capacity"]);
                aux = Convert.ToDouble(memory["MaxVoltage"]) / 1000;
                if (aux == 0)  this.MaxVoltage = "Desconhecido";
                else this.MaxVoltage = string.Format("{0:0.0} Volts", Convert.ToDouble(memory["MaxVoltage"]) / 1000);
                this.TipoMemoria = VerificaTipoMemoria(Convert.ToInt32(memory["MemoryType"]), Convert.ToInt32(memory["MaxVoltage"]));
                this.Frequecia = string.Format("{0} MHz", memory["Speed"]);
                this.FrequeciaClock = string.Format("{0} MHz", memory["ConfiguredClockSpeed"]);
            } 
            this.CapacidadeTotal = Conversoes.ConverterUnMedida(BitsTotal.ToString());  
        }
      
        public float PercentUso() { return memoryInUse.NextValue(); }
        public string CapacidadeLivre() { return Conversoes.ConverterUnMedida(memoryAvailable.NextValue().ToString()); }
        public string CapacidadeUtilizada() { return Conversoes.ConverterUnMedida((this.BitsTotal - memoryAvailable.NextValue()).ToString()); }


       public string VerificaTipoMemoria(int MemoryType, int MaxVoltage)
        {
            switch (MemoryType)
            {
                case 20:

                    return "DDR";
                 

                case 21:

                    return "DDR2";

                case 22:

                    return "DDR2 FB-DIMM";

                case 24:
                    return "DDR3";
                    
                default:

                    if (MemoryType == 0 || MemoryType > 24 || MaxVoltage > 1200)
                    {
                      return "DDR4";                       
                    }

                    else
                    {
                        return "OUTRO";
                    }
                   
            } 
        } 
 
    }
}
<file_sep>/TP_ARQUITETURA/Form1.cs
﻿using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using MetroFramework.Forms;
using MetroFramework.Controls;

namespace TP_ARQUITETURA
{
    public partial class Form1 : MetroForm
    {
        List<Disco> storage = new List<Disco>();
        Disco disks = new Disco();
        Processador proc = new Processador();
        Memoria ram = new Memoria();
        public Form1()
        {
            InitializeComponent();

            disks.GetInfoDisk(ref storage);
            InsertInfoListStorage(ref metroListViewStorage, storage);

            txt_proc_l1.Text = Convert.ToString(proc.L1Cache);
            txt_proc_l2.Text = Convert.ToString(proc.L2Cache);
            txt_proc_l3.Text = Convert.ToString(proc.L3Cache);
            txt_proc_log.Text = Convert.ToString(proc.ProcessadoresLogicos);
            txt_proc_modelo.Text = proc.Nome;
            txt_prox_nuc.Text = Convert.ToString(proc.Nucleos);
            txt_proc_arq.Text = proc.Arquitetura;
            txt_proc_freqmax.Text = proc.FrequeciaMaxima;

            txt_ram_bar.Text = ram.TipoMemoria;
            txt_ram_freq.Text = ram.Frequecia;
            txt_ram_Clock.Text = ram.FrequeciaClock;
            txt_ram_volts.Text = ram.MaxVoltage;           
            txt_ram_total.Text = ram.CapacidadeTotal;
           
       
        }
        
        private void InsertInfoListStorage(ref MetroListView lst, List<Disco> storage)
        {
            lst.Items.Clear();
            ListViewGroup grp;
            string[] Texts = { "DeviceID", "Nome Unidade", "Rótulo", "Tipo Partição", "Tipo Disco", "Capacidade Total", "Capacidade Utilizada", "Capacidade Livre" };
            string[] Properties = { "DeviceID", "NomeUnidade", "Rotulo", "TipoParticao", "TipoDisco", "CapacidadeTotal", "CapacidadeUilizada", "CapacidadeLivre" };
            try
            {
                foreach (Disco disk in storage)
                {
                    grp = lst.Groups.Add(disk.Nome.ToString(), disk.Nome.ToString());

                    for (int i = 0; i < Texts.Length; i++)
                    {
                        ListViewItem item = new ListViewItem(grp);
                        if (lst.Items.Count % 2 != 0)
                            item.BackColor = Color.White;
                        else item.BackColor = Color.WhiteSmoke;
                        item.Text = Texts[i];
                        item.SubItems.Add(disk.GetProperties(Properties[i]));
                        lst.Items.Add(item);

                    }
                   
                }
            
            }


            catch (Exception exp)
            {
                MessageBox.Show("can't get data because of the followeing error \n" + exp.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Information);
            }


        }
private void label4_Click(object sender, EventArgs e)
        {

        }

        private void textBox4_TextChanged(object sender, EventArgs e)
        {

        }

        private void label3_Click(object sender, EventArgs e)
        {

        }

        private void textBox3_TextChanged(object sender, EventArgs e)
        {

        }

        private void label3_Click_1(object sender, EventArgs e)
        {

        }

        private void textBox3_TextChanged_1(object sender, EventArgs e)
        {

        }

        private void label9_Click(object sender, EventArgs e)
        {

        }

        private void textBox9_TextChanged(object sender, EventArgs e)
        {

        }

        private void label5_Click(object sender, EventArgs e)
        {

        }

        private void textBox5_TextChanged(object sender, EventArgs e)
        {

        }

        private void groupBox3_Enter(object sender, EventArgs e)
        {

        }

        private void label8_Click(object sender, EventArgs e)
        {

        }

        private void timer1_Tick(object sender, EventArgs e)
        {
            float percentCPUInUse = proc.PercentUso();
            float percentMemoryInUse = ram.PercentUso();

           
            txt_ram_livre.Text = ram.CapacidadeLivre();
            txt_ram_uso.Text = ram.CapacidadeUtilizada();
            circularProgressBarCPU.Value = (int)percentCPUInUse; // adiciona a porcentagem do CPU em uso ao valor (gráfico) da barra
            circularProgressBarCPU.Text = string.Format("{0:0.00}%", percentCPUInUse);
            circularProgressBarMemory.Value = (int)percentMemoryInUse; // adiciona a porcentagem da memória primária ao valor (gráfico) da barra
            circularProgressBarMemory.Text = string.Format("{0:0.00}%", percentMemoryInUse);
        }

        private void metroButton1_Click(object sender, EventArgs e)
        {
            Form2 formInformation = new Form2();
            formInformation.Show();
        }

     
    }
}
<file_sep>/TP_ARQUITETURA/Disco.cs
﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Management;
using System.Diagnostics;

//using System.Management.ManagementObject;
//using System.Diagnostics.PerformanceCounter;

namespace TP_ARQUITETURA
{
    public class Disco
    {
        

        //VARIAVEIS COM GETSET
        public string NomeUnidade { get; set; }
        public string DeviceID { get; set; }
        public string Nome { get; set; }
        public string Rotulo { get; set; }
        public string CapacidadeTotal { get; set; }
        public string CapacidadeLivre { get; set; }
        public string CapacidadeUtilizada { get; set; }
        public string TipoParticao { get; set; }
        public string TipoDisco{ get; set; }


        //CONSTRUTOR
        public Disco()
        {
            
        }

        public void GetInfoDisk(ref List<Disco> Disks)
        {
            ManagementObjectSearcher InfoDisk = new ManagementObjectSearcher("root\\CIMV2", "SELECT * FROM Win32_Volume");

            foreach (ManagementObject Disk in InfoDisk.Get())
            {
                foreach (PropertyData Propriedade in Disk.Properties)
                {
                    if (Propriedade.Name.Length > 4 && Propriedade.Name == "Access" && Disk["DeviceID"] != null)
                    {
                                Disco novoDisco = new Disco();
                                novoDisco.Nome = Disk["Name"].ToString();                               
                                novoDisco.DeviceID = Disk["DeviceID"].ToString();
                        try
                        {
                            novoDisco.Rotulo = Disk["Label"].ToString();
                        }
                        catch (NullReferenceException)
                        {
                            novoDisco.Rotulo = "null";
                        }
                                
                        try
                        {
                            
                            novoDisco.NomeUnidade = Disk["Caption"].ToString();
                            novoDisco.CapacidadeTotal = Conversoes.ConverterUnMedida(Disk["Capacity"].ToString());
                            novoDisco.CapacidadeLivre = Conversoes.ConverterUnMedida(Disk["FreeSpace"].ToString());
                            novoDisco.CapacidadeUtilizada = Conversoes.ConverterUnMedida((Convert.ToDouble(Disk["Capacity"]) - Convert.ToDouble(Disk["FreeSpace"])).ToString());
                            novoDisco.TipoParticao = Disk["FileSystem"].ToString();
                        }
                        catch (NullReferenceException)
                        {
                            
                            novoDisco.NomeUnidade = "null";
                            novoDisco.CapacidadeTotal = "null";
                            novoDisco.CapacidadeLivre = "null";
                            novoDisco.CapacidadeUtilizada = "null";
                            novoDisco.TipoParticao = "null";
                        }

                        switch (Convert.ToInt32(Disk["DriveType"]))
                        {
                            case 1:
                                novoDisco.TipoDisco = "Nenhum diretório raiz";
                                break;
                            case 2:
                                novoDisco.TipoDisco = "Disco removível";
                                break;
                            case 3:
                                novoDisco.TipoDisco = "Disco local";
                                break;
                            case 4:
                                novoDisco.TipoDisco = "Unidade de rede";
                                break;
                            case 5:
                                novoDisco.TipoDisco = "Disco compacto";
                                break;
                            case 6:
                                novoDisco.TipoDisco = "Disco RAM";
                                break;

                            default:
                                novoDisco.TipoDisco = "Desconhecido";
                                break;
                        }
                            
                                Disks.Add(novoDisco);
                    }
                }
            }
        }

        public string GetProperties(string query)
        {
            switch (query)
            {
                case "DeviceID":
                    return this.DeviceID;

                case "Nome":
                    return this.Nome;

                case "NomeUnidade":
                    return this.NomeUnidade;

                case "Rotulo":
                    return this.Rotulo;

                case "TipoParticao":
                    return this.TipoParticao;

                case "TipoDisco":
                    return this.TipoDisco;

                case "CapacidadeTotal":
                    return this.CapacidadeTotal;

                case "CapacidadeUilizada":
                    return this.CapacidadeUtilizada;

                case "CapacidadeLivre":
                    return this.CapacidadeLivre;

                default:
                    return "No Information Available";
            }
        }
    }
}
<file_sep>/TP_ARQUITETURA/Processador.cs
﻿using System;
using System.Collections.Generic; 
using System.Diagnostics;
using System.Linq; 
using System.Text;
using System.Threading.Tasks;
using System.Management;


namespace TP_ARQUITETURA
{
    public class Processador
    {
        private PerformanceCounter cpuCounter = new PerformanceCounter("Processor", "% Processor Time", "_Total");
        private ManagementObjectSearcher InfoProcess = new ManagementObjectSearcher("root\\CIMV2", "SELECT * FROM Win32_Processor");
        private ManagementObjectSearcher InfoCache = new ManagementObjectSearcher("root\\CIMV2", "SELECT * FROM Win32_CacheMemory");

        // VARIAVEIS COM GETSET
        public string Nome { get; set; }
        public string Nucleos { get; set; }
        public string ProcessadoresLogicos { get; set; }
        public string FrequeciaMaxima { get; set; }
        public string Arquitetura { get; set; }
        public string L1Cache { get; set; }
        public string L2Cache { get; set; }
        public string L3Cache { get; set; }

    
        //CONSTRUTOR
        public Processador()
        {
            this.InfoProcessador();

        }

        private void InfoProcessador()
        {
            
            foreach (ManagementObject processador in InfoProcess.Get())
            {
                this.Nome = processador["Name"].ToString();
                this.Nucleos = processador["NumberOfCores"].ToString();
                this.ProcessadoresLogicos = processador["NumberOfLogicalProcessors"].ToString();

                this.L2Cache = string.Format("{0} KB",processador["L2CacheSize"]);
                this.L3Cache = string.Format("{0:0.0} MB", Convert.ToDouble(processador["L3CacheSize"])/1024);
                this.FrequeciaMaxima = string.Format("{0:0.0} GHz", Convert.ToDouble(processador["CurrentClockSpeed"])/1000);

                switch (Convert.ToInt32(processador["Architecture"]))
                {
                    case 0:
                        this.Arquitetura = "x86";
                        break;
                    case 9:
                        this.Arquitetura = "x64";
                        break;
						
					default:
                        this.Arquitetura = "Desconhecido";
						break;
                }

            }

            foreach(ManagementObject cache in InfoCache.Get())
            {
                if (Convert.ToString(cache["Purpose"]).Contains("L1"))
                {
                    this.L1Cache = string.Format("{0} x {1} KB", this.Nucleos ,cache["InstalledSize"]);
                } 
                
            }

        }

        public float PercentUso() { return cpuCounter.NextValue(); }
    }
}
