IC2-IC3: The SCADA Stack That Turns a Plant Into a Live Web Model

From Arduino firmware to Django APIs to a React-based flow diagram, this repository shows how industrial control can become visible, traceable, and teachable in one system.

6 to 8 min read • View on GitHub • More from equipoPI

A wide factory scene drawn as a control loop, with sensors and an Arduino-like board on one side, a relay of data moving through the middle, and a node-based web dashboard on the other. The image explains how physical process state is mirrored into software so operators can read the plant as a live model.
IC2-IC3 is interesting because it does not stop at telemetry. It closes the loop from hardware to backend to interface, so the plant is represented as a system rather than a pile of signals.
Key Takeaways

A Factory You Can Read Like a Graph

Most SCADA demos show data. IC2-IC3 shows relationships. A sensor changes, the backend evaluates the plant, the interface updates, and the operator sees the result as a live graph instead of a flat stream of numbers.

That matters because industrial software is usually fragmented. Control happens on the edge, records live in a separate system, and the interface is just a window. This repository tries to collapse those layers into one coherent model.

The key idea is not just that the UI displays the plant. It reconstructs process topology so the operator can see how one event propagates through state, alarms, and audit history.


Why This Is More Than a Student SCADA Demo

The repository has student-project fingerprints, but it also shows stronger instincts than a typical Arduino-plus-dashboard build. The backend models are structured, the serializers are split by purpose, and the UI is built around explicit process state rather than ad hoc widgets.

That combination suggests the authors cared about boundaries. In practice, that means the system can be reasoned about in layers: device logic at the edge, operational truth in Django, and a visual model in React.

DimensionTraditional SCADA or legacy dashboardIC2-IC3
Deployment modelOften monolithic, vendor-tied, and hard to inspectSplit across firmware, Django, and React
UI representationPanels, tables, and static alarmsNode graph that mirrors process topology
AuditabilityFrequently bolted on laterActions and system state are treated as records
State derivationMostly display-firstPlant status is computed from alarms and metrics
MaintainabilityCommonly opaque and inheritedModular firmware and explicit backend models

Three Layers, One Process

The repository is organized around three named layers: ic1 for firmware, mysite for the Django backend, and scada-ui for the frontend. That is a useful separation because each layer has a different job and a different failure mode.

The firmware handles the physical world. The backend stores plant data, evaluates conditions, and exposes APIs. The frontend turns that state into a readable control-room view.

The backend does the real work of interpretation

In mysite/polls/models.py, Fabrica does more than store fields. Its state is derived from operational conditions such as alarms and performance metrics, which is a better SCADA pattern than passive CRUD.

# Conceptual pattern from the backend model
class Fabrica(models.Model):
    porcentaje_produccion = models.DecimalField(...)
    temperatura_promedio = models.DecimalField(...)
    alarmas_activas = models.IntegerField(default=0)
    estado = models.CharField(max_length=20)

    def actualizar_metricas(self):
        if self.alarmas_activas > 0:
            self.estado = "CRITICO"
        else:
            self.estado = "OPERATIVO"
        self.save()

That is the important shift. The system is not just storing what happened. It is computing operational truth from the current plant condition, which makes the data more useful to both operators and developers.

A close-up of a node-based industrial dashboard where a tank, pump, valve, alarm, and audit log are tightly connected. One pump is marked as failing, the tank level is changing, and the state propagates across the graph to show how the interface reflects process health rather than merely displaying raw values.
The UI is strongest when it behaves like a mental model of the plant. Here, the graph is not decoration. It is the process, made legible.

The UI Mirrors the Real Process

The most legible idea in the repository is ScadaFlowDiagram.tsx. Built with @xyflow/react, it turns the plant into a topology the operator can inspect, not just a dashboard they can scan.

That matters because the interface makes causality visible. When a sensor changes, the backend updates. When the backend changes state, alarms shift. When alarms shift, the graph changes color and the audit trail records the action.

The UI also points at a bigger design principle: if the screen mirrors the system, the operator does not need to translate between different mental models. That saves time, but it also reduces ambiguity.

Hover, click, step, explain

The article plan calls for a mini-app that highlights one node, traces downstream effects, and steps through alarm propagation. That is the right instinct. A SCADA interface should teach the system by making state transitions easy to inspect.

Why the Firmware Layout Matters

The Arduino side is more disciplined than most hobby hardware projects. Splitting logic across files such as control_bombas.ino, funcion_de_nivel.ino, and bluetooth.ino keeps each concern separate.

That modularity matters because firmware gets messy fast. Once sensing, actuation, and communication are tangled together, the code becomes hard to test and harder to trust. This layout suggests the opposite instinct.

// File-level separation keeps the control path readable
// control_bombas.ino
// funcion_de_nivel.ino
// bluetooth.ino

void loop() {
  leerNivel();
  controlarBombas();
  manejarBluetooth();
}

What It Borrows, What It Replaces

IC2-IC3 does not need to replace enterprise SCADA to be interesting. Its value is as a modern teaching model: decoupled services, explicit state, visual topology, and audit-aware operations.

QuestionLegacy expectationIC2-IC3 answer
Where is the truth stored?Scattered across screens and controllersIn derived backend models and API records
What does the operator see?A status boardA graph of the process itself
How are actions tracked?Often through separate logsThrough audit-first application behavior
How easy is it to extend?Usually tied to vendor patternsModular across firmware, backend, and UI
What is the learning value?ProcedureSystem structure

The strongest lesson is not that this repository is production-ready. It is that industrial systems become easier to build and reason about when the control path is modeled end to end.