WINCE 电池状态(C#)

WINCE 电池状态(C#)              

分类：             电量              2013-04-18 12:08     397人阅读     评论(1)     收藏     举报    
Wince电量

 

根据网上搜集资料，最后整理 分享下

[csharp] view plaincopyprint?
  1. using System;  
  2. using System.Linq;  
  3. using System.Collections.Generic;  
  4. using System.Text;  
  5. using System.Runtime.InteropServices;  
  6. using System.Drawing;  
  7.   
  8. namespace PDAeffect  
  9. {  
  10.    public class BatteryControl  
  11.     {  
  12.        /// <summary>  
  13.         /// 外边框  
  14.         /// </summary>  
  15.         private Point[] BatteryPolygon = new Point[8];  
  16.         /// <summary>  
  17.         /// 是否充电状态  
  18.         /// </summary>  
  19.         private State AState = State.Normal;  
  20.         private int Percent = 0;  
  21.         private int iLeft = 30 + 2, iTop = 178, iWidth = 20, iHeight = 10;  
  22.         private int iRectWidth = 0;  
  23.         private Rectangle Rect = new Rectangle();  
  24.         private string text = "";  
  25.         private SYSTEM_POWER_STATUS_EX status = new SYSTEM_POWER_STATUS_EX();  
  26.         /// <summary>  
  27.         /// 电池当前状态 Charge：充电中；UnderCharge：电量不足；Normal：电池正常使用.  
  28.         /// </summary>  
  29.         public enum State  
  30.         {  
  31.             /// <summary>  
  32.             /// 充电中  
  33.             /// </summary>  
  34.             Charge,  
  35.             /// <summary>  
  36.             /// 充电不足  
  37.             /// </summary>  
  38.             UnderCharge,  
  39.             /// <summary>  
  40.             /// 正常状态  
  41.             /// </summary>  
  42.             Normal,  
  43.             /// <summary>  
  44.             /// 充电完成  
  45.             /// </summary>  
  46.             ChargeFinally  
  47.         };  
  48.         private class SYSTEM_POWER_STATUS_EX  
  49.         {  
  50.             public byte ACLineStatus = 0;  
  51.             public byte BatteryFlag = 0;  
  52.             public byte BatteryLifePercent = 0;  
  53.             public byte Reserved1 = 0;  
  54.             public uint BatteryLifeTime = 0;  
  55.             public uint BatteryFullLifeTime = 0;  
  56.             public byte Reserved2 = 0;  
  57.             public byte BackupBatteryFlag = 0;  
  58.             public byte BackupBatteryLifePercent = 0;  
  59.             public byte Reserved3 = 0;  
  60.             public uint BackupBatteryLifeTime = 0;  
  61.             public uint BackupBatteryFullLifeTime = 0;  
  62.         }  
  63.         [DllImport("coredll")]  
  64.         private static extern int GetSystemPowerStatusEx(SYSTEM_POWER_STATUS_EX lpSystemPowerStatus, bool fUpdate);  
  65.         [DllImport("coredll")]  
  66.         public static extern void SystemIdleTimerReset();  
  67.         /// <summary>  
  68.         /// 构造函数 在屏幕默认位置构建电池形状  
  69.         /// </summary>  
  70.         public void Battery()  
  71.         {  
  72.             SetPolygon();  
  73.         }  
  74.         /// <summary>  
  75.         /// 构造函数 电池形状的X和Y坐标  
  76.         /// </summary>  
  77.         /// <param name="StartLeft">电池形状的X坐标</param>  
  78.         /// <param name="StartTop">电池形状的Y坐标</param>  
  79.         public void Battery(int StartLeft, int StartTop)  
  80.         {  
  81.             iLeft = StartLeft;  
  82.             iTop = StartTop;  
  83.             SetPolygon();  
  84.         }  
  85.         /// <summary>  
  86.         /// 构造函数 根据X坐标、Y坐标、宽度、高度构造电池形状  
  87.         /// </summary>  
  88.         /// <param name="StartLeft">电池形状的X坐标</param>  
  89.         /// <param name="StartTop">电池形状的Y坐标</param>  
  90.         /// <param name="StartWidth">电池形状的宽度</param>  
  91.         /// <param name="StartHeight">电池形状的高度</param>  
  92.         public void  Battery(int StartLeft, int StartTop, int StartWidth, int StartHeight)  
  93.         {  
  94.             iLeft = StartLeft;  
  95.             iTop = StartTop;  
  96.             iWidth = StartWidth;  
  97.             iHeight = StartHeight;  
  98.             SetPolygon();  
  99.         }  
  100.         /// <summary>  
  101.         /// 设置电池形状  
  102.         /// </summary>  
  103.         void SetPolygon()  
  104.         {  
  105.             int Head = 2;  
  106.             int HeightLowHalf = (Height - Head) / 2;  
  107.             //外边框  
  108.             BatteryPolygon[0].X = iLeft;  
  109.             BatteryPolygon[0].Y = iTop;  
  110.             BatteryPolygon[1].X = iLeft + iWidth;  
  111.             BatteryPolygon[1].Y = iTop;  
  112.             BatteryPolygon[2].X = iLeft + iWidth;  
  113.             BatteryPolygon[2].Y = iTop + HeightLowHalf;  
  114.             BatteryPolygon[3].X = iLeft + iWidth + Head;  
  115.             BatteryPolygon[3].Y = iTop + HeightLowHalf;  
  116.             BatteryPolygon[4].X = iLeft + iWidth + Head;  
  117.             BatteryPolygon[4].Y = iTop + HeightLowHalf + Head;  
  118.             BatteryPolygon[5].X = iLeft + iWidth;  
  119.             BatteryPolygon[5].Y = iTop + HeightLowHalf + Head;  
  120.             BatteryPolygon[6].X = iLeft + iWidth;  
  121.             BatteryPolygon[6].Y = iTop + HeightLowHalf + Head + HeightLowHalf;  
  122.             BatteryPolygon[7].X = iLeft;  
  123.             BatteryPolygon[7].Y = iTop + HeightLowHalf + Head + HeightLowHalf;  
  124.             //内矩形  
  125.             Rect.X = BatteryPolygon[0].X + 2;  
  126.             Rect.Y = BatteryPolygon[0].Y + 2;  
  127.             Rect.Width = BatteryPolygon[6].X - BatteryPolygon[0].X - 3;  
  128.             Rect.Height = BatteryPolygon[6].Y - BatteryPolygon[0].Y - 3;  
  129.             iRectWidth = Rect.Width;  
  130.             GetBatteryState();  
  131.         }  
  132.         /// <summary>  
  133.         /// 获取电池状态  
  134.         /// </summary>  
  135.        public void GetBatteryState()  
  136.         {  
  137.             if (GetSystemPowerStatusEx(status, false) == 1)  
  138.             {  
  139.                 if (status.ACLineStatus == 1)  
  140.                 {  
  141.                     //BatteryFlag = 128  充电完成  
  142.                     if(status.BatteryFlag == 128)  
  143.                     //if (status.BatteryLifePercent >= 100)  
  144.                     {  
  145.                         //status.BatteryLifePercent = 100;  //.BatteryFullLifeTime  
  146.                         text = "充电完成...";  
  147.                         AState = State.ChargeFinally;  
  148.                     }  //BatteryFlag = 8 正在充电  
  149.                     else  
  150.                     {  
  151.                         AState = State.Charge;  
  152.                         text = "充电中...";  
  153.                     }  
  154.                 }  
  155.                 else  
  156.                 {  
  157.                     //BatteryFlag = 1 正在使用电池  
  158.                     AState = State.Normal;                     
  159.                     if (status.BatteryLifePercent > 100) status.BatteryLifePercent = 100;  
  160.                     text = status.BatteryLifePercent.ToString() + "%";  
  161.                 }  
  162.                 Percent = status.BatteryLifePercent;  
  163.                 if (Percent <= 20)  
  164.                 {  
  165.                     AState = State.UnderCharge;  
  166.                     text = "电量不足...";  
  167.                 }  
  168.                 Rect.Width = iRectWidth * ((Percent + 5) > 100 ? 100 : Percent + 8) / 100;  
  169.             }  
  170.         }  
  171.         /// <summary>  
  172.         /// 电池形状X坐标  
  173.         /// </summary>  
  174.         public int Left  
  175.         {  
  176.             get { return iLeft; }  
  177.             set { iLeft = value; SetPolygon(); }  
  178.         }  
  179.         /// <summary>  
  180.         /// 电池形状Y坐标  
  181.         /// </summary>  
  182.         public int Top  
  183.         {  
  184.             get { return iTop; }  
  185.             set { iTop = value; SetPolygon(); }  
  186.         }  
  187.         /// <summary>  
  188.         /// 电池形状宽度  
  189.         /// </summary>  
  190.         public int Width  
  191.         {  
  192.             get { return iWidth; }  
  193.             set { iWidth = value; SetPolygon(); }  
  194.         }  
  195.         /// <summary>  
  196.         /// 电池形状高度  
  197.         /// </summary>  
  198.         public int Height  
  199.         {  
  200.             get { return iHeight; }  
  201.             set { iHeight = value; SetPolygon(); }  
  202.         }  
  203.         /// <summary>  
  204.         /// 电池电量百分比  
  205.         /// </summary>  
  206.         public int BatteryPercent  
  207.         {  
  208.             get { return Percent; }  
  209.         }  
  210.         /// <summary>  
  211.         /// 电池状态  
  212.         /// </summary>  
  213.         public Rectangle BatteryState  
  214.         {  
  215.             get  
  216.             {  
  217.                 GetBatteryState();  
  218.                 return Rect;  
  219.             }  
  220.         }  
  221.         /// <summary>  
  222.         /// 电池外边框  
  223.         /// </summary>  
  224.         public Point[] BatteryStateRect  
  225.         {  
  226.             get { return BatteryPolygon; }  
  227.             set { BatteryPolygon = value; }  
  228.         }  
  229.         /// <summary>  
  230.         /// 当前电池状态，有充电、充电不足、正常 三种状态  
  231.         /// </summary>  
  232.         public State Status  
  233.         {  
  234.             get { return AState; }  
  235.         }  
  236.         /// <summary>  
  237.         /// 电池显示的内容  
  238.         /// </summary>  
  239.         public string Text  
  240.         {  
  241.             get { return text; }  
  242.         }  
  243.     }  
  244. }  
using System;
using System.Linq;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;
using System.Drawing;

namespace PDAeffect
{
   public class BatteryControl
    {
       /// <summary>
        /// 外边框
        /// </summary>
        private Point[] BatteryPolygon = new Point[8];
        /// <summary>
        /// 是否充电状态
        /// </summary>
        private State AState = State.Normal;
        private int Percent = 0;
        private int iLeft = 30 + 2, iTop = 178, iWidth = 20, iHeight = 10;
        private int iRectWidth = 0;
        private Rectangle Rect = new Rectangle();
        private string text = "";
        private SYSTEM_POWER_STATUS_EX status = new SYSTEM_POWER_STATUS_EX();
        /// <summary>
        /// 电池当前状态 Charge：充电中；UnderCharge：电量不足；Normal：电池正常使用.
        /// </summary>
        public enum State
        {
            /// <summary>
            /// 充电中
            /// </summary>
            Charge,
            /// <summary>
            /// 充电不足
            /// </summary>
            UnderCharge,
            /// <summary>
            /// 正常状态
            /// </summary>
            Normal,
            /// <summary>
            /// 充电完成
            /// </summary>
            ChargeFinally
        };
        private class SYSTEM_POWER_STATUS_EX
        {
            public byte ACLineStatus = 0;
            public byte BatteryFlag = 0;
            public byte BatteryLifePercent = 0;
            public byte Reserved1 = 0;
            public uint BatteryLifeTime = 0;
            public uint BatteryFullLifeTime = 0;
            public byte Reserved2 = 0;
            public byte BackupBatteryFlag = 0;
            public byte BackupBatteryLifePercent = 0;
            public byte Reserved3 = 0;
            public uint BackupBatteryLifeTime = 0;
            public uint BackupBatteryFullLifeTime = 0;
        }
        [DllImport("coredll")]
        private static extern int GetSystemPowerStatusEx(SYSTEM_POWER_STATUS_EX lpSystemPowerStatus, bool fUpdate);
        [DllImport("coredll")]
        public static extern void SystemIdleTimerReset();
        /// <summary>
        /// 构造函数 在屏幕默认位置构建电池形状
        /// </summary>
        public void Battery()
        {
            SetPolygon();
        }
        /// <summary>
        /// 构造函数 电池形状的X和Y坐标
        /// </summary>
        /// <param name="StartLeft">电池形状的X坐标</param>
        /// <param name="StartTop">电池形状的Y坐标</param>
        public void Battery(int StartLeft, int StartTop)
        {
            iLeft = StartLeft;
            iTop = StartTop;
            SetPolygon();
        }
        /// <summary>
        /// 构造函数 根据X坐标、Y坐标、宽度、高度构造电池形状
        /// </summary>
        /// <param name="StartLeft">电池形状的X坐标</param>
        /// <param name="StartTop">电池形状的Y坐标</param>
        /// <param name="StartWidth">电池形状的宽度</param>
        /// <param name="StartHeight">电池形状的高度</param>
        public void  Battery(int StartLeft, int StartTop, int StartWidth, int StartHeight)
        {
            iLeft = StartLeft;
            iTop = StartTop;
            iWidth = StartWidth;
            iHeight = StartHeight;
            SetPolygon();
        }
        /// <summary>
        /// 设置电池形状
        /// </summary>
        void SetPolygon()
        {
            int Head = 2;
            int HeightLowHalf = (Height - Head) / 2;
            //外边框
            BatteryPolygon[0].X = iLeft;
            BatteryPolygon[0].Y = iTop;
            BatteryPolygon[1].X = iLeft + iWidth;
            BatteryPolygon[1].Y = iTop;
            BatteryPolygon[2].X = iLeft + iWidth;
            BatteryPolygon[2].Y = iTop + HeightLowHalf;
            BatteryPolygon[3].X = iLeft + iWidth + Head;
            BatteryPolygon[3].Y = iTop + HeightLowHalf;
            BatteryPolygon[4].X = iLeft + iWidth + Head;
            BatteryPolygon[4].Y = iTop + HeightLowHalf + Head;
            BatteryPolygon[5].X = iLeft + iWidth;
            BatteryPolygon[5].Y = iTop + HeightLowHalf + Head;
            BatteryPolygon[6].X = iLeft + iWidth;
            BatteryPolygon[6].Y = iTop + HeightLowHalf + Head + HeightLowHalf;
            BatteryPolygon[7].X = iLeft;
            BatteryPolygon[7].Y = iTop + HeightLowHalf + Head + HeightLowHalf;
            //内矩形
            Rect.X = BatteryPolygon[0].X + 2;
            Rect.Y = BatteryPolygon[0].Y + 2;
            Rect.Width = BatteryPolygon[6].X - BatteryPolygon[0].X - 3;
            Rect.Height = BatteryPolygon[6].Y - BatteryPolygon[0].Y - 3;
            iRectWidth = Rect.Width;
            GetBatteryState();
        }
        /// <summary>
        /// 获取电池状态
        /// </summary>
       public void GetBatteryState()
        {
            if (GetSystemPowerStatusEx(status, false) == 1)
            {
                if (status.ACLineStatus == 1)
                {
                    //BatteryFlag = 128  充电完成
                    if(status.BatteryFlag == 128)
                    //if (status.BatteryLifePercent >= 100)
                    {
                        //status.BatteryLifePercent = 100;  //.BatteryFullLifeTime
                        text = "充电完成...";
                        AState = State.ChargeFinally;
                    }  //BatteryFlag = 8 正在充电
                    else
                    {
                        AState = State.Charge;
                        text = "充电中...";
                    }
                }
                else
                {
                    //BatteryFlag = 1 正在使用电池
                    AState = State.Normal;                   
                    if (status.BatteryLifePercent > 100) status.BatteryLifePercent = 100;
                    text = status.BatteryLifePercent.ToString() + "%";
                }
                Percent = status.BatteryLifePercent;
                if (Percent <= 20)
                {
                    AState = State.UnderCharge;
                    text = "电量不足...";
                }
                Rect.Width = iRectWidth * ((Percent + 5) > 100 ? 100 : Percent + 8) / 100;
            }
        }
        /// <summary>
        /// 电池形状X坐标
        /// </summary>
        public int Left
        {
            get { return iLeft; }
            set { iLeft = value; SetPolygon(); }
        }
        /// <summary>
        /// 电池形状Y坐标
        /// </summary>
        public int Top
        {
            get { return iTop; }
            set { iTop = value; SetPolygon(); }
        }
        /// <summary>
        /// 电池形状宽度
        /// </summary>
        public int Width
        {
            get { return iWidth; }
            set { iWidth = value; SetPolygon(); }
        }
        /// <summary>
        /// 电池形状高度
        /// </summary>
        public int Height
        {
            get { return iHeight; }
            set { iHeight = value; SetPolygon(); }
        }
        /// <summary>
        /// 电池电量百分比
        /// </summary>
        public int BatteryPercent
        {
            get { return Percent; }
        }
        /// <summary>
        /// 电池状态
        /// </summary>
        public Rectangle BatteryState
        {
            get
            {
                GetBatteryState();
                return Rect;
            }
        }
        /// <summary>
        /// 电池外边框
        /// </summary>
        public Point[] BatteryStateRect
        {
            get { return BatteryPolygon; }
            set { BatteryPolygon = value; }
        }
        /// <summary>
        /// 当前电池状态，有充电、充电不足、正常 三种状态
        /// </summary>
        public State Status
        {
            get { return AState; }
        }
        /// <summary>
        /// 电池显示的内容
        /// </summary>
        public string Text
        {
            get { return text; }
        }
    }
}

 

方法1：

[csharp] view plaincopyprint?
  1. WinCE获取电池充电状态  
  2.   
  3. SYSTEM_POWER_STATUS_EX2 powerState;  
  4.   
  5.     memset(&powerState, 0, sizeof(powerState));  
  6.   
  7.     DWORD dwResult = GetSystemPowerStatusEx2(&powerState, sizeof(powerState), TRUE);  
  8.   
  9.     if(dwResult != 0)  
  10.   
  11.     {  
  12.   
  13.         if(powerState.ACLineStatus == AC_LINE_ONLINE)  
  14.   
  15.         {  
  16.   
  17.             //MessageBox(_T("交流电"));  
  18.   
  19.             if(powerState.BatteryFlag != BATTERY_FLAG_HIGH)  
  20.   
  21.             {  
  22.   
  23.                 // 正在充电  
  24.   
  25.                 //SetPowerStepBmp(200);  
  26.   
  27.                 MessageBox(_T("充电..."));  
  28.   
  29.             }  
  30.   
  31.             else  
  32.   
  33.             {  
  34.   
  35.                 // 充电结束  
  36.   
  37.                 //SetPowerStepBmp(300);  
  38.   
  39.                 MessageBox(_T("充电结束..."));  
  40.   
  41.             }  
  42.   
  43.         }  
  44.   
  45.         else  
  46.   
  47.         {  
  48.   
  49.             MessageBox(_T("直流电"));  
  50.   
  51.             //INT pow = GetPowerStep((INT)powerState.BatteryLifePercent);  
  52.   
  53.             //SetPowerStepBmp((INT)powerState.BatteryLifePercent);  
  54.   
  55.         }  
  56.   
  57.     }     
WinCE获取电池充电状态

SYSTEM_POWER_STATUS_EX2 powerState;

    memset(&powerState, 0, sizeof(powerState));

    DWORD dwResult = GetSystemPowerStatusEx2(&powerState, sizeof(powerState), TRUE);

    if(dwResult != 0)

    {

        if(powerState.ACLineStatus == AC_LINE_ONLINE)

        {

            //MessageBox(_T("交流电"));

            if(powerState.BatteryFlag != BATTERY_FLAG_HIGH)

            {

                // 正在充电

                //SetPowerStepBmp(200);

                MessageBox(_T("充电..."));

            }

            else

            {

                // 充电结束

                //SetPowerStepBmp(300);

                MessageBox(_T("充电结束..."));

            }

        }

        else

        {

            MessageBox(_T("直流电"));

            //INT pow = GetPowerStep((INT)powerState.BatteryLifePercent);

            //SetPowerStepBmp((INT)powerState.BatteryLifePercent);

        }

    }

效果图（见右上角）：

     (部分桌面内容，受保护已抹掉)

 

 

posted @ 2014-03-27 20:46  哈哈好玩  阅读(421)  评论(0)    收藏  举报