> For the complete documentation index, see [llms.txt](https://wiki.inels.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://wiki.inels.com/inels-bus/inels-design-manager-idm3/what-inels3-and-idm3-are.md).

# What iNELS3 and iDM3 are

*Part 1 — Understand the system. Read this before you install anything.*

***

## In one paragraph

**iNELS3** is a wired building control system. Instead of running mains power from a light switch straight to a light, you run a thin data cable (the **BUS**) between all the small devices in the building, and a **central unit** decides what happens when. Pressing a button no longer *is* the act of switching the light — pressing a button *tells the central unit* that it was pressed, and the central unit decides what to do about it.

**iDM3** — *iNELS3 Designer & Manager* — is the Windows program you are reading about. It is where you tell the central unit what to do. You build a **project** on your PC, then upload it to the central unit. From that moment the building behaves the way your project says it should, whether or not your PC is still connected.

This manual teaches you to build that project.

<figure><img src="https://407891681-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FErjlplToL8l7jIChGVB2%2Fuploads%2Fmh9XK2dLPtXZUg2clyeo%2F001.jpg?alt=media&amp;token=d54ef16a-8739-49d5-9d29-4aa7cc67378a" alt=""><figcaption></figcaption></figure>

***

## The four things you need to know

Everything else in this manual sits on these four ideas.

### The central unit (CU)

The brain. A DIN-rail box that holds your project and runs it. It is the only device that makes decisions — every other device either reports something or does something.

iDM3 3.5.3 works with these central units:

| Central unit |                                                                                                                                                       |
| ------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
| CU3-08M      | Use this for new installations                                                                                                                        |
| CU3-09M      | The only one with a **DALI master** ([Ch. 21](/inels-bus/inels-design-manager-idm3/idm3-dali-manager-reference.md))                                   |
| CU3-10M      | The only one with an **RS-485 port** — required for Modbus RTU ([Ch. 32](/inels-bus/inels-design-manager-idm3/idm3-modbus-rtu-and-ip-integration.md)) |
| CU3-07M      | **Obsolete.** Still supported so you can service existing installations — do not specify it for new work.                                             |

**This manual uses the CU3-08M in all examples.** If you are working on an older site built around a CU3-07M, everything here still applies; only the unit you pick in the Device manager differs.

The CU has an Ethernet connection. That is how iDM3 talks to it, and how the system connects to phones, apps, and third-party systems.

### The BUS

The cable that links everything. Devices are wired along it, and each one gets an **address** so the central unit can tell them apart. A single central unit supports a limited number of devices and a limited total current draw on the BUS — iDM3 tracks these limits for you and warns you before you exceed them (see [Chapter 16](/inels-bus/inels-design-manager-idm3/idm3-device-manager-reference.md)).

> This manual does not cover cabling, mounting, or power budgets. For those, see the **iDM3 installation manual** (`Advance/Documentation/EN_iDM3_installation_manual_Rev19.pdf`), which ships with the software.

### Units

The physical devices on the BUS. Every unit is one of two kinds, and the difference matters:

* **Units that report things** — wall buttons, binary inputs, temperature sensors, card readers. They tell the central unit that something happened.
* **Units that do things** — relay outputs, dimmers, blind actuators, heating outputs. They wait to be told what to do.

Many units are both. A GSB3-40 glass switch has four buttons (reporting) *and* a temperature sensor (also reporting). A DA3-22M dimmer has dimmer outputs (doing) *and* external inputs (reporting).

iDM3 3.5.3 supports around 50 unit types. The full list is in [Appendix D](/inels-bus/inels-design-manager-idm3/idm3-supported-units.md).

### The project

One file on your PC, with the extension **`.elp`**, that holds *everything*: which units exist, what their addresses are, what they are called, which room they are in, and — most importantly — all the rules about what happens when. You edit the `.elp` on your PC; you upload it to the CU to make it real.

<figure><img src="https://407891681-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FErjlplToL8l7jIChGVB2%2Fuploads%2F4vvCTbAjHZcyS8vNkc5C%2F002.jpg?alt=media&amp;token=0da333b1-08dc-4342-9e7d-741493fa8519" alt=""><figcaption></figcaption></figure>

***

## How a job actually goes

The whole workflow, start to finish:

```
   ┌─────────────────────────────────────────────────────────┐
   │  1. DESIGN          on your PC, in iDM3                 │
   │     Add the units you installed. Give them names.       │
   │     Write the rules: what happens when.                 │
   │     Result: a .elp project file                         │
   └────────────────────────┬────────────────────────────────┘
                            │  Save to central unit
                            ▼
   ┌─────────────────────────────────────────────────────────┐
   │  2. UPLOAD          over Ethernet, PC → CU              │
   │     iDM3 compiles the project and sends it to the CU.   │
   └────────────────────────┬────────────────────────────────┘
                            │
                            ▼
   ┌─────────────────────────────────────────────────────────┐
   │  3. RUN             the CU, on its own                  │
   │     The building now works. Your PC can go home.        │
   └────────────────────────┬────────────────────────────────┘
                            │  Load from central unit
                            ▼
   ┌─────────────────────────────────────────────────────────┐
   │  4. CHANGE          later, back in iDM3                 │
   │     Pull the project back off the CU, edit, re-upload.  │
   └─────────────────────────────────────────────────────────┘
```

{% hint style="info" %}
Step 4 is worth dwelling on. Because the CU stores the project, you can walk up to an installation you have never seen, connect, choose **Load from central unit**, and get the entire configuration back — including the names the original installer gave everything. You are never locked out of a system just because you lost the file.
{% endhint %}

<figure><img src="https://407891681-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FErjlplToL8l7jIChGVB2%2Fuploads%2FM8tExJFWkr2vSUMfr2K5%2F003.jpg?alt=media&amp;token=a6ece25f-8eaf-4aa5-bcf8-cf314324a69f" alt=""><figcaption></figcaption></figure>

<figure><img src="https://407891681-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FErjlplToL8l7jIChGVB2%2Fuploads%2FT31wxOXDXhXkxcg46PXk%2F004.jpg?alt=media&amp;token=5558c242-3ab9-4e6e-b19d-14c2fc907344" alt=""><figcaption></figcaption></figure>

<figure><img src="https://407891681-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FErjlplToL8l7jIChGVB2%2Fuploads%2FBwYoPGRyhGqhKmptNT8v%2F005.jpg?alt=media&amp;token=ec5e57ff-551a-43a2-be3d-1c78f52a926e" alt=""><figcaption></figcaption></figure>

***

## What "programming" means here

You will not write code. There is no scripting language in iDM3, no text editor, no syntax to learn. You program by filling in dialogs, and every rule you create has the same shape:

> **When** *this happens* → **do** *that*.

That's it. A four-button wall switch that controls two lights, a dimmer, and the heating is just several of those rules stacked up.

[Chapter 2](/inels-bus/inels-design-manager-idm3/how-programming-works-in-idm3.md) explains this shape properly — what counts as "this happens", what counts as "do that", and how to attach conditions so a rule only fires sometimes. It is the most important chapter in this manual. Everything after it is detail.

***

## What you need before you start

**To follow the tutorials in Part 2, you need:**

|                                        |                                                                                                      |
| -------------------------------------- | ---------------------------------------------------------------------------------------------------- |
| A Windows PC                           | iDM3 is a Windows program (.NET Framework 4.8). It does not run on macOS or Linux.                   |
| iDM3 installed                         | [Chapter 3](/inels-bus/inels-design-manager-idm3/installing-idm3-and-first-run.md) walks through it. |
| A central unit                         | Powered, wired to the BUS, and reachable from your PC over Ethernet.                                 |
| At least one input and one output unit | Tutorial 1 uses a GSB3-40 button and an SA3-02M relay. Any equivalent pair works.                    |
| The units' BUS addresses               | Set during installation. You will type these into iDM3.                                              |

**You do not need** any programming experience, and you do not need to have installed the hardware yourself.

***

## Words you will meet constantly

Skim these now — you do not need to memorise them, but seeing them once here will make Chapter 2 easier. The full list is in [Appendix E](/inels-bus/inels-design-manager-idm3/idm3-glossary.md).

| Term                 | Meaning                                                               |
| -------------------- | --------------------------------------------------------------------- |
| **CU**               | Central unit — the brain that runs your project                       |
| **BUS**              | The data cable linking all units                                      |
| **Unit**             | A physical device on the BUS                                          |
| **Master / slave**   | A master unit runs its own BUS segment; slaves hang off it            |
| **Project** (`.elp`) | The file holding your entire configuration                            |
| **Actor**            | The thing that *starts* a rule (a button, a sensor, a timer)          |
| **Consumer**         | The thing a rule *acts on* (a light, a dimmer, a heating area)        |
| **Wire**             | One rule, connecting an actor to consumers. Nothing to do with cable. |
| **Action**           | *Which* event on the actor fires the rule (e.g. `Short down`)         |
| **Function**         | *What* the rule does to the consumer (e.g. `Digital switch ON`)       |
| **Group**            | Several consumers controlled as one                                   |
| **Macro**            | A saved bundle of functions you can reuse                             |

> **Careful with the word "wire".** In iNELS3 a *wire* is a rule inside your project — a logical connection between an actor and a consumer. It is not a piece of cable. Cables are covered in the installation manual; wires are covered here.

***

**Next:** [Chapter 2 — How programming works](/inels-bus/inels-design-manager-idm3/how-programming-works-in-idm3.md) — the one idea the whole system is built on.

***

### Also on this wiki

* Introduction to the iDM (iNELS Design Manager)