HomePi

Projekt HomePi - Die Spannungsversorgung

Die Spannungsversorgung des HomePi erfolgt grundlegend über ein Schaltnetzteil, welches eine Spannung von +24 V und bis zu 3 A Strom liefert.
Diese +24 V werden über einen Phoenixstecker auf die Spannungsversorgungsplatine gegeben, auf welcher dann alle benötigten Spannungen erzeugt werden.

Die Spannungsversorgungsplatine verfügt zum Schutz des HomePi über eine 2,5 A Rückstellsicherung (Polyfuse), die bei zu hohen Strömen abschaltet. Weiterhin besitzt sie eine Schutzdiode in Sperrrichtung, welche beim Anschließen einer falschen Polarität einen Kurzschluss verursacht, damit die zuvor genannte Sicherung auslöst und folglich die restliche Schaltung schützt.

Spannungsebenen

24 V Schaltnetzteil

Über vier TSR-Schaltregler von TracoPower mit hohem Wirkungsgrad werden aus den +24 V auf der Spannungsversorgungsplatine die folgenden Spannungen für das System erzeugt:

  • +5 V mit bis zu 2 A für interne Verwendung.
    Dient der Versorgung des Raspberry Pi und anderen Bauteilen innerhalb der Zentrale. Zur Vermeidung von Störungen am Raspberry Pi wird diese Spannung über zwei getrennte Leitungen zur / auf der Backplane verteilt.
  • +5 V mit bis zu 1 A für externe Verwendung.
    Dient der getrennten Versorgung von extern (außerhalb der Zentrale) angebundenen Komponenten. Durch die getrennte Spannungsversorgung von externen Komponenten sollen Störungen von außerhalb auf den Raspberry Pi vermindert werden.
  • +3,3 V mit bis zu 1 A für interne Verwendung.
    Dient der Versorgung diverser Komponenten innerhalb der Zentrale.
  • +12 V mit bis zu 1 A für interne Verwendung.
    Dient der Versorgung von beispielsweise einem Lüfter innerhalb der Zentrale.

Zusätzlich zu diesen vier Spannungen werden auch die +24 V an die Backplane weitergegeben und stehen somit bei Bedarf jeder Einschubplatine zur Verfügung.

Zur einfachen (groben) Sichtkontrolle ist für jede Spannung eine eigene LED vorgesehen.

HomePi Spannungsversorgungsplatine (Rev. 2020/04)

Messung der Leistungsaufnahme

Die Spannungsversorgungsplatine verfügt zudem über einen Strom- und Leistungssensor vom Typ INA226, welcher über den I²C-Bus an den Raspberry Pi angebunden ist.

Der INA226 misst die genaue aktuelle Eingangsspannung (+24 V) und die über einen speziellen Shunt-Widerstand (0,02 Ω, 1 %, 5 W) abfallende Spannung. Mit diesen Werten können der aktuelle Strom und die aktuelle Leistungsaufnahme des Gesamtsystems ermittelt werden.

Abgefragt werden die Daten in ioBroker mit Hilfe des ioBroker.i2c Adapters über ein folgendes Skript:

ioBroker INA226 Skript
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
/**
 * ioBroker script to read voltages and calculate power from INA226 power monitor IC.
 *
 * Copyright (C) 2020-2024 Peter Müller <peter@crycode.de> (https://crycode.de)
 */

const INA_ADDRESS = 0x40;
const R_SHUNT = 0.02;

const CONFIGURATION_REGISTER = 0x00;
const SHUNT_VOLTAGE_REGISTER = 0x01;
const BUS_VOLTAGE_REGISTER = 0x02;

const SHUNT_VOLTAGE_LSB = 0.0000025; // 2.5µV
const BUS_VOLTAGE_LSB = 0.00125; // 1.25mV

const CONFIGURATION_REGISTER_VALUE = 0x4427; // 16 averages, 1.1ms conversion time, shunt and bus continuous

const STATE_SHUNT_VOLTAGE = '0_userdata.0.power-monitor.shunt-voltage';
const STATE_BUS_VOLTAGE = '0_userdata.0.power-monitor.bus-voltage';
const STATE_POWER = '0_userdata.0.power-monitor.power';

/**
 * Function to read data from INA226.
 */
function readIna () {
  sendTo('i2c.0', 'read', {
    address: INA_ADDRESS,
    register: SHUNT_VOLTAGE_REGISTER,
    bytes: 2
  }, (buf) => {
    let shuntVoltage = buf.readUInt16BE();
    if (shuntVoltage & 0x8000) {
      shuntVoltage -= 1; // subtract 1
      shuntVoltage ^= 0xFFFF; // invert bits
      shuntVoltage *= -1; // negate
    }
    shuntVoltage = shuntVoltage * SHUNT_VOLTAGE_LSB;

    sendTo('i2c.0', 'read', {
      address: INA_ADDRESS,
      register: BUS_VOLTAGE_REGISTER,
      bytes: 2
    }, (buf) => {
      let busVoltage = buf.readUInt16BE();
      busVoltage = busVoltage * BUS_VOLTAGE_LSB;

      let power = busVoltage * shuntVoltage / R_SHUNT;

      setState(STATE_SHUNT_VOLTAGE, Math.round(shuntVoltage * 100000) / 100000, true);
      setState(STATE_BUS_VOLTAGE, Math.round(busVoltage * 1000) / 1000, true);
      setState(STATE_POWER, Math.round(power * 100) / 100, true);
    });
  });
}

// create the  objects if not exists
if (!getObject(STATE_SHUNT_VOLTAGE)) {
  setObject(STATE_SHUNT_VOLTAGE, {
    type: 'state',
    common: {
      name: 'Shunt-Spannung',
      role: 'value',
      type: 'number',
      unit: 'V',
      read: true,
      write: false
    },
    native: {},
  });
}
if (!getObject(STATE_BUS_VOLTAGE)) {
  setObject(STATE_BUS_VOLTAGE, {
    type: 'state',
    common: {
      name: 'Bus-Spannung',
      role: 'value',
      type: 'number',
      unit: 'V',
      read: true,
      write: false
    },
    native: {},
  });
}
if (!getObject(STATE_POWER)) {
  setObject(STATE_POWER, {
    type: 'state',
    common: {
      name: 'Leistung',
      role: 'value',
      type: 'number',
      unit: 'W',
      read: true,
      write: false
    },
    native: {},
  });
}

// write config to INA226 on startup ...
let buf = Buffer.alloc(2);
buf.writeUInt16BE(CONFIGURATION_REGISTER_VALUE, 0);
sendTo('i2c.0', 'write', {
  address: INA_ADDRESS,
  register: CONFIGURATION_REGISTER,
  data: buf
}, (b) => {
  // ... then read data and schedule readings
  readIna();
  schedule('0,30 * * * * *', readIna); // every 30 seconds
});

Schaltplan und Platinenlayout

HomePi Spannungsversorgung Rev. 2020/04 Schaltplan
HomePi Spannungsversorgung Rev. 2020/04 Platinenlayout

Downloads: Schaltplan+Layout als PDF, Eagle Schaltplan, Eagle Platinenlayout