计算机运行状态监视器开源硬件

2077738 2023-02-01 | zip | 0.07 MB | 次下载 | 免费

资料介绍

描述

我想在屏幕上显示我电脑的当前状态，比如CPU使用率、内存使用率、当前温度、风扇转速等信息。

在这个项目中，我使用AIDA64来收集电脑信息。

AIDA64 是由 FinalWire Ltd（一家匈牙利公司）开发的运行在 OS 操作系统上的系统信息、诊断和审计应用程序。它在 pc 或网页上显示有关计算机组件的详细信息。网页显示信息的内容和格式可以自定义。当然，网页格式对于我们的应用来说是没有用的。我们只需要 pc 运行时状态参数。

我使用wizfi360作为http客户端来访问这个网页并获取参数。WizFi360是一个WiFi模块，可以通过命令连接WiFi，进行TCP或TCP（SSL）连接。我用过很多次了，很方便。

RP2040作为一个MCU，从wizfi360获取pc运行状态参数后，进行数据处理，并将内容显示在屏幕上。

本项目分为四步：

第一步：设置AIDA64，使运行参数可以通过http获取；

Step2：在Arduino IDE中安装库文件和板卡支持

第三步：通过WizFi360从http获取参数，并解析参数；

第四步：在屏幕上显示电脑的运行状态（GC9A01）；

以下是分步说明。

第一步：设置AIDA64，使运行参数可以通过http获取；

打开 Aida64 并转到“文件”>>“首选项”>>“LCD”。然后勾选“启用 Remotesensor LCD SUPPORT”。

进入“LCD Items”，添加需要添加到LCD上显示的运行参数。

需要记录下添加参数的“Label”和“Uint”，后面在Arduino IDE中会用到。

我分别添加了以下参数：

中央处理器频率

内存使用情况

显卡频率

IP地址

温度

“应用”和“确定”保存。

Step2：在Arduino IDE中安装库文件和板卡支持

为 Arduino IDE 添加“WIZnet WizFi360-EVB-PICO”支持

打开 Arduino IDE 并转到“文件”->“首选项”。

在弹出的对话框中，在“Additional Boards Manager URLs”字段中输入以下 URL：

https://github.com/earlephilhower/arduino-pico/releases/download/global/package_rp2040_index.json

通过“Board Manager”搜索“WizFi360”并安装 Board 支持

“工具->开发板：”***”-> Raspberry Pi RP2040 Boards(2.6.1)”选择“WIZnet WizFi360-EVB-PICO”。

添加“GFX Library for rduino”，该库支持圆屏GC9A01。

Step3：通过WizFi360从http获取参数，并解析参数；

#include "WizFi360.h"

// Wi-Fi info //
char ssid[] = "WIZNET_test";       // your network SSID (name)//
char pass[] = "********";          // your network password//
int status = WL_IDLE_STATUS;       // the Wifi radio's status//
WiFiServer server(5051);

初始化WizFi360模块的串口，修改波特率为2000000bps（wizfi360的最大波特率）。

第一次初始化为115200，然后在WiZfi360库的初始化部分加入设置波特率（2000000），第二次改为2000000bps。

// initialize serial port for WizFi360 module//
#if defined(ARDUINO_WIZNET_WIZFI360_EVB_PICO)
  Serial2.begin(2000000);
  WiFi.init(&Serial2);
  Serial2.begin(2000000); 
#endif

在“void setup()”中查看wifi的wizfi360 Link状态

// check for the presence of the shield//
  if (WiFi.status() == WL_NO_SHIELD) {
    Serial.println("WiFi shield not present");
    // don't continue//
    while (true);
  }
  // attempt to connect to WiFi network//
  while ( status != WL_CONNECTED) {
    Serial.print("Attempting to connect to WPA SSID: ");
    Serial.println(ssid);
    // Connect to WPA/WPA2 network//
    status = WiFi.begin(ssid, pass);
  }
  Serial.println("You're connected to the network");

在电脑的80端口创建TCP Socket，获取PC的运行状态。

// if you get a connection, report back via serial
        if (client.connect(Aida64IpAddr, 80)) {
          Serial.println("Connected to server");
          // Make a HTTP request
          client.println(String("GET /sse HTTP/1.1"));
          client.println(String("Host: ") + (String)Aida64IpAddr);
          client.println("Connection: close");
          client.println();
          data_now = 0;
          json_String = "";
        }

获取到数据后，解析HTML的Header信息，将参数status存储在一个String'json_String'中。

while (client.available()) {
            myBuffer.push(client.read()); 
            data_now =1;
          }
          if(data_now)
          {
              json_start = false;
              while (myBuffer.pop(value)) {
                Serial.print((char)value);
                if(json_start)
                {
                  json_String += (char)value;
                }
                if(value == 10) //ascii "\n"
                {
                   if(find_n == true)
                   {
                      json_start = true;                       
                      find_n = false;
                   }
                   else
                   {
                      json_start = false;
                      find_n = true;
                   }                  
                }
                else
                {
                    find_n = false;
                }
            }
            Serial.println("json_String:");
            Serial.println(json_String);

HTTP数据如下：

HTTP/1.1 200 OK
Content-Type: text/event-stream
Cache-Control: no-cache
Access-Control-Allow-Origin: *
Access-Control-Expose-Headers: *
Access-Control-Allow-Credentials: true
 
data: Page0|{|}Simple1|CPU Frequency 3890 MHz{|}Simple2|Memory Usage 56%{|}Simple3|GPU Frequency 350MHz{|}Simple4|IP Address 10.0.1.42/{|}Simple5|Temperature 48C{|}

我们需要的是“数据”部分，相关的参数可以通过下面的流程判断分解出来。

uint16_t dataStart = 0;
            uint16_t dataEnd = 0;
            String dataStr;
            //json_String = "data: Page0|{|}Simple1|CPU Frequency 998 MHz{|}Simple2|Memory Usage 43%{|}Simple3|GPU1 Usage 0%{|}Simple4|GPU2 Core Frequency 350 MHz{|}Simple5|IP Address 10.0.1.42/{|}Simple6|Motherboard Temperature 47{|}";
            dataStart = json_String.indexOf("CPU Frequency") + strlen("CPU Frequency");
            dataEnd = json_String.indexOf("MHz", dataStart);
            dataStr = json_String.substring(dataStart, dataEnd);
            Cpu_frequency = dataStr.toInt();
            Serial.print("CPU Frequency:");         
            Serial.print(Cpu_frequency);     
            Serial.println("MHz");   
            
            dataStart = json_String.indexOf("Memory Usage") + strlen("Memory Usage");
            dataEnd = json_String.indexOf("%", dataStart);
            dataStr = json_String.substring(dataStart, dataEnd);
            memory_usage = dataStr.toInt();
            Serial.print("Memory Usage:");         
            Serial.print(memory_usage);   
            Serial.println("%");             

            dataStart = json_String.indexOf("GPU Frequency") + strlen("GPU Frequency");
            dataEnd = json_String.indexOf("MHz", dataStart);
            dataStr = json_String.substring(dataStart, dataEnd);
            GPU_Frequency = dataStr.toInt();
            Serial.print("GPU frequency:");         
            Serial.print(GPU_Frequency);   
            Serial.println("MHz");
            
            dataStart = json_String.indexOf("Temperature") + strlen("Temperature");
            dataEnd = json_String.indexOf("C", dataStart);
            dataStr = json_String.substring(dataStart, dataEnd);
            Temperature = dataStr.toInt();  
            Serial.print("Temperature:");
            Serial.print(Temperature); 
            Serial.println("C");
            
            dataStart = json_String.indexOf("IP Address") + strlen("IP Address");
            dataEnd = json_String.indexOf("/", dataStart);
            dataStr = json_String.substring(dataStart, dataEnd);
            Serial.print("IP Address:");  
            Serial.print(dataStr);
            Serial.println("/");
            
            dataEnd = dataStr.indexOf(".", 0);
            ip_uint8[0] = (dataStr.substring(0, dataEnd)).toInt();
            Serial.println(ip_uint8[0]);
            dataStart = dataEnd+1;
            dataEnd = dataStr.indexOf(".", dataStart);
            ip_uint8[1] = (dataStr.substring(dataStart, dataEnd)).toInt();
            Serial.println(ip_uint8[1]);
            dataStart = dataEnd+1;
            dataEnd = dataStr.indexOf(".", dataStart);
            ip_uint8[2] = (dataStr.substring(dataStart, dataEnd)).toInt();
            Serial.println(ip_uint8[2]);
            dataStart = dataEnd+1;
            dataEnd = dataStr.indexOf(".", dataStart);
            ip_uint8[3] = (dataStr.substring(dataStart, dataEnd)).toInt();
            Serial.println(ip_uint8[3]);

这里我们使用前面记录的关键字“Label”和“Uints”，分别作为参数的开始和结束，从而将“数据”分隔成一个单独的运行参数。

CPU 频率 MHz
内存使用率
GPU频率 兆赫
IP 地址 /
温度 C

至此我们就完成了参数的获取。

第四步：在屏幕上显示电脑的运行状态（GC9A01）；

#include 
Arduino_GFX *tft = create_default_Arduino_GFX();

在“libraries\GFX_Library_for_Arduino\src\Arduino_GFX_Library.h”中定义 GC9A01 使用的引脚

#elif defined(ARDUINO_RASPBERRY_PI_PICO)||defined(ARDUINO_WIZNET_WIZFI360_EVB_PICO)||defined(ARDUINO_WIZNET_5100S_EVB_PICO)
#define DF_GFX_SCK 26
#define DF_GFX_MOSI 27
#define DF_GFX_MISO GFX_NOT_DEFINED
#define DF_GFX_CS 25
#define DF_GFX_DC 23
#define DF_GFX_RST 28
#define DF_GFX_BL 22

在“void setup()”中初始化屏幕并打开屏幕的背光

tft->begin();
  tft->fillScreen(BLACK);
  pinMode(22, OUTPUT); 
  digitalWrite(22, HIGH);
  Display_Begin();

为了界面的美观显示，我们在“Setup()”的时候编写了界面的框架。

void display_dashboard()
{
  tft->fillArc(120,120, 46, 120, 0, 90, OLIVE);
  tft->fillRect(150,123,100,27,WHITE);
  tft->setTextColor(OLIVE);
  tft->setCursor(175, 125);
  tft->setTextSize(3);
  tft->println("LAN");
  tft->fillArc(120,120, 117, 120, 0, 90, OLIVE); 
  tft->fillArc(120,120, 46, 48, 0, 90, OLIVE); 
  
  tft->fillArc(120,120, 46, 120, 90, 180, YELLOW);
  tft->fillRect(0,123,100,27,WHITE);
  tft->setTextColor(YELLOW);
  tft->setCursor(15, 125);
  tft->setTextSize(3);
  tft->println("GPU");
  tft->fillArc(120,120, 117, 120, 90, 180, YELLOW); 
  tft->fillArc(120,120, 46, 48, 90, 180, YELLOW); 

  tft->fillArc(120,120, 46, 120, 270, 360, GREEN);
  tft->fillRect(150,90,100,27,WHITE);
  tft->setTextColor(GREEN);
  tft->setCursor(175, 92);
  tft->setTextSize(3);
  tft->println("RAM");
  tft->fillArc(120,120, 117, 120, 270, 360, GREEN); 
  tft->fillArc(120,120, 46, 48, 270, 360, GREEN); 
  
  tft->fillArc(120,120, 46, 120, 180, 270, ORANGE); 
  tft->fillRect(0,90,100,27,WHITE);
  tft->setTextColor(ORANGE);
  tft->setCursor(15, 92);
  tft->setTextSize(3);
  tft->println("CPU");
  tft->fillArc(120,120, 117, 120, 180, 270, ORANGE); 
  tft->fillArc(120,120, 46, 48, 180, 270, ORANGE); 

  tft->drawRoundRect(126,165,45,20,10,WHITE);
  tft->drawRoundRect(127,166,43,18,9,WHITE);
  tft->drawRoundRect(126,188,45,20,10,WHITE);
  tft->drawRoundRect(127,189,43,18,9,WHITE);
  tft->drawRoundRect(171,165,45,20,10,WHITE);
  tft->drawRoundRect(172,166,43,18,9,WHITE);
  tft->drawRoundRect(171,188,45,20,10,WHITE);
  tft->drawRoundRect(172,189,43,18,9,WHITE);     
  
  tft->fillArc(120,120, 39, 45, 0, 360, WHITE);
  tft->fillCircle(120,120,39,GREENYELLOW);

  tft->setTextColor(WHITE);
  tft->setTextSize(3);
  
  tft->setCursor(43, 55);
  tft->println("MHz");  
  tft->setCursor(175, 30);
  tft->println("%");
  tft->setCursor(58, 192);
  tft->println("MHz"); 
  
  tft->drawRoundRect(132,55,60,20,10,WHITE);
  tft->drawRoundRect(133,56,58,18,9,WHITE);
}

此时屏幕显示如下：

在STEP3中获取到参数后，通过以下处理，将屏幕显示更新为PC的运行参数。

if(Temperature < 60)
          {
            tft->fillCircle(120,120,39,GREENYELLOW);
          }
          else if(Temperature < 85)
          {
            tft->fillCircle(120,120,39,ORANGE);
          }
          else
          {
            tft->fillCircle(120,120,39,RED);
          }
          tft->setTextColor(WHITE);
          tft->setCursor(85, 104);
          tft->setTextSize(4);
          tft->println(Temperature);
          tft->setCursor(140, 112);
          tft->setTextSize(3);
          tft->println("C");
          tft->setCursor(133, 99);
          tft->setTextSize(2);
          tft->println("o");
          
          tft->fillRect(43,30,70,25,ORANGE);
          tft->setTextColor(WHITE);
          tft->setCursor(43, 30);
          tft->setTextSize(3);
          tft->println(Cpu_frequency);
          
          tft->fillRect(132,30,35,25,GREEN);
          tft->setTextColor(WHITE);
          tft->setCursor(132, 30);
          tft->setTextSize(3);
          tft->println(memory_usage);
          
          tft->fillRoundRect(136,58,54,14,8,GREEN);
          uint8_t memory_uint8 = memory_usage*54/100;
          tft->fillRoundRect(136,58,memory_uint8,14,8,WHITE);
          
          tft->fillRect(31,165,80,25,YELLOW);
          if(GPU_Frequency>=1000)
          {
            tft->setCursor(43, 165);
          }
          else
          {
            tft->setCursor(58, 165);
          }            
          tft->setTextSize(3);
          tft->println(GPU_Frequency);

          tft->setTextSize(2);
          tft->setCursor(131, 168);
          tft->println(ip_uint8[0]);
          tft->setCursor(176, 168);
          tft->println(ip_uint8[1]);
          tft->setCursor(131, 191);
          tft->println(ip_uint8[2]);
          tft->setCursor(176, 191);
          tft->println(ip_uint8[3]);