|
24 | 24 | #include <app/reporting/reporting.h>
|
25 | 25 | #include <app/util/attribute-storage.h>
|
26 | 26 |
|
27 |
| - |
28 | 27 | using namespace chip;
|
29 | 28 | using namespace chip::app;
|
30 | 29 | using namespace chip::app::DataModel;
|
@@ -66,143 +65,155 @@ CHIP_ERROR Instance::Read(const ConcreteReadAttributePath & aPath, AttributeValu
|
66 | 65 | {
|
67 | 66 | switch (aPath.mAttributeId)
|
68 | 67 | {
|
69 |
| - case FeatureMap::Id: |
| 68 | + case FeatureMap::Id: |
70 | 69 | ReturnErrorOnFailure(aEncoder.Encode(mFeature.Raw()));
|
71 | 70 | break;
|
72 |
| - case PowerMode::Id: |
73 |
| - ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetPowerMode())); |
74 |
| - break; |
| 71 | + case PowerMode::Id: |
| 72 | + ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetPowerMode())); |
| 73 | + break; |
75 | 74 | case NumberOfMeasurementTypes::Id:
|
76 |
| - ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetNumberOfMeasurementTypes())); |
77 |
| - break; |
| 75 | + ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetNumberOfMeasurementTypes())); |
| 76 | + break; |
78 | 77 | case Accuracy::Id:
|
79 |
| - ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetAccuracy())); |
80 |
| - break; |
| 78 | + ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetAccuracy())); |
| 79 | + break; |
81 | 80 | case Ranges::Id:
|
82 |
| - if (!SupportsOptAttr(OptionalAttributes::kOptionalAttributeRanges)) |
| 81 | + if (!SupportsOptAttr(OptionalAttributes::kOptionalAttributeRanges)) |
83 | 82 | {
|
84 | 83 | return CHIP_IM_GLOBAL_STATUS(UnsupportedAttribute);
|
85 | 84 | }
|
86 |
| - ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetRanges())); |
87 |
| - break; |
| 85 | + ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetRanges())); |
| 86 | + break; |
88 | 87 | case Voltage::Id:
|
89 |
| - if (!SupportsOptAttr(OptionalAttributes::kOptionalAttributeVoltage)) |
| 88 | + if (!SupportsOptAttr(OptionalAttributes::kOptionalAttributeVoltage)) |
90 | 89 | {
|
91 | 90 | return CHIP_IM_GLOBAL_STATUS(UnsupportedAttribute);
|
92 | 91 | }
|
93 |
| - ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetVoltage())); |
94 |
| - break; |
| 92 | + ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetVoltage())); |
| 93 | + break; |
95 | 94 | case ActiveCurrent::Id:
|
96 |
| - if (!SupportsOptAttr(OptionalAttributes::kOptionalAttributeActiveCurrent)) |
| 95 | + if (!SupportsOptAttr(OptionalAttributes::kOptionalAttributeActiveCurrent)) |
97 | 96 | {
|
98 | 97 | return CHIP_IM_GLOBAL_STATUS(UnsupportedAttribute);
|
99 | 98 | }
|
100 |
| - ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetActiveCurrent())); |
101 |
| - break; |
| 99 | + ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetActiveCurrent())); |
| 100 | + break; |
102 | 101 | case ReactiveCurrent::Id:
|
103 |
| - if (!SupportsOptAttr(OptionalAttributes::kOptionalAttributeReactiveCurrent)) |
| 102 | + if (!SupportsOptAttr(OptionalAttributes::kOptionalAttributeReactiveCurrent)) |
104 | 103 | {
|
105 | 104 | return CHIP_IM_GLOBAL_STATUS(UnsupportedAttribute);
|
106 | 105 | }
|
107 |
| - VerifyOrReturnError(HasFeature(ElectricalPowerMeasurement::Feature::kAlternatingCurrent), CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE, |
108 |
| - ChipLogError(Zcl, "Electrical Power Measurement: can not get ReactiveCurrent, feature is not supported")); |
109 |
| - ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetReactiveCurrent())); |
110 |
| - break; |
| 106 | + VerifyOrReturnError( |
| 107 | + HasFeature(ElectricalPowerMeasurement::Feature::kAlternatingCurrent), CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE, |
| 108 | + ChipLogError(Zcl, "Electrical Power Measurement: can not get ReactiveCurrent, feature is not supported")); |
| 109 | + ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetReactiveCurrent())); |
| 110 | + break; |
111 | 111 | case ApparentCurrent::Id:
|
112 |
| - if (!SupportsOptAttr(OptionalAttributes::kOptionalAttributeApparentCurrent)) |
| 112 | + if (!SupportsOptAttr(OptionalAttributes::kOptionalAttributeApparentCurrent)) |
113 | 113 | {
|
114 | 114 | return CHIP_IM_GLOBAL_STATUS(UnsupportedAttribute);
|
115 | 115 | }
|
116 |
| - VerifyOrReturnError(HasFeature(ElectricalPowerMeasurement::Feature::kAlternatingCurrent), CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE, |
117 |
| - ChipLogError(Zcl, "Electrical Power Measurement: can not get ApparentCurrent, feature is not supported")); |
118 |
| - ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetApparentCurrent())); |
119 |
| - break; |
| 116 | + VerifyOrReturnError( |
| 117 | + HasFeature(ElectricalPowerMeasurement::Feature::kAlternatingCurrent), CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE, |
| 118 | + ChipLogError(Zcl, "Electrical Power Measurement: can not get ApparentCurrent, feature is not supported")); |
| 119 | + ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetApparentCurrent())); |
| 120 | + break; |
120 | 121 | case ActivePower::Id:
|
121 |
| - ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetActivePower())); |
122 |
| - break; |
| 122 | + ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetActivePower())); |
| 123 | + break; |
123 | 124 | case ReactivePower::Id:
|
124 |
| - if (!SupportsOptAttr(OptionalAttributes::kOptionalAttributeReactivePower)) |
| 125 | + if (!SupportsOptAttr(OptionalAttributes::kOptionalAttributeReactivePower)) |
125 | 126 | {
|
126 | 127 | return CHIP_IM_GLOBAL_STATUS(UnsupportedAttribute);
|
127 | 128 | }
|
128 |
| - VerifyOrReturnError(HasFeature(ElectricalPowerMeasurement::Feature::kAlternatingCurrent), CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE, |
129 |
| - ChipLogError(Zcl, "Electrical Power Measurement: can not get ReactivePower, feature is not supported")); |
130 |
| - ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetReactivePower())); |
131 |
| - break; |
| 129 | + VerifyOrReturnError(HasFeature(ElectricalPowerMeasurement::Feature::kAlternatingCurrent), |
| 130 | + CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE, |
| 131 | + ChipLogError(Zcl, "Electrical Power Measurement: can not get ReactivePower, feature is not supported")); |
| 132 | + ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetReactivePower())); |
| 133 | + break; |
132 | 134 | case ApparentPower::Id:
|
133 |
| - if (!SupportsOptAttr(OptionalAttributes::kOptionalAttributeApparentPower)) |
| 135 | + if (!SupportsOptAttr(OptionalAttributes::kOptionalAttributeApparentPower)) |
134 | 136 | {
|
135 | 137 | return CHIP_IM_GLOBAL_STATUS(UnsupportedAttribute);
|
136 | 138 | }
|
137 |
| - VerifyOrReturnError(HasFeature(ElectricalPowerMeasurement::Feature::kAlternatingCurrent), CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE, |
138 |
| - ChipLogError(Zcl, "Electrical Power Measurement: can not get ApparentPower, feature is not supported")); |
139 |
| - ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetApparentPower())); |
140 |
| - break; |
| 139 | + VerifyOrReturnError(HasFeature(ElectricalPowerMeasurement::Feature::kAlternatingCurrent), |
| 140 | + CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE, |
| 141 | + ChipLogError(Zcl, "Electrical Power Measurement: can not get ApparentPower, feature is not supported")); |
| 142 | + ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetApparentPower())); |
| 143 | + break; |
141 | 144 | case RMSVoltage::Id:
|
142 |
| - if (!SupportsOptAttr(OptionalAttributes::kOptionalAttributeRMSVoltage)) |
| 145 | + if (!SupportsOptAttr(OptionalAttributes::kOptionalAttributeRMSVoltage)) |
143 | 146 | {
|
144 | 147 | return CHIP_IM_GLOBAL_STATUS(UnsupportedAttribute);
|
145 | 148 | }
|
146 |
| - VerifyOrReturnError(HasFeature(ElectricalPowerMeasurement::Feature::kAlternatingCurrent), CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE, |
147 |
| - ChipLogError(Zcl, "Electrical Power Measurement: can not get RMSVoltage, feature is not supported")); |
148 |
| - ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetRMSVoltage())); |
149 |
| - break; |
| 149 | + VerifyOrReturnError(HasFeature(ElectricalPowerMeasurement::Feature::kAlternatingCurrent), |
| 150 | + CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE, |
| 151 | + ChipLogError(Zcl, "Electrical Power Measurement: can not get RMSVoltage, feature is not supported")); |
| 152 | + ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetRMSVoltage())); |
| 153 | + break; |
150 | 154 | case RMSCurrent::Id:
|
151 |
| - if (!SupportsOptAttr(OptionalAttributes::kOptionalAttributeRMSCurrent)) |
| 155 | + if (!SupportsOptAttr(OptionalAttributes::kOptionalAttributeRMSCurrent)) |
152 | 156 | {
|
153 | 157 | return CHIP_IM_GLOBAL_STATUS(UnsupportedAttribute);
|
154 | 158 | }
|
155 |
| - VerifyOrReturnError(HasFeature(ElectricalPowerMeasurement::Feature::kAlternatingCurrent), CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE, |
156 |
| - ChipLogError(Zcl, "Electrical Power Measurement: can not get RMSCurrent, feature is not supported")); |
157 |
| - ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetRMSCurrent())); |
158 |
| - break; |
| 159 | + VerifyOrReturnError(HasFeature(ElectricalPowerMeasurement::Feature::kAlternatingCurrent), |
| 160 | + CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE, |
| 161 | + ChipLogError(Zcl, "Electrical Power Measurement: can not get RMSCurrent, feature is not supported")); |
| 162 | + ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetRMSCurrent())); |
| 163 | + break; |
159 | 164 | case RMSPower::Id:
|
160 |
| - if (!SupportsOptAttr(OptionalAttributes::kOptionalAttributeRMSPower)) |
| 165 | + if (!SupportsOptAttr(OptionalAttributes::kOptionalAttributeRMSPower)) |
161 | 166 | {
|
162 | 167 | return CHIP_IM_GLOBAL_STATUS(UnsupportedAttribute);
|
163 | 168 | }
|
164 |
| - VerifyOrReturnError(HasFeature(ElectricalPowerMeasurement::Feature::kAlternatingCurrent), CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE, |
165 |
| - ChipLogError(Zcl, "Electrical Power Measurement: can not get RMSPower, feature is not supported")); |
166 |
| - ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetRMSPower())); |
167 |
| - break; |
| 169 | + VerifyOrReturnError(HasFeature(ElectricalPowerMeasurement::Feature::kAlternatingCurrent), |
| 170 | + CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE, |
| 171 | + ChipLogError(Zcl, "Electrical Power Measurement: can not get RMSPower, feature is not supported")); |
| 172 | + ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetRMSPower())); |
| 173 | + break; |
168 | 174 | case Frequency::Id:
|
169 |
| - if (!SupportsOptAttr(OptionalAttributes::kOptionalAttributeFrequency)) |
| 175 | + if (!SupportsOptAttr(OptionalAttributes::kOptionalAttributeFrequency)) |
170 | 176 | {
|
171 | 177 | return CHIP_IM_GLOBAL_STATUS(UnsupportedAttribute);
|
172 | 178 | }
|
173 |
| - VerifyOrReturnError(HasFeature(ElectricalPowerMeasurement::Feature::kAlternatingCurrent), CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE, |
174 |
| - ChipLogError(Zcl, "Electrical Power Measurement: can not get Frequency, feature is not supported")); |
175 |
| - ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetFrequency())); |
176 |
| - break; |
| 179 | + VerifyOrReturnError(HasFeature(ElectricalPowerMeasurement::Feature::kAlternatingCurrent), |
| 180 | + CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE, |
| 181 | + ChipLogError(Zcl, "Electrical Power Measurement: can not get Frequency, feature is not supported")); |
| 182 | + ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetFrequency())); |
| 183 | + break; |
177 | 184 | case HarmonicCurrents::Id:
|
178 |
| - VerifyOrReturnError(HasFeature(ElectricalPowerMeasurement::Feature::kHarmonics), CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE, |
179 |
| - ChipLogError(Zcl, "Electrical Power Measurement: can not get HarmonicCurrents, feature is not supported")); |
180 |
| - ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetHarmonicCurrents())); |
181 |
| - break; |
| 185 | + VerifyOrReturnError( |
| 186 | + HasFeature(ElectricalPowerMeasurement::Feature::kHarmonics), CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE, |
| 187 | + ChipLogError(Zcl, "Electrical Power Measurement: can not get HarmonicCurrents, feature is not supported")); |
| 188 | + ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetHarmonicCurrents())); |
| 189 | + break; |
182 | 190 | case HarmonicPhases::Id:
|
183 |
| - VerifyOrReturnError(HasFeature(ElectricalPowerMeasurement::Feature::kPowerQuality), CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE, |
184 |
| - ChipLogError(Zcl, "Electrical Power Measurement: can not get HarmonicPhases, feature is not supported")); |
185 |
| - ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetHarmonicPhases())); |
186 |
| - break; |
| 191 | + VerifyOrReturnError( |
| 192 | + HasFeature(ElectricalPowerMeasurement::Feature::kPowerQuality), CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE, |
| 193 | + ChipLogError(Zcl, "Electrical Power Measurement: can not get HarmonicPhases, feature is not supported")); |
| 194 | + ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetHarmonicPhases())); |
| 195 | + break; |
187 | 196 | case PowerFactor::Id:
|
188 |
| - if (!SupportsOptAttr(OptionalAttributes::kOptionalAttributePowerFactor)) |
| 197 | + if (!SupportsOptAttr(OptionalAttributes::kOptionalAttributePowerFactor)) |
189 | 198 | {
|
190 | 199 | return CHIP_IM_GLOBAL_STATUS(UnsupportedAttribute);
|
191 | 200 | }
|
192 |
| - VerifyOrReturnError(HasFeature(ElectricalPowerMeasurement::Feature::kAlternatingCurrent), CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE, |
193 |
| - ChipLogError(Zcl, "Electrical Power Measurement: can not get PowerFactor, feature is not supported")); |
194 |
| - ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetPowerFactor())); |
195 |
| - break; |
| 201 | + VerifyOrReturnError(HasFeature(ElectricalPowerMeasurement::Feature::kAlternatingCurrent), |
| 202 | + CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE, |
| 203 | + ChipLogError(Zcl, "Electrical Power Measurement: can not get PowerFactor, feature is not supported")); |
| 204 | + ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetPowerFactor())); |
| 205 | + break; |
196 | 206 | case NeutralCurrent::Id:
|
197 |
| - if (!SupportsOptAttr(OptionalAttributes::kOptionalAttributeNeutralCurrent)) |
| 207 | + if (!SupportsOptAttr(OptionalAttributes::kOptionalAttributeNeutralCurrent)) |
198 | 208 | {
|
199 | 209 | return CHIP_IM_GLOBAL_STATUS(UnsupportedAttribute);
|
200 | 210 | }
|
201 |
| - VerifyOrReturnError(HasFeature(ElectricalPowerMeasurement::Feature::kPolyphasePower), CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE, |
202 |
| - ChipLogError(Zcl, "Electrical Power Measurement: can not get NeutralCurrent, feature is not supported")); |
203 |
| - ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetNeutralCurrent())); |
204 |
| - break; |
205 |
| - } |
| 211 | + VerifyOrReturnError( |
| 212 | + HasFeature(ElectricalPowerMeasurement::Feature::kPolyphasePower), CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE, |
| 213 | + ChipLogError(Zcl, "Electrical Power Measurement: can not get NeutralCurrent, feature is not supported")); |
| 214 | + ReturnErrorOnFailure(aEncoder.Encode(mDelegate.GetNeutralCurrent())); |
| 215 | + break; |
| 216 | + } |
206 | 217 | return CHIP_NO_ERROR;
|
207 | 218 | }
|
208 | 219 |
|
|
0 commit comments