API tools faq
paste
SemlerPDX

AVCS SENS AIDA64 Shared Memory Monitor MAIN-v8 Inline Function in C# for VoiceAttack & AIDA64

SemlerPDX
Jun 14th, 2022 (edited)
264
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C# 7.11 KB | None | 0 0
raw download clone embed print report
  1. //AVCS SENS - AIDA64 External Applications Shared Memory Monitoring Function
  2. // -Gets new data string from memory every 2 seconds
  3. // by SemlerPDX Mar2022 (with much help from Pfeil!)
  4. // VETERANS-GAMING.COM
  5.  
  6. using System;
  7. using System.Text;
  8. using System.Linq;
  9. using System.Windows.Forms;
  10. using System.IO.MemoryMappedFiles;
  11. using System.Runtime.InteropServices;
  12. using System.Collections.Generic;
  13.  
  14. public class VAInline
  15. {
  16.     double SharedMemTimerDelay = 2000;
  17.     bool debugging = false;
  18.    
  19.     private void t_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
  20.     {
  21.         if (VA.GetBoolean("AVCS_SENS_Test_SharedMem") == true)
  22.         {
  23.             SharedMemTest();
  24.             VA.SetBoolean("AVCS_SENS_Test_SharedMem", false);
  25.             if (VA.GetBoolean("AVCS_SENS_Test_OnlyTest") == true)
  26.                 VA.SetBoolean("AVCS_SENS_Monitoring", false);
  27.         }
  28.         else
  29.         {
  30.             SharedMemGet(debugging);
  31.         }
  32.        
  33.         if (VA.GetBoolean("AVCS_SENS_Monitoring") != true)
  34.         {
  35.             (sender as System.Timers.Timer).Stop();
  36.             VA.SetBoolean("AVCS_SENS_Logging", false);
  37.             VA.WriteToLog("AVCS AIDA64 Shared Memory Monitor has been terminated...", "black");
  38.         }
  39.         if (VA.Stopped)
  40.         {
  41.             VA.SetBoolean("AVCS_SENS_Diagnostics_Active", false);
  42.             VA.SetBoolean("AVCS_SENS_Diagnosing", false);
  43.             VA.ResetStopFlag();
  44.         }
  45.     }
  46.    
  47.     private void SharedMemGet(bool debugging)
  48.     {
  49.         int? faultCount;
  50.         try
  51.         {
  52.             if (VA.GetInt("~avcs_memfault_count") != null)
  53.             {
  54.                 faultCount = VA.GetInt("~avcs_memfault_count");
  55.                 if (faultCount >= 2)
  56.                     throw new AVCSexception();
  57.             }
  58.             SharedMemSaver sf = new SharedMemSaver();
  59.             sf.OpenView(VA);
  60.             if (sf.GetData(VA) != "")
  61.             {
  62.                 VA.SetText("AVCS_SENS_SHAREDMEM_XML", sf.GetData(VA));
  63.                 if (debugging || VA.GetBoolean("AVCS_SENS_DebugSensors") == true)
  64.                     VA.WriteToLog(sf.GetData(VA), "blank");
  65.             }
  66.             if (VA.GetBoolean("AVCS_SharedMem_Monitor_Startup") != null)
  67.             {
  68.                 if (String.IsNullOrEmpty(VA.GetText("AVCS_SENS_SHAREDMEM_XML")))
  69.                     throw new AVCSexception();
  70.             }
  71.         }
  72.         catch (AVCSexception e)
  73.         {
  74.             e.SharedMemGetException(VA);
  75.         }
  76.     }
  77.    
  78.     private void SharedMemTest()
  79.     {
  80.         int? faultCount;
  81.         try
  82.         {
  83.             if (VA.GetInt("~avcs_memfault_count") != null)
  84.             {
  85.                 faultCount = VA.GetInt("~avcs_memfault_count");
  86.                 if (faultCount >= 2)
  87.                     throw new AVCSexception();
  88.             }
  89.             SharedMemSaver sf = new SharedMemSaver();
  90.             sf.OpenView(VA);
  91.             if (sf.GetData(VA) != "")
  92.             {
  93.                 VA.WriteToLog(sf.GetData(VA), "blank");
  94.                 VA.SetText("AVCS_SENS_SHAREDMEM_XML", sf.GetData(VA));
  95.                 VA.WriteToLog("AVCS AIDA64 Shared Memory Test has succeeded!", "green");
  96.                 VA.SetText("AVCS_SENS_Test_ReturnTTS", "Test succeeded.");
  97.             }
  98.         }
  99.         catch (AVCSexception e)
  100.         {
  101.             e.SharedMemTestException(VA);
  102.         }
  103.     }
  104.    
  105.     private void SharedMemTimer()
  106.     {
  107.         System.Timers.Timer t = new System.Timers.Timer(SharedMemTimerDelay);
  108.         t.Elapsed += t_Elapsed;
  109.         VA.WriteToLog("AVCS AIDA64 Shared Memory Monitor is now running...", "black");
  110.         t.Start();
  111.     }
  112.    
  113.    
  114.     public class AVCSexception : Exception
  115.     {
  116.         public void SharedMemTestException(dynamic VA)
  117.         {
  118.             VA.SetText("AVCS_SENS_SHAREDMEM_XML", null);
  119.             VA.SetBoolean("AVCS_SENS_Logging", false);
  120.             VA.SetBoolean("AVCS_SENS_Monitoring", false);
  121.             VA.SetText("AVCS_SENS_Test_ReturnTTS", "Test failed. Please check settings.");
  122.             VA.WriteToLog("AVCS AIDA64 Shared Memory Test has failed!", "red");
  123.             VA.WriteToLog("Please check AIDA64 settings. See user guide for more information.", "blank");
  124.         }
  125.         public void SharedMemGetException(dynamic VA)
  126.         {
  127.             VA.SetText("AVCS_SENS_SHAREDMEM_XML", null);
  128.             VA.SetBoolean("AVCS_SENS_Logging", false);
  129.             VA.SetBoolean("AVCS_SENS_Monitoring", false);
  130.             VA.WriteToLog("AVCS AIDA64 Shared Memory Monitor has failed to get data!", "red");
  131.             VA.WriteToLog("Please check AIDA64 settings. See user guide for more information.", "blank");
  132.             if (VA.GetBoolean("AVCS_SharedMem_Monitor_Startup") != null)
  133.             {
  134.                 VA.SetText("AVCS_SENS_TTS_WILDCARD", "Sensor Monitor startup has failed. Please check settings.");
  135.                 VA.Command.Execute("F_SAY_TTS", false);
  136.             }
  137.         }
  138.     }
  139.    
  140.    
  141.    
  142.     public void main()
  143.     {
  144.        
  145.         if (VA.GetBoolean("AVCS_SENS_Monitoring") != true && VA.GetBoolean("AVCS_SharedMem_Monitor_Startup") != true)
  146.         {
  147.             VA.SetBoolean("AVCS_SharedMem_Monitor_Startup", true);
  148.             SharedMemGet(debugging);
  149.             if (String.IsNullOrEmpty(VA.GetText("AVCS_SENS_SHAREDMEM_XML")))
  150.             {
  151.                 VA.SetText("AVCS_SENS_SHAREDMEM_XML", null);
  152.                 VA.SetBoolean("AVCS_SENS_Logging", false);
  153.                 VA.SetBoolean("AVCS_SENS_Monitoring", false);
  154.             }
  155.             else
  156.             {
  157.                 VA.SetBoolean("AVCS_SENS_Monitoring", true);
  158.                 SharedMemTimer();
  159.             }
  160.         }
  161.         VA.SetBoolean("AVCS_SharedMem_Monitor_Startup", null);
  162.     }
  163.  
  164. }
  165.  
  166.  
  167.  
  168. class SharedMemSaver
  169. {
  170.     #region Win32 API stuff
  171.     public const int FILE_MAP_READ = 0x0004;
  172.     private static dynamic VA;
  173.    
  174.     [DllImport("Kernel32", CharSet = CharSet.Auto, SetLastError = true)]
  175.     internal static extern IntPtr OpenFileMapping(int dwDesiredAccess,
  176.     bool bInheritHandle, StringBuilder lpName);
  177.  
  178.     [DllImport("Kernel32", CharSet = CharSet.Auto, SetLastError = true)]
  179.     internal static extern IntPtr MapViewOfFile(IntPtr hFileMapping,
  180.     int dwDesiredAccess, int dwFileOffsetHigh, int dwFileOffsetLow,
  181.     int dwNumberOfBytesToMap);
  182.  
  183.     [DllImport("Kernel32.dll")]
  184.     internal static extern bool UnmapViewOfFile(IntPtr map);
  185.  
  186.     [DllImport("kernel32.dll")]
  187.     internal static extern bool CloseHandle(IntPtr hObject);
  188.     #endregion
  189.  
  190.     private bool fileOpen = false;
  191.     private IntPtr map;
  192.     private IntPtr handle;
  193.  
  194.     ~SharedMemSaver()
  195.     {
  196.         CloseView(VA);
  197.     }
  198.  
  199.     public bool OpenView(dynamic VA)
  200.     {
  201.         int? memfaultCount;
  202.         try
  203.         {
  204.             if (!fileOpen)
  205.             {
  206.                 StringBuilder sharedMemFile = new StringBuilder("AIDA64_SensorValues");
  207.                 handle = OpenFileMapping(FILE_MAP_READ, false, sharedMemFile);
  208.                 if (handle == IntPtr.Zero)
  209.                 {
  210.                     if (VA.GetInt("~avcs_memfault_count") != null)
  211.                     {
  212.                         memfaultCount = VA.GetInt("~avcs_memfault_count");
  213.                         memfaultCount += 1;
  214.                         VA.SetInt("~avcs_memfault_count", memfaultCount);
  215.                     }
  216.                     else
  217.                     {
  218.                         memfaultCount = 1;
  219.                         VA.SetInt("~avcs_memfault_count", memfaultCount);
  220.                     }
  221.                     throw new Exception("Unable to open file mapping.");
  222.                 }
  223.                 map = MapViewOfFile(handle, FILE_MAP_READ, 0, 0, 0);
  224.                 if (map == IntPtr.Zero)
  225.                 {
  226.                     if (VA.GetInt("~avcs_memfault_count") != null)
  227.                     {
  228.                         memfaultCount = VA.GetInt("~avcs_memfault_count");
  229.                         memfaultCount += 1;
  230.                         VA.SetInt("~avcs_memfault_count", memfaultCount);
  231.                     }
  232.                     else
  233.                     {
  234.                         memfaultCount = 1;
  235.                         VA.SetInt("~avcs_memfault_count", memfaultCount);
  236.                     }
  237.                     throw new Exception("Unable to read shared memory.");
  238.                 }
  239.                 fileOpen = true;
  240.             }
  241.             return fileOpen;
  242.         }
  243.         catch
  244.         {
  245.             return false;
  246.         }
  247.     }
  248.  
  249.     public void CloseView(dynamic VA)
  250.     {
  251.         if (fileOpen)
  252.         {
  253.             UnmapViewOfFile(map);
  254.             CloseHandle(handle);
  255.         }
  256.     }
  257.  
  258.     public String GetData(dynamic VA)
  259.     {
  260.         if (fileOpen)
  261.         {
  262.             try
  263.             {
  264.                 String data = (String)Marshal.PtrToStringAnsi(map);
  265.                 return data;
  266.             }
  267.             catch
  268.             {
  269.                 return null;
  270.             }
  271.         }  
  272.         else       
  273.         {
  274.             return null;
  275.         }
  276.     }
  277. }
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!