DotNetty 实现 Modbus TCP 系列 (四) Client & Server

Client

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
public class ModbusClient
{
	public string Ip { get; }
	public int Port { get; }
	public short UnitIdentifier { get; }
	public IChannel Channel { get; private set; }

	private MultithreadEventLoopGroup group;
	private ConnectionState connectionState;
	private ushort transactionIdentifier;
	private readonly string handlerName = "response";

	public ModbusClient(short unitIdentifier, string ip, int port = 502)
	{
		Ip = ip;
		Port = port;
		UnitIdentifier = unitIdentifier;

		connectionState = ConnectionState.NotConnected;
	}

	public async Task Connect()
	{
		group = new MultithreadEventLoopGroup();

		try
		{
			var bootstrap = new Bootstrap();
			bootstrap
				.Group(group)
				.Channel<TcpSocketChannel>()
				.Option(ChannelOption.TcpNodelay, true)
				.Handler(new ActionChannelInitializer<ISocketChannel>(channel =>
				{
					IChannelPipeline pipeline = channel.Pipeline;

					pipeline.AddLast("encoder", new ModbusEncoder());
					pipeline.AddLast("decoder", new ModbusDecoder(false));

					pipeline.AddLast(handlerName, new ModbusResponseHandler());
				}));

			connectionState = ConnectionState.Pending;

			Channel = await bootstrap.ConnectAsync(new IPEndPoint(IPAddress.Parse(Ip), Port));

			connectionState = ConnectionState.Connected;
		}
		catch (Exception exception)
		{
			throw exception;
		}
	}

	public async Task Close()
	{
		if (ConnectionState.Connected == connectionState)
		{
			try
			{
				await Channel.CloseAsync();
			}
			finally
			{
				await group.ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(1));

				connectionState = ConnectionState.NotConnected;
			}
		}
	}

	public ushort CallModbusFunction(ModbusFunction function)
	{
		if (ConnectionState.Connected != connectionState || Channel == null)
		{
			throw new Exception("Not connected!");
		}

		SetTransactionIdentifier();

		ModbusHeader header = new ModbusHeader(transactionIdentifier, UnitIdentifier);
		ModbusFrame frame = new ModbusFrame(header, function);
		Channel.WriteAndFlushAsync(frame);

		return transactionIdentifier;
	}

	public T CallModbusFunctionSync<T>(ModbusFunction function) where T : ModbusFunction
	{
		var transactionIdentifier = CallModbusFunction(function);

		var handler = (ModbusResponseHandler)Channel.Pipeline.Get(handlerName);
		if (handler == null)
		{
			throw new Exception("Not connected!");
		}

		return (T)handler.GetResponse(transactionIdentifier).Function;
	}

	private void SetTransactionIdentifier()
	{
		if (transactionIdentifier < ushort.MaxValue)
		{
			transactionIdentifier++;
		}
		else
		{
			transactionIdentifier = 1;
		}
	}

	public ushort ReadHoldingRegistersAsync(ushort startingAddress, ushort quantity)
	{
		var function = new ReadHoldingRegistersRequest(startingAddress, quantity);
		return CallModbusFunction(function);
	}

	public ReadHoldingRegistersResponse ReadHoldingRegisters(ushort startingAddress, ushort quantity)
	{
		var function = new ReadHoldingRegistersRequest(startingAddress, quantity);
		return CallModbusFunctionSync<ReadHoldingRegistersResponse>(function);
	}
}



public enum ConnectionState
{
	NotConnected = 0,
	Connected = 1,
	Pending = 2,
}

(文中代码仅添加了 0x03 的方法)

在 Client 中封装了 Modbus 请求方法，对同一个功能同时有同步方法(ReadHoldingRegistersAsync)和异步方法(ReadHoldingRegisters)。同步方法仅返回 TransactionIdentifier(传输标识)，异步方法返回响应结果。

ModbusResponseHandler 修改为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
public class ModbusResponseHandler : SimpleChannelInboundHandler<ModbusFrame>
{
	private readonly int timeoutMilliseconds = 2000;
	private Dictionary<ushort, ModbusFrame> responses = new Dictionary<ushort, ModbusFrame>();
	protected override void ChannelRead0(IChannelHandlerContext ctx, ModbusFrame msg)
	{
		responses.Add(msg.Header.TransactionIdentifier, msg);
	}

	public ModbusFrame GetResponse(ushort transactionIdentifier)
	{
		ModbusFrame frame = null;
		var timeoutDateTime = DateTime.Now.AddMilliseconds(timeoutMilliseconds);
		do
		{
			Thread.Sleep(1);
			if (responses.ContainsKey(transactionIdentifier))
			{
				frame = responses[transactionIdentifier];
				responses.Remove(transactionIdentifier);
			}
		}
		while (frame == null && DateTime.Now < timeoutDateTime);

		if(frame == null)
		{
			throw new Exception("No Response");
		}
		else if(frame.Function is ExceptionFunction)
		{
			throw new Exception(frame.Function.ToString());
		}

		return frame;
	}

	public override void ExceptionCaught(IChannelHandlerContext context, Exception exception)
	{
		context.CloseAsync();
	}
}

Server

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
public class ModbusServer
{
	private ModbusResponseService responseService;
	private ServerState serverState;
	public int Port { get; }
	public IChannel Channel { get; private set; }
	private IEventLoopGroup bossGroup;
	private IEventLoopGroup workerGroup;
	public ModbusServer(ModbusResponseService responseService, int port = 502)
	{
		this.responseService = responseService;
		Port = port;
		serverState = ServerState.NotStarted;
	}

	public async Task Start()
	{
		bossGroup = new MultithreadEventLoopGroup(1);
		workerGroup = new MultithreadEventLoopGroup();

		try
		{
			var bootstrap = new ServerBootstrap();
			bootstrap.Group(bossGroup, workerGroup);

			bootstrap
				.Channel<TcpServerSocketChannel>()
				.Option(ChannelOption.SoBacklog, 100)
				.ChildHandler(new ActionChannelInitializer<IChannel>(channel =>
				{
					IChannelPipeline pipeline = channel.Pipeline;
					pipeline.AddLast("encoder", new ModbusEncoder());
					pipeline.AddLast("decoder", new ModbusDecoder(true));

					pipeline.AddLast("request", new ModbusRequestHandler(responseService));
				}));

			serverState = ServerState.Starting;

			Channel = await bootstrap.BindAsync(Port);

			serverState = ServerState.Started;
		}
		finally
		{
			
		}
	}

	public async Task Stop()
	{
		if (ServerState.Starting == serverState)
		{
			try
			{
				await Channel.CloseAsync();
			}
			finally
			{
				await Task.WhenAll(
					bossGroup.ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(1)),
					workerGroup.ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(1)));

				serverState = ServerState.NotStarted;
			}
		}
	}
}

public enum ServerState
{
	NotStarted = 0,
	Started = 1,
	Starting = 2,
}

实例化 Server 时需要传入 ModbusResponseService 的实现，实现示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class ModbusResponse : ModbusResponseService
{
	public override ModbusFunction ReadHoldingRegisters(ReadHoldingRegistersRequest request)
	{
		var registers = ReadRegisters(request.Quantity);
		var response = new ReadHoldingRegistersResponse(registers);

		return response;
	}
	
	private ushort[] ReadRegisters(ushort quantity)
	{
		var registers = new ushort[quantity];

		Random ran = new Random();
		for (int i = 0; i < registers.Length; i++)
		{
			registers[i] = (ushort)ran.Next(ushort.MinValue, ushort.MaxValue);
		}

		return registers;
	}
}

(文中代码仅添加了 0x03 的方法)

开源地址：modbus-tcp

展开全文 >>

DotNetty 实现 Modbus TCP 系列 (三) Codecs & Handler

DotNetty 作为一个半成品，我们不需要关注细节的实现，只需要关注自己的业务即可，所以最主要的就是处理 Codecs 和 Handler。

所有的 Codecs 和 Handler 均直接或间接继承自 ChannelHandlerAdapter。为什么要分为 Codecs 和 Handler，个人理解是 Codecs 负责将消息解码为我们所需的对象或者将处理的结果编码，Handler 对解码得到的对象进行逻辑处理，达到职责分离的目的。

DotNetty 中可以注册多个 Codecs/Handler，入站消息按照注册的先后顺序执行，出站消息按照注册的先后逆序执行。

对于 Client 端：

  • 入站：ModbusDecoder –> ModbusResponseHandler
  • 出站：ModbusEncoder

对于 Server 端：

  • 入站：ModbusDecoder –> ModbusRequestHandler
  • 出站：ModbusEncoder

ModbusDecoder

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
public class ModbusDecoder : ByteToMessageDecoder
{
	private bool isServerMode;
	private readonly short maxFunctionCode = 0x80;
	private readonly string typeName = "Karonda.ModbusTcp.Entity.Function.{0}.{1}{0}";

	public ModbusDecoder(bool isServerMode)
	{
		this.isServerMode = isServerMode;
	}
	protected override void Decode(IChannelHandlerContext context, IByteBuffer input, List<object> output)
	{
		//Transaction Identifier + Protocol Identifier + Length + Unit Identifier + Function Code
		if (input.Capacity < 2 + 2 + 2 + 1 + 1)
		{
			return;
		}

		ModbusHeader header = new ModbusHeader(input);
		short functionCode = input.ReadByte();
		ModbusFunction function = null;

		if(Enum.IsDefined(typeof(ModbusCommand), functionCode))
		{
			var command = Enum.GetName(typeof(ModbusCommand), functionCode);

			function = (ModbusFunction)Activator.CreateInstance(Type.GetType(string.Format(typeName, isServerMode ? "Request" : "Response", command)));
		}


		if (functionCode >= maxFunctionCode)
		{
			function = new ExceptionFunction(functionCode);
		}
		else if(function == null)
		{
			function = new ExceptionFunction(functionCode, 0x01);
		}

		function.Decode(input);
		ModbusFrame frame = new ModbusFrame(header, function);

		output.Add(frame);
	}
}

ModbusDecoder 继承了 ByteToMessageDecoder。继承了 ByteToMessageDecoder 的类必须实现的唯一的抽象方法：Decode，该方法将 ByteBuffer 解析为 List，如果 List 不为空则会将该 List 传递给下一个 ChannelHandlerAdapter。

ModbusDecoder 同时为 Client 端和 Server 端使用，如果是 Server 端则将消息解析成请求类，反之如果是 Client 端则将消息解析成响应类。

ModbusResponseHandler

1
2
3
4
5
6
7
8
9
10
11
12
13
public class ModbusResponseHandler : SimpleChannelInboundHandler<ModbusFrame>
{
	private Dictionary<ushort, ModbusFrame> responses = new Dictionary<ushort, ModbusFrame>();
	protected override void ChannelRead0(IChannelHandlerContext ctx, ModbusFrame msg)
	{
		responses.Add(msg.Header.TransactionIdentifier, msg);
	}

	public override void ExceptionCaught(IChannelHandlerContext context, Exception exception)
	{
		context.CloseAsync();
	}
}

将接收到的响应信息加入 responses 供后续处理。

ModbusRequestHandler

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class ModbusRequestHandler : SimpleChannelInboundHandler<ModbusFrame>
{
	private ModbusResponseService responseService;
	public ModbusRequestHandler(ModbusResponseService responseService)
	{
		this.responseService = responseService;
	}

	protected override void ChannelRead0(IChannelHandlerContext ctx, ModbusFrame msg)
	{
		var function = msg.Function;
		var  response = responseService.Execute(function);

		var header = msg.Header;
		var frame = new ModbusFrame(header, response);

		ctx.WriteAndFlushAsync(frame);
	}
}

responseService 为一个抽象类，用来自定义处理接收到的请求并返回结果，需要在实现 Server 端时继承并实现。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public abstract class ModbusResponseService
{
	public ModbusFunction Execute(ModbusFunction function)
	{
		if (function is ReadHoldingRegistersRequest)
		{
			var request = (ReadHoldingRegistersRequest)function;
			return ReadHoldingRegisters(request);
		}

		throw new Exception("Function Not Support");
	}

	public abstract ModbusFunction ReadHoldingRegisters(ReadHoldingRegistersRequest request);
}

(文中代码仅添加了 0x03 的方法)

ModbusEncoder

1
2
3
4
5
6
7
8
9
10
11
12
13
public class ModbusEncoder : ChannelHandlerAdapter
{
	public override Task WriteAsync(IChannelHandlerContext context, object message)
	{
		if (message is ModbusFrame)
		{
			var frame = (ModbusFrame)message;
			return context.WriteAndFlushAsync(frame.Encode());
		}

		return context.WriteAsync(message);
	}
}

如果是 ModbusFrame 消息则 Flush，否则传递到下一个 ChannelHandlerAdapter。

开源地址：modbus-tcp

展开全文 >>

DotNetty 实现 Modbus TCP 系列 (二) ModbusFunction 类图及继承举例

ModbusFunction 类图如下：

如前文所述，所有请求/相应的 PDU 均继承自 ModbusFunction，其子类传入对应的 Function Code 并实现三个方法：

  1. CalculateLength：Data 部分的长度(该方法也可以为属性，但属性没有强制性，怕漏掉故改为抽象方法)
  2. Decode：从缓冲区解析 Data
  3. Encode：在传输前对 Data 编码

实现举例

每个 Function Code 均对应 ModbusFunction 的两个子类：请求类和响应类，以 0x03(读取保持寄存器值)为例：

请求类

请求报文 Data 说明：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
public class ReadHoldingRegistersRequest : ModbusFunction
{
	public ushort StartingAddress { get; private set; }
	public ushort Quantity { get; private set; }

	public ReadHoldingRegistersRequest()
		: base((short)ModbusCommand.ReadHoldingRegisters)
	{

	}

	public ReadHoldingRegistersRequest(ushort startingAddress, ushort quantity)
		: base((short)ModbusCommand.ReadHoldingRegisters)
	{
		StartingAddress = startingAddress;
		Quantity = quantity;
	}

	public override int CalculateLength()
	{
		return 2 + 2; // StartingAddress Length + Quantity Length
	}
	public override void Decode(IByteBuffer buffer)
	{
		StartingAddress = buffer.ReadUnsignedShort();
		Quantity = buffer.ReadUnsignedShort();
	}
	public override IByteBuffer Encode()
	{
		IByteBuffer buffer = Unpooled.Buffer();
		buffer.WriteByte(FunctionCode);

		buffer.WriteUnsignedShort(StartingAddress);
		buffer.WriteUnsignedShort(Quantity);

		return buffer;
	}
}

响应类

响应报文 Data 说明：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
public class ReadHoldingRegistersResponse : ModbusFunction
{
	private ushort byteCount;
	public ushort[] Registers { get; private set; }

	public ReadHoldingRegistersResponse()
		: base((short)ModbusCommand.ReadHoldingRegisters)
	{

	}

	public ReadHoldingRegistersResponse(ushort[] registers)
		: base((short)ModbusCommand.ReadHoldingRegisters)
	{
		Registers = registers;
		byteCount = (ushort)(registers.Length * 2);
	}

	public override int CalculateLength()
	{
		return 1 + byteCount;
	}

	public override void Decode(IByteBuffer buffer)
	{
		byteCount = buffer.ReadByte();
		Registers = new ushort[byteCount / 2];
		for (int i = 0; i < Registers.Length; i++)
		{
			Registers[i] = buffer.ReadUnsignedShort();
		}

	}

	public override IByteBuffer Encode()
	{
		IByteBuffer buffer = Unpooled.Buffer();
		buffer.WriteByte(FunctionCode);
		buffer.WriteByte(byteCount);

		foreach (var register in Registers)
		{
			buffer.WriteUnsignedShort(register);
		}

		return buffer;
	}
}

其中 ModbusCommand 为 Function Code 的枚举：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
enum ModbusCommand : short
{

	ReadCoils = 0x01,
	ReadDiscreteInputs = 0x02,
	ReadHoldingRegisters = 0x03,
	ReadInputRegisters = 0x04,
	WriteSingleCoil = 0x05,
	WriteSingleRegister = 0x06,

	WriteMultipleCoils = 0x0F,
	WriteMultipleRegisters = 0x10,

}

文中为方便理解请求类和响应类均直接继承 ModbusFunction，实际开发中请求类和响应类均没有直接继承 ModbusFunction，而是根据其他 Function Code 的 Data 进行再次抽象后继承。

开源地址：modbus-tcp

展开全文 >>

DotNetty 实现 Modbus TCP 系列 (一) 报文类

Modbus TCP/IP 报文

  • 报文最大长度为 260 byte (ADU = 7 byte MBAP Header + 253 byte PDU)
  • Length = Unit Identifier 长度 + PDU 长度

MBAP Header

PDU

PDU 由两部分构成：Function Code(功能码) 和 Data 组成

Function Code

部分功能码：

报文类

ModbusHeader

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
public class ModbusHeader
{
	public ushort TransactionIdentifier { get; set; }
	public ushort ProtocolIdentifier { get; set; }
	public ushort Length { get; set; }
	public short UnitIdentifier { get; set; }

	public ModbusHeader(IByteBuffer buffer)
	{
		TransactionIdentifier = buffer.ReadUnsignedShort();
		ProtocolIdentifier = buffer.ReadUnsignedShort();
		Length = buffer.ReadUnsignedShort();
		UnitIdentifier = buffer.ReadByte();
	}

	public ModbusHeader(ushort transactionIdentifier, short unitIdentifier)
		: this(transactionIdentifier, 0x0000, unitIdentifier) // for modbus protocol: Protocol Identifier = 0x00
	{

	}

	private ModbusHeader(ushort transactionIdentifier, ushort protocolIdentifier, short unitIdentifier)
	{
		TransactionIdentifier = transactionIdentifier;
		ProtocolIdentifier = protocolIdentifier;
		UnitIdentifier = unitIdentifier;
	}

	public IByteBuffer Encode()
	{
		IByteBuffer buffer = Unpooled.Buffer();

		buffer.WriteUnsignedShort(TransactionIdentifier);
		buffer.WriteUnsignedShort(ProtocolIdentifier);
		buffer.WriteUnsignedShort(Length);
		buffer.WriteByte(UnitIdentifier);

		return buffer;
	}
}

ModbusHeader 对应 MBAP Header，包含两个构造函数：第一个构造函数用于从缓冲区解析消息头，第二个构造函数用来请求/响应时手动构造消息头。Encode 方法用于在传输前对消息头进行编码。

ModbusFunction

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public abstract class ModbusFunction
{
	protected short FunctionCode { get; }

	protected ModbusFunction(short functionCode)
	{
		FunctionCode = functionCode;
	}
	/// <summary>
	/// PDU length -1 (not include function code length)
	/// </summary>
	/// <returns></returns>
	public abstract int CalculateLength();   

	public abstract void Decode(IByteBuffer buffer);

	public abstract IByteBuffer Encode();

}

ModbusFunction 对应 PDU，该类为抽象类，所有的请求/相应的 PDU 均继承自该类。实际使用中根据 FunctionCode 实例化具体的子类对象。其中 CalculateLength 方法用来计算 Data 部分的长度，Decode 方法用于从缓冲区解析 Data，Encode 方法用于在传输前对 Data 编码。

ModbusFrame

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class ModbusFrame
{
	public ModbusHeader Header { get; set; }
	public ModbusFunction Function { get; set; }

	public ModbusFrame(ModbusHeader header, ModbusFunction function)
	{
		Header = header;
		Function = function;
	}

	public IByteBuffer Encode()
	{
		Header.Length = (ushort)(1 + 1 + Function.CalculateLength());// Unit Identifier + Function Code + data length

		IByteBuffer buffer = Unpooled.Buffer();

		buffer.WriteBytes(Header.Encode());
		buffer.WriteBytes(Function.Encode());

		return buffer;
	}
}

ModbusFrame 对应 ADU。Encode 方法用于在传输前对 ADU 编码。

开源地址：modbus-tcp

展开全文 >>

C# 获取文件详细备注信息 (如图片、视频实际创建时间)

在整理照片/视频时想根据实际拍摄时间重命名文件，但 System.IO.FileInfo 只能获取到文件的创建时间或最后写入时间，不符合要求，遂寻找解决方案

方案 1: System.Drawing

  1. c#从相机拍摄的照片中提取拍摄时间
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
static void Main(string[] args)
{
	var file = @"D:\image\IMG_6789.JPG";

	var image = Image.FromFile(file);
	var propItems = image.PropertyItems;

	var propItem = image.GetPropertyItem(0x9003); //Id 为 0x9003 表示拍照的时间
	var propItemValue = propItem.Value;

	image.Dispose();

	var dateTimeStr = System.Text.Encoding.ASCII.GetString(propItemValue).Trim('\0');

	var dt = DateTime.ParseExact(dateTimeStr, "yyyy:MM:dd HH:mm:ss", CultureInfo.InvariantCulture);

	Console.WriteLine(dt);
}

此方法仅适用于图片：pass

方案 2: shell32

  1. C#通过shell32获取文件详细备注信息

  2. [How to use Shell32 within a C# application?](How to use Shell32 within a C# application?)

  3. Exception when using Shell32 to get File extended properties

操作步骤：

  1. 添加shell32引用 (C:\Windows\System32\shell32.dll 或 在 VS 中添加引用 .COM -> Microsoft Shell Controls and Automation)

  2. 设置 dll “嵌入互操作类型” 为 false

1
2
3
4
5
6
7
8
9
10
static void Main(string[] args)
{
	var file = @"D:\image\IMG_6789.JPG";

	var shell = new ShellClass();
	var dir = shell.NameSpace(Path.GetDirectoryName(file));
	var item = dir.ParseName(Path.GetFileName(file));

	var dateTimeStr = dir.GetDetailsOf(item, 12);// 12 为照片拍摄时间
}

此方法适用于图片和视频(id 不同)，但是在实际中获取到的时间字符串包含乱码无法转换成时间：pass

方案 3: Microsoft.WindowsAPICodePack.Shell (采用方案)

  1. how-do-i-find-the-date-a-video-avi-mp4-was-actually-recorded

  2. Microsoft.WindowsAPICodePack-Shell

1
2
3
4
5
6
7
8
9
10
11
static void Main(string[] args)
{
	var file = @"D:\image\IMG_6789.JPG";

	ShellObject obj = ShellObject.FromParsingName(file);
	var takenDate = obj.Properties.System.ItemDate.Value;

	Console.WriteLine(takenDate);

	Console.ReadLine();
}

此方法完全符合要求，支持所有类型的文件。同时也可以获取文件的其他信息，如作者等

开源地址

展开全文 >>

Java 下载 HLS (m3u8) 视频

下载索引文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public String getIndexFile() throws Exception{
	URL url = new URL(originUrlpath);
	//下载资源
	BufferedReader in = new BufferedReader(new InputStreamReader(url.openStream(),"UTF-8"));

	String content = "" ;
	String line;
	while ((line = in.readLine()) != null) {
		content += line + "\n";
	}
	in.close();

	return content;
}

解析索引文件

1
2
3
4
5
6
7
8
9
10
11
12
public List analysisIndex(String content) throws Exception{
	Pattern pattern = Pattern.compile(".*ts");
	Matcher ma = pattern.matcher(content);

	List<String> list = new ArrayList<String>();

	while(ma.find()){
		list.add(ma.group());
	}

	return list;
}

下载视频片段

同步下载

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
public HashMap downLoadIndexFile(List<String> urlList){
	HashMap<Integer,String> keyFileMap = new HashMap<>();

	for(int i =0;i<urlList.size();i++){
		String subUrlPath = urlList.get(i);
		String fileOutPath = folderPath + File.separator + i + ".ts";
		keyFileMap.put(i, fileOutPath);
		try{
			downloadNet(preUrlPath + subUrlPath, fileOutPath);

			System.out.println("成功："+ (i + 1) +"/" + urlList.size());
		}catch (Exception e){
			System.err.println("失败："+ (i + 1) +"/" + urlList.size());
		}
	}

	return  keyFileMap;
}

private void downloadNet(String fullUrlPath, String fileOutPath) throws Exception {

	//int bytesum = 0;
	int byteread = 0;

	URL url = new URL(fullUrlPath);
	URLConnection conn = url.openConnection();
	InputStream inStream = conn.getInputStream();
	FileOutputStream fs = new FileOutputStream(fileOutPath);

	byte[] buffer = new byte[1204];
	while ((byteread = inStream.read(buffer)) != -1) {
		//bytesum += byteread;
		fs.write(buffer, 0, byteread);
	}
}

多线程下载

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
public void downLoadIndexFileAsync(List<String> urlList, HashMap<Integer,String> keyFileMap) throws Exception{
	int downloadForEveryThread = (urlList.size() + threadQuantity - 1)/threadQuantity;
	if(downloadForEveryThread == 0) downloadForEveryThread = urlList.size();

	for(int i=0; i<urlList.size();i+=downloadForEveryThread){
		int startIndex = i;
		int endIndex = i + downloadForEveryThread - 1;
		if(endIndex >= urlList.size())
			endIndex = urlList.size() - 1;

		new DownloadThread(urlList, startIndex, endIndex, keyFileMap).start();
	}
}

class DownloadThread extends Thread{
	private List<String> urlList;
	private int startIndex;
	private int endIndex;
	private HashMap<Integer,String> keyFileMap;

	public DownloadThread(List<String> urlList, int startIndex, int endIndex, HashMap<Integer,String> keyFileMap){
		this.urlList = urlList;
		this.startIndex = startIndex;
		this.endIndex = endIndex;
		this.keyFileMap = keyFileMap;
	}
	@Override
	public void run(){
		for(int i=startIndex;i<=endIndex;i++){
			String subUrlPath = urlList.get(i);
			String fileOutPath = folderPath + File.separator + i + ".ts";
			keyFileMap.put(i, fileOutPath);
			String message = "%s: 线程 " + (startIndex/(endIndex - startIndex) + 1)
					+ ", "+ (i + 1) +"/" + urlList.size() +", 合计: %d";
			try{
				downloadNet(preUrlPath + subUrlPath, fileOutPath);

				System.out.println(String.format(message, "成功", keyFileMap.size()));
			}catch (Exception e){
				System.err.println(String.format(message, "失败", keyFileMap.size()));
			}
		}
	}
}

视频片段合成

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public String composeFile(HashMap<Integer,String> keyFileMap) throws Exception{

	if(keyFileMap.isEmpty()) return null;

	String fileOutPath = rootPath + File.separator + fileName;
	FileOutputStream fileOutputStream = new FileOutputStream(new File(fileOutPath));
	byte[] bytes = new byte[1024];
	int length = 0;
	for(int i=0; i<keyFileMap.size(); i++){
		String nodePath = keyFileMap.get(i);
		File file = new File(nodePath);
		if(!file.exists())  continue;

		FileInputStream fis = new FileInputStream(file);
		while ((length = fis.read(bytes)) != -1) {
			fileOutputStream.write(bytes, 0, length);
		}
	}

	return fileName;
}

开源地址：hlsdownloader

参考：M3U8在线视频文件下载合成MP4视频

展开全文 >>

在 Web 页面使用 VLC 插件播放 m3u8 视频流 (360 极速模式)

背景

公司有个旧项目需要添加在线播放 m3u8 视频流，但是该流不知道什么原因使用 Video.js 或 hls.js 均无法播放，最后找到解决方案可使用 VLC 插件播放(360 极速模式下)

示例代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
<!DOCTYPE html>
<html>
<head>
<title>web camera</title>
<meta http-equiv="content-type" content="text/html; charset=UTF-8">
<script type="text/javascript">  
 //仅适用于IE浏览器是，并且安装有vlc插件，则返回true；  
    function isInsalledIEVLC(){    
        var vlcObj = null;  
        var vlcInstalled= false;   
        try {  
            vlcObj = new ActiveXObject("VideoLAN.Vlcplugin.1");   
            if( vlcObj != null ){   
                vlcInstalled = true   
            }  
        } catch (e) {  
            vlcInstalled= false;  
        }          
        return vlcInstalled;  
    }   

    //仅适用于firefox浏览器是，并且安装有vlc插件，则返回true；  
    function isInsalledFFVLC(){  
         var numPlugins=navigator.plugins.length;  
         for  (i=0;i<numPlugins;i++){   
              plugin=navigator.plugins[i];  
              if(plugin.name.indexOf("VideoLAN") > -1 || plugin.name.indexOf("VLC") > -1){   
                 return true;  
            }  
         }  
         return false;  
    }  

    /* 浏览器检测 */  
    function checkBrowser(){  
        var browser=navigator.appName;  
        var b_version=navigator.appVersion; 
        var version=parseFloat(b_version);
        var download_url = "https://download.videolan.org/pub/videolan/vlc/2.2.1/win32/";
        if ( browser=="Netscape"  && version>=4) {  
            if(isInsalledFFVLC()){  
                //alert("已装VLC插件");  
            }else{  
                alert("未装VLC插件,请先安装插件");
                location.href=download_url;  
            }  
        }else if(browser=="Microsoft Internet Explorer" && version>=4) {  
            if(isInsalledIEVLC()){  
                //alert("已装VLC插件");  
            }else{  
                alert("未装VLC插件,请先安装插件");
                location.href=download_url;
            }  
        }  
    }  
</script>


</head>

<body bgcolor="white" text="black" onload="checkBrowser();">

<embed type="application/x-vlc-plugin" pluginspage="http://www.videola.org"
    width="640" height="480" id="vlc" version="VideoLAN.VLCPlugin.2" autoplay="yes" loop="no" 
    target="https://video-dev.github.io/streams/x36xhzz/x36xhzz.m3u8" >

</body>
</html>

** 注意：不管本地操作系统是 32 位还是 64 均需安装 32 位的 VLC 播放器，否则插件无法成功安装 **

参考：利用vlc插件将IP摄像头嵌入网页和网页播放RTSP流

展开全文 >>

在 Web 页面中使用离线地图

所需工具&插件：

  1. MapDownloader (提取码: spx6)
  2. GISMysqlToLocalFile (提取码: vus6)
  3. Leaflet

操作

  1. 参考：java离线地图web GIS制作 下载好所需地图瓦片，本文以百度地图/深圳为例
  2. 使用 Leaflet 加载地图瓦片：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>web 版离线地图测试页面</title>
    
    <link rel="stylesheet" href="https://unpkg.com/leaflet@1.4.0/dist/leaflet.css" />    
    
</head>
<body>

    <div id="map" style="width:90%;height:600px;margin-top:30px;text-align:center;margin:0 auto;">
    </div>

    <script src="https://unpkg.com/leaflet@1.4.0/dist/leaflet.js"></script>
    
    <script type="text/javascript">
        window.onload=function () {
            var map = L.map('map').setView([22.56414255434805,114.153442382813], 11);
            L.tileLayer('./img/788865972/{z}/{x}/{y}.png'
                , {
                    minZoom: 10,
                    maxZoom: 12,
                    attribution: '<b style="color:#dddddd">百度地图</b>'
                })
            .addTo(map);
            
        };    
    </script>
    
</body>
</html>

注：本文演示是将瓦片文件与代码文件放在一起，实际使用中最好自建瓦片地图服务。

在线演示

参考：

  1. java离线地图web GIS制作

  2. chenwuwen/OffineMap

展开全文 >>

使用 Travis CI 自动部署 Hexo 站点至 GitHub Pages

Hexo 与 GitHub Pages 安装配置请参考：Hexo 与 GitHub Pages

本文源码与生成的静态文件在同一项目下，源码在 source 分支，静态文件在 master 分支

  1. 新增 token

    登录 GitHub: Settings–> Developer settings–> Personal access tokens–> Generate new token

    image

    记下产生的 token

  2. 使用 GitHub 帐号登陆 Travis CI ，开启项目：

    image

  3. 项目设置：

    image

    image

  4. 新增 travis 配置文件

    在源码根目录新增 .travis.yml 文件，内容如下：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    language: node_js
    node_js: stable

    install:
    - npm install

    script:
    - hexo g

    after_script:
    - cd ./public
    - git init
    - git config user.name "VictorBu"
    - git config user.email "victorbu.xx@gmail.com"
    - git add .
    - git commit -m "add/edit"
    - git push --force --quiet "https://${github_token}@${GH_REF}" master:master

    branches:
    only:
        - source
        
    cache:
    directories:
        - node_modules
        
    env:
    global:
    - GH_REF: github.com/VictorBu/victorbu.github.io.git
    • github_token：为前面步骤 Environment Variables 中设置的 token 变量名
    • branches：设置源码所在的分支，本文为 source
    • 修改 user.name, user.email, 仓库地址, 静态文件对应分支

  5. push 文章到 source 目录，Travis CI 即会自动编译并发布

备注

如果需要绑定域名，把 CNAME 文件放置在源码的根目录/source 文件夹下即可

参考

如何快速搭建一个有域名且持续集成的hexo博客(2.0版)

展开全文 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

很惭愧<br><br>只做了一点微小的工作<br>谢谢大家