ZKTeco live20R指纹采集识别适配谷歌浏览器

原创 于 2021-07-25 14:42:05 发布 · 4.6k 阅读 · 19 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#ZKTeco #live20R 指纹 #谷歌浏览器插件 #websocket

为解决谷歌浏览器不支持指纹采集器的问题，采用WebSocket技术实现浏览器与桌面应用间的通信，成功将指纹图像实时展示在网页上。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

最近手头的软件项目需要用到指纹采集器，于是上某宝淘了下，发现成熟的指纹采集模块厂家不多。找了一家销量最高的。价格也挺便宜的。

大多数都有桌面版和IE浏览器插件，但是都没有谷歌浏览器版本的。郁闷！

项目是基于谷歌浏览器做的，但是谷歌浏览器不支持activeX控件。网上也有可以让activeX控件适配谷歌浏览器的方法，但是都不保证可用。本着网上没有就自己造的原则，我开始了适配之旅。

曲线救国，既然浏览器端不行那就走客户端，我的思路是这样的：

1、在桌面搭建websocket服务端，监听某个特定的端口的websocket连接 。服务端使用官方提供的客户端SDK来做采集指纹操作。采集到指纹后把数据转换成红色的指纹图片，然后把图片转成base64数据，传给客户端。

2、客户端，即谷歌浏览器端，通过websocket和服务端的服务进行连接，客户端连接服务后，服务端自动记录连接ID，通过该ID把base64格式图片数据发送到浏览器，浏览器把图片进行转换，变成图片显示。效果如下

以上为思路，说干就干，上代码前先把必须的websocket包安装一下，在vs2019里，项目-》引用，右键，管理NuGet程序包，搜索并安装SuperWebSocket.

下面是代码：

服务端主程序：

using libzkfpcsharp;
using Microsoft.Win32;
using SuperSocket.SocketBase.Config;
using SuperWebSocket;
using System;
using System.Drawing;
using System.IO;
using System.Runtime.InteropServices;
using System.Threading;
using System.Windows.Forms;
namespace FP_Service
{
    public partial class Form1 : Form
    {
        IntPtr mDevHandle = IntPtr.Zero;
        IntPtr FormHandle = IntPtr.Zero;
        string strBase64 = "";
        private bool isclose;
        bool bIsTimeToDie = false;
        byte[] FPBuffer;
        byte[][] RegTmps = new byte[3][];
        byte[] CapTmp = new byte[2048];
        int cbCapTmp = 2048;

        private int mfpWidth = 0;
        private int mfpHeight = 0;
        private WebSocketServer mWebSocketServer;
        private string mSessionID = "";
        const int MESSAGE_CAPTURED_OK = 0x0400 + 6;
        [DllImport("user32.dll", EntryPoint = "SendMessage")]
        public static extern int SendMessage(IntPtr hwnd, int wMsg, IntPtr wParam, IntPtr lParam);
        public Form1()
        {
            InitializeComponent();
        }
      
        private void Form1_Load(object sender, EventArgs e)
        {

            FormHandle = this.Handle;
            base.Left = Screen.GetBounds(this).Width - base.Width - 5;
            base.Top = Screen.GetBounds(this).Height - base.Height - 50;
            FirstAutoRun(true);//添加进系统服务，开机自启动。
            CheckAutoRun(Application.ExecutablePath, true);//添加进系统服务，开机自启动。
            int ret = zkfperrdef.ZKFP_ERR_OK;
            if ((ret = zkfp2.Init()) == zkfperrdef.ZKFP_ERR_OK)
            {
                int nCount = zkfp2.GetDeviceCount();
                if (nCount < 0)
                {
                    zkfp2.Terminate();
                    label1.Text="未发现指纹采集设备!";
                }
            }
            else
            {
                label1.Text = "初始化失败, 返回值为：" + ret;
            }
            //Setup();
            ServerConfig config = new ServerConfig{
                Ip = "127.0.0.1",
                Port = 8891,
                MaxConnectionNumber = 100,
                Name = "FPServer"
            };
            mWebSocketServer = new WebSocketServer();
            if (mWebSocketServer.Setup(config)) 
            { 
                label1.Text = "初始化服务成功。";
                mWebSocketServer.NewSessionConnected += MWebSocketServer_NewSessionConnected1;
            } 
            else {
                label1.Text = "初始化服务失败！"; 
            }
           if( mWebSocketServer.Start()) { label1.Text = "开启服务成功。";
              
            } else { label1.Text = "开启服务失败！"; }
         
            if (IntPtr.Zero == (mDevHandle = zkfp2.OpenDevice(0)))
            {
                label1.Text = "开启设备失败!";
                return;
            }
            else
            {
                for (int i = 0; i < 3; i++)
                {
                    RegTmps[i] = new byte[2048];
                }
                byte[] paramValue = new byte[4];
                int size = 4;
                zkfp2.GetParameters(mDevHandle, 1, paramValue, ref size);
                zkfp2.ByteArray2Int(paramValue, ref mfpWidth);

                size = 4;
                zkfp2.GetParameters(mDevHandle, 2, paramValue, ref size);
                zkfp2.ByteArray2Int(paramValue, ref mfpHeight);

                FPBuffer = new byte[mfpWidth * mfpHeight];

                Thread captureThread = new Thread(new ThreadStart(DoCapture));
                captureThread.IsBackground = true;
                captureThread.Start();
                bIsTimeToDie = false;
                label1.Text = "设备已连接";
            }

        }
    
        private void DoCapture()
        {
            while (!bIsTimeToDie)
            {
                cbCapTmp = 2048;
                int ret = zkfp2.AcquireFingerprint(mDevHandle, FPBuffer, CapTmp, ref cbCapTmp);
             
                if (ret == zkfp.ZKFP_ERR_OK)
                {
                    SendMessage(FormHandle, MESSAGE_CAPTURED_OK, IntPtr.Zero, IntPtr.Zero);
                }
                Thread.Sleep(200);
            }
        }
        private string ToBase64(Bitmap bmp)
        {
            try
            {
                MemoryStream ms = new MemoryStream();
                bmp.Save(ms, System.Drawing.Imaging.ImageFormat.Png);
                byte[] arr = new byte[ms.Length];
                ms.Position = 0;
                ms.Read(arr, 0, (int)ms.Length);
                ms.Close();
                String strbaser64 = Convert.ToBase64String(arr);
                return strbaser64;
            }
            catch (Exception ex)
            {
                MessageBox.Show("转换失败:" + ex.Message);
                return "";
            }
        }
        private static Bitmap UpdateColor(Bitmap bitmap)
        {
            int width = bitmap.Width;
            int height = bitmap.Height;
            Bitmap newmap = new Bitmap(width, height);
            Color pixel;
            for (int i = 0; i < width; i++)
            {
                for (int j = 0; j < height; j++)
                {
                    pixel = bitmap.GetPixel(i, j); // 获取原图的像素点颜色值
                    int r, g, b, a;
                    r = pixel.R;
                    g = pixel.G;
                    b = pixel.B;
                    a = pixel.A;
                   

                    // 判断是否为白色背景
                    if ( b > 120|| r > 120 || g > 120)
                    {
                        newmap.SetPixel(i, j, Color.FromArgb(0,255, 255, 255));
                    }
                    else
                    {
                        newmap.SetPixel(i, j, Color.Red);
                    }
                }
            }
            return newmap;
        }
        protected override void DefWndProc(ref Message m)
        {
            switch (m.Msg)
            {
                case MESSAGE_CAPTURED_OK:
                    {
                        MemoryStream ms = new MemoryStream();
                        BitmapFormat.GetBitmap(FPBuffer, mfpWidth, mfpHeight, ref ms);
                        Bitmap bmp = UpdateColor( new Bitmap(ms));
                        //Bitmap bmp =new Bitmap(ms);
                        strBase64 = ToBase64(bmp);
                        pictureBox2.Image = bmp;

                        foreach (WebSocketSession sendSession in mWebSocketServer.GetAllSessions())
                        {
                            if (sendSession.SessionID.Equals(mSessionID))
                            {
                                sendSession.Send(strBase64);
                                break;
                            }
                        }

                    }
                    break;

                default:
                    base.DefWndProc(ref m);
                    break;
            }
        }

    
        private void MWebSocketServer_NewSessionConnected1(WebSocketSession session)
        {
            mSessionID = session.SessionID;//客户端连接成功保存ID至session
        }
     

        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            if (!isclose)
            {
                e.Cancel = true;
                base.Hide();
            }
        }

        private void button2_Click(object sender, EventArgs e)
        {
            isclose = true;
            this.Close();
        }

        private void checkBox1_CheckedChanged(object sender, EventArgs e)
        {
            if (checkBox1.Checked)
            {
                SetAutoRun(Application.ExecutablePath, false, true);
            }
            else
            {
                SetAutoRun(Application.ExecutablePath, true, true);
            }
        }
        public void SetAutoRun(string fileName, bool isAutoRun, bool isCurrentUser)
        {
            RegistryKey reg = null;
            try
            {
                if (!File.Exists(fileName))
                {
                    throw new Exception("Not File!");
                }
                string name = fileName.Substring(fileName.LastIndexOf("\\") + 1);
                if (isCurrentUser)
                {
                    reg = Registry.CurrentUser.OpenSubKey("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run", true);
                    if (reg == null)
                    {
                        reg = Registry.CurrentUser.CreateSubKey("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run");
                    }
                    if (isAutoRun)
                    {
                        if (reg.GetValue(name) == null)
                        {
                            reg.SetValue(name, fileName);
                        }
                        else if (!reg.GetValue(name).Equals(fileName))
                        {
                            reg.SetValue(name, fileName);
                        }
                    }
                    else
                    {
                        reg.DeleteValue(name);
                    }
                }
                else
                {
                    reg = Registry.LocalMachine.OpenSubKey("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run", true);
                    if (reg == null)
                    {
                        reg = Registry.LocalMachine.CreateSubKey("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run");
                    }
                    if (isAutoRun)
                    {
                        if (reg.GetValue(name) == null)
                        {
                            reg.SetValue(name, fileName);
                        }
                        else if (!reg.GetValue(name).Equals(fileName))
                        {
                            reg.SetValue(name, fileName);
                        }
                    }
                    else
                    {
                        reg.DeleteValue(name);
                    }
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.ToString());
            }
            finally
            {
                if (reg != null)
                {
                    reg.Close();
                }
            }
        }
        public void FirstAutoRun(bool isCurrentUser)
        {
            RegistryKey reg = null;
            try
            {
                string name = "Run";
                if (isCurrentUser)
                {
                    reg = Registry.CurrentUser.OpenSubKey("SOFTWARE\\WC\\FPWebServer\\", true);
                    if (reg == null)
                    {
                        reg = Registry.CurrentUser.CreateSubKey("SOFTWARE\\WC\\FPWebServer\\");
                    }
                    if (reg.GetValue(name) == null)
                    {
                        this.SetAutoRun(Application.ExecutablePath, true, true);
                        reg.SetValue(name, true);
                    }
                }
                else
                {
                    reg = Registry.LocalMachine.OpenSubKey("SOFTWARE\\WC\\FPWebServer\\", true);
                    if (reg == null)
                    {
                        reg = Registry.LocalMachine.CreateSubKey("SOFTWARE\\WC\\FPWebServer\\");
                    }
                    if (reg.GetValue(name) == null)
                    {
                        this.SetAutoRun(Application.ExecutablePath, true, false);
                        reg.SetValue(name, true);
                    }
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.ToString());
            }
            finally
            {
                if (reg != null)
                {
                    reg.Close();
                }
            }
        }

        public void CheckAutoRun(string fileName, bool isCurrentUser)
        {
            RegistryKey reg = null;
            try
            {
                if (!File.Exists(fileName))
                {
                    throw new Exception("Not File!");
                }
                string name = fileName.Substring(fileName.LastIndexOf("\\") + 1);
                if (isCurrentUser)
                {
                    reg = Registry.CurrentUser.OpenSubKey("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run", true);
                    if (reg == null)
                    {
                        reg = Registry.CurrentUser.CreateSubKey("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run");
                    }
                    if (reg.GetValue(name) == null)
                    {
                        checkBox1.Checked = false;
                    }
                    else
                    {
                       checkBox1.Checked = true;
                    }
                }
                else
                {
                    reg = Registry.LocalMachine.OpenSubKey("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run", true);
                    if (reg == null)
                    {
                        reg = Registry.LocalMachine.CreateSubKey("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run");
                    }
                    if (reg.GetValue(name) == null)
                    {
                        checkBox1.Checked = false;
                    }
                    else
                    {
                        checkBox1.Checked = true;
                    }
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.ToString());
            }
            finally
            {
                if (reg != null)
                {
                    reg.Close();
                }
            }
        }

        private void Form1_FormClosed(object sender, FormClosedEventArgs e)
        {
            mWebSocketServer.Stop();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            int ret = zkfperrdef.ZKFP_ERR_OK;
            if ((ret = zkfp2.Init()) == zkfperrdef.ZKFP_ERR_OK)
            {
                int nCount = zkfp2.GetDeviceCount();
                if (nCount < 0)
                {
                    zkfp2.Terminate();
                    label1.Text = "未发现指纹采集设备!";
                }
            }
            else
            {
                label1.Text = "初始化失败, 返回值为：" + ret;
            }
        }

        private void notifyIcon1_Click(object sender, EventArgs e)
        {
            if (base.Visible)
            {
                base.Hide();
                return;
            }
            base.Show();
        }
    }
}
using libzkfpcsharp;
using Microsoft.Win32;
using SuperSocket.SocketBase.Config;
using SuperWebSocket;
using System;
using System.Drawing;
using System.IO;
using System.Runtime.InteropServices;
using System.Threading;
using System.Windows.Forms;
namespace FP_Service
{
    public partial class Form1 : Form
    {
        IntPtr mDevHandle = IntPtr.Zero;
        IntPtr FormHandle = IntPtr.Zero;
        string strBase64 = "";
        private bool isclose;
        bool bIsTimeToDie = false;
        byte[] FPBuffer;
        byte[][] RegTmps = new byte[3][];
        byte[] CapTmp = new byte[2048];
        int cbCapTmp = 2048;

        private int mfpWidth = 0;
        private int mfpHeight = 0;
        private WebSocketServer mWebSocketServer;
        private string mSessionID = "";
        const int MESSAGE_CAPTURED_OK = 0x0400 + 6;
        [DllImport("user32.dll", EntryPoint = "SendMessage")]
        public static extern int SendMessage(IntPtr hwnd, int wMsg, IntPtr wParam, IntPtr lParam);
        public Form1()
        {
            InitializeComponent();
        }
      
        private void Form1_Load(object sender, EventArgs e)
        {

            FormHandle = this.Handle;
            base.Left = Screen.GetBounds(this).Width - base.Width - 5;
            base.Top = Screen.GetBounds(this).Height - base.Height - 50;
            FirstAutoRun(true);//添加进系统服务，开机自启动。
            CheckAutoRun(Application.ExecutablePath, true);//添加进系统服务，开机自启动。
            int ret = zkfperrdef.ZKFP_ERR_OK;
            if ((ret = zkfp2.Init()) == zkfperrdef.ZKFP_ERR_OK)
            {
                int nCount = zkfp2.GetDeviceCount();
                if (nCount < 0)
                {
                    zkfp2.Terminate();
                    label1.Text="未发现指纹采集设备!";
                }
            }
            else
            {
                label1.Text = "初始化失败, 返回值为：" + ret;
            }
            //Setup();
            ServerConfig config = new ServerConfig{
                Ip = "127.0.0.1",
                Port = 8891,
                MaxConnectionNumber = 100,
                Name = "FPServer"
            };
            mWebSocketServer = new WebSocketServer();
            if (mWebSocketServer.Setup(config)) 
            { 
                label1.Text = "初始化服务成功。";
                mWebSocketServer.NewSessionConnected += MWebSocketServer_NewSessionConnected1;
            } 
            else {
                label1.Text = "初始化服务失败！"; 
            }
           if( mWebSocketServer.Start()) { label1.Text = "开启服务成功。";
              
            } else { label1.Text = "开启服务失败！"; }
         
            if (IntPtr.Zero == (mDevHandle = zkfp2.OpenDevice(0)))
            {
                label1.Text = "开启设备失败!";
                return;
            }
            else
            {
                for (int i = 0; i < 3; i++)
                {
                    RegTmps[i] = new byte[2048];
                }
                byte[] paramValue = new byte[4];
                int size = 4;
                zkfp2.GetParameters(mDevHandle, 1, paramValue, ref size);
                zkfp2.ByteArray2Int(paramValue, ref mfpWidth);

                size = 4;
                zkfp2.GetParameters(mDevHandle, 2, paramValue, ref size);
                zkfp2.ByteArray2Int(paramValue, ref mfpHeight);

                FPBuffer = new byte[mfpWidth * mfpHeight];

                Thread captureThread = new Thread(new ThreadStart(DoCapture));
                captureThread.IsBackground = true;
                captureThread.Start();
                bIsTimeToDie = false;
                label1.Text = "设备已连接";
            }

        }
    
        private void DoCapture()
        {
            while (!bIsTimeToDie)
            {
                cbCapTmp = 2048;
                int ret = zkfp2.AcquireFingerprint(mDevHandle, FPBuffer, CapTmp, ref cbCapTmp);
             
                if (ret == zkfp.ZKFP_ERR_OK)
                {
                    SendMessage(FormHandle, MESSAGE_CAPTURED_OK, IntPtr.Zero, IntPtr.Zero);
                }
                Thread.Sleep(200);
            }
        }
        private string ToBase64(Bitmap bmp)
        {
            try
            {
                MemoryStream ms = new MemoryStream();
                bmp.Save(ms, System.Drawing.Imaging.ImageFormat.Png);
                byte[] arr = new byte[ms.Length];
                ms.Position = 0;
                ms.Read(arr, 0, (int)ms.Length);
                ms.Close();
                String strbaser64 = Convert.ToBase64String(arr);
                return strbaser64;
            }
            catch (Exception ex)
            {
                MessageBox.Show("转换失败:" + ex.Message);
                return "";
            }
        }
        private static Bitmap UpdateColor(Bitmap bitmap)
        {
            int width = bitmap.Width;
            int height = bitmap.Height;
            Bitmap newmap = new Bitmap(width, height);
            Color pixel;
            for (int i = 0; i < width; i++)
            {
                for (int j = 0; j < height; j++)
                {
                    pixel = bitmap.GetPixel(i, j); // 获取原图的像素点颜色值
                    int r, g, b, a;
                    r = pixel.R;
                    g = pixel.G;
                    b = pixel.B;
                    a = pixel.A;
                   

                    // 判断是否为白色背景
                    if ( b > 120|| r > 120 || g > 120)
                    {
                        newmap.SetPixel(i, j, Color.FromArgb(0,255, 255, 255));
                    }
                    else
                    {
                        newmap.SetPixel(i, j, Color.Red);
                    }
                }
            }
            return newmap;
        }
        protected override void DefWndProc(ref Message m)
        {
            switch (m.Msg)
            {
                case MESSAGE_CAPTURED_OK:
                    {
                        MemoryStream ms = new MemoryStream();
                        BitmapFormat.GetBitmap(FPBuffer, mfpWidth, mfpHeight, ref ms);
                        Bitmap bmp = UpdateColor( new Bitmap(ms));
                        //Bitmap bmp =new Bitmap(ms);
                        strBase64 = ToBase64(bmp);
                        pictureBox2.Image = bmp;

                        foreach (WebSocketSession sendSession in mWebSocketServer.GetAllSessions())
                        {
                            if (sendSession.SessionID.Equals(mSessionID))
                            {
                                sendSession.Send(strBase64);
                                break;
                            }
                        }

                    }
                    break;

                default:
                    base.DefWndProc(ref m);
                    break;
            }
        }

    
        private void MWebSocketServer_NewSessionConnected1(WebSocketSession session)
        {
            mSessionID = session.SessionID;//客户端连接成功保存ID至session
        }
     

        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            if (!isclose)
            {
                e.Cancel = true;
                base.Hide();
            }
        }

        private void button2_Click(object sender, EventArgs e)
        {
            isclose = true;
            this.Close();
        }

        private void checkBox1_CheckedChanged(object sender, EventArgs e)
        {
            if (checkBox1.Checked)
            {
                SetAutoRun(Application.ExecutablePath, false, true);
            }
            else
            {
                SetAutoRun(Application.ExecutablePath, true, true);
            }
        }
        public void SetAutoRun(string fileName, bool isAutoRun, bool isCurrentUser)
        {
            RegistryKey reg = null;
            try
            {
                if (!File.Exists(fileName))
                {
                    throw new Exception("Not File!");
                }
                string name = fileName.Substring(fileName.LastIndexOf("\\") + 1);
                if (isCurrentUser)
                {
                    reg = Registry.CurrentUser.OpenSubKey("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run", true);
                    if (reg == null)
                    {
                        reg = Registry.CurrentUser.CreateSubKey("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run");
                    }
                    if (isAutoRun)
                    {
                        if (reg.GetValue(name) == null)
                        {
                            reg.SetValue(name, fileName);
                        }
                        else if (!reg.GetValue(name).Equals(fileName))
                        {
                            reg.SetValue(name, fileName);
                        }
                    }
                    else
                    {
                        reg.DeleteValue(name);
                    }
                }
                else
                {
                    reg = Registry.LocalMachine.OpenSubKey("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run", true);
                    if (reg == null)
                    {
                        reg = Registry.LocalMachine.CreateSubKey("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run");
                    }
                    if (isAutoRun)
                    {
                        if (reg.GetValue(name) == null)
                        {
                            reg.SetValue(name, fileName);
                        }
                        else if (!reg.GetValue(name).Equals(fileName))
                        {
                            reg.SetValue(name, fileName);
                        }
                    }
                    else
                    {
                        reg.DeleteValue(name);
                    }
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.ToString());
            }
            finally
            {
                if (reg != null)
                {
                    reg.Close();
                }
            }
        }
        public void FirstAutoRun(bool isCurrentUser)
        {
            RegistryKey reg = null;
            try
            {
                string name = "Run";
                if (isCurrentUser)
                {
                    reg = Registry.CurrentUser.OpenSubKey("SOFTWARE\\WC\\FPWebServer\\", true);
                    if (reg == null)
                    {
                        reg = Registry.CurrentUser.CreateSubKey("SOFTWARE\\WC\\FPWebServer\\");
                    }
                    if (reg.GetValue(name) == null)
                    {
                        this.SetAutoRun(Application.ExecutablePath, true, true);
                        reg.SetValue(name, true);
                    }
                }
                else
                {
                    reg = Registry.LocalMachine.OpenSubKey("SOFTWARE\\WC\\FPWebServer\\", true);
                    if (reg == null)
                    {
                        reg = Registry.LocalMachine.CreateSubKey("SOFTWARE\\WC\\FPWebServer\\");
                    }
                    if (reg.GetValue(name) == null)
                    {
                        this.SetAutoRun(Application.ExecutablePath, true, false);
                        reg.SetValue(name, true);
                    }
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.ToString());
            }
            finally
            {
                if (reg != null)
                {
                    reg.Close();
                }
            }
        }

        public void CheckAutoRun(string fileName, bool isCurrentUser)
        {
            RegistryKey reg = null;
            try
            {
                if (!File.Exists(fileName))
                {
                    throw new Exception("Not File!");
                }
                string name = fileName.Substring(fileName.LastIndexOf("\\") + 1);
                if (isCurrentUser)
                {
                    reg = Registry.CurrentUser.OpenSubKey("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run", true);
                    if (reg == null)
                    {
                        reg = Registry.CurrentUser.CreateSubKey("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run");
                    }
                    if (reg.GetValue(name) == null)
                    {
                        checkBox1.Checked = false;
                    }
                    else
                    {
                       checkBox1.Checked = true;
                    }
                }
                else
                {
                    reg = Registry.LocalMachine.OpenSubKey("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run", true);
                    if (reg == null)
                    {
                        reg = Registry.LocalMachine.CreateSubKey("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run");
                    }
                    if (reg.GetValue(name) == null)
                    {
                        checkBox1.Checked = false;
                    }
                    else
                    {
                        checkBox1.Checked = true;
                    }
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.ToString());
            }
            finally
            {
                if (reg != null)
                {
                    reg.Close();
                }
            }
        }

        private void Form1_FormClosed(object sender, FormClosedEventArgs e)
        {
            mWebSocketServer.Stop();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            int ret = zkfperrdef.ZKFP_ERR_OK;
            if ((ret = zkfp2.Init()) == zkfperrdef.ZKFP_ERR_OK)
            {
                int nCount = zkfp2.GetDeviceCount();
                if (nCount < 0)
                {
                    zkfp2.Terminate();
                    label1.Text = "未发现指纹采集设备!";
                }
            }
            else
            {
                label1.Text = "初始化失败, 返回值为：" + ret;
            }
        }

        private void notifyIcon1_Click(object sender, EventArgs e)
        {
            if (base.Visible)
            {
                base.Hide();
                return;
            }
            base.Show();
        }
    }
}

服务端指纹数据转图片：

using System;
using System.Runtime.InteropServices;
using System.IO;

namespace FP_Service
{
    public class BitmapFormat
    {
        public struct BITMAPFILEHEADER
        {
            public ushort bfType;
            public int bfSize;
            public ushort bfReserved1;
            public ushort bfReserved2;
            public int bfOffBits;
        }

        public struct MASK
        {
            public byte redmask;
            public byte greenmask;
            public byte bluemask;
            public byte rgbReserved;
        }

        public struct BITMAPINFOHEADER
        {
            public int biSize;
            public int biWidth;
            public int biHeight;
            public ushort biPlanes;
            public ushort biBitCount;
            public int biCompression;
            public int biSizeImage;
            public int biXPelsPerMeter;
            public int biYPelsPerMeter;
            public int biClrUsed;
            public int biClrImportant;
        }

        /*******************************************
        * 函数名称：RotatePic       
        * 函数功能：旋转图片，目的是保存和显示的图片与按的指纹方向不同     
        * 函数入参：BmpBuf---旋转前的指纹字符串
        * 函数出参：ResBuf---旋转后的指纹字符串
        * 函数返回：无
        *********************************************/
        public static void RotatePic(byte[] BmpBuf, int width, int height, ref byte[] ResBuf)
        {
            int RowLoop = 0;
            int ColLoop = 0;
            int BmpBuflen = width * height;

            try
            {
                for (RowLoop = 0; RowLoop < BmpBuflen; )
                {
                    for (ColLoop = 0; ColLoop < width; ColLoop++)
                    {
                        ResBuf[RowLoop + ColLoop] = BmpBuf[BmpBuflen - RowLoop - width + ColLoop];
                    }

                    RowLoop = RowLoop + width;
                }
            }
            catch (Exception ex)
            {
                //ZKCE.SysException.ZKCELogger logger = new ZKCE.SysException.ZKCELogger(ex);
                //logger.Append();
            }
        }

        /*******************************************
        * 函数名称：StructToBytes       
        * 函数功能：将结构体转化成无符号字符串数组     
        * 函数入参：StructObj---被转化的结构体
        *           Size---被转化的结构体的大小
        * 函数出参：无
        * 函数返回：结构体转化后的数组
        *********************************************/
        public static byte[] StructToBytes(object StructObj, int Size)
        {
            int StructSize = Marshal.SizeOf(StructObj);
            byte[] GetBytes = new byte[StructSize];

            try
            {
                IntPtr StructPtr = Marshal.AllocHGlobal(StructSize);
                Marshal.StructureToPtr(StructObj, StructPtr, false);
                Marshal.Copy(StructPtr, GetBytes, 0, StructSize);
                Marshal.FreeHGlobal(StructPtr);

                if (Size == 14)
                {
                    byte[] NewBytes = new byte[Size];
                    int Count = 0;
                    int Loop = 0;

                    for (Loop = 0; Loop < StructSize; Loop++)
                    {
                        if (Loop != 2 && Loop != 3)
                        {
                            NewBytes[Count] = GetBytes[Loop];
                            Count++;
                        }
                    }

                    return NewBytes;
                }
                else
                {
                    return GetBytes;
                }
            }
            catch (Exception ex)
            {
                //ZKCE.SysException.ZKCELogger logger = new ZKCE.SysException.ZKCELogger(ex);
                //logger.Append();

                return GetBytes;
            }
        }

        /*******************************************
        * 函数名称：GetBitmap       
        * 函数功能：将传进来的数据保存为图片     
        * 函数入参：buffer---图片数据
        *           nWidth---图片的宽度
        *           nHeight---图片的高度
        * 函数出参：无
        * 函数返回：无
        *********************************************/
        public static void GetBitmap(byte[] buffer, int nWidth, int nHeight, ref MemoryStream ms)
        {
            int ColorIndex = 0;
            ushort m_nBitCount = 8;
            int m_nColorTableEntries = 256;
            byte[] ResBuf = new byte[nWidth * nHeight*2];

            try
            {
                BITMAPFILEHEADER BmpHeader = new BITMAPFILEHEADER();
                BITMAPINFOHEADER BmpInfoHeader = new BITMAPINFOHEADER();
                MASK[] ColorMask = new MASK[m_nColorTableEntries];

                int w = (((nWidth + 3) / 4) * 4);

                //图片头信息
                BmpInfoHeader.biSize = Marshal.SizeOf(BmpInfoHeader);
                BmpInfoHeader.biWidth = nWidth;
                BmpInfoHeader.biHeight = nHeight;
                BmpInfoHeader.biPlanes = 1;
                BmpInfoHeader.biBitCount = m_nBitCount;
                BmpInfoHeader.biCompression = 0;
                BmpInfoHeader.biSizeImage = 0;
                BmpInfoHeader.biXPelsPerMeter = 0;
                BmpInfoHeader.biYPelsPerMeter = 0;
                BmpInfoHeader.biClrUsed = m_nColorTableEntries;
                BmpInfoHeader.biClrImportant = m_nColorTableEntries;

                //文件头信息
                BmpHeader.bfType = 0x4D42;
                BmpHeader.bfOffBits = 14 + Marshal.SizeOf(BmpInfoHeader) + BmpInfoHeader.biClrUsed * 4;
                BmpHeader.bfSize = BmpHeader.bfOffBits + ((((w * BmpInfoHeader.biBitCount + 31) / 32) * 4) * BmpInfoHeader.biHeight);
                BmpHeader.bfReserved1 = 0;
                BmpHeader.bfReserved2 = 0;

                ms.Write(StructToBytes(BmpHeader, 14), 0, 14);
                ms.Write(StructToBytes(BmpInfoHeader, Marshal.SizeOf(BmpInfoHeader)), 0, Marshal.SizeOf(BmpInfoHeader));

                //调试板信息
                for (ColorIndex = 0; ColorIndex < m_nColorTableEntries; ColorIndex++)
                {
                   
                    ColorMask[ColorIndex].redmask = (byte)ColorIndex;;
                    ColorMask[ColorIndex].greenmask = (byte)ColorIndex;
                    ColorMask[ColorIndex].bluemask = (byte)ColorIndex;
                    //ColorMask[ColorIndex].greenmask = (byte)ColorIndex;
                    //ColorMask[ColorIndex].bluemask = (byte)ColorIndex;
                    ColorMask[ColorIndex].rgbReserved = 0;

                    ms.Write(StructToBytes(ColorMask[ColorIndex], Marshal.SizeOf(ColorMask[ColorIndex])), 0, Marshal.SizeOf(ColorMask[ColorIndex]));
                }

                //图片旋转，解决指纹图片倒立的问题
                RotatePic(buffer, nWidth, nHeight, ref ResBuf);

                byte[] filter = null;
                if (w - nWidth > 0)
                {
                    filter = new byte[w - nWidth];
                }
                for (int i = 0; i < nHeight; i++)
                {
                    ms.Write(ResBuf, i * nWidth, nWidth);
                    if (w - nWidth > 0)
                    {
                        ms.Write(ResBuf, 0, w - nWidth);
                    }
                }
            }
            catch (Exception ex)
            {
               // ZKCE.SysException.ZKCELogger logger = new ZKCE.SysException.ZKCELogger(ex);
               // logger.Append();
            }
        }

        /*******************************************
        * 函数名称：WriteBitmap       
        * 函数功能：将传进来的数据保存为图片     
        * 函数入参：buffer---图片数据
        *           nWidth---图片的宽度
        *           nHeight---图片的高度
        * 函数出参：无
        * 函数返回：无
        *********************************************/
        public static void WriteBitmap(byte[] buffer, int nWidth, int nHeight)
        {
            int ColorIndex = 0;
            ushort m_nBitCount = 8;
            int m_nColorTableEntries = 256;
            byte[] ResBuf = new byte[nWidth * nHeight];

            try
            {

                BITMAPFILEHEADER BmpHeader = new BITMAPFILEHEADER();
                BITMAPINFOHEADER BmpInfoHeader = new BITMAPINFOHEADER();
                MASK[] ColorMask = new MASK[m_nColorTableEntries];
                int w = (((nWidth + 3) / 4) * 4);
                //图片头信息
                BmpInfoHeader.biSize = Marshal.SizeOf(BmpInfoHeader);
                BmpInfoHeader.biWidth = nWidth;
                BmpInfoHeader.biHeight = nHeight;
                BmpInfoHeader.biPlanes = 1;
                BmpInfoHeader.biBitCount = m_nBitCount;
                BmpInfoHeader.biCompression = 0;
                BmpInfoHeader.biSizeImage = 0;
                BmpInfoHeader.biXPelsPerMeter = 0;
                BmpInfoHeader.biYPelsPerMeter = 0;
                BmpInfoHeader.biClrUsed = m_nColorTableEntries;
                BmpInfoHeader.biClrImportant = m_nColorTableEntries;

                //文件头信息
                BmpHeader.bfType = 0x4D42;
                BmpHeader.bfOffBits = 14 + Marshal.SizeOf(BmpInfoHeader) + BmpInfoHeader.biClrUsed * 4;
                BmpHeader.bfSize = BmpHeader.bfOffBits + ((((w * BmpInfoHeader.biBitCount + 31) / 32) * 4) * BmpInfoHeader.biHeight);
                BmpHeader.bfReserved1 = 0;
                BmpHeader.bfReserved2 = 0;

                Stream FileStream = File.Open("finger.bmp", FileMode.Create, FileAccess.Write);
                BinaryWriter TmpBinaryWriter = new BinaryWriter(FileStream);

                TmpBinaryWriter.Write(StructToBytes(BmpHeader, 14));
                TmpBinaryWriter.Write(StructToBytes(BmpInfoHeader, Marshal.SizeOf(BmpInfoHeader)));

                //调试板信息
                for (ColorIndex = 0; ColorIndex < m_nColorTableEntries; ColorIndex++)
                {
                    ColorMask[ColorIndex].redmask = (byte)ColorIndex;
                    ColorMask[ColorIndex].greenmask = (byte)ColorIndex;
                    ColorMask[ColorIndex].bluemask = (byte)ColorIndex;
                    ColorMask[ColorIndex].rgbReserved = 0;

                    TmpBinaryWriter.Write(StructToBytes(ColorMask[ColorIndex], Marshal.SizeOf(ColorMask[ColorIndex])));
                }

                //图片旋转，解决指纹图片倒立的问题
                RotatePic(buffer, nWidth, nHeight, ref ResBuf);

                //写图片
                //TmpBinaryWriter.Write(ResBuf);
                byte[] filter = null;
                if (w - nWidth > 0)
                {
                    filter = new byte[w - nWidth];
                }
                for (int i = 0; i < nHeight; i++)
                {
                    TmpBinaryWriter.Write(ResBuf, i * nWidth, nWidth);
                    if (w - nWidth > 0)
                    {
                        TmpBinaryWriter.Write(ResBuf, 0, w - nWidth);
                    }
                }

                FileStream.Close();
                TmpBinaryWriter.Close();
            }
            catch (Exception ex)
            {
                //ZKCE.SysException.ZKCELogger logger = new ZKCE.SysException.ZKCELogger(ex);
                //logger.Append();
            }
        }
    }
}

客户端，浏览器端代码：

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>fp</title>
  <meta name="description" content="fp">

  <meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1, maximum-scale=1, user-scalable=no">

  <meta name="apple-mobile-web-app-capable" content="yes">
  <meta name="apple-mobile-web-app-status-bar-style" content="black">

  <link rel="stylesheet" href="css/signature-pad.css">
  <script src="/jquery.min.js" type="text/javascript"></script>
</head>
<body onselectstart="return false">


    <div id="signature-pad" class="signature-pad">
        <div>

        </div>
        <div class="signature-pad--body">
            <table width="100%" border="0" cellspacing="0">
                <tr align="center">
                    <td width="100%"><img src="https://img-blog.csdnimg.cn/2022010611375296516.png" alt="" width="256" height="288" id="imgDiv" align="middle" /></td>
                </tr>
            </table>
        </div>
      
    </div>
    <script type="text/javascript">
        var ws;
        $(document).ready(function () {

            // test if the browser supports web sockets
            if ("WebSocket" in window) {
                connect("ws://127.0.0.1:8891/");
            } else {
                $('#es').val('浏览器不支持此指纹仪!');
            };

            // function to send data on the web socket
            function ws_send(str) {
                try {
                    ws.send(str);
                } catch (err) {
                    $('#es').val('error');
                }
            }

            // connect to the specified host
            function connect(host) {

                $('#es').val('Connecting to " + host + " ...');
                try {
                    ws = new WebSocket(host); // create the web socket
                } catch (err) {
                    $('#es').val('error');
                }

                ws.onopen = function () {
                   // $('#es').val('设备连接成功!');
                };

                ws.onmessage = function (evt) {

                    var obj = evt.data;
                 
                    var img = document.getElementById("imgDiv");
                    img.src = "data:image/png;base64," + obj;

                };

                ws.onclose = function () {
                   // document.getElementById("es").value = "Closed!";
                };
            };

        });

    </script>

</body>
</html>

以上就是全部代码，服务端运行后会自动注册服务到系统，下次开机可自启动，如果不想可在程序里关闭。（指纹识别采集的数据转图片后是黑色的，实际需要红色的，在这里通过判断图片像素点的色纸批量修改黑色到红色）。

我是一个为了做产品啥都学的程序员，希望这些文字能给你些许的帮助。

博客
ASP.NET CORE基础教程(二)-中间件
05-02 1694
ASP.NET CORE基础教程(二)-中间件中间件概述所谓中间件就是嵌入到应用中用来处理请求和响应的软件。在管道中每一个元件都能够选择是否把请求传递给下一个元件，同时能在下一个元件被调用前后执行相应的操作。此时相应的请求委托便会在管道中建立用来响应http请求。
博客
ASP.NET CORE基础教程(一)-启动文件Startup
04-29 5229
ASP.NET CORE基础教程(一)-启动文件StartupStartup类起到配置处理监听请求通道的作用。Startup类ASP.NET CORE应用程序必须有Startup文件，在主函数中调用，可以随意命名，但通常使用系统默认的startup. 可以通过startup的构造函数进行依赖注入。通过IHostingEnvironment、ILoggerFactory等加载各种配置或是日志等等。
博客
C#自定义控件之-自定义MessageBox
10-28 1万+
每次谈到系统自带的控件，博主就是各种不满意（应该不止我一个吧），这次也不例外，今天的主角是messagebox控件。任何开发者都无法直视当自己做的美观的软件弹出提示时居然是奇丑无比的系统自带提示框。同样是为了方便以后使用和分享给大家，这里博主把项目中用到的一个messagebox控件的制作过程提供给大家。首先，新建解决方案，这里取名MessageBoxEx,然后新建窗体名为messagebox
博客
C#自定义控件之-winform美化
10-28 2万+
对于系统自带的窗体，博主实在不敢恭维，测试时使用方便快捷，但真正项目中无法使用，只因不美观的外表，每次都很头疼窗体的美化，这里列出一些需要解决的问题和自己收集到的解决方法，如有错误请指出。废话不多说先上一张最近写的一个小工具的效果图。以上是工具的基本截图，在工具的制作中对窗体的自定义包括以下几点：一、无边框拖动窗体当设置窗体的fromboderstyle为null时，系统自带的窗体
博客
C#自定义控件之-TabControl美化
10-27 2万+
使用C#开发了很多桌面应用程序，一直苦恼于系统自带的控件太丑，网上资源又太乱，因此为了以后自己使用和方便他人从这篇博文开始，陆续把自己收集整理的各类控件分享给大家一块学习，有不对的地方还请大家指出。不废话了，今天的主角是-----TabControl问题一：tabpage无法占满整个tabcontroltabcontrol在客户端中使用的频率还是挺高的，但是系统自带的tabcontrol通
博客
Metaverse元宇宙系列之Facebook改名META背后的布局和野心
11-01 889
随着世界通讯巨头facebook近日改名meta，元宇宙metaverse的热度不断攀升。meta一词充斥着整个互联网和各种“高端聊天”，大家都在滔滔不绝的讨论着这个话题。你要是不能说出个123，你都不好意思和别人聊天。今天小四儿就和大家探讨一下元宇宙这个话题，由于要说的太多，所以开了这个系列，把小四儿自己对元宇宙（metaverse）的理解逐条和大家分享。第一个问题，我替大家来问，“啥是元宇宙(metaverse)?”元宇宙这个说法并不是新的概念，它最早源于1992年美国著名科幻小..
博客
嵌入式UWB定位测距设备开发实战（12）硬件之AIR820主控
10-26 1573
原理图及PCB这一部分主控采用AIR820，不了解的可以看我之前的文章。元器件选型-AIR820https://blog.csdn.net/lcj401175209/article/details/118481624主控主要包含主控模块、sim卡部分，下图红色部分为主控电路。1.主控部分PCB这部分有点大，毕竟air820也不是一个小模块，引脚众多，工程里直接有天线的原理图，包括4G天线、蓝牙WiFi天线、以及GPS天线。详细的可查看我在立创EDA的开源工程，可直接使用。...
博客
嵌入式UWB定位测距设备开发实战（11）硬件之UWB测距
10-26 1813
原理图及PCBUWB部分电路：这部分主要是系统的高精度测距部分，如果你对UWB并不了解，可以看我之前的文章关于UWB以及高精度测距的文章。UWB测距选型https://blog.csdn.net/lcj401175209/article/details/118574934由于UWB测距部分需要的精度比较高，因此这部分采用单独的控制器STM32来操作DW1000模块，并将测得的距离通过串口输出给主控使用，这一部分属于单独功能，如果用不到可以直接从系统中摘除。（如下图红色部分）1.ST...
博客
嵌入式UWB定位测距设备开发实战（10）硬件之电源部分
07-26 1233
原理图及PCB电源是一个系统至关重要的部分，这部分做的好坏，直接决定了设备的续航。因此也是我比较看重的部分。本产品所使用的EDA是立创EDA，大家可以尝试以下，个人觉得一点也不比AD差，对于一般的电路足够用了。上面是我的工程文件的示意图，我把工程分为电源部分、电平转换部分、AIR820主控部分、SIM卡部分以及UWB测距部分，今天主要分析电源部分。先来设备PCB电路板调试版本实物图。最下面的TYPE-C接口是为了方便调试加上的，最终的PCB里是没有的。电源充放电采用的是英...
博客
嵌入式UWB定位测距设备开发实战（9）硬件之原理图软件选择
07-14 1179
接着上节，这节本来应该和大家探讨关于电源部分的电路。但是转念一想，好像差点啥？在我刚要准备原理图的时候，突然想起来了，画原理图、PCB软件似乎没有介绍。因此再讲电源部分硬件之前，在这里插入一节，来讲一下软件。俗话说，工欲善其事、必先利其器。这话不假，要做硬件，原理图软件必不可少。作为一个嵌入式工程师你用的画图软件是什么呢？欢迎大家在评论区留下你的答案。以下列举了目前市面上主流的几款软件：1、【AltiumDesigner】 也就是大家常说的AD，它的前身是大名鼎鼎的ptot...
博客
嵌入式UWB定位测距设备开发实战（8）硬件之数据与充电接口
07-12 797
现在市面流行的充电接口绝大多数都是type-c接口，也就是下面这样的本设计中，充电座就是这种接口，毕竟充电线好找。type-c最大的好处就是可以随意插拔，不分方向。定位设备的充电数据接口就需要另外考虑了，因为设备需要长时间佩戴，插线充电显然不现实，因此需要充电底座卡在设备上充电。关于设备充电的方案，有一下两种：1、无线充电：优点：无线充电，不需要对外露出物理线路即可进行充电，设计的防水等级可以做的很高。缺点：电路复杂，需要额外的无线充放电部分，成本偏高，效率不高。另外不能够进
博客
嵌入式UWB定位测距设备开发实战（7）硬件之天线选型
07-09 2021
由于UWB定位测距设备中用到了4G、WiFi、蓝牙、以及UWB这四种无线通信技术，因此需要相应的天线。等等天线?是家里电视用的那个卫星接收机吗？是的，原理都一样，都是对信号进行收集整理的部分。 说到天线，可能大部分同学都觉得太高深了，整不了。我一开始和大家的想法是一样的，但是产品需要，必须使用。再加上我是一个为了做产品啥都学的程序员（这话可不能白说，手动掐腰），最终我也是咬着牙去学习的，关于天线的一些知识。以下就和大家来一起分享关于天线部分的选型。天线是啥？天线...
博客
嵌入式UWB定位测距设备开发实战（6）硬件之UWB测距选型
07-08 1953
由于设备具有押解功能，因此需要能够测量定位设备到测距手表的实时距离，目前市面上有两种方案用来测距：1、蓝牙的基于信号强度的测量方法（RSSI），原理很好理解，就是基站发射的信号强度随着传播的距离的增大贰衰减，根据一定的公式计算，即可获得收到信号的点到基站的大致距离。优点：技术非常成熟，支持力度大，遇到问题很好解决，主要是价格便宜，蓝牙方案的模块可以做到10元以内，非常适合对于精度要求并不是特别高的场景使用，尤其是固定可视场景。缺点:信号衰减大，穿透能力不行，只要有遮挡物，信号强度衰减厉害，导致测
博客
嵌入式UWB定位测距设备开发实战（5）硬件之电源部分选型
07-08 829
电源是一个设备的基础部分，这部分可以说对一款产品至关重要，需要考虑续航的同时还需要兼顾成本，由于UWB定位测距设备是通过4G网和服务器进行通信的，4G设备峰值电流很大。同时UWB测距通信的峰值电流也需要很大，初步计算，电流瞬时峰值可达到2A，因此对于电池供电部分的选型需要额外注意。电源部分需要注意以下几点：1、电路瞬时峰值电流：如果供电部分不达标，会导致电流系统重启或者工作异常，产品中定位设备里充电部分采用IP5312，它具有充电2.1A放点2.4A的充放电电流，可自适应电流调节，把对电...
博客
嵌入式UWB定位测距设备开发实战（4）硬件之元器件选型
07-05 1361
上面几篇都是关于产品的一些设计思路和简介，从这篇开始就是真正的干货了，接下来的一个主要部分就是设计硬件的开发。第一步，任何做硬件的人都跳不过的一步，方案选型，我个人认为这是一个产品最重要的一步，所谓万事开头难，方案确定了产品的开发流程也就相应确定了。元器件选型提到元器件选型，大多数人都比较头疼，并不是最好的功能最强大的才是最好的。这个需要从自己的产品实际出发，需要考虑一下两点：1、成本：成本永远是第一位的，要把有限的预算发挥最大的价值，在价格一致的情况下尽量考虑功能最多的。2、技术支持力度：
博客
嵌入式UWB定位测距设备开发实战（3）产品软硬件架构
07-04 806
以下为软硬件架构示意图1、硬件部分：UWB测距定位设备：完成和中移物联网onenet平台的连接进行设备数据的上报和相关报警信息的上报。UWB测距基站（手表）：和定位设备配对，进行高精度测距，可以实时测出手表到定位设备的距离，精度可以达到10cm.视频设备：使用海康的执法记录仪。2、软件部分：定位设备管理平台：可对定位设备进行远程配置、可展示定位设备的位置等设备信息。设备配置微信小程序:通过微信小程序可以实时查看定位设备的位置信息，同时可以对设备进行相关的控制。视频预览存储
博客
嵌入式UWB定位测距设备开发实战（2）产品设计思路
07-04 773
嵌入式UWB定位设备主要应用在监视押解场景中，因此此需要满足一下功能特点：1、定位功能：这是最基本的功能，设备需要根据配置每隔一定时间上报自己的位置信息。这里使用的是复合定位，室外使用GPS+北斗，室内时使用LBS+WiFi定位。2、防拆、防破坏：当使用者私自打开定位设备或者暴力破坏设备时，设备需要第一时间将报警信号通过网络传回后台服务进行报警信息推送，同时设备自身需要发出声音报警。3、超距报警：由于有押解使用场景，因此设备需要有押解功能，也就是佩戴者距离押解人员超过一定距离后需要有声音报警。本
博客
嵌入式UWB定位测距设备开发实战（1）简介
07-04 1075
从这篇文章开始，我将最近在做的的uwb测距定位脚环的项目开发实战系统的跟大家捋一遍，记录一下整个开发过程、主要是记录自己的一些心得和一些坑，方便后续参考。当然如果能给你带来一些帮助，那我肯定也很高兴的。这些年也做了一些软硬件相关的项目和产品。我对开发产品的看法是，产品需要什么技术，我就去学习什么技术。没有什么是学不会的，就算不会，现在百度，CSDN等等好多学习的地方。自己去找找总会有的。...
博客
ASP.NET CORE基础教程系列目录
04-29 885
ASP.NET CORE基础教程系列目录本篇为asp.netcore 基础教程系列开篇之作，也是目录同时也是规划，整个基础教程根据官方的基础整理，主要是为了记录学习，同时也方便大家查看。
博客
使用hexo+github pages开通了自己的个人博客
04-19 459
博客地址http://netcoreblog.com,以后所有文章会在CSDN和个人博客发布，欢迎来踩。
评论 17
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值