FINS (Factory Interface Network Service) is Omron’s proprietary protocol for talking to its controllers: it reads and writes PLC memory areas (CIO, DM, W, H, A) through commands identified by a two-byte code. It runs over Ethernet on port 9600, in UDP or TCP, and also over serial links and Controller Link.
Where FINS shows up on the plant floor
FINS turns up wherever there is Omron control, which in Spain is especially common in packaging, food and beverage, and in machinery delivered by original equipment manufacturers that standardise on the brand. It spans the classic series through to current machine controllers, which keep FINS while adding EtherNet/IP messaging and, on some models, an embedded OPC-UA server. Addressing has three levels (network, node and unit) so a request can cross segments where routing tables exist; on simple Ethernet installations the node number is usually derived from the last octet of the IP address. The most used commands are memory area read and write, and the set also includes controller status and clock reads plus CPU mode change commands.
FINS versus EtherNet/IP, Host Link and Modbus TCP
The most frequent confusion is between FINS and Host Link, the older serial ASCII protocol from the same vendor: they are not the same thing, although FINS commands can be encapsulated in Host Link frames to reach a serial port. The difference that matters on a new project is another one: FINS addresses by memory location, so you have to know that the shift output count lives in a specific word of the DM area, while EtherNet/IP messaging on modern controllers addresses by variable name. The consequence is maintenance: if the programmer reorganises memory, an address-based integration breaks silently and keeps returning plausible numbers, whereas a name-based one fails explicitly. Against Modbus TCP, FINS shares the approach (numeric addresses, no authentication) but is vendor-specific and exposes the PLC native areas directly, without the register layer Modbus imposes.
Getting FINS data into a data layer
Reading over FINS is non-intrusive polling: it needs no change to the controller program and no line stop, provided the controller has a spare Ethernet port and the service enabled. The cost sits elsewhere. Communications are served by the CPU inside its own scan cycle, so aggressive polling (many small requests at high frequency) lengthens that cycle and can affect control. Each command also returns a bounded block of words, so the right strategy is grouping the variables of interest into contiguous memory areas and reading them in a few large requests, rather than scattering them and chaining dozens of reads.
Two limitations shape the quality of the resulting data. The first is that FINS returns raw words: no type, no units, no scaling. A floating-point value occupies two consecutive words whose order depends on how the program stores it, and a counter may be binary or BCD. Without the address map the machine builder is supposed to supply, extraction turns into reverse engineering. The second is that the protocol carries no timestamp: the instant recorded is the collector’s, so the real temporal resolution of the data is the polling period, not the PLC cycle. If the process changes faster than that period, the data simply does not exist, however continuous the history looks.
On security, FINS has neither authentication nor encryption, and the same frames that read memory include CPU mode change commands: the protocol does not distinguish permissions, so the restriction has to live in the network and in the device configuration, not in the client. The UDP variant also guarantees no delivery, so the collector must implement retries and detect lost or duplicated responses; on a plant network carrying real traffic, the TCP variant usually brings fewer surprises. The sensible pattern is speaking FINS once, on a device at the edge, normalising types, scaling and names there, and republishing the result over OPC-UA or MQTT, so no downstream system depends on one controller’s memory map. That work is the subject of PLC connectivity.
Related terms
FINS is one of the access paths to the PLC, alongside Modbus and the OPC-UA servers embedded in recent controllers. Its readings are usually consolidated at the edge before being published towards the SCADA, the historian or a Unified Namespace.