C# RFID接收控制台程序

C#控制台应用程序，用于接收和处理来自RFID阅读器的数据。该程序支持串口通信和网络通信两种方式，能够解析RFID标签数据并进行处理和存储。

代码

RFIDReader.cs (主程序)

using System;
using System.Collections.Generic;
using System.IO.Ports;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Newtonsoft.Json;

namespace RFIDReaderConsole
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.Title = "RFID Reader Console";
            Console.WriteLine("RFID Reader Console Application");
            Console.WriteLine("==============================");
            Console.WriteLine("1. Serial Port Mode");
            Console.WriteLine("2. TCP/IP Mode");
            Console.Write("Select mode: ");
            
            var input = Console.ReadLine();
            if (input == "1")
            {
                RunSerialMode();
            }
            else if (input == "2")
            {
                RunNetworkMode();
            }
            else
            {
                Console.WriteLine("Invalid selection. Exiting...");
            }
        }

        static void RunSerialMode()
        {
            Console.WriteLine("\nSERIAL PORT MODE");
            Console.WriteLine("----------------");
            
            // 获取可用串口
            var ports = SerialPort.GetPortNames();
            if (ports.Length == 0)
            {
                Console.WriteLine("No serial ports found!");
                return;
            }
            
            Console.WriteLine("Available ports:");
            for (int i = 0; i < ports.Length; i++)
            {
                Console.WriteLine($"{i + 1}. {ports[i]}");
            }
            
            Console.Write("Select port number: ");
            if (!int.TryParse(Console.ReadLine(), out int portIndex) || portIndex < 1 || portIndex > ports.Length)
            {
                Console.WriteLine("Invalid selection!");
                return;
            }
            
            string selectedPort = ports[portIndex - 1];
            Console.Write("Enter baud rate (default 9600): ");
            int baudRate = int.TryParse(Console.ReadLine(), out int br) ? br : 9600;
            
            using (var reader = new RFIDSerialReader(selectedPort, baudRate))
            {
                reader.OnTagDetected += HandleTagDetected;
                reader.Start();
                
                Console.WriteLine($"\nListening on {selectedPort} at {baudRate} baud...");
                Console.WriteLine("Press ENTER to stop");
                Console.ReadLine();
                
                reader.Stop();
            }
        }

        static void RunNetworkMode()
        {
            Console.WriteLine("\nTCP/IP MODE");
            Console.WriteLine("-----------");
            
            Console.Write("Enter IP address to listen on (default 0.0.0.0): ");
            string ipAddress = Console.ReadLine();
            if (string.IsNullOrWhiteSpace(ipAddress)) ipAddress = "0.0.0.0";
            
            Console.Write("Enter port (default 8080): ");
            int port = int.TryParse(Console.ReadLine(), out int p) ? p : 8080;
            
            using (var reader = new RFIDNetworkReader(ipAddress, port))
            {
                reader.OnTagDetected += HandleTagDetected;
                reader.Start();
                
                Console.WriteLine($"\nListening on {ipAddress}:{port}...");
                Console.WriteLine("Press ENTER to stop");
                Console.ReadLine();
                
                reader.Stop();
            }
        }

        static void HandleTagDetected(object sender, TagDetectedEventArgs e)
        {
            Console.WriteLine($"\n[{DateTime.Now}] Tag Detected!");
            Console.WriteLine($"Reader ID: {e.ReaderId}");
            Console.WriteLine($"Tag ID: {e.TagId}");
            Console.WriteLine($"Antenna: {e.Antenna}");
            Console.WriteLine($"RSSI: {e.Rssi} dBm");
            Console.WriteLine($"Timestamp: {e.Timestamp}");
            Console.WriteLine($"Raw Data: {e.RawData}");
            
            // 在实际应用中，这里可以添加数据库存储、业务逻辑处理等
            SaveTagData(e);
        }

        static void SaveTagData(TagDetectedEventArgs e)
        {
            // 在实际应用中，这里可以将数据保存到数据库或文件
            // 这里简化为控制台输出
            Console.WriteLine("Data saved to database (simulated)");
        }
    }

    public class TagDetectedEventArgs : EventArgs
    {
        public string ReaderId { get; set; }
        public string TagId { get; set; }
        public int Antenna { get; set; }
        public int Rssi { get; set; }
        public DateTime Timestamp { get; set; }
        public string RawData { get; set; }
    }

    public abstract class RFIDReader : IDisposable
    {
        public event EventHandler<TagDetectedEventArgs> OnTagDetected;
        protected bool _isRunning;
        protected Thread _workerThread;

        public abstract void Start();
        public abstract void Stop();

        protected virtual void RaiseTagDetected(TagDetectedEventArgs args)
        {
            OnTagDetected?.Invoke(this, args);
        }

        public virtual void Dispose()
        {
            Stop();
        }
    }

    public class RFIDSerialReader : RFIDReader
    {
        private SerialPort _serialPort;
        private readonly string _portName;
        private readonly int _baudRate;

        public RFIDSerialReader(string portName, int baudRate = 9600)
        {
            _portName = portName;
            _baudRate = baudRate;
        }

        public override void Start()
        {
            _serialPort = new SerialPort(_portName, _baudRate, Parity.None, 8, StopBits.One)
            {
                Handshake = Handshake.None,
                ReadTimeout = 500,
                WriteTimeout = 500
            };

            try
            {
                _serialPort.Open();
                _isRunning = true;
                _workerThread = new Thread(ReadData);
                _workerThread.Start();
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error opening serial port: {ex.Message}");
            }
        }

        private void ReadData()
        {
            var buffer = new byte[1024];
            var sb = new StringBuilder();

            while (_isRunning)
            {
                try
                {
                    if (_serialPort.BytesToRead > 0)
                    {
                        int bytesRead = _serialPort.Read(buffer, 0, buffer.Length);
                        string data = Encoding.ASCII.GetString(buffer, 0, bytesRead);
                        sb.Append(data);

                        // 检查是否收到完整的数据包
                        string content = sb.ToString();
                        if (content.Contains("\r\n"))
                        {
                            ProcessData(content);
                            sb.Clear();
                        }
                    }
                    Thread.Sleep(50);
                }
                catch (TimeoutException) { }
                catch (Exception ex)
                {
                    Console.WriteLine($"Serial port error: {ex.Message}");
                    Thread.Sleep(1000);
                }
            }
        }

        private void ProcessData(string data)
        {
            // 示例数据格式: "R123,A1,TAG001,45,-65\r\n"
            var lines = data.Split(new[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries);
            foreach (var line in lines)
            {
                var parts = line.Split(',');
                if (parts.Length >= 5)
                {
                    var args = new TagDetectedEventArgs
                    {
                        ReaderId = parts[0],
                        Antenna = int.Parse(parts[1].Substring(1)),
                        TagId = parts[2],
                        Rssi = int.Parse(parts[4]),
                        Timestamp = DateTime.Now,
                        RawData = line
                    };
                    RaiseTagDetected(args);
                }
            }
        }

        public override void Stop()
        {
            _isRunning = false;
            if (_workerThread != null && _workerThread.IsAlive)
            {
                _workerThread.Join(1000);
            }
            if (_serialPort != null && _serialPort.IsOpen)
            {
                _serialPort.Close();
            }
        }

        public override void Dispose()
        {
            Stop();
            _serialPort?.Dispose();
        }
    }

    public class RFIDNetworkReader : RFIDReader
    {
        private TcpListener _listener;
        private TcpClient _client;
        private NetworkStream _stream;
        private readonly string _ipAddress;
        private readonly int _port;

        public RFIDNetworkReader(string ipAddress, int port)
        {
            _ipAddress = ipAddress;
            _port = port;
        }

        public override void Start()
        {
            try
            {
                var ip = IPAddress.Parse(_ipAddress);
                _listener = new TcpListener(ip, _port);
                _listener.Start();
                _isRunning = true;
                _workerThread = new Thread(ListenForClients);
                _workerThread.Start();
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error starting TCP listener: {ex.Message}");
            }
        }

        private void ListenForClients()
        {
            while (_isRunning)
            {
                try
                {
                    _client = _listener.AcceptTcpClient();
                    _stream = _client.GetStream();
                    Console.WriteLine($"Client connected: {_client.Client.RemoteEndPoint}");
                    
                    var buffer = new byte[1024];
                    var sb = new StringBuilder();
                    
                    while (_isRunning && _client.Connected)
                    {
                        if (_stream.DataAvailable)
                        {
                            int bytesRead = _stream.Read(buffer, 0, buffer.Length);
                            string data = Encoding.UTF8.GetString(buffer, 0, bytesRead);
                            sb.Append(data);
                            
                            // 检查是否收到完整的数据包
                            string content = sb.ToString();
                            if (content.Contains("\n"))
                            {
                                ProcessData(content);
                                sb.Clear();
                            }
                        }
                        Thread.Sleep(50);
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine($"Network error: {ex.Message}");
                }
                finally
                {
                    _stream?.Close();
                    _client?.Close();
                }
            }
        }

        private void ProcessData(string data)
        {
            // 示例JSON格式: {"reader":"R1","antenna":1,"tag":"TAG123","rssi":-65,"timestamp":"2023-05-01T12:34:56"}
            var lines = data.Split(new[] { "\n" }, StringSplitOptions.RemoveEmptyEntries);
            foreach (var line in lines)
            {
                try
                {
                    var tagData = JsonConvert.DeserializeObject<Dictionary<string, object>>(line);
                    var args = new TagDetectedEventArgs
                    {
                        ReaderId = tagData["reader"].ToString(),
                        Antenna = Convert.ToInt32(tagData["antenna"]),
                        TagId = tagData["tag"].ToString(),
                        Rssi = Convert.ToInt32(tagData["rssi"]),
                        Timestamp = DateTime.Parse(tagData["timestamp"].ToString()),
                        RawData = line
                    };
                    RaiseTagDetected(args);
                }
                catch (Exception ex)
                {
                    Console.WriteLine($"Error parsing JSON: {ex.Message}");
                }
            }
        }

        public override void Stop()
        {
            _isRunning = false;
            if (_workerThread != null && _workerThread.IsAlive)
            {
                _workerThread.Join(1000);
            }
            _stream?.Close();
            _client?.Close();
            _listener?.Stop();
        }
    }
}

App.config (配置文件)

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <appSettings>
    <!-- 串口默认设置 -->
    <add key="DefaultPort" value="COM3"/>
    <add key="DefaultBaudRate" value="9600"/>
    
    <!-- 网络默认设置 -->
    <add key="DefaultIpAddress" value="0.0.0.0"/>
    <add key="DefaultPort" value="8080"/>
    
    <!-- 日志设置 -->
    <add key="LogFilePath" value="rfid_log.txt"/>
    <add key="LogLevel" value="Info"/> <!-- Debug, Info, Warning, Error -->
  </appSettings>
</configuration>

程序功能说明

1. 两种工作模式

• 串口模式：通过RS232/RS485串口连接RFID阅读器
• 网络模式：通过TCP/IP网络连接RFID阅读器

2. 核心功能

• 实时接收RFID标签数据
• 解析标签信息（标签ID、天线号、信号强度等）
• 触发事件处理机制
• 模拟数据存储功能

3. 数据格式支持

• 串口模式：文本格式（如 "R123,A1,TAG001,45,-65\r\n"）
• 网络模式：JSON格式（如 {"reader":"R1","antenna":1,"tag":"TAG123","rssi":-65,"timestamp":"2023-05-01T12:34:56"}）

4. 事件处理

• 当检测到RFID标签时触发OnTagDetected事件
• 事件参数包含完整的标签信息

使用说明

1. 串口模式

1. 选择正确的串口号（程序会自动列出可用端口）
2. 设置波特率（默认为9600）
3. 程序开始监听串口数据
4. 当RFID标签经过阅读器时，程序会显示标签信息

2. 网络模式

1. 设置监听的IP地址（默认为0.0.0.0，即所有网卡）
2. 设置监听端口（默认为8080）
3. 程序开始监听网络连接
4. 当RFID阅读器通过网络发送数据时，程序会解析并显示标签信息

3. 数据处理

在HandleTagDetected方法中，您可以添加自定义处理逻辑：

• 存储到数据库
• 发送到消息队列
• 触发业务逻辑
• 与其他系统集成

参考代码 c#做的 RFID接收控制台程序 www.youwenfan.com/contentcst/122425.html

扩展功能建议

1. 添加数据库存储

static void SaveTagData(TagDetectedEventArgs e)
{
    using (var conn = new SqlConnection(connectionString))
    {
        var cmd = new SqlCommand(
            "INSERT INTO TagReadings (ReaderId, TagId, Antenna, Rssi, Timestamp, RawData) " +
            "VALUES (@ReaderId, @TagId, @Antenna, @Rssi, @Timestamp, @RawData)", conn);
        
        cmd.Parameters.AddWithValue("@ReaderId", e.ReaderId);
        cmd.Parameters.AddWithValue("@TagId", e.TagId);
        cmd.Parameters.AddWithValue("@Antenna", e.Antenna);
        cmd.Parameters.AddWithValue("@Rssi", e.Rssi);
        cmd.Parameters.AddWithValue("@Timestamp", e.Timestamp);
        cmd.Parameters.AddWithValue("@RawData", e.RawData);
        
        conn.Open();
        cmd.ExecuteNonQuery();
    }
}

2. 添加WebSocket实时推送

private static WebSocketServer _webSocketServer;

static void StartWebSocketServer()
{
    _webSocketServer = new WebSocketServer("ws://localhost:8181");
    _webSocketServer.Start(socket =>
    {
        socket.OnOpen = () => Console.WriteLine("WebSocket connected");
        socket.OnClose = () => Console.WriteLine("WebSocket disconnected");
        socket.OnMessage = message => Console.WriteLine($"WebSocket message: {message}");
    });
}

static void BroadcastTagData(TagDetectedEventArgs e)
{
    var json = JsonConvert.SerializeObject(new {
        e.ReaderId, e.TagId, e.Antenna, e.Rssi, e.Timestamp
    });
    
    foreach (var socket in _webSocketServer.WebSocketServices.Hosts.First().Sessions.Sessions.Values)
    {
        socket.Send(json);
    }
}

3. 添加REST API接口

static void StartApiServer()
{
    var httpServer = new HttpServer(new Uri("http://localhost:5000/"));
    httpServer.Start();
    
    httpServer.Register("/", (req, res) => {
        res.ContentType = "text/html";
        res.Write("<html><body><h1>RFID Reader API</h1></body></html>");
    });
    
    httpServer.Register("/tags", (req, res) => {
        // 返回最近的标签读取记录
    });
}

4. 添加日志记录功能

static void LogTagData(TagDetectedEventArgs e, string level = "INFO")
{
    var logEntry = $"{DateTime.Now:yyyy-MM-dd HH:mm:ss}|{level}|{e.ReaderId}|{e.TagId}|{e.Antenna}|{e.Rssi}|{e.RawData}\n";
    
    File.AppendAllText(ConfigurationManager.AppSettings["LogFilePath"], logEntry);
    
    if (level == "ERROR")
    {
        Console.ForegroundColor = ConsoleColor.Red;
        Console.WriteLine(logEntry);
        Console.ResetColor();
    }
}

实际应用案例

1. 仓储管理系统

• 跟踪货物进出仓库
• 实时监控库存位置
• 自动化盘点流程

2. 人员门禁系统

• 员工身份验证
• 进出记录追踪
• 考勤系统集成

3. 生产线追踪

• 产品组装过程追踪
• 质量控制点记录
• 生产效率分析

4. 资产管理系统

• 固定资产追踪
• 设备使用监控
• 预防性维护提醒

部署说明

1. 系统要求

• .NET Framework 4.7.2 或更高版本
• 支持串口通信或网络连接
• 可选：数据库服务器（SQL Server, MySQL等）

2. 安装步骤

1. 编译源代码生成可执行文件
2. 配置RFID阅读器参数（串口或网络）
3. 运行程序并设置监听参数
4. （可选）配置数据库连接

3. 运行方式

• 作为控制台应用程序直接运行
• 作为Windows服务安装（需额外代码）
• 在Docker容器中运行（需Linux环境）

总结

这个C# RFID接收控制台程序提供了一个灵活、可扩展的解决方案，用于接收和处理来自RFID阅读器的数据。程序支持两种通信模式（串口和网络），能够解析不同格式的数据，并通过事件机制提供灵活的处理方式。

主要特点：

• 双模式支持（串口/网络）
• 可扩展的事件处理机制
• 支持多种数据格式
• 模块化设计便于扩展
• 简单易用的控制台界面