Interface Cluster

This cluster provides a mechanism for querying data about electrical power as measured by the server.

Per the Matter specification you cannot use ElectricalPowerMeasurementCluster without enabling certain feature combinations. You must use the with factory method to obtain a working cluster.

See

MatterSpecification.v13.Cluster § 2.13

interface Cluster {
    id: ClusterId;
    name: string;
    with: (<const SelectionT>(...selection: SelectionT) => Of<Of<{
        attributes: {
            accuracy: FixedAttribute<TypeFromFields<{
                accuracyRanges: FieldType<(...)[]>;
                maxMeasuredValue: FieldType<(...) | (...)>;
                measured: FieldType<boolean>;
                measurementType: FieldType<MeasurementType>;
                minMeasuredValue: FieldType<(...) | (...)>;
            }>[], any>;
            activeCurrent: OptionalAttribute<null | number | bigint, any>;
            activePower: Attribute<null | number | bigint, any>;
            numberOfMeasurementTypes: FixedAttribute<number, any>;
            powerMode: Attribute<ElectricalPowerMeasurement.PowerMode, any>;
            ranges: OptionalAttribute<TypeFromFields<{
                endSystime: OptionalFieldType<(...) | (...)>;
                endTimestamp: OptionalFieldType<number>;
                max: FieldType<(...) | (...)>;
                maxSystime: OptionalFieldType<(...) | (...)>;
                maxTimestamp: OptionalFieldType<number>;
                measurementType: FieldType<MeasurementType>;
                min: FieldType<(...) | (...)>;
                minSystime: OptionalFieldType<(...) | (...)>;
                minTimestamp: OptionalFieldType<number>;
                startSystime: OptionalFieldType<(...) | (...)>;
                startTimestamp: OptionalFieldType<number>;
            }>[], any>;
            voltage: OptionalAttribute<null | number | bigint, any>;
        };
        events: {
            measurementPeriodRanges: OptionalEvent<TypeFromFields<{
                ranges: FieldType<TypeFromFields<(...)>[]>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    apparentCurrent: OptionalAttribute<null | number | bigint, any>;
                    apparentPower: OptionalAttribute<null | number | bigint, any>;
                    frequency: OptionalAttribute<null | number | bigint, any>;
                    powerFactor: OptionalAttribute<null | number | bigint, any>;
                    reactiveCurrent: OptionalAttribute<null | number | bigint, any>;
                    reactivePower: OptionalAttribute<null | number | bigint, any>;
                    rmsCurrent: OptionalAttribute<null | number | bigint, any>;
                    rmsPower: OptionalAttribute<null | number | bigint, any>;
                    rmsVoltage: OptionalAttribute<null | number | bigint, any>;
                };
            };
            flags: {
                alternatingCurrent: true;
            };
        }, {
            component: {
                attributes: {
                    harmonicCurrents: Attribute<null | (...)[], any>;
                };
            };
            flags: {
                harmonics: true;
            };
        }, {
            component: {
                attributes: {
                    harmonicPhases: Attribute<null | (...)[], any>;
                };
            };
            flags: {
                powerQuality: true;
            };
        }, {
            component: {
                attributes: {
                    neutralCurrent: OptionalAttribute<null | number | bigint, any>;
                };
            };
            flags: {
                polyphasePower: true;
            };
        }, {
            component: false;
            flags: {
                alternatingCurrent: false;
                polyphasePower: true;
            };
        }, {
            component: false;
            flags: {
                alternatingCurrent: false;
                harmonics: true;
            };
        }, {
            component: false;
            flags: {
                alternatingCurrent: false;
                powerQuality: true;
            };
        }, {
            component: false;
            flags: {
                alternatingCurrent: false;
                directCurrent: false;
            };
        }];
        features: {
            alternatingCurrent: BitFlag;
            directCurrent: BitFlag;
            harmonics: BitFlag;
            polyphasePower: BitFlag;
            powerQuality: BitFlag;
        };
        id: 144;
        name: "ElectricalPowerMeasurement";
        revision: 1;
    }>, SelectionT>);
}

Hierarchy (view full)

Properties

id name with

Properties

id

id: ClusterId

name

name: string

with

with: (<const SelectionT>(...selection: SelectionT) => Of<Of<{
    attributes: {
        accuracy: FixedAttribute<TypeFromFields<{
            accuracyRanges: FieldType<(...)[]>;
            maxMeasuredValue: FieldType<(...) | (...)>;
            measured: FieldType<boolean>;
            measurementType: FieldType<MeasurementType>;
            minMeasuredValue: FieldType<(...) | (...)>;
        }>[], any>;
        activeCurrent: OptionalAttribute<null | number | bigint, any>;
        activePower: Attribute<null | number | bigint, any>;
        numberOfMeasurementTypes: FixedAttribute<number, any>;
        powerMode: Attribute<ElectricalPowerMeasurement.PowerMode, any>;
        ranges: OptionalAttribute<TypeFromFields<{
            endSystime: OptionalFieldType<(...) | (...)>;
            endTimestamp: OptionalFieldType<number>;
            max: FieldType<(...) | (...)>;
            maxSystime: OptionalFieldType<(...) | (...)>;
            maxTimestamp: OptionalFieldType<number>;
            measurementType: FieldType<MeasurementType>;
            min: FieldType<(...) | (...)>;
            minSystime: OptionalFieldType<(...) | (...)>;
            minTimestamp: OptionalFieldType<number>;
            startSystime: OptionalFieldType<(...) | (...)>;
            startTimestamp: OptionalFieldType<number>;
        }>[], any>;
        voltage: OptionalAttribute<null | number | bigint, any>;
    };
    events: {
        measurementPeriodRanges: OptionalEvent<TypeFromFields<{
            ranges: FieldType<TypeFromFields<(...)>[]>;
        }>, any>;
    };
    extensions: readonly [{
        component: {
            attributes: {
                apparentCurrent: OptionalAttribute<null | number | bigint, any>;
                apparentPower: OptionalAttribute<null | number | bigint, any>;
                frequency: OptionalAttribute<null | number | bigint, any>;
                powerFactor: OptionalAttribute<null | number | bigint, any>;
                reactiveCurrent: OptionalAttribute<null | number | bigint, any>;
                reactivePower: OptionalAttribute<null | number | bigint, any>;
                rmsCurrent: OptionalAttribute<null | number | bigint, any>;
                rmsPower: OptionalAttribute<null | number | bigint, any>;
                rmsVoltage: OptionalAttribute<null | number | bigint, any>;
            };
        };
        flags: {
            alternatingCurrent: true;
        };
    }, {
        component: {
            attributes: {
                harmonicCurrents: Attribute<null | (...)[], any>;
            };
        };
        flags: {
            harmonics: true;
        };
    }, {
        component: {
            attributes: {
                harmonicPhases: Attribute<null | (...)[], any>;
            };
        };
        flags: {
            powerQuality: true;
        };
    }, {
        component: {
            attributes: {
                neutralCurrent: OptionalAttribute<null | number | bigint, any>;
            };
        };
        flags: {
            polyphasePower: true;
        };
    }, {
        component: false;
        flags: {
            alternatingCurrent: false;
            polyphasePower: true;
        };
    }, {
        component: false;
        flags: {
            alternatingCurrent: false;
            harmonics: true;
        };
    }, {
        component: false;
        flags: {
            alternatingCurrent: false;
            powerQuality: true;
        };
    }, {
        component: false;
        flags: {
            alternatingCurrent: false;
            directCurrent: false;
        };
    }];
    features: {
        alternatingCurrent: BitFlag;
        directCurrent: BitFlag;
        harmonics: BitFlag;
        polyphasePower: BitFlag;
        powerQuality: BitFlag;
    };
    id: 144;
    name: "ElectricalPowerMeasurement";
    revision: 1;
}>, SelectionT>)

Type declaration

    • <const SelectionT>(...selection): Of<Of<{
          attributes: {
              accuracy: FixedAttribute<TypeFromFields<{
                  accuracyRanges: FieldType<(...)[]>;
                  maxMeasuredValue: FieldType<(...) | (...)>;
                  measured: FieldType<boolean>;
                  measurementType: FieldType<MeasurementType>;
                  minMeasuredValue: FieldType<(...) | (...)>;
              }>[], any>;
              activeCurrent: OptionalAttribute<null | number | bigint, any>;
              activePower: Attribute<null | number | bigint, any>;
              numberOfMeasurementTypes: FixedAttribute<number, any>;
              powerMode: Attribute<ElectricalPowerMeasurement.PowerMode, any>;
              ranges: OptionalAttribute<TypeFromFields<{
                  endSystime: OptionalFieldType<(...) | (...)>;
                  endTimestamp: OptionalFieldType<number>;
                  max: FieldType<(...) | (...)>;
                  maxSystime: OptionalFieldType<(...) | (...)>;
                  maxTimestamp: OptionalFieldType<number>;
                  measurementType: FieldType<MeasurementType>;
                  min: FieldType<(...) | (...)>;
                  minSystime: OptionalFieldType<(...) | (...)>;
                  minTimestamp: OptionalFieldType<number>;
                  startSystime: OptionalFieldType<(...) | (...)>;
                  startTimestamp: OptionalFieldType<number>;
              }>[], any>;
              voltage: OptionalAttribute<null | number | bigint, any>;
          };
          events: {
              measurementPeriodRanges: OptionalEvent<TypeFromFields<{
                  ranges: FieldType<TypeFromFields<(...)>[]>;
              }>, any>;
          };
          extensions: readonly [{
              component: {
                  attributes: {
                      apparentCurrent: OptionalAttribute<null | number | bigint, any>;
                      apparentPower: OptionalAttribute<null | number | bigint, any>;
                      frequency: OptionalAttribute<null | number | bigint, any>;
                      powerFactor: OptionalAttribute<null | number | bigint, any>;
                      reactiveCurrent: OptionalAttribute<null | number | bigint, any>;
                      reactivePower: OptionalAttribute<null | number | bigint, any>;
                      rmsCurrent: OptionalAttribute<null | number | bigint, any>;
                      rmsPower: OptionalAttribute<null | number | bigint, any>;
                      rmsVoltage: OptionalAttribute<null | number | bigint, any>;
                  };
              };
              flags: {
                  alternatingCurrent: true;
              };
          }, {
              component: {
                  attributes: {
                      harmonicCurrents: Attribute<null | (...)[], any>;
                  };
              };
              flags: {
                  harmonics: true;
              };
          }, {
              component: {
                  attributes: {
                      harmonicPhases: Attribute<null | (...)[], any>;
                  };
              };
              flags: {
                  powerQuality: true;
              };
          }, {
              component: {
                  attributes: {
                      neutralCurrent: OptionalAttribute<null | number | bigint, any>;
                  };
              };
              flags: {
                  polyphasePower: true;
              };
          }, {
              component: false;
              flags: {
                  alternatingCurrent: false;
                  polyphasePower: true;
              };
          }, {
              component: false;
              flags: {
                  alternatingCurrent: false;
                  harmonics: true;
              };
          }, {
              component: false;
              flags: {
                  alternatingCurrent: false;
                  powerQuality: true;
              };
          }, {
              component: false;
              flags: {
                  alternatingCurrent: false;
                  directCurrent: false;
              };
          }];
          features: {
              alternatingCurrent: BitFlag;
              directCurrent: BitFlag;
              harmonics: BitFlag;
              polyphasePower: BitFlag;
              powerQuality: BitFlag;
          };
          id: 144;
          name: "ElectricalPowerMeasurement";
          revision: 1;
      }>, SelectionT>

    • Select features using ClusterComposer.compose.

      Type Parameters

      • const SelectionT extends FeatureSelection<Of<{
            attributes: {
                accuracy: FixedAttribute<TypeFromFields<{
                    accuracyRanges: FieldType<(...)[]>;
                    maxMeasuredValue: FieldType<(...) | (...)>;
                    measured: FieldType<boolean>;
                    measurementType: FieldType<MeasurementType>;
                    minMeasuredValue: FieldType<(...) | (...)>;
                }>[], any>;
                activeCurrent: OptionalAttribute<null | number | bigint, any>;
                activePower: Attribute<null | number | bigint, any>;
                numberOfMeasurementTypes: FixedAttribute<number, any>;
                powerMode: Attribute<ElectricalPowerMeasurement.PowerMode, any>;
                ranges: OptionalAttribute<TypeFromFields<{
                    endSystime: OptionalFieldType<(...) | (...)>;
                    endTimestamp: OptionalFieldType<number>;
                    max: FieldType<(...) | (...)>;
                    maxSystime: OptionalFieldType<(...) | (...)>;
                    maxTimestamp: OptionalFieldType<number>;
                    measurementType: FieldType<MeasurementType>;
                    min: FieldType<(...) | (...)>;
                    minSystime: OptionalFieldType<(...) | (...)>;
                    minTimestamp: OptionalFieldType<number>;
                    startSystime: OptionalFieldType<(...) | (...)>;
                    startTimestamp: OptionalFieldType<number>;
                }>[], any>;
                voltage: OptionalAttribute<null | number | bigint, any>;
            };
            events: {
                measurementPeriodRanges: OptionalEvent<TypeFromFields<{
                    ranges: FieldType<TypeFromFields<(...)>[]>;
                }>, any>;
            };
            extensions: readonly [{
                component: {
                    attributes: {
                        apparentCurrent: OptionalAttribute<null | number | bigint, any>;
                        apparentPower: OptionalAttribute<null | number | bigint, any>;
                        frequency: OptionalAttribute<null | number | bigint, any>;
                        powerFactor: OptionalAttribute<null | number | bigint, any>;
                        reactiveCurrent: OptionalAttribute<null | number | bigint, any>;
                        reactivePower: OptionalAttribute<null | number | bigint, any>;
                        rmsCurrent: OptionalAttribute<null | number | bigint, any>;
                        rmsPower: OptionalAttribute<null | number | bigint, any>;
                        rmsVoltage: OptionalAttribute<null | number | bigint, any>;
                    };
                };
                flags: {
                    alternatingCurrent: true;
                };
            }, {
                component: {
                    attributes: {
                        harmonicCurrents: Attribute<null | (...)[], any>;
                    };
                };
                flags: {
                    harmonics: true;
                };
            }, {
                component: {
                    attributes: {
                        harmonicPhases: Attribute<null | (...)[], any>;
                    };
                };
                flags: {
                    powerQuality: true;
                };
            }, {
                component: {
                    attributes: {
                        neutralCurrent: OptionalAttribute<null | number | bigint, any>;
                    };
                };
                flags: {
                    polyphasePower: true;
                };
            }, {
                component: false;
                flags: {
                    alternatingCurrent: false;
                    polyphasePower: true;
                };
            }, {
                component: false;
                flags: {
                    alternatingCurrent: false;
                    harmonics: true;
                };
            }, {
                component: false;
                flags: {
                    alternatingCurrent: false;
                    powerQuality: true;
                };
            }, {
                component: false;
                flags: {
                    alternatingCurrent: false;
                    directCurrent: false;
                };
            }];
            features: {
                alternatingCurrent: BitFlag;
                directCurrent: BitFlag;
                harmonics: BitFlag;
                polyphasePower: BitFlag;
                powerQuality: BitFlag;
            };
            id: 144;
            name: "ElectricalPowerMeasurement";
            revision: 1;
        }>>

      Parameters

      Returns Of<Of<{
          attributes: {
              accuracy: FixedAttribute<TypeFromFields<{
                  accuracyRanges: FieldType<(...)[]>;
                  maxMeasuredValue: FieldType<(...) | (...)>;
                  measured: FieldType<boolean>;
                  measurementType: FieldType<MeasurementType>;
                  minMeasuredValue: FieldType<(...) | (...)>;
              }>[], any>;
              activeCurrent: OptionalAttribute<null | number | bigint, any>;
              activePower: Attribute<null | number | bigint, any>;
              numberOfMeasurementTypes: FixedAttribute<number, any>;
              powerMode: Attribute<ElectricalPowerMeasurement.PowerMode, any>;
              ranges: OptionalAttribute<TypeFromFields<{
                  endSystime: OptionalFieldType<(...) | (...)>;
                  endTimestamp: OptionalFieldType<number>;
                  max: FieldType<(...) | (...)>;
                  maxSystime: OptionalFieldType<(...) | (...)>;
                  maxTimestamp: OptionalFieldType<number>;
                  measurementType: FieldType<MeasurementType>;
                  min: FieldType<(...) | (...)>;
                  minSystime: OptionalFieldType<(...) | (...)>;
                  minTimestamp: OptionalFieldType<number>;
                  startSystime: OptionalFieldType<(...) | (...)>;
                  startTimestamp: OptionalFieldType<number>;
              }>[], any>;
              voltage: OptionalAttribute<null | number | bigint, any>;
          };
          events: {
              measurementPeriodRanges: OptionalEvent<TypeFromFields<{
                  ranges: FieldType<TypeFromFields<(...)>[]>;
              }>, any>;
          };
          extensions: readonly [{
              component: {
                  attributes: {
                      apparentCurrent: OptionalAttribute<null | number | bigint, any>;
                      apparentPower: OptionalAttribute<null | number | bigint, any>;
                      frequency: OptionalAttribute<null | number | bigint, any>;
                      powerFactor: OptionalAttribute<null | number | bigint, any>;
                      reactiveCurrent: OptionalAttribute<null | number | bigint, any>;
                      reactivePower: OptionalAttribute<null | number | bigint, any>;
                      rmsCurrent: OptionalAttribute<null | number | bigint, any>;
                      rmsPower: OptionalAttribute<null | number | bigint, any>;
                      rmsVoltage: OptionalAttribute<null | number | bigint, any>;
                  };
              };
              flags: {
                  alternatingCurrent: true;
              };
          }, {
              component: {
                  attributes: {
                      harmonicCurrents: Attribute<null | (...)[], any>;
                  };
              };
              flags: {
                  harmonics: true;
              };
          }, {
              component: {
                  attributes: {
                      harmonicPhases: Attribute<null | (...)[], any>;
                  };
              };
              flags: {
                  powerQuality: true;
              };
          }, {
              component: {
                  attributes: {
                      neutralCurrent: OptionalAttribute<null | number | bigint, any>;
                  };
              };
              flags: {
                  polyphasePower: true;
              };
          }, {
              component: false;
              flags: {
                  alternatingCurrent: false;
                  polyphasePower: true;
              };
          }, {
              component: false;
              flags: {
                  alternatingCurrent: false;
                  harmonics: true;
              };
          }, {
              component: false;
              flags: {
                  alternatingCurrent: false;
                  powerQuality: true;
              };
          }, {
              component: false;
              flags: {
                  alternatingCurrent: false;
                  directCurrent: false;
              };
          }];
          features: {
              alternatingCurrent: BitFlag;
              directCurrent: BitFlag;
              harmonics: BitFlag;
              polyphasePower: BitFlag;
              powerQuality: BitFlag;
          };
          id: 144;
          name: "ElectricalPowerMeasurement";
          revision: 1;
      }>, SelectionT>

Settings

Member Visibility

On This Page

Properties