FPGA GOOSE Message Filtering and Multi-Core Subtask Execution
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current systems handling GOOSE messages are inefficient and time-consuming, particularly when dealing with a large number of messages, as they rely on CPU processing without adequate filtering or prioritization, leading to increased processing times.
Innovation Solution
An embedded system utilizing a Field Programmable Gate Array (FPGA) to filter subscribed GOOSE messages and preconfigure tasks as multiple subtasks executed by different processing cores, optimizing message processing efficiency by distributing tasks across cores.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If CPU processes all GOOSE messages sequentially, then the system can handle message processing, but the processing time increases significantly when dealing with large numbers of messages
Solution Approach 1:
The patent segments the GOOSE message processing task into multiple independent subtasks (message reception, filtering, parsing, and publishing) that can be executed in parallel on different CPU cores. The filtering subtask identifies subscribed messages, while parsing and publishing subtasks process the filtered messages concurrently, transforming sequential CPU processing into parallel multi-core processing to reduce overall processing time.
Solution Approach 2:
The patent implements preliminary filtering of GOOSE messages before full processing. The filtering subtask预先 identifies which messages the system subscribes to based on message identifiers, allowing the system to discard unsubscribed messages early in the process. This preliminary action reduces the workload for subsequent parsing and publishing operations, significantly decreasing processing time for large message volumes.
2Productivity
If the CPU filters GOOSE messages one by one, then the system can determine subscribed messages, but the filtering process becomes inefficient and time-consuming
Solution Approach 1:
The filtering function is segmented into a dedicated filtering subtask that operates independently on specific CPU cores. This subtask processes message identification and subscription matching in parallel with other processing functions, transforming the sequential one-by-one filtering into concurrent batch filtering, thereby improving filtering efficiency and reducing time consumption.
Solution Approach 2:
The patent introduces an intermediary filtering mechanism that acts as a mediator between message reception and full processing. The filtering subtask serves as an intermediate layer that pre-processes messages by identifying subscribed ones before they reach the parsing and publishing stages. This intermediary filtering approach reduces the overall processing burden and time required for handling large numbers of GOOSE messages.
3Speed
If a single CPU core processes all tasks, then the system structure remains simple, but the processing speed and efficiency are limited
Solution Approach 1:
The patent segments the processing system into multiple CPU cores, each dedicated to specific subtasks. The first CPU core handles message reception and filtering, while the second CPU core handles parsing and publishing. This segmentation enables parallel processing of GOOSE messages, significantly increasing processing speed. The segmentation is implemented through task scheduling mechanisms that distribute subtasks across available cores, achieving high-speed processing while maintaining manageable system architecture complexity.
Data Source
AI summary
The present disclosure discloses an embedded system and a message processing method. The embedded system includes a field programmable gate array (FPGA) configured to determine at least one first generic object-oriented substation event (GOOSE) message to which the embedded system subscribes from a plurality of externally received GOOSE messages, wherein each first GOOSE message triggers an execution of one first task, and the first task is preconfigured as a plurality of subtasks; a first processing core configured to execute at least one first subtask of the plurality of subtasks; and a second processing core configured to execute at least one second subtask of the plurality of subtasks; wherein an execution of a 1st first subtask of the at least one first subtask is triggered by the first GOOSE message, and the at least one second subtask is executed after an execution of the at least one first subtask is completed.