Ciao! Sono

Federico Calò

Sviluppatore Software | Divulgatore Tecnico

Creo applicazioni web moderne e strumenti digitali personalizzati per aiutare le attività a crescere attraverso l'innovazione tecnologica. La mia passione è unire informatica ed economia per generare valore reale.

Contattami

Chi Sono

La mia passione per l'informatica è nata tra i banchi dell'Istituto Tecnico Commerciale di Maglie, dove ho scoperto il potere della programmazione e il fascino di creare soluzioni digitali. Fin da subito, ho capito che l'informatica non era solo codice, ma uno strumento straordinario per trasformare idee in realtà.

Durante gli studi superiori in Sistemi Informativi Aziendali, ho iniziato a intrecciare informatica ed economia, comprendendo come la tecnologia possa essere il motore della crescita per qualsiasi attività. Questa visione mi ha accompagnato all'Università degli Studi di Bari, dove ho conseguito la Laurea in Informatica, approfondendo le mie competenze tecniche e la mia passione per lo sviluppo software.

Oggi metto questa esperienza al servizio di imprese, professionisti e startup, creando soluzioni digitali su misura che automatizzano processi, ottimizzano risorse e aprono nuove opportunità di business. Perché la vera innovazione inizia quando la tecnologia incontra le esigenze reali delle persone.

Le Mie Competenze

Analisi Dati & Modelli Previsionali

Trasformo i dati in insights strategici con analisi approfondite e modelli predittivi per decisioni informate

Automazione Processi

Creo strumenti personalizzati che automatizzano operazioni ripetitive e liberano tempo per attività a valore aggiunto

Sistemi Custom

Sviluppo sistemi software su misura, dalle integrazioni tra piattaforme alle dashboard personalizzate

const federico = {
  nome: "Federico Calò",
  ruolo: "Sviluppatore Software",
  città: "Bari, Italia",
  missione: "Aiutare attraverso l'informatica",
  passioni: [
    "Codice Pulito",
    "Innovazione",
    "Crescita Continua"
  ]
};

La Mia Missione

Credo fermamente che l'informatica sia lo strumento più potente per trasformare le idee in realtà e migliorare la vita delle persone.

🚀

Democratizzare la Tecnologia

La mia missione è rendere l'informatica accessibile a tutti: dalle piccole imprese locali alle startup innovative, fino ai professionisti che vogliono digitalizzare la propria attività. Ogni realtà merita di sfruttare le potenzialità del digitale.

💡

Unire Informatica ed Economia

Non è solo questione di scrivere codice: è capire come la tecnologia possa generare valore reale. Intrecciando competenze informatiche e visione economica, aiuto le attività a crescere, ottimizzare processi e raggiungere nuovi traguardi di efficienza e redditività.

🎯

Creare Soluzioni su Misura

Ogni attività è unica, e così devono esserlo le soluzioni. Sviluppo strumenti personalizzati che rispondono alle esigenze specifiche di ciascun cliente, automatizzando processi ripetitivi e liberando tempo per ciò che conta davvero: far crescere il business.

Trasforma la Tua Attività con la Tecnologia

Dicembre 2024

Visualizza

Master SQL

RoadMap.sh

Novembre 2024

Visualizza

Oracle Certified Foundations Associate

Oracle

Ottobre 2024

Visualizza

People Leadership Credential

Connect

Settembre 2024

💻 Linguaggi & Tecnologie

☕Java

🐍Python

📜JavaScript

🅰️Angular

⚛️React

🔷TypeScript

🗄️SQL

🐘PHP

🎨CSS/SCSS

🔧Node.js

🐳Docker

🌿Git

💼

12/2024 - Presente

Custom Software Engineering Analyst

Accenture

Bari, Puglia, Italia · Ibrida Analisi e sviluppo di sistemi informatici attraverso l'utilizzo di Java e Quarkus in Health and Public Sector. Formazione continua su tecnologie moderne per la creazione di soluzioni software personalizzate ed efficienti e sugli agenti.

💼

06/2022 - 12/2024

Analista software e Back End Developer Associate Consultant

Links Management and Technology SpA

Esperienza nell'analisi di sistemi software as-is e flussi ETL utilizzando PowerCenter. Formazione completata su Spring Boot per lo sviluppo di applicazioni backend moderne e scalabili. Sviluppatore Backend specializzato in Spring Boot, con esperienza in progettazione di database, analisi, sviluppo e testing dei task assegnati.

💼

02/2021 - 10/2021

Programmatore software

Adesso.it (prima era WebScience srl)

Esperienza nell'analisi AS-IS e TO-BE, evoluzioni SEO ed evoluzioni website per migliorare le performance e l'engagement degli utenti.

🎓

2018 - 2025

Laurea in Informatica

Università degli Studi di Bari Aldo Moro

Bachelor's degree in Computer Science, focusing on software engineering, algorithms, and modern development practices.

📚

2013 - 2018

Diploma - Sistemi Informativi Aziendali

Istituto Tecnico Commerciale di Maglie

Technical diploma specializing in Business Information Systems, combining IT knowledge with business management.

Contattami

Hai un progetto in mente? Parliamone! Compila il form qui sotto e ti risponderò al più presto.

* Campi obbligatori. I tuoi dati saranno utilizzati solo per rispondere alla tua richiesta.

Smart Building IoT: Sensor Integration & Edge Computing

Europe's smart building market reached €7.5 billion in 2025, growing from €6.3 billion in 2024, driven by EU energy efficiency regulations and ESG pressure from real estate investors. Pilots with AI-driven Building Management Systems have demonstrated energy consumption reductions of 20-50%, with the greatest gains in HVAC-intensive buildings.

In this article, we build the complete architecture of an IoT system for smart buildings: from integrating building automation protocols (BACnet, Modbus, KNX) to edge processing with MQTT, from real-time energy analysis to ML-based HVAC automation with occupancy prediction.

What You'll Learn

Building automation protocols: BACnet, Modbus RTU/TCP, KNX, DALI
Edge computing with IoT gateways: Raspberry Pi/industrial PC with Node-RED
MQTT broker: topic design and QoS for sensor data
Time-series ingestion with InfluxDB and Grafana
Occupancy prediction with ML: automatic energy savings
HVAC automation: PID controller and demand-driven ventilation
Energy benchmarking: ENERGY STAR Score and ISO 50001
Building digital twin with real-time updates

Building Automation Protocols

Modern commercial and residential buildings use specialized communication protocols to connect sensors, actuators, and control systems. The coexistence of these standards in a single building (often legacy + modern) is the main integration challenge.

Main Protocols

BACnet/IP: ASHRAE standard for commercial buildings; used for HVAC, access control, fire safety
Modbus TCP/RTU: simple industrial protocol; energy sensors, inverters, PLCs
KNX: European standard for residential and commercial buildings; lighting, blinds, heating
DALI: specific to lighting control; advanced dimming and grouping
Zigbee/Z-Wave: wireless mesh for low-power sensors (temperature, occupancy, CO2)
MQTT: modern IoT protocol; bridge between legacy protocols and cloud
OPC-UA: industrial interoperability; growing adoption in smart buildings

Edge Computing Architecture

The fundamental pattern is 3-tier edge: sensors/actuators (field level) -> edge gateway (local processing, protocol translation) -> cloud (analytics, ML, dashboard). Edge processing is critical to reduce latency, bandwidth consumption, and ensure operational continuity even when disconnected from the cloud.

import * as bacnet from 'node-bacnet';
import Aedes from 'aedes';
import net from 'net';

interface SensorReading {
  deviceId: string;
  sensorType: 'temperature' | 'humidity' | 'co2' | 'occupancy' | 'energy' | 'illuminance';
  value: number;
  unit: string;
  timestamp: string;
  quality: 'good' | 'uncertain' | 'bad';
}

export class BACnetGateway {
  private client = new bacnet.Client();

  constructor(private readonly mqttBroker: Aedes) {}

  startDiscovery(): void {
    // Who-Is broadcast: discover all BACnet devices on the network
    this.client.whoIs();

    this.client.on('iAm', (device: any) => {
      console.log(`Discovered BACnet device: #123;device.deviceId} at #123;device.address}`);
      this.schedulePolling(device.deviceId, device.address);
    });
  }

  private schedulePolling(deviceId: number, address: string): void {
    const POLL_INTERVAL_MS = 60_000;

    const poll = async () => {
      try {
        // Read Present Value for temperature sensor (Analog Input object)
        await new Promise<void>((resolve) => {
          this.client.readProperty(
            { ip: address },
            { type: 0, instance: 1 },  // type 0 = Analog Input
            bacnet.enum.PropertyIdentifier.PRESENT_VALUE,
            (err: Error | null, data: any) => {
              if (!err) {
                const reading: SensorReading = {
                  deviceId: `bacnet-#123;deviceId}-0-1`,
                  sensorType: 'temperature',
                  value: data.values[0].value,
                  unit: '°C',
                  timestamp: new Date().toISOString(),
                  quality: 'good',
                };
                const topic = `building/#123;deviceId}/sensor/temperature/1`;
                this.mqttBroker.publish({
                  cmd: 'publish',
                  topic,
                  payload: Buffer.from(JSON.stringify(reading)),
                  qos: 1,
                  retain: true,
                  dup: false,
                }, () => resolve());
              } else {
                resolve();
              }
            }
          );
        });
      } catch (err) {
        console.warn('Poll error:', err);
      }
    };

    poll();
    setInterval(poll, POLL_INTERVAL_MS);
  }
}

export function createEdgeMqttBroker(port = 1883): Aedes {
  const broker = new Aedes();
  const server = net.createServer(broker.handle);
  server.listen(port, () => console.log(`MQTT broker on port #123;port}`));
  return broker;
}

Modbus Integration: Energy Meters and PLCs

Modbus is the dominant protocol for electricity meters, photovoltaic inverters, and industrial PLCs. Integration requires reading specific registers with the modbus-serial library.

import ModbusRTU from 'modbus-serial';

export class ModbusEnergyMeter {
  private client = new ModbusRTU();

  async connect(port: string, baudRate = 9600, slaveId = 1): Promise<void> {
    await this.client.connectRTUBuffered(port, { baudRate });
    this.client.setID(slaveId);
    this.client.setTimeout(3000);
  }

  // Example: Carlo Gavazzi EM340 energy meter (common Modbus map)
  async readEnergyData(): Promise<{
    activePowerW: number;
    activeEnergyKwh: number;
    voltageV: number;
    currentA: number;
    powerFactor: number;
  }> {
    const voltageReg = await this.client.readHoldingRegisters(0x0000, 2);
    const currentReg = await this.client.readHoldingRegisters(0x0006, 2);
    const powerReg = await this.client.readHoldingRegisters(0x000C, 2);
    const energyReg = await this.client.readHoldingRegisters(0x0034, 4);
    const pfReg = await this.client.readHoldingRegisters(0x002E, 2);

    const toFloat = (regs: number[]) => {
      const buf = Buffer.alloc(4);
      buf.writeUInt16BE(regs[0], 0);
      buf.writeUInt16BE(regs[1], 2);
      return buf.readFloatBE(0);
    };

    return {
      voltageV: toFloat(voltageReg.data),
      currentA: toFloat(currentReg.data),
      activePowerW: toFloat(powerReg.data),
      activeEnergyKwh: toFloat(energyReg.data.slice(0, 2)) / 10,
      powerFactor: toFloat(pfReg.data),
    };
  }

  async startContinuousReading(
    intervalMs: number,
    onReading: (reading: Awaited<ReturnType<ModbusEnergyMeter['readEnergyData']>>) => void
  ): Promise<void> {
    const loop = async () => {
      try {
        const reading = await this.readEnergyData();
        onReading(reading);
      } catch (err) {
        console.error('Modbus read error:', err);
        await new Promise(r => setTimeout(r, 5000));
      }
    };
    setInterval(loop, intervalMs);
  }
}

InfluxDB Time-Series Storage

InfluxDB v3 is the reference time-series database for high-frequency IoT. With batch writes and InfluxQL/Flux queries, it handles billions of data points with excellent performance.

import { InfluxDB, Point } from '@influxdata/influxdb-client';

const client = new InfluxDB({
  url: process.env['INFLUXDB_URL']!,
  token: process.env['INFLUXDB_TOKEN']!,
});

const writeApi = client.getWriteApi(
  process.env['INFLUXDB_ORG']!,
  process.env['INFLUXDB_BUCKET']!,
  'ms'
);

export async function writeSensorReading(reading: SensorReading, buildingId: string): Promise<void> {
  const point = new Point('sensor_reading')
    .tag('building_id', buildingId)
    .tag('device_id', reading.deviceId)
    .tag('sensor_type', reading.sensorType)
    .floatField('value', reading.value)
    .timestamp(new Date(reading.timestamp));

  writeApi.writePoint(point);
}

// Flux query: hourly energy consumption last 7 days
export const ENERGY_QUERY_7D = `
from(bucket: "smart-building")
  |> range(start: -7d)
  |> filter(fn: (r) => r["_measurement"] == "energy_meter")
  |> filter(fn: (r) => r["building_id"] == "building-001")
  |> filter(fn: (r) => r["_field"] == "active_power_w")
  |> aggregateWindow(every: 1h, fn: mean, createEmpty: false)
  |> yield(name: "mean_power_hourly")
`;

// Alert when power exceeds threshold
export const POWER_ALERT_QUERY = `
from(bucket: "smart-building")
  |> range(start: -5m)
  |> filter(fn: (r) => r["_measurement"] == "energy_meter")
  |> filter(fn: (r) => r["_field"] == "active_power_w")
  |> filter(fn: (r) => r["_value"] > 150000)  // 150kW threshold
  |> yield(name: "power_alerts")
`;

Occupancy Prediction with ML for HVAC Automation

The most impactful use case: predicting occupancy of each building zone 30-60 minutes in advance to pre-condition (or shut down) the HVAC system, maximizing comfort and minimizing energy consumption.

interface OccupancyFeatures {
  hourOfDay: number;         // 0-23
  dayOfWeek: number;         // 0-6 (0=Monday)
  monthOfYear: number;       // 1-12
  isHoliday: boolean;
  currentCo2Ppm: number;     // CO2 sensor (occupancy proxy)
  currentPirTriggered: boolean;
  temperatureDelta: number;
}

// HVAC setpoint calculation based on occupancy prediction
export function calculateHVACSetpoint(
  zoneId: string,
  occupancyPrediction: { occupied: boolean; confidence: number },
  currentTemp: number
): { heatingSetpoint: number; coolingSetpoint: number; fanMode: string; mode: string } {
  const COMFORT_HEATING = 21.5;
  const COMFORT_COOLING = 24.0;
  const SETBACK_HEATING = 18.0;
  const SETBACK_COOLING = 27.0;

  const isOccupied = occupancyPrediction.occupied && occupancyPrediction.confidence > 0.65;

  if (isOccupied) {
    return {
      heatingSetpoint: COMFORT_HEATING,
      coolingSetpoint: COMFORT_COOLING,
      fanMode: 'auto',
      mode: 'auto',
    };
  }

  // Setback mode - energy savings
  return {
    heatingSetpoint: SETBACK_HEATING,
    coolingSetpoint: SETBACK_COOLING,
    fanMode: 'off',
    mode: currentTemp < SETBACK_HEATING ? 'heat'
      : currentTemp > SETBACK_COOLING ? 'cool'
      : 'off',
  };
}

Energy Benchmarking KPIs

KPI	Formula	Efficient Building Target
EUI (Energy Use Intensity)	kWh/year / m2	<100 kWh/m2 (offices, Mediterranean climate)
PUE (Power Usage Effectiveness)	Total power / IT power	<1.5 for in-building data centers
Thermal Comfort Index	% hours in comfort range (20-24°C)	>95% of occupied hours
CO2 Air Quality	Average PPM in occupied zones	<800 ppm (ASHRAE 62.1)
Occupancy-Based Savings	kWh saved vs baseline	20-35% HVAC savings

OT/IT Security: Critical Infrastructure

BACnet and Modbus systems were designed for closed networks and have limited security (often no authentication). Before connecting building automation systems to IP networks, implement: network segmentation (dedicated OT VLAN), unidirectional firewall (data diode) for OT-to-IT communication, VPN for remote gateway access, and traffic anomaly monitoring. An attack on a building's HVAC systems can cause significant physical damage.

Conclusions

IoT integration in smart buildings is a major technical and business opportunity: energy savings of 20-50%, improved occupant comfort, and reduced CO2 emissions. Edge computing architecture ensures operational resilience even when disconnected from the cloud, while machine learning for occupancy prediction automates HVAC decisions that previously required continuous human intervention.