Hello there is it me you are looking for?

SysModule/src/BATStat/batfuncs.rs

@@ -0,0 +1,70 @@
+use crate::BatUsageProtobuf;
+use std::{fs::File, io::prelude::*, io::BufReader, io::Read, thread, time};
+
+#[derive(Debug)]
+pub struct BatUsage {
+    Charge_Full_Design: u32,
+    Charge_Full: u32,
+    Charge_Now: u32,
+}
+
+impl BatUsage {
+    pub fn new() -> BatUsage {
+        BatUsage {
+            Charge_Full_Design: 0,
+            Charge_Full: 0,
+            Charge_Now: 0,
+        }
+    }
+
+    fn update_values(&mut self, line_vector: Vec<u32>) {
+        self.Charge_Full_Design = line_vector[0];
+        self.Charge_Full = line_vector[1];
+        self.Charge_Now = line_vector[2];
+    }
+
+    pub fn convert_to_protobuf(&self) -> BatUsageProtobuf {
+        BatUsageProtobuf {
+            charge_full_design: self.Charge_Full_Design,
+            charge_full: self.Charge_Full,
+            charge_now: self.Charge_Now,
+        }
+    }
+}
+
+pub async fn main_bat_stat_handler(statefull_bat_usage: &mut BatUsage) {
+    println!("This is bat");
+    loop {
+        let statbatinfo_fd = match File::open("/sys/class/power_supply/BAT0/uevent") {
+            Ok(x) => x,
+            Err(_) => {
+                // panic!("I use Arch BTW.");
+                let statbatinfo_fd = match File::open("/sys/class/power_supply/BAT1/uevent") {
+                    Ok(x) => x,
+                    Err(_) => {
+                        panic!("Ok, what the hell are you using?");
+                    }
+                };
+                statbatinfo_fd
+            }
+        };
+
+        let mut buff_reader = BufReader::new(&statbatinfo_fd);
+        let mut batinfo = String::new();
+        let _ = buff_reader.read_to_string(&mut batinfo);
+
+        let mut lines: Vec<&str> = batinfo.split("\n").into_iter().collect();
+        let mut temp_vec: Vec<u32> = Vec::new();
+        // println!("{:?}", lines);
+
+        for i in 9..12 {
+            let pos1 = lines[i].chars().position(|c| c == '=').unwrap() + 1;
+            let finalvalue = lines[i].get(pos1..).unwrap();
+            let line_val = finalvalue.trim().parse::<u32>().unwrap();
+            temp_vec.push(line_val);
+            // println!("{:?}", temp_vec);
+        }
+        statefull_bat_usage.update_values(temp_vec);
+        thread::sleep(time::Duration::from_millis(100));
+    }
+}

SysModule/src/BATStat/mod.rs

@@ -0,0 +1 @@
+pub mod batfuncs;

SysModule/src/CPUStat/statfuncs.rs

@@ -194,23 +194,23 @@ impl MultiCpuUsage {
             }
         };
         let mut usage = self.calculate_recent_usage(needed_cpu_id) as f32;
-        if usage.is_nan(){
+        if usage.is_nan() {
             usage = 0.0
         }
         CpuUsageProtobuf {
             cpu_id: String::from(needed_cpu_id.to_string()),
-            cpu_usage: usage
+            cpu_usage: usage,
         }
     }
-    pub fn convert_to_detail_protobuf(&self) -> crate::InitDataProtobuf{
+    pub fn convert_to_detail_protobuf(&self) -> crate::InitDataProtobuf {
         let mut largest = 0;
-        for i in self.irq_usage.keys(){
-            if *i>largest{
+        for i in self.irq_usage.keys() {
+            if *i > largest {
                 largest = *i
             }
         }
-        crate::InitDataProtobuf{
-            number_of_cpu : largest
+        crate::InitDataProtobuf {
+            number_of_cpu: largest,
         }
     }
 }

SysModule/src/data.proto

@@ -13,6 +13,11 @@ message MemUsage {
   uint32 Mem_Buffer = 4;
   uint32 Mem_Cached = 5;
 }
+message BatUsage {
+  uint32 Charge_Full_Design = 1;
+  uint32 Charge_Full = 2;
+  uint32 Charge_Now = 3;
+}
 
 message InitData {
   int32 number_of_cpu = 1;
@@ -21,6 +26,7 @@ message InitData {
 
 message EmptyReq {}
 message MemUsageRequest { float prev_mem_usage = 1; }
+message BatUsageRequest { float prev_bat_usage = 1; }
 message CpuUsageRequest { string needed_cpu_usage = 1; }
 
 service FetchData {
@@ -30,3 +36,4 @@ service FetchData {
 }
 
 service FetchDataMem { rpc FetchMemUsage(MemUsageRequest) returns (MemUsage); }
+service FetchDataBat{ rpc FetchBatUsage(BatUsageRequest) returns (BatUsage); }

SysModule/src/main.rs

@@ -5,6 +5,7 @@
 #![feature(get_mut_unchecked)]
 
 //Local module system :
+mod BATStat;
 mod CPUStat;
 mod MEMStat;
 
@@ -21,82 +22,114 @@ use tonic::transport::Server;
 pub mod protobuf {
     tonic::include_proto!("data.protobuf");
 }
+use protobuf::BatUsage as BatUsageProtobuf;
 use protobuf::CpuUsage as CpuUsageProtobuf;
-use protobuf::MemUsage as MemUsageProtobuf;
 use protobuf::InitData as InitDataProtobuf;
-use protobuf::{CpuUsageRequest, MemUsageRequest, EmptyReq};
+use protobuf::MemUsage as MemUsageProtobuf;
+use protobuf::{BatUsageRequest, CpuUsageRequest, EmptyReq, MemUsageRequest};
+
 //Server trait
+use protobuf::fetch_data_bat_server::{FetchDataBat, FetchDataBatServer};
+use protobuf::fetch_data_mem_server::{FetchDataMem, FetchDataMemServer};
 use protobuf::fetch_data_server::{FetchData, FetchDataServer};
-use protobuf::fetch_data_mem_server::{ FetchDataMem, FetchDataMemServer};
+
+//Rust side structs
+use BATStat::batfuncs::BatUsage;
+use CPUStat::statfuncs::MultiCpuUsage;
+use MEMStat::memfuncs::MemUsage;
 
 #[tonic::async_trait]
 impl FetchData for MultiCpuUsage {
     async fn init_cpu_detail(
         &self,
         req: tonic::Request<EmptyReq>,
-        ) -> std::result::Result<tonic::Response<InitDataProtobuf>, tonic::Status> {
-        return Ok(tonic::Response::new(self.convert_to_detail_protobuf()))
-    }    
+    ) -> std::result::Result<tonic::Response<InitDataProtobuf>, tonic::Status> {
+        return Ok(tonic::Response::new(self.convert_to_detail_protobuf()));
+    }
     async fn fetch_cpu_usage(
         &self,
         req: tonic::Request<CpuUsageRequest>,
-        ) -> std::result::Result<tonic::Response<CpuUsageProtobuf>, tonic::Status> {
+    ) -> std::result::Result<tonic::Response<CpuUsageProtobuf>, tonic::Status> {
         let request_paylod = req.into_inner();
-        return Ok(tonic::Response::new(self.convert_to_protobuf(request_paylod)));
-    }    
+        return Ok(tonic::Response::new(
+            self.convert_to_protobuf(request_paylod),
+        ));
+    }
 }
 
 #[tonic::async_trait]
-impl FetchDataMem for MemUsage{
+impl FetchDataMem for MemUsage {
     async fn fetch_mem_usage(
         &self,
         req: tonic::Request<MemUsageRequest>,
-        ) -> std::result::Result<tonic::Response<MemUsageProtobuf>, tonic::Status> {
+    ) -> std::result::Result<tonic::Response<MemUsageProtobuf>, tonic::Status> {
         return Ok(tonic::Response::new(self.convert_to_protobuf()));
     }
 }
 
-//Rust side structs
-use CPUStat::statfuncs::MultiCpuUsage;
-use MEMStat::memfuncs::MemUsage;
+#[tonic::async_trait]
+impl FetchDataBat for BatUsage {
+    async fn fetch_bat_usage(
+        &self,
+        req: tonic::Request<BatUsageRequest>,
+    ) -> std::result::Result<tonic::Response<BatUsageProtobuf>, tonic::Status> {
+        return Ok(tonic::Response::new(self.convert_to_protobuf()));
+    }
+}
 
 #[tokio::main]
 async fn main() -> Result<()> {
     //Do note, tokio uses single OS thread for all spawned threads
     //Non Blocking spawns :
 
     /*     tokio::spawn(async {
-           MEMStat::memfuncs::main_mem_stat_handler(mem_tx).await;
-           });
-           */
+    MEMStat::memfuncs::main_mem_stat_handler(mem_tx).await;
+    });
+    */
     let mut statefull_cpu_usage = MultiCpuUsage::new();
     let mut arc_statefull_cpu_usage = Arc::new(statefull_cpu_usage);
     let clone = Arc::clone(&arc_statefull_cpu_usage);
 
     let mut statefull_mem_usage = MemUsage::new();
-    let mut arc_statefull_mem_usage = Arc:: new(statefull_mem_usage);
-    let clone1=Arc::clone(&arc_statefull_mem_usage);
+    let mut arc_statefull_mem_usage = Arc::new(statefull_mem_usage);
+    let clone1 = Arc::clone(&arc_statefull_mem_usage);
 
+    let mut statefull_bat_usage = BatUsage::new();
+    let mut arc_statefull_bat_usage = Arc::new(statefull_bat_usage);
+    let clone2 = Arc::clone(&arc_statefull_bat_usage);
 
-    tokio::spawn(async move{
+    tokio::spawn(async move {
         let addr = "[::1]:5001".parse().unwrap();
         println!("Listening on port 5001");
         Server::builder()
             .add_service(FetchDataServer::from_arc(clone))
             .add_service(FetchDataMemServer::from_arc(clone1))
+            .add_service(FetchDataBatServer::from_arc(clone2))
             .serve(addr)
             .await;
     });
-    unsafe{
-        tokio::spawn(async move{
-            CPUStat::statfuncs::main_cpu_stat_handler(&mut Arc::get_mut_unchecked(&mut arc_statefull_cpu_usage)).await;
+    unsafe {
+        tokio::spawn(async move {
+            CPUStat::statfuncs::main_cpu_stat_handler(&mut Arc::get_mut_unchecked(
+                &mut arc_statefull_cpu_usage,
+            ))
+            .await;
+        });
+        tokio::spawn(async move {
+            MEMStat::memfuncs::main_mem_stat_handler(&mut Arc::get_mut_unchecked(
+                &mut arc_statefull_mem_usage,
+            ))
+            .await;
         });
-        tokio::spawn(async move{
-            MEMStat::memfuncs::main_mem_stat_handler(&mut Arc::get_mut_unchecked(&mut arc_statefull_mem_usage)).await;
-        }).await;
+        tokio::spawn(async move {
+            BATStat::batfuncs::main_bat_stat_handler(&mut Arc::get_mut_unchecked(
+                &mut arc_statefull_bat_usage,
+            ))
+            .await;
+        })
+        .await;
         //Last await is to keep the main thread alive in the aysnc space.
     }
 
-
     Ok(())
 }

SysPerfTUI/globals/globals.go

@@ -1,8 +1,9 @@
 package globals
 
 import (
-	"google.golang.org/grpc"
 	"sync"
+
+	"google.golang.org/grpc"
 )
 
 var Mainwaitgroup *sync.WaitGroup
@@ -24,3 +25,7 @@ var Mem_cached_percentage int32
 
 var Mem_free float64
 var Mem_free_percentage int32
+
+var Charge_full_design int32
+var Charge_full int32
+var Charge_now int32

SysPerfTUI/go.mod

@@ -10,14 +10,14 @@ require (
 
 require (
 	github.com/gdamore/encoding v1.0.0 // indirect
-	github.com/gdamore/tcell/v2 v2.5.1 // indirect
+	github.com/gdamore/tcell/v2 v2.6.0 // indirect
 	github.com/golang/protobuf v1.5.2 // indirect
 	github.com/lucasb-eyer/go-colorful v1.2.0 // indirect
-	github.com/mattn/go-runewidth v0.0.13 // indirect
-	github.com/rivo/uniseg v0.2.0 // indirect
-	golang.org/x/net v0.0.0-20201021035429-f5854403a974 // indirect
-	golang.org/x/sys v0.0.0-20220704084225-05e143d24a9e // indirect
-	golang.org/x/term v0.0.0-20220526004731-065cf7ba2467 // indirect
-	golang.org/x/text v0.3.7 // indirect
+	github.com/mattn/go-runewidth v0.0.14 // indirect
+	github.com/rivo/uniseg v0.4.3 // indirect
+	golang.org/x/net v0.0.0-20220722155237-a158d28d115b // indirect
+	golang.org/x/sys v0.5.0 // indirect
+	golang.org/x/term v0.5.0 // indirect
+	golang.org/x/text v0.7.0 // indirect
 	google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013 // indirect
 )