max_stars_count
int64 301
224k
| text
stringlengths 6
1.05M
| token_count
int64 3
727k
|
|---|---|---|
348 | <gh_stars>100-1000
{"nom":"Saint-Prix","circ":"4ème circonscription","dpt":"Val-d'Oise","inscrits":5784,"abs":3385,"votants":2399,"blancs":134,"nuls":34,"exp":2231,"res":[{"nuance":"REM","nom":"<NAME>","voix":1259},{"nuance":"LR","nom":"M. <NAME>","voix":972}]} | 110 |
6,224 | <gh_stars>1000+
/*
* Copyright (c) 2021 Synopsys
*
* SPDX-License-Identifier: Apache-2.0
*/
#ifndef ZEPHYR_LIB_LIBC_ARCMWDT_INCLUDE_FCNTL_H_
#define ZEPHYR_LIB_LIBC_ARCMWDT_INCLUDE_FCNTL_H_
#include_next <fcntl.h>
#define F_DUPFD 0
#define F_GETFL 3
#define F_SETFL 4
/*
* MWDT fcntl.h doesn't provide O_NONBLOCK, however it provides other file IO
* definitions. Let's define O_NONBLOCK and check that it doesn't overlap with
* any other file IO defines.
*/
#ifndef O_NONBLOCK
#define O_NONBLOCK 0x4000
#if O_NONBLOCK & (O_RDONLY | O_WRONLY | O_RDWR | O_NDELAY | O_CREAT | O_APPEND | O_TRUNC | O_EXCL)
#error "O_NONBLOCK conflicts with other O_*** file IO defines!"
#endif
#endif
#endif /* ZEPHYR_LIB_LIBC_ARCMWDT_INCLUDE_FCNTL_H_ */
| 339 |
581 | /**
* @author <NAME> <<EMAIL>>
*/
#include "phasar/PhasarLLVM/DataFlowSolver/IfdsIde/IFDSFieldSensTaintAnalysis/FlowFunctions/StoreInstFlowFunction.h"
namespace psr {
std::set<ExtendedValue>
StoreInstFlowFunction::computeTargetsExt(ExtendedValue &Fact) {
const auto *const StoreInst = llvm::cast<llvm::StoreInst>(currentInst);
const auto *const SrcMemLocationMatr = StoreInst->getValueOperand();
const auto *const DstMemLocationMatr = StoreInst->getPointerOperand();
const auto FactMemLocationSeq =
DataFlowUtils::getMemoryLocationSeqFromFact(Fact);
auto SrcMemLocationSeq =
DataFlowUtils::getMemoryLocationSeqFromMatr(SrcMemLocationMatr);
auto DstMemLocationSeq =
DataFlowUtils::getMemoryLocationSeqFromMatr(DstMemLocationMatr);
bool IsArgumentPatch =
DataFlowUtils::isPatchableArgumentStore(SrcMemLocationMatr, Fact);
bool IsVaListArgumentPatch =
DataFlowUtils::isPatchableVaListArgument(SrcMemLocationMatr, Fact);
bool IsReturnValuePatch =
DataFlowUtils::isPatchableReturnValue(SrcMemLocationMatr, Fact);
bool IsSrcMemLocation = !SrcMemLocationSeq.empty();
std::set<ExtendedValue> TargetFacts;
/*
* Patch argument
*
* We have 3 differenct cases to consider here:
*
* 1) Patching of memory location sequence for a regular argument
* 2) Patching of memory location sequence for a vararg (int foo(int n, ...))
* 3) Patching of va list memory location sequence for a vararg (int
* foo(va_list args))
*
*/
if (IsArgumentPatch) {
bool PatchMemLocation = !DstMemLocationSeq.empty();
if (PatchMemLocation) {
bool IsArgCoerced = SrcMemLocationMatr->getName().contains("coerce");
if (IsArgCoerced) {
assert(DstMemLocationSeq.size() > 1);
DstMemLocationSeq.pop_back();
}
const auto PatchableMemLocationSeq =
IsVaListArgumentPatch
? DataFlowUtils::getVaListMemoryLocationSeqFromFact(Fact)
: DataFlowUtils::getMemoryLocationSeqFromFact(Fact);
const auto PatchedMemLocationSeq =
DataFlowUtils::patchMemoryLocationFrame(PatchableMemLocationSeq,
DstMemLocationSeq);
ExtendedValue EV(Fact);
if (IsVaListArgumentPatch) {
EV.setVaListMemLocationSeq(PatchedMemLocationSeq);
} else {
EV.setMemLocationSeq(PatchedMemLocationSeq);
EV.resetVarArgIndex();
}
TargetFacts.insert(EV);
traceStats.add(StoreInst, DstMemLocationSeq);
LOG_DEBUG("Patched memory location (arg/store)");
LOG_DEBUG("Source");
DataFlowUtils::dumpFact(Fact);
LOG_DEBUG("Destination");
DataFlowUtils::dumpFact(EV);
}
}
/*
* Patch return value
*/
else if (IsReturnValuePatch) {
bool PatchMemLocation = !DstMemLocationSeq.empty();
if (PatchMemLocation) {
bool IsExtractValue =
llvm::isa<llvm::ExtractValueInst>(SrcMemLocationMatr);
if (IsExtractValue) {
assert(DstMemLocationSeq.size() > 1);
DstMemLocationSeq.pop_back();
}
const auto PatchedMemLocationSeq =
DataFlowUtils::patchMemoryLocationFrame(FactMemLocationSeq,
DstMemLocationSeq);
ExtendedValue EV(Fact);
EV.setMemLocationSeq(PatchedMemLocationSeq);
TargetFacts.insert(EV);
traceStats.add(StoreInst, DstMemLocationSeq);
LOG_DEBUG("Patched memory location (ret/store)");
LOG_DEBUG("Source");
DataFlowUtils::dumpFact(Fact);
LOG_DEBUG("Destination");
DataFlowUtils::dumpFact(EV);
}
}
/*
* If we got a memory location then we need to find all tainted memory
* locations for it and create a new relocated address that relatively works
* from the memory location destination. If the value is a pointer so is the
* desination as the store instruction is defined as <store, ty val, *ty dst>
* that means we need to remove all facts that started at the destination.
*/
else if (IsSrcMemLocation) {
bool IsArrayDecay = DataFlowUtils::isArrayDecay(SrcMemLocationMatr);
if (IsArrayDecay) {
SrcMemLocationSeq.pop_back();
}
bool GenFact = DataFlowUtils::isSubsetMemoryLocationSeq(SrcMemLocationSeq,
FactMemLocationSeq);
bool KillFact = DataFlowUtils::isSubsetMemoryLocationSeq(
DstMemLocationSeq, FactMemLocationSeq) ||
DataFlowUtils::isKillAfterStoreFact(Fact);
if (GenFact) {
const auto RelocatableMemLocationSeq =
DataFlowUtils::getRelocatableMemoryLocationSeq(FactMemLocationSeq,
SrcMemLocationSeq);
const auto RelocatedMemLocationSeq =
DataFlowUtils::joinMemoryLocationSeqs(DstMemLocationSeq,
RelocatableMemLocationSeq);
ExtendedValue EV(Fact);
EV.setMemLocationSeq(RelocatedMemLocationSeq);
TargetFacts.insert(EV);
traceStats.add(StoreInst, DstMemLocationSeq);
LOG_DEBUG("Relocated memory location (store)");
LOG_DEBUG("Source");
DataFlowUtils::dumpFact(Fact);
LOG_DEBUG("Destination");
DataFlowUtils::dumpFact(EV);
}
if (!KillFact) {
TargetFacts.insert(Fact);
}
} else {
bool GenFact = DataFlowUtils::isValueTainted(SrcMemLocationMatr, Fact);
bool KillFact = DataFlowUtils::isSubsetMemoryLocationSeq(
DstMemLocationSeq, FactMemLocationSeq) ||
DataFlowUtils::isKillAfterStoreFact(Fact);
if (GenFact) {
ExtendedValue EV(StoreInst);
EV.setMemLocationSeq(DstMemLocationSeq);
TargetFacts.insert(EV);
traceStats.add(StoreInst, DstMemLocationSeq);
}
if (!KillFact) {
TargetFacts.insert(Fact);
}
}
return TargetFacts;
}
} // namespace psr
| 2,491 |
1,305 | /*
* Copyright (c) 2002, 2003, Oracle and/or its affiliates. All rights reserved.
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
/**
*/
package com.sun.corba.se.spi.servicecontext;
import org.omg.IOP.RMICustomMaxStreamFormat;
import javax.rmi.CORBA.*;
import org.omg.CORBA.SystemException;
import org.omg.CORBA_2_3.portable.InputStream;
import org.omg.CORBA_2_3.portable.OutputStream;
import com.sun.corba.se.spi.ior.iiop.GIOPVersion;
import com.sun.corba.se.impl.encoding.MarshalInputStream;
import com.sun.corba.se.impl.encoding.MarshalOutputStream;
import com.sun.corba.se.impl.orbutil.ORBUtility;
public class MaxStreamFormatVersionServiceContext extends ServiceContext {
private byte maxStreamFormatVersion;
// The singleton uses the maximum version indicated by our
// ValueHandler.
public static final MaxStreamFormatVersionServiceContext singleton
= new MaxStreamFormatVersionServiceContext();
public MaxStreamFormatVersionServiceContext() {
maxStreamFormatVersion = ORBUtility.getMaxStreamFormatVersion();
}
public MaxStreamFormatVersionServiceContext(byte maxStreamFormatVersion) {
this.maxStreamFormatVersion = maxStreamFormatVersion;
}
public MaxStreamFormatVersionServiceContext(InputStream is,
GIOPVersion gv) {
super(is, gv) ;
maxStreamFormatVersion = is.read_octet();
}
public static final int SERVICE_CONTEXT_ID = RMICustomMaxStreamFormat.value;
public int getId() { return SERVICE_CONTEXT_ID; }
public void writeData(OutputStream os) throws SystemException
{
os.write_octet(maxStreamFormatVersion);
}
public byte getMaximumStreamFormatVersion()
{
return maxStreamFormatVersion;
}
public String toString()
{
return "MaxStreamFormatVersionServiceContext["
+ maxStreamFormatVersion + "]";
}
}
| 743 |
352 | <filename>src/tiny_core/defer.cc
/*
*Author:GeneralSandman
*Code:https://github.com/GeneralSandman/TinyWeb
*E-mail:<EMAIL>
*Web:www.generalsandman.cn
*/
/*---XXX---
*
****************************************
*
*/
#include <tiny_core/defer.h>
#include <tiny_base/exception.h>
void defaultFun()
{
}
void defauleFunExce(Exception &e)
{
}
void Defer::m_fRunCallBacks()
{
while (!m_nChains.empty())
{
Chain tmp = m_nChains.front();
m_nChains.pop_front();
callBack c = tmp.first;
errorBack e = tmp.second;
if (m_nNextChain)
{
try
{
c();
}
catch (Exception &e)
{
m_nPreException = e;
m_nNextChain = false;
}
catch (...)
{
m_nNextChain = false;
}
}
else
{
try
{
e(m_nPreException);
//If no exception,set m_nNextChain as true;
m_nNextChain = true;
}
catch (Exception &e)
{
m_nPreException = e;
m_nNextChain = false;
}
catch (...)
{
m_nNextChain = false;
}
}
}
}
Defer::Defer()
: m_nNextChain(true),
m_nPreException("noException"),
m_nIsCalling(false),
m_nCalled(false)
{
LOG(Debug) << "class Defer constructor\n";
}
void Defer::addCallBack(callBack c)
{
addCallBacks(c, defauleFunExce);
}
void Defer::addErrorBack(errorBack e)
{
addCallBacks(defaultFun, e);
}
void Defer::addCallBacks(callBack c, errorBack e)
{
m_nChains.push_back(Chain(c, e));
}
void Defer::callback()
{
if (m_nIsCalling || m_nCalled)
return;
m_nNextChain = true;
m_nIsCalling = true;
m_nCalled = true;
m_fRunCallBacks();
m_nIsCalling = false;
}
void Defer::errorback(Exception &exc)
{
if (m_nIsCalling || m_nCalled)
return;
m_nNextChain = false;
m_nPreException = exc;
m_nIsCalling = true;
m_nCalled = true;
m_fRunCallBacks();
m_nIsCalling = false;
}
Defer::~Defer()
{
LOG(Debug) << "class Defer constructor\n";
} | 1,236 |
348 | <reponame>chamberone/Leaflet.PixiOverlay
{"nom":"Sanxay","circ":"3ème circonscription","dpt":"Vienne","inscrits":459,"abs":239,"votants":220,"blancs":20,"nuls":6,"exp":194,"res":[{"nuance":"REM","nom":"<NAME>","voix":135},{"nuance":"FN","nom":"<NAME>","voix":59}]} | 107 |
348 | {"nom":"Lamotte-Brebière","circ":"4ème circonscription","dpt":"Somme","inscrits":193,"abs":107,"votants":86,"blancs":11,"nuls":2,"exp":73,"res":[{"nuance":"REM","nom":"<NAME>","voix":44},{"nuance":"FN","nom":"<NAME>","voix":29}]} | 93 |
6,036 | <reponame>dennyac/onnxruntime
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
#include "intrin_gemv_ll_ir.h"
#include "core/providers/nuphar/compiler/x86/scheduler/tensorize/tensorize_utilities.h"
#include <tvm/buffer.h>
#include <tvm/codegen.h>
#include <tvm/ir.h>
namespace onnxruntime {
namespace nuphar {
const int32_t dim0 = 1;
const int32_t dim1 = 8;
NaiveLLVMIRGemvTensorization::NaiveLLVMIRGemvTensorization(const std::string& name)
: TensorizeBase(name, "NaiveLLVMIRGemvTensorization_Parameter", {dim0, dim1}) {}
tvm::TensorIntrin NaiveLLVMIRGemvTensorization::CreateTensorIntrin() {
tvm::Expr m(dim0);
tvm::Expr l(dim1);
auto a = tvm::placeholder({l});
auto b = tvm::placeholder({m, l});
auto k = tvm::reduce_axis({0, l});
auto c = tvm::compute({m}, [&](tvm::Var i) {
return tvm::sum(a(k) * b(i, k), {k});
});
auto a_buf = tvm::BufferNode::make(
tvm::Var("a", tvm::Handle()),
a->dtype,
a->shape,
/*strides*/ {1},
tvm::Var("a_offset"),
"a",
"",
0,
/*offset_factor*/ 1);
auto b_buf = tvm::BufferNode::make(
tvm::Var("b", tvm::Handle()),
b->dtype,
b->shape,
/*strides*/ {tvm::Var("s1"), 1},
tvm::Var("b_offset"),
"b",
"",
0,
/*offset_factor*/ 1);
auto c_buf = tvm::BufferNode::make(
tvm::Var("c", tvm::Handle()),
c->dtype,
c->shape,
/*strides*/ {1},
tvm::Var("c_offset"),
"c",
"",
0,
/*offset_factor*/ 1);
auto a_float32x8 = a_buf.vload({0}, HalideIR::Float(32, 8));
auto b_float32x8 = b_buf.vload({0, 0}, HalideIR::Float(32, 8));
auto z_float32x8 = tvm::make_const(HalideIR::Float(32, 8), 0);
auto axb = tvm_codegen::LLVMIntrinsic(HalideIR::Float(32, 8),
"llvm.x86.fma.vfmadd.ps.256",
{a_float32x8,
b_float32x8,
z_float32x8});
auto sum = tvm_codegen::ExtractElement(axb, 0);
for (int i = 1; i < 8; ++i) {
auto z0 = tvm_codegen::ExtractElement(axb, i);
sum += z0;
}
auto body = c_buf.vstore({0}, sum);
auto reset = c_buf.vstore({0}, tvm::make_const(HalideIR::Float(32, 1), 0));
auto update = c_buf.vstore({0}, sum + c_buf.vload({0}, HalideIR::Float(32, 1)));
return tvm::TensorIntrinNode::make(
"intrin_gemv_ll_ir",
c->op,
{a, b},
{a_buf, b_buf, c_buf},
body,
reset,
update);
}
} // namespace nuphar
} // namespace onnxruntime
| 1,338 |
4,036 | <reponame>vadi2/codeql<gh_stars>1000+
def print_annotation(message, line, offset, length):
print("Message: " + message)
print("Line: " + line)
print("Offset: " + offset)
print("Length: " + length) | 81 |
449 | int trilinear_forward_cuda(THCudaTensor * lut, THCudaTensor * image, THCudaTensor * output,
int lut_dim, int shift, float binsize, int width, int height, int batch);
int trilinear_backward_cuda(THCudaTensor * image, THCudaTensor * image_grad, THCudaTensor * lut_grad,
int lut_dim, int shift, float binsize, int width, int height, int batch);
| 175 |
521 | #ifndef ELLE_CRYPTOGRAPHY_HASH_HH
# define ELLE_CRYPTOGRAPHY_HASH_HH
# include <elle/cryptography/fwd.hh>
# include <elle/cryptography/Oneway.hh>
# include <iosfwd>
namespace elle
{
namespace cryptography
{
/*----------.
| Functions |
`----------*/
/// Hash a plain text and return a digest message.
elle::Buffer
hash(elle::ConstWeakBuffer const& plain,
Oneway const oneway);
/// Hash blocks of data (last block empty) and return a digest message.
elle::Buffer
hash(std::function<elle::ConstWeakBuffer (void)> next_block,
Oneway const oneway);
/// Hash an input stream and return a digest message.
elle::Buffer
hash(std::istream& plain,
Oneway const oneway);
}
}
#endif
| 289 |
416 | <reponame>spring-operator/spring-roo
package org.springframework.roo.shell;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
/**
* Provides an implementation for {@link ShellContext}
*
* @author <NAME>
* @since 2.0
*/
public class ShellContextImpl implements ShellContext {
private boolean force;
private String profile;
private String executedCommand;
private Map<String, String> parameters;
public ShellContextImpl() {
this.force = false;
this.profile = "";
this.executedCommand = "";
this.parameters = new HashMap<String, String>();
}
@Override
public boolean isForce() {
return this.force;
}
@Override
public String getProfile() {
return this.profile;
}
@Override
public String getExecutedCommand() {
return this.executedCommand;
}
@Override
public Map<String, String> getParameters() {
return this.parameters;
}
/**
* Set value of current executed command
*
* @param command
*/
public void setExecutedCommand(String command) {
this.executedCommand = command;
}
/**
* Set a list of parameters like defined parameters on Spring Roo Shell
*
* @param parameters
*/
public void setParameters(Map<String, String> parameters) {
for (Entry<String, String> param : parameters.entrySet()) {
setParameter(param.getKey(), param.getValue());
}
}
/**
* Add new parameter on current parameters map.
*
* @param key
* @param value
*/
public void setParameter(String key, String value) {
// Check --force global parameter
if ("force".equals(key)) {
if (("".equals(value) || "true".equals(value))) {
this.force = true;
this.parameters.put(key, "true");
return;
} else {
this.force = false;
this.parameters.put(key, "false");
return;
}
}
// Check --profile global parameter
if ("profile".equals(key)) {
this.profile = value;
}
this.parameters.put(key, value);
}
}
| 721 |
852 | import FWCore.ParameterSet.Config as cms
XMLIdealGeometryESSource = cms.ESSource("XMLIdealGeometryESSource",
geomXMLFiles = cms.vstring('Geometry/CMSCommonData/data/materials.xml',
'Geometry/TrackerCommonData/data/trackermaterial.xml',
'Geometry/TrackerCommonData/data/tecmaterial.xml',
'Geometry/TrackerCommonData/data/trackerbulkhead.xml',
'Geometry/TrackerCommonData/data/trackerother.xml',
'Geometry/TrackerCommonData/data/tracker.xml',
'Geometry/CMSCommonData/data/normal/cmsextent.xml',
'Geometry/TrackerCommonData/data/cms.xml'),
rootNodeName = cms.string('cms:CMSE')
)
| 268 |
342 | <reponame>ShivamPytho/parsifal<filename>parsifal/settings/tests.py
# flake8: noqa
from .base import *
PASSWORD_HASHERS = ["django.contrib.auth.hashers.MD5PasswordHasher"]
GOOGLE_RECAPTCHA_ENABLED = False
| 90 |
575 | <filename>weblayer/browser/java/org/chromium/weblayer_private/interfaces/BrowserFragmentArgs.java
// Copyright 2019 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
package org.chromium.weblayer_private.interfaces;
/** Keys for the Bundle of arguments with which BrowserFragments are created. */
public interface BrowserFragmentArgs {
String PROFILE_NAME = "profile_name";
String PERSISTENCE_ID = "persistence_id";
/**
* A boolean value indicating whether the profile is incognito.
*/
String IS_INCOGNITO = "is_incognito";
}
| 200 |
852 |
#include "FWCore/PluginManager/interface/ProblemTracker.h"
#include "FWCore/ServiceRegistry/test/stubs/DummyServiceE0.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/ServiceRegistry/interface/ServicesManager.h"
#include "FWCore/ServiceRegistry/interface/ActivityRegistry.h"
#include "FWCore/ServiceRegistry/interface/ServiceWrapper.h"
#include "FWCore/Utilities/interface/Exception.h"
#include "FWCore/ServiceRegistry/interface/ServiceToken.h"
#include <cstdlib>
#include <vector>
#include <memory>
#include <iostream>
class TestServicesManagerOrder {
public:
static edm::ServiceToken makeToken(std::shared_ptr<edm::serviceregistry::ServicesManager> iManager) {
return edm::ServiceToken(iManager);
}
};
int main() try {
using namespace edm::serviceregistry;
// We must initialize the plug-in manager first
edm::AssertHandler ah;
// These services check the order their constructor, postBeginJob,
// postEndJob, and destructor are called and if they are not
// called in the correct order they will abort
typedef testserviceregistry::DummyServiceE0 Service0;
typedef testserviceregistry::DummyServiceA1 Service1;
typedef testserviceregistry::DummyServiceD2 Service2;
typedef testserviceregistry::DummyServiceB3 Service3;
typedef testserviceregistry::DummyServiceC4 Service4;
// Build the services in a manner similar to the way the are constructed
// in a cmsRun job. Build one service directly, then three based
// on parameter sets, then another one directly. ServiceB3
// includes an explicit dependence on ServiceD2 so build on
// demand is also tested.
std::vector<edm::ParameterSet> vps;
auto legacy = std::make_shared<ServicesManager>(vps);
edm::ActivityRegistry ar;
edm::ParameterSet pset;
legacy->put(std::make_shared<ServiceWrapper<Service0>>(std::make_unique<Service0>(pset, ar)));
legacy->copySlotsFrom(ar);
edm::ServiceToken legacyToken = TestServicesManagerOrder::makeToken(legacy);
std::vector<edm::ParameterSet> vps1;
edm::ParameterSet ps1;
std::string typeName1("DummyServiceA1");
ps1.addParameter("@service_type", typeName1);
vps1.push_back(ps1);
// The next two are intentionally swapped to test build
// on demand feature. DummyServiceB3 depends on DummyServiceD2
// so they should end up getting built in the reverse of the
// order specified here.
edm::ParameterSet ps3;
std::string typeName3("DummyServiceB3");
ps3.addParameter("@service_type", typeName3);
vps1.push_back(ps3);
edm::ParameterSet ps2;
std::string typeName2("DummyServiceD2");
ps2.addParameter("@service_type", typeName2);
vps1.push_back(ps2);
auto legacy2 = std::make_shared<ServicesManager>(legacyToken, kTokenOverrides, vps1);
edm::ServiceToken legacyToken2 = TestServicesManagerOrder::makeToken(legacy2);
ServicesManager sm(legacyToken2, kOverlapIsError, vps);
edm::ActivityRegistry ar4;
edm::ParameterSet pset4;
sm.put(std::make_shared<ServiceWrapper<Service4>>(std::make_unique<Service4>(pset4, ar4)));
sm.copySlotsFrom(ar4);
edm::ActivityRegistry actReg;
sm.connectTo(actReg);
actReg.postBeginJobSignal_();
actReg.postEndJobSignal_();
return 0;
} catch (cms::Exception const& e) {
std::cerr << e.explainSelf() << std::endl;
return 1;
} catch (std::exception const& e) {
std::cerr << e.what() << std::endl;
return 1;
}
| 1,101 |
4,653 | <gh_stars>1000+
#include "opencv_modules.h"
#ifdef HAVE_IO
#include "ioConstants.h"
using namespace cv;
void IoConstants::Init(v8::Local<v8::Object> target) {
FF_SET_CV_CONSTANT(target, CAP_PROP_POS_MSEC);
FF_SET_CV_CONSTANT(target, CAP_PROP_POS_FRAMES);
FF_SET_CV_CONSTANT(target, CAP_PROP_POS_AVI_RATIO);
FF_SET_CV_CONSTANT(target, CAP_PROP_FRAME_WIDTH);
FF_SET_CV_CONSTANT(target, CAP_PROP_FRAME_HEIGHT);
FF_SET_CV_CONSTANT(target, CAP_PROP_FPS);
FF_SET_CV_CONSTANT(target, CAP_PROP_FOURCC);
FF_SET_CV_CONSTANT(target, CAP_PROP_FRAME_COUNT);
FF_SET_CV_CONSTANT(target, CAP_PROP_FORMAT);
FF_SET_CV_CONSTANT(target, CAP_PROP_MODE);
FF_SET_CV_CONSTANT(target, CAP_PROP_BRIGHTNESS);
FF_SET_CV_CONSTANT(target, CAP_PROP_CONTRAST);
FF_SET_CV_CONSTANT(target, CAP_PROP_SATURATION);
FF_SET_CV_CONSTANT(target, CAP_PROP_HUE);
FF_SET_CV_CONSTANT(target, CAP_PROP_GAIN);
FF_SET_CV_CONSTANT(target, CAP_PROP_EXPOSURE);
FF_SET_CV_CONSTANT(target, CAP_PROP_CONVERT_RGB);
FF_SET_CV_CONSTANT(target, CAP_PROP_WHITE_BALANCE_BLUE_U);
FF_SET_CV_CONSTANT(target, CAP_PROP_RECTIFICATION);
FF_SET_CV_CONSTANT(target, CAP_PROP_MONOCHROME);
FF_SET_CV_CONSTANT(target, CAP_PROP_SHARPNESS);
FF_SET_CV_CONSTANT(target, CAP_PROP_AUTO_EXPOSURE);
FF_SET_CV_CONSTANT(target, CAP_PROP_GAMMA);
FF_SET_CV_CONSTANT(target, CAP_PROP_TEMPERATURE);
FF_SET_CV_CONSTANT(target, CAP_PROP_TRIGGER);
FF_SET_CV_CONSTANT(target, CAP_PROP_TRIGGER_DELAY);
FF_SET_CV_CONSTANT(target, CAP_PROP_WHITE_BALANCE_RED_V);
FF_SET_CV_CONSTANT(target, CAP_PROP_ZOOM);
FF_SET_CV_CONSTANT(target, CAP_PROP_FOCUS);
FF_SET_CV_CONSTANT(target, CAP_PROP_GUID);
FF_SET_CV_CONSTANT(target, CAP_PROP_ISO_SPEED);
FF_SET_CV_CONSTANT(target, CAP_PROP_BACKLIGHT);
FF_SET_CV_CONSTANT(target, CAP_PROP_PAN);
FF_SET_CV_CONSTANT(target, CAP_PROP_TILT);
FF_SET_CV_CONSTANT(target, CAP_PROP_ROLL);
FF_SET_CV_CONSTANT(target, CAP_PROP_IRIS);
FF_SET_CV_CONSTANT(target, CAP_PROP_SETTINGS);
#if CV_VERSION_GREATER_EQUAL(3, 1, 0)
FF_SET_CV_CONSTANT(target, CAP_PROP_BUFFERSIZE);
FF_SET_CV_CONSTANT(target, CAP_PROP_AUTOFOCUS);
#endif
#if CV_VERSION_LOWER_THAN(4, 0, 0)
FF_SET_CV_CONSTANT(target, CAP_MODE_BGR);
FF_SET_CV_CONSTANT(target, CAP_MODE_RGB);
FF_SET_CV_CONSTANT(target, CAP_MODE_GRAY);
FF_SET_CV_CONSTANT(target, CAP_MODE_YUYV);
#endif
FF_SET_CV_CONSTANT(target, CAP_ANY);
FF_SET_CV_CONSTANT(target, CAP_VFW);
FF_SET_CV_CONSTANT(target, CAP_V4L);
FF_SET_CV_CONSTANT(target, CAP_V4L2);
FF_SET_CV_CONSTANT(target, CAP_FIREWIRE);
FF_SET_CV_CONSTANT(target, CAP_IEEE1394);
FF_SET_CV_CONSTANT(target, CAP_DC1394);
FF_SET_CV_CONSTANT(target, CAP_CMU1394);
FF_SET_CV_CONSTANT(target, CAP_QT);
FF_SET_CV_CONSTANT(target, CAP_UNICAP);
FF_SET_CV_CONSTANT(target, CAP_DSHOW);
FF_SET_CV_CONSTANT(target, CAP_PVAPI);
FF_SET_CV_CONSTANT(target, CAP_OPENNI);
FF_SET_CV_CONSTANT(target, CAP_OPENNI_ASUS);
FF_SET_CV_CONSTANT(target, CAP_ANDROID);
FF_SET_CV_CONSTANT(target, CAP_XIAPI);
FF_SET_CV_CONSTANT(target, CAP_AVFOUNDATION);
FF_SET_CV_CONSTANT(target, CAP_GIGANETIX);
FF_SET_CV_CONSTANT(target, CAP_MSMF);
FF_SET_CV_CONSTANT(target, CAP_WINRT);
FF_SET_CV_CONSTANT(target, CAP_INTELPERC);
FF_SET_CV_CONSTANT(target, CAP_OPENNI2);
FF_SET_CV_CONSTANT(target, CAP_OPENNI2_ASUS);
FF_SET_CV_CONSTANT(target, CAP_GPHOTO2);
#if CV_VERSION_GREATER_EQUAL(3, 1, 0)
FF_SET_CV_CONSTANT(target, CAP_GSTREAMER);
FF_SET_CV_CONSTANT(target, CAP_FFMPEG);
FF_SET_CV_CONSTANT(target, CAP_IMAGES);
#endif
#if CV_VERSION_GREATER_EQUAL(3, 2, 0)
FF_SET_CV_CONSTANT(target, CAP_ARAVIS);
#endif
FF_SET_CV_CONSTANT(target, VIDEOWRITER_PROP_QUALITY);
FF_SET_CV_CONSTANT(target, VIDEOWRITER_PROP_FRAMEBYTES);
#if CV_VERSION_GREATER_EQUAL(3, 1, 0)
FF_SET_CV_CONSTANT(target, VIDEOWRITER_PROP_NSTRIPES);
#endif
}
#endif
| 1,858 |
1,266 | <gh_stars>1000+
#!/usr/bin/env python3
class SlackBot():
def __init__(self, clientClass, token, channels):
self.client = clientClass(token=token)
self.channels = channels
def postMessage(self, channelIn, message):
channel = None
if channelIn and channelIn[0] == 'U':
channel = channelIn
if channelIn in self.channels:
channel = self.channels[channelIn]
if not channel:
raise AssertionError(
"Invalid channel: Channel must be a user ID or configured with a channel name")
self.client.chat_postMessage(channel=channel, text=message)
def getUsers(self):
# Note: users.list only returns up to 500 users. If this limit is exceeded,
# pagination will need to be implemented.
users = self.client.users_list()
return users['members']
def getUserByName(self, username):
# Note: The Slack API does NOT provide a way to search for users and
# recommends the below approach. This is not ideal, but will suffice
# while we have a low user count in ABC slack.
users = self.getUsers()
for user in users:
if username in [user['profile'][nameAttribute] for nameAttribute in [
'real_name',
'real_name_normalized',
'display_name',
'display_name_normalized',
]]:
return user
return None
def formatMentionByName(self, username):
user = self.getUserByName(username)
if user:
return '<@{}>'.format(user['id'])
return None
| 702 |
960 | <reponame>harri97/google-http-java-client
/*
* Copyright (c) 2012 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
* in compliance with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
* or implied. See the License for the specific language governing permissions and limitations under
* the License.
*/
package com.google.api.client.http;
import java.io.IOException;
import java.io.OutputStream;
/**
* Empty HTTP content of length zero just to force {@link HttpRequest#execute()} to add the header
* {@code Content-Length: 0}.
*
* <p>Note that there is no {@code Content-Length} header if the HTTP request content is {@code
* null} . However, when making a request like PUT or POST without a {@code Content-Length} header,
* some servers may respond with a {@code 411 Length Required} error. Specifying the {@code
* Content-Length: 0} header may work around that problem.
*
* @since 1.11
* @author <NAME>
*/
public class EmptyContent implements HttpContent {
public long getLength() throws IOException {
return 0;
}
public String getType() {
return null;
}
public void writeTo(OutputStream out) throws IOException {
out.flush();
}
public boolean retrySupported() {
return true;
}
}
| 444 |
1,564 | <filename>core/src/main/java/org/modelmapper/internal/util/ArrayIterator.java<gh_stars>1000+
/*
* Copyright 2011 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.modelmapper.internal.util;
import java.lang.reflect.Array;
import java.util.Iterator;
/**
* @author <NAME>
*/
public class ArrayIterator implements Iterator<Object> {
private final Object array;
private final int length;
private int index;
/**
* @throws IllegalArgumentException if {@code array} is not an array
*/
public ArrayIterator(Object array) {
Assert.isTrue(array.getClass().isArray());
this.array = array;
length = Array.getLength(array);
}
public boolean hasNext() {
return index < length;
}
public Object next() {
return Array.get(array, index++);
}
public void remove() {
}
}
| 455 |
672 | <filename>library/src/main/java/com/bytedance/raphael/RaphaelReceiver.java
/*
* Copyright (C) 2021 ByteDance Inc
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.bytedance.raphael;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.text.TextUtils;
import java.io.File;
/**
* adb shell am broadcast -a com.bytedance.raphael.ACTION_START -f 0x01000000 --es configs 0xCF0400 --es regex ".*libXXX\\.so$"
* adb shell am broadcast -a com.bytedance.raphael.ACTION_STOP -f 0x01000000
* adb shell am broadcast -a com.bytedance.raphael.ACTION_PRINT -f 0x01000000
*/
public class RaphaelReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context ctx, Intent intent) {
String action = intent.getAction();
if ("com.bytedance.raphael.ACTION_START".equals(action)) {
Raphael.start(getConfigs(intent.getStringExtra("configs")), getSpace(ctx), intent.getStringExtra("regex"));
} else if ("com.bytedance.raphael.ACTION_STOP".equals(action)) {
Raphael.stop();
} else if ("com.bytedance.raphael.ACTION_PRINT".equals(action)) {
Raphael.print();
}
}
int getConfigs(String params) {
if (TextUtils.isEmpty(params)) {
return Raphael.MAP64_MODE | Raphael.ALLOC_MODE | 0xF0000 | 4096;
}
try {
return Integer.decode(params);
} catch (NumberFormatException e) {
e.printStackTrace();
return Raphael.MAP64_MODE | Raphael.ALLOC_MODE | 0xF0000 | 4096;
}
}
String getSpace(Context ctx) {
File space = ctx.getExternalFilesDir("raphael");
if (!space.exists()) {
space.mkdir();
}
return space.getAbsolutePath();
}
} | 880 |
1,352 | <reponame>empiredan/pegasus
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
#pragma once
#include <rocksdb/statistics.h>
#include "utils.h"
namespace pegasus {
namespace test {
class statistics
{
public:
statistics(std::shared_ptr<rocksdb::Statistics> hist_stats);
void start();
void finished_ops(int64_t num_ops, enum operation_type op_type);
void stop();
void merge(const statistics &other);
void report(operation_type op_type);
void add_bytes(int64_t n);
void add_message(const std::string &msg);
private:
uint32_t report_step(uint64_t current_report) const;
// the start time of benchmark
uint64_t _start;
// the stop time of benchmark
uint64_t _finish;
// how many operations are done
uint64_t _done;
// the point(operation count) at which the next report
uint64_t _next_report;
// how many bytes the benchmark read/write
uint64_t _bytes;
// the last operation's finish time
uint64_t _last_op_finish;
// the information of benchmark operation
std::string _message;
// histogram performance analyzer
std::shared_ptr<rocksdb::Statistics> _hist_stats;
};
} // namespace test
} // namespace pegasus
| 612 |
4,036 | <reponame>vadi2/codeql
class Test {
void f(boolean x, boolean y, Boolean a, Boolean b) {
boolean w;
w = a == false;
w = x != true;
w = a ? false : b;
w = a ? true : false;
w = x ? y : true;
}
void g(int x, int y) {
boolean w;
w = !(x > y);
w = !(x != y);
}
public Boolean getBool(int i) {
if (i > 2)
return i == 3 ? true : null; // ok; expression can't be simplified
return i == 1 ? false : null; // ok; expression can't be simplified
}
public Boolean getBoolNPE(int i) {
if (i > 2)
return i == 3 ? true : ((Boolean)null); // should be reported; both this and the simplified version have equal NPE behavior
return i == 1 ? false : ((Boolean)null); // should be reported; both this and the simplified version have equal NPE behavior
}
}
| 313 |
669 | from abc import ABC, abstractmethod
class PoseInitializer(ABC):
@abstractmethod
def get_pose(self):
return NotImplemented
| 50 |
1,056 | <reponame>arusinha/incubator-netbeans
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.openide.loaders;
import org.openide.nodes.Node;
/**
* This handler is used by DataFolder.FolderNode.setName() method.
* FolderNode.setName() uses Lookup.getDefault() to lookup for instances of
* FolderRenameHandler. If there is one instance found, it's handleRename(...)
* method is called to handle rename request. More than one instance of
* FolderRenameHandler is not allowed.
*
* @since 5.4
* @author <NAME>
*/
public interface FolderRenameHandler {
/**
* @param folder on this folder rename was requested
* @param newName new name of folder
* @throws java.lang.IllegalArgumentException thrown if rename cannot be performed
*/
void handleRename(DataFolder folder, String newName) throws IllegalArgumentException ;
}
| 439 |
5,169 | {
"name": "Addition",
"version": "1.5.0",
"summary": "iOS扩展类集",
"homepage": "https://github.com/CaiChenghan/Addition",
"license": "MIT",
"authors": {
"蔡成汉": "<EMAIL>"
},
"source": {
"git": "https://github.com/CaiChenghan/Addition.git",
"tag": "1.5.0"
},
"platforms": {
"ios": "8.0"
},
"requires_arc": true,
"source_files": "Addition/Addition.h",
"subspecs": [
{
"name": "NSData",
"source_files": "Addition/NSData+Addition.{h,m}"
},
{
"name": "NSDictionary",
"source_files": "Addition/NSDictionary+Addition.{h,m}"
},
{
"name": "NSDictionary",
"source_files": "Addition/NSDictionary+Addition.{h,m}"
},
{
"name": "NSMutableDictionary",
"source_files": "Addition/NSMutableDictionary+Addition.{h,m}"
},
{
"name": "NSArray",
"source_files": "Addition/NSArray+Addition.{h,m}"
},
{
"name": "NSDate",
"source_files": "Addition/NSDate+Addition.{h,m}"
},
{
"name": "NSString",
"source_files": "Addition/NSString+Addition.{h,m}",
"dependencies": {
"Addition/NSData": [
]
}
},
{
"name": "NSObject",
"source_files": "Addition/NSObject+Addition.{h,m}",
"dependencies": {
"Addition/NSString": [
]
}
},
{
"name": "UIColor",
"source_files": "Addition/UIColor+Addition.{h,m}"
},
{
"name": "UIImage",
"source_files": "Addition/UIImage+Addition.{h,m}"
},
{
"name": "UIView",
"source_files": "Addition/UIView+Addition.{h,m}"
},
{
"name": "UIFont",
"source_files": "Addition/UIFont+Addition.{h,m}"
},
{
"name": "UIScrollView",
"source_files": "Addition/UIScrollView+Addition.{h,m}"
}
]
}
| 953 |
4,013 | <reponame>antonblr/checkov<gh_stars>1000+
from checkov.arm.checks import *
| 29 |
414 | <gh_stars>100-1000
//
// RCDChatConfig.h
// SealTalk
//
// Created by hrx on 2019/7/9.
// Copyright © 2019 RongCloud. All rights reserved.
//
#import <RongIMLib/RongIMLib.h>
#import "RCDGroupInfo.h"
NS_ASSUME_NONNULL_BEGIN
@interface RCDChatConfig : RCConversation <NSCoding>
@property (nonatomic, assign) BOOL screenCaptureNotification;
@property (nonatomic, assign) RCDGroupMessageClearStatus messageClearStatus;
+ (instancetype)chatConfigWithConversationType:(RCConversationType)conversationType
targetId:(NSString *)targetId
screenCaptureNotification:(BOOL)screenCaptureNotification;
+ (instancetype)chatConfigWithConversationType:(RCConversationType)conversationType
targetId:(NSString *)targetId
screenCaptureNotification:(BOOL)screenCaptureNotification
messageClearStatus:(RCDGroupMessageClearStatus)clearStatus;
@end
NS_ASSUME_NONNULL_END
| 422 |
713 | <filename>documentation/src/main/asciidoc/topics/code_examples/QuickstartDefaultCache.java
// Add a entry
cache.put("key", "value");
// Validate the entry is now in the cache
assertEqual(1, cache.size());
assertTrue(cache.containsKey("key"));
// Remove the entry from the cache
Object v = cache.remove("key");
// Validate the entry is no longer in the cache
assertEqual("value", v);
| 119 |
713 | # Definition for a binary tree node.
# class TreeNode(object):
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
from collections import deque
class Solution(object):
def isCompleteTree(self, root):
"""
:type root: TreeNode
:rtype: bool
"""
bfsLevelOrder = [root]
currentIdx = 0
while bfsLevelOrder[currentIdx]:
currentNode = bfsLevelOrder[currentIdx]
bfsLevelOrder.append(currentNode.left)
bfsLevelOrder.append(currentNode.right)
currentIdx += 1
return not any(bfsLevelOrder[currentIdx:])
| 317 |
11,356 | <filename>thirdparty/libjson/_internal/TestSuite2/JSONDebug/JSON_FAIL.cpp
#include "JSON_FAIL.h"
#include "../../Source/JSONDebug.h"
#if defined JSON_DEBUG
#ifndef JSON_STDERROR
static json_string last;
#ifdef JSON_LIBRARY
static void callback(const json_char * p){ last = p; }
#else
static void callback(const json_string & p){ last = p; }
#endif
#endif
#endif
const json_string fail_constf = JSON_TEXT("fail"); //should pass the same pointer all the way through, no copies
const json_string null_constf = JSON_TEXT("");
#if defined JSON_DEBUG || defined JSON_SAFE
json_error_callback_t origCallbackf = NULL;
#endif
void testJSONDebug_JSON_FAIL::setUp(const std::string & methodName){
BaseTest::setUp(methodName);
#if defined JSON_DEBUG
#ifndef JSON_STDERROR
origCallbackf = JSONDebug::register_callback(callback); //check that the callback was called
last = null_constf;
#endif
#endif
}
void testJSONDebug_JSON_FAIL::tearDown(void){
BaseTest::tearDown();
#if defined JSON_DEBUG
#ifndef JSON_STDERROR
JSONDebug::register_callback(origCallbackf); //check that the callback was called
#endif
#endif
}
/**
* Make sure fails do call the callback
*/
void testJSONDebug_JSON_FAIL::testFail(void){
#if defined JSON_DEBUG
#ifndef JSON_STDERROR
JSON_FAIL(fail_constf);
assertEquals(last, fail_constf); //make sure the callback was actually called
#endif
#endif
}
| 505 |
2,338 | //===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03
// <utility>
// template <class T1, class T2> struct pair
// template<class U, class V> pair& operator=(pair<U, V>&& p);
#include <utility>
#include <memory>
#include <cassert>
#include "test_macros.h"
#include "archetypes.h"
struct Derived : ConstexprTestTypes::MoveOnly {
Derived() = default;
TEST_CONSTEXPR_CXX20 Derived(ConstexprTestTypes::MoveOnly&&){};
};
struct CountAssign {
int copied = 0;
int moved = 0;
TEST_CONSTEXPR_CXX20 CountAssign() = default;
TEST_CONSTEXPR_CXX20 CountAssign(const int){};
TEST_CONSTEXPR_CXX20 CountAssign& operator=(CountAssign const&) {
++copied;
return *this;
}
TEST_CONSTEXPR_CXX20 CountAssign& operator=(CountAssign&&) {
++moved;
return *this;
}
};
struct CopyAssignableInt {
CopyAssignableInt& operator=(int&) { return *this; }
};
struct NotAssignable {
NotAssignable& operator=(NotAssignable const&) = delete;
NotAssignable& operator=(NotAssignable&&) = delete;
};
struct MoveAssignable {
MoveAssignable& operator=(MoveAssignable const&) = delete;
MoveAssignable& operator=(MoveAssignable&&) = default;
};
struct CopyAssignable {
CopyAssignable& operator=(CopyAssignable const&) = default;
CopyAssignable& operator=(CopyAssignable&&) = delete;
};
TEST_CONSTEXPR_CXX20 bool test() {
{
typedef std::pair<Derived, short> P1;
typedef std::pair<ConstexprTestTypes::MoveOnly, long> P2;
P1 p1(Derived(), static_cast<short>(4));
P2 p2;
p2 = std::move(p1);
assert(p2.second == 4);
}
{
using P = std::pair<int, CountAssign>;
using T = std::pair<long, CountAssign>;
T t(42, -42);
P p(101, 101);
p = std::move(t);
assert(p.first == 42);
assert(p.second.moved == 1);
assert(p.second.copied == 0);
assert(t.second.moved == 0);
assert(t.second.copied == 0);
}
{ // test const requirement
using T = std::pair<CopyAssignableInt, CopyAssignableInt>;
using P = std::pair<int, int>;
static_assert(!std::is_assignable<T&, P&&>::value, "");
static_assert(!std::is_assignable<P&, T&&>::value, "");
}
{
// Make sure we can't move-assign from a pair containing a reference
// if that type isn't copy-constructible (since otherwise we'd be
// stealing the object through the reference).
using P1 = std::pair<MoveAssignable, long>;
using P2 = std::pair<MoveAssignable&, int>;
static_assert(!std::is_assignable<P1&, P2&&>::value, "");
// ... but this should work since we're going to steal out of the
// incoming rvalue reference.
using P3 = std::pair<MoveAssignable, long>;
using P4 = std::pair<MoveAssignable&&, int>;
static_assert(std::is_assignable<P3&, P4&&>::value, "");
}
{
// We assign through the reference and don't move out of the incoming ref,
// so this doesn't work (but would if the type were CopyAssignable).
{
using P1 = std::pair<MoveAssignable&, long>;
using P2 = std::pair<MoveAssignable&, int>;
static_assert(!std::is_assignable<P1&, P2&&>::value, "");
}
// ... works if it's CopyAssignable
{
using P1 = std::pair<CopyAssignable&, long>;
using P2 = std::pair<CopyAssignable&, int>;
static_assert(std::is_assignable<P1&, P2&&>::value, "");
}
// For rvalue-references, we can move-assign if the type is MoveAssignable,
// or CopyAssignable (since in the worst case the move will decay into a copy).
{
using P1 = std::pair<MoveAssignable&&, long>;
using P2 = std::pair<MoveAssignable&&, int>;
static_assert(std::is_assignable<P1&, P2&&>::value, "");
using P3 = std::pair<CopyAssignable&&, long>;
using P4 = std::pair<CopyAssignable&&, int>;
static_assert(std::is_assignable<P3&, P4&&>::value, "");
}
// In all cases, we can't move-assign if the types are not assignable,
// since we assign through the reference.
{
using P1 = std::pair<NotAssignable&, long>;
using P2 = std::pair<NotAssignable&, int>;
static_assert(!std::is_assignable<P1&, P2&&>::value, "");
using P3 = std::pair<NotAssignable&&, long>;
using P4 = std::pair<NotAssignable&&, int>;
static_assert(!std::is_assignable<P3&, P4&&>::value, "");
}
}
return true;
}
int main(int, char**) {
test();
#if TEST_STD_VER >= 20
static_assert(test());
#endif
return 0;
}
| 1,856 |
679 | /**************************************************************
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*************************************************************/
#ifndef DIALOG_HXX
#define DIALOG_HXX
#include <vcl/image.hxx>
#include <vcl/dialog.hxx>
#include <vcl/fixed.hxx>
#include <vcl/button.hxx>
#include <vcl/image.hxx>
#include <sfx2/tabdlg.hxx>
#include <vcl/combobox.hxx>
#include <svx/charmap.hxx>
#include <sfx2/basedlgs.hxx>
#include <vcl/field.hxx>
#include <vcl/menubtn.hxx>
#include <vcl/scrbar.hxx>
#include <vcl/ctrl.hxx>
#include <vcl/menu.hxx>
#include <vcl/outdev.hxx>
#include <svtools/ctrlbox.hxx>
#include <svtools/ctrltool.hxx>
#include "utility.hxx"
#include "format.hxx"
#include "symbol.hxx"
class SubsetMap;
#define CATEGORY_NONE 0xFFFF
/**************************************************************************/
const XubString GetFontStyleName(const Font &rFont);
void SetFontStyle(const XubString &rStyleName, Font &rFont);
/**************************************************************************/
class SmPrintOptionsTabPage : public SfxTabPage
{
FixedLine aFixedLine1;
CheckBox aTitle;
CheckBox aText;
CheckBox aFrame;
FixedLine aFixedLine2;
RadioButton aSizeNormal;
RadioButton aSizeScaled;
RadioButton aSizeZoomed;
MetricField aZoom;
FixedLine aFixedLine3;
CheckBox aNoRightSpaces;
CheckBox aSaveOnlyUsedSymbols;
DECL_LINK(SizeButtonClickHdl, Button *);
virtual sal_Bool FillItemSet(SfxItemSet& rSet);
virtual void Reset(const SfxItemSet& rSet);
public:
static SfxTabPage* Create(Window *pWindow, const SfxItemSet &rSet);
SmPrintOptionsTabPage(Window *pParent, const SfxItemSet &rOptions);
};
/**************************************************************************/
class SmShowFont : public Control
{
virtual void Paint(const Rectangle&);
public:
SmShowFont(Window *pParent, const ResId& rResId) :
Control(pParent, rResId)
{
}
void SetFont(const Font& rFont);
};
class SmFontDialog : public ModalDialog
{
FixedText aFixedText1;
ComboBox aFontBox;
CheckBox aBoldCheckBox;
CheckBox aItalicCheckBox;
OKButton aOKButton1;
CancelButton aCancelButton1;
SmShowFont aShowFont;
FixedText aFixedText2;
Font Face;
DECL_LINK(FontSelectHdl, ComboBox *);
DECL_LINK(FontModifyHdl, ComboBox *);
DECL_LINK(AttrChangeHdl, CheckBox *);
void InitColor_Impl();
virtual void DataChanged( const DataChangedEvent& rDCEvt );
public:
SmFontDialog(Window * pParent, OutputDevice *pFntListDevice, sal_Bool bHideCheckboxes, sal_Bool bFreeRes = sal_True);
const Font& GetFont() const { return Face; }
void SetFont(const Font &rFont);
};
/**************************************************************************/
class SmFontSizeDialog : public ModalDialog
{
FixedText aFixedText1;
MetricField aBaseSize;
FixedText aFixedText4;
MetricField aTextSize;
FixedText aFixedText5;
MetricField aIndexSize;
FixedText aFixedText6;
MetricField aFunctionSize;
FixedText aFixedText7;
MetricField aOperatorSize;
FixedText aFixedText8;
MetricField aBorderSize;
FixedLine aFixedLine1;
OKButton aOKButton1;
CancelButton aCancelButton1;
PushButton aDefaultButton;
DECL_LINK(DefaultButtonClickHdl, Button *);
public:
SmFontSizeDialog(Window *pParent, sal_Bool bFreeRes = sal_True);
void ReadFrom(const SmFormat &rFormat);
void WriteTo (SmFormat &rFormat) const;
};
/**************************************************************************/
class SmFontTypeDialog : public ModalDialog
{
FixedText aFixedText1;
SmFontPickListBox aVariableFont;
FixedText aFixedText2;
SmFontPickListBox aFunctionFont;
FixedText aFixedText3;
SmFontPickListBox aNumberFont;
FixedText aFixedText4;
SmFontPickListBox aTextFont;
FixedText aFixedText5;
SmFontPickListBox aSerifFont;
FixedText aFixedText6;
SmFontPickListBox aSansFont;
FixedText aFixedText7;
SmFontPickListBox aFixedFont;
FixedLine aFixedLine1;
FixedLine aFixedLine2;
OKButton aOKButton1;
CancelButton aCancelButton1;
MenuButton aMenuButton;
PushButton aDefaultButton;
OutputDevice *pFontListDev;
DECL_LINK(MenuSelectHdl, Menu *);
DECL_LINK(DefaultButtonClickHdl, Button *);
public:
SmFontTypeDialog(Window *pParent, OutputDevice *pFntListDevice, sal_Bool bFreeRes = sal_True);
void ReadFrom(const SmFormat &rFormat);
void WriteTo (SmFormat &rFormat) const;
};
/**************************************************************************/
#define NOCATEGORIES 10
class SmCategoryDesc : public Resource
{
XubString Name;
XubString *Strings[4];
Bitmap *Graphics[4]; /* regular bitmaps */
Bitmap *GraphicsH[4]; /* high contrast bitmaps */
sal_uInt16 Minimum[4];
sal_uInt16 Maximum[4];
sal_uInt16 Value[4];
sal_Bool bIsHighContrast;
public:
SmCategoryDesc(const ResId &rResId, sal_uInt16 nCategoryIdx);
~SmCategoryDesc();
const XubString & GetName() const { return Name; }
const XubString * GetString(sal_uInt16 Index) const { return Strings[Index]; }
sal_uInt16 GetMinimum(sal_uInt16 Index) { return Minimum[Index]; }
sal_uInt16 GetMaximum(sal_uInt16 Index) { return Maximum[Index]; }
sal_uInt16 GetValue(sal_uInt16 Index) const { return Value[Index]; }
void SetValue(sal_uInt16 Index, sal_uInt16 nVal) { Value[Index] = nVal;}
void SetHighContrast( sal_Bool bVal ) { bIsHighContrast = bVal; }
const Bitmap * GetGraphic(sal_uInt16 Index) const
{
return bIsHighContrast ? GraphicsH[Index] : Graphics[Index];
}
};
class SmDistanceDialog : public ModalDialog
{
FixedText aFixedText1;
MetricField aMetricField1;
FixedText aFixedText2;
MetricField aMetricField2;
FixedText aFixedText3;
MetricField aMetricField3;
CheckBox aCheckBox1;
FixedText aFixedText4;
MetricField aMetricField4;
OKButton aOKButton1;
CancelButton aCancelButton1;
MenuButton aMenuButton;
PushButton aDefaultButton;
FixedBitmap aBitmap;
FixedLine aFixedLine;
SmCategoryDesc *Categories[NOCATEGORIES];
sal_uInt16 nActiveCategory;
sal_Bool bScaleAllBrackets;
DECL_LINK(GetFocusHdl, Control *);
DECL_LINK(MenuSelectHdl, Menu *);
DECL_LINK(DefaultButtonClickHdl, Button *);
DECL_LINK(CheckBoxClickHdl, CheckBox *);
using Window::SetHelpId;
void SetHelpId(MetricField &rField, const rtl::OString& sHelpId);
void SetCategory(sal_uInt16 Category);
void ApplyImages();
public:
SmDistanceDialog(Window *pParent, sal_Bool bFreeRes = sal_True);
~SmDistanceDialog();
void ReadFrom(const SmFormat &rFormat);
void WriteTo (SmFormat &rFormat) /*const*/;
// Window
virtual void DataChanged( const DataChangedEvent &rEvt );
};
/**************************************************************************/
class SmAlignDialog : public ModalDialog
{
RadioButton aLeft;
RadioButton aCenter;
RadioButton aRight;
FixedLine aFixedLine1;
OKButton aOKButton1;
CancelButton aCancelButton1;
PushButton aDefaultButton;
DECL_LINK(DefaultButtonClickHdl, Button *);
public:
SmAlignDialog(Window *pParent, sal_Bool bFreeRes = sal_True);
void ReadFrom(const SmFormat &rFormat);
void WriteTo (SmFormat &rFormat) const;
};
/**************************************************************************/
class SmShowSymbolSet : public Control
{
SymbolPtrVec_t aSymbolSet;
ScrollBar aVScrollBar;
Size aOutputSize;
Link aSelectHdlLink;
Link aDblClickHdlLink;
sal_uInt16 nLen;
sal_uInt16 nRows, nColumns;
sal_uInt16 nSelectSymbol;
virtual void Paint(const Rectangle&);
virtual void MouseButtonDown(const MouseEvent& rMEvt);
virtual void KeyInput(const KeyEvent& rKEvt);
DECL_LINK( ScrollHdl, ScrollBar* );
public:
SmShowSymbolSet(Window *pParent, const ResId& rResId);
void SetSymbolSet(const SymbolPtrVec_t& rSymbolSet);
void SelectSymbol(sal_uInt16 nSymbol);
sal_uInt16 GetSelectSymbol() const { return nSelectSymbol; }
void SetSelectHdl(const Link& rLink) { aSelectHdlLink = rLink; }
void SetDblClickHdl(const Link& rLink) { aDblClickHdlLink = rLink; }
};
////////////////////////////////////////////////////////////////////////////////
class SmShowSymbol : public Control
{
Link aDblClickHdlLink;
virtual void Paint(const Rectangle&);
virtual void MouseButtonDown(const MouseEvent& rMEvt);
public:
SmShowSymbol(Window *pParent, const ResId& rResId) :
Control(pParent, rResId) {}
void SetSymbol(const SmSym *pSymbol);
void SetDblClickHdl(const Link &rLink) { aDblClickHdlLink = rLink; }
};
////////////////////////////////////////////////////////////////////////////////
class SmSymDefineDialog;
class SmSymbolDialog : public ModalDialog
{
FixedText aSymbolSetText;
ListBox aSymbolSets;
SmShowSymbolSet aSymbolSetDisplay;
FixedText aSymbolName;
SmShowSymbol aSymbolDisplay;
PushButton aGetBtn;
PushButton aCloseBtn;
PushButton aEditBtn;
SmViewShell &rViewSh;
SmSymbolManager &rSymbolMgr;
String aSymbolSetName;
SymbolPtrVec_t aSymbolSet;
OutputDevice *pFontListDev;
DECL_LINK(SymbolSetChangeHdl, ListBox *);
DECL_LINK(SymbolChangeHdl, SmShowSymbolSet *);
DECL_LINK(SymbolDblClickHdl, SmShowSymbolSet *);
DECL_LINK(CloseClickHdl, Button *);
DECL_LINK(EditClickHdl, Button *);
DECL_LINK(GetClickHdl, Button *);
void FillSymbolSets(sal_Bool bDeleteText = sal_True);
void SetSymbolSetManager(SmSymbolManager &rMgr);
const SmSym *GetSymbol() const;
void InitColor_Impl();
virtual void DataChanged( const DataChangedEvent& rDCEvt );
public:
SmSymbolDialog(Window * pParent, OutputDevice *pFntListDevice,
SmSymbolManager &rSymbolMgr, SmViewShell &rViewShell, sal_Bool bFreeRes = sal_True);
virtual ~SmSymbolDialog();
sal_Bool SelectSymbolSet(const XubString &rSymbolSetName);
void SelectSymbol(sal_uInt16 nSymbolPos);
sal_uInt16 GetSelectedSymbol() const { return aSymbolSetDisplay.GetSelectSymbol(); }
};
////////////////////////////////////////////////////////////////////////////////
class SmShowChar : public Control
{
virtual void Paint(const Rectangle&);
public:
SmShowChar(Window *pParent, const ResId& rResId)
: Control(pParent, rResId)
{
}
void SetSymbol( const SmSym *pSym );
void SetSymbol( sal_UCS4 cChar, const Font &rFont );
};
////////////////////////////////////////////////////////////////////////////////
class SmSymDefineDialog : public ModalDialog
{
FixedText aOldSymbolText;
ComboBox aOldSymbols;
FixedText aOldSymbolSetText;
ComboBox aOldSymbolSets;
SvxShowCharSet aCharsetDisplay;
FixedText aSymbolText;
ComboBox aSymbols;
FixedText aSymbolSetText;
ComboBox aSymbolSets;
FixedText aFontText;
ListBox aFonts;
FixedText aFontsSubsetFT;
ListBox aFontsSubsetLB;
FixedText aStyleText;
FontStyleBox aStyles;
FixedText aOldSymbolName;
SmShowChar aOldSymbolDisplay;
FixedText aOldSymbolSetName;
FixedText aSymbolName;
SmShowChar aSymbolDisplay;
FixedText aSymbolSetName;
OKButton aOkBtn;
CancelButton aCancelBtn;
PushButton aAddBtn;
PushButton aChangeBtn;
PushButton aDeleteBtn;
FixedImage aRightArrow;
Image aRigthArrow_Im;
Image aRigthArrow_Im_HC; // hi-contrast version
SmSymbolManager aSymbolMgrCopy,
&rSymbolMgr;
const SmSym *pOrigSymbol;
const SubsetMap *pSubsetMap;
FontList *pFontList;
DECL_LINK(OldSymbolChangeHdl, ComboBox *);
DECL_LINK(OldSymbolSetChangeHdl, ComboBox *);
DECL_LINK(ModifyHdl, ComboBox *);
DECL_LINK(FontChangeHdl, ListBox *);
DECL_LINK(SubsetChangeHdl, ListBox*);
DECL_LINK(StyleChangeHdl, ComboBox *);
DECL_LINK(CharHighlightHdl, Control* pControl);
DECL_LINK(AddClickHdl, Button *);
DECL_LINK(ChangeClickHdl, Button *);
DECL_LINK(DeleteClickHdl, Button *);
void FillSymbols(ComboBox &rComboBox, sal_Bool bDeleteText = sal_True);
void FillSymbolSets(ComboBox &rComboBox, sal_Bool bDeleteText = sal_True);
void FillFonts(sal_Bool bDeleteText = sal_True);
void FillStyles(sal_Bool bDeleteText = sal_True);
void SetSymbolSetManager(const SmSymbolManager &rMgr);
void SetFont(const XubString &rFontName, const XubString &rStyleName);
void SetOrigSymbol(const SmSym *pSymbol, const XubString &rSymbolSetName);
void UpdateButtons();
sal_Bool SelectSymbolSet(ComboBox &rComboBox, const XubString &rSymbolSetName,
sal_Bool bDeleteText);
sal_Bool SelectSymbol(ComboBox &rComboBox, const XubString &rSymbolName,
sal_Bool bDeleteText);
sal_Bool SelectFont(const XubString &rFontName, sal_Bool bApplyFont);
sal_Bool SelectStyle(const XubString &rStyleName, sal_Bool bApplyFont);
SmSym * GetSymbol(const ComboBox &rComboBox);
const SmSym * GetSymbol(const ComboBox &rComboBox) const
{
return ((SmSymDefineDialog *) this)->GetSymbol(rComboBox);
}
void InitColor_Impl();
virtual void DataChanged( const DataChangedEvent& rDCEvt );
public:
SmSymDefineDialog(Window *pParent, OutputDevice *pFntListDevice, SmSymbolManager &rMgr, sal_Bool bFreeRes = sal_True);
~SmSymDefineDialog();
using OutputDevice::SetFont;
// Dialog
virtual short Execute();
sal_Bool SelectOldSymbolSet(const XubString &rSymbolSetName)
{
return SelectSymbolSet(aOldSymbolSets, rSymbolSetName, sal_False);
}
sal_Bool SelectOldSymbol(const XubString &rSymbolName)
{
return SelectSymbol(aOldSymbols, rSymbolName, sal_False);
}
sal_Bool SelectSymbolSet(const XubString &rSymbolSetName)
{
return SelectSymbolSet(aSymbolSets, rSymbolSetName, sal_False);
}
sal_Bool SelectSymbol(const XubString &rSymbolName)
{
return SelectSymbol(aSymbols, rSymbolName, sal_False);
}
sal_Bool SelectFont(const XubString &rFontName) { return SelectFont(rFontName, sal_True); }
sal_Bool SelectStyle(const XubString &rStyleName) { return SelectStyle(rStyleName, sal_True); };
void SelectChar(xub_Unicode cChar);
};
#endif
| 6,030 |
1,899 | #include <stdio.h>
#include "graph.h"
namespace bgslibrary
{
namespace algorithms
{
namespace lbp_mrf
{
Graph::Graph(void(*err_function)(char *))
{
error_function = err_function;
node_block = new Block<node>(NODE_BLOCK_SIZE, error_function);
arc_block = new Block<arc>(NODE_BLOCK_SIZE, error_function);
flow = 0;
}
Graph::~Graph()
{
delete node_block;
delete arc_block;
}
Graph::node_id Graph::add_node()
{
node *i = node_block->New();
i->first = NULL;
i->tr_cap = 0;
return (node_id)i;
}
void Graph::add_edge(node_id from, node_id to, captype cap, captype rev_cap)
{
arc *a, *a_rev;
a = arc_block->New(2);
a_rev = a + 1;
a->sister = a_rev;
a_rev->sister = a;
a->next = ((node*)from)->first;
((node*)from)->first = a;
a_rev->next = ((node*)to)->first;
((node*)to)->first = a_rev;
a->head = (node*)to;
a_rev->head = (node*)from;
a->r_cap = cap;
a_rev->r_cap = rev_cap;
}
void Graph::set_tweights(node_id i, captype cap_source, captype cap_sink)
{
flow += (cap_source < cap_sink) ? cap_source : cap_sink;
((node*)i)->tr_cap = cap_source - cap_sink;
}
void Graph::add_tweights(node_id i, captype cap_source, captype cap_sink)
{
//register
captype delta = ((node*)i)->tr_cap; // 'register' storage class specifier is deprecated and incompatible with C++17
if (delta > 0) cap_source += delta;
else cap_sink -= delta;
flow += (cap_source < cap_sink) ? cap_source : cap_sink;
((node*)i)->tr_cap = cap_source - cap_sink;
}
}
}
}
| 910 |
2,649 | <filename>app/src/main/java/json/chao/com/wanandroid/contract/main/SearchListContract.java<gh_stars>1000+
package json.chao.com.wanandroid.contract.main;
import json.chao.com.wanandroid.base.presenter.AbstractPresenter;
import json.chao.com.wanandroid.base.view.AbstractView;
import json.chao.com.wanandroid.core.bean.main.collect.FeedArticleData;
import json.chao.com.wanandroid.core.bean.main.collect.FeedArticleListData;
/**
* @author quchao
* @date 2018/3/13
*/
public interface SearchListContract {
interface View extends AbstractView {
/**
* Show search list
*
* @param feedArticleListData FeedArticleListData
*/
void showSearchList(FeedArticleListData feedArticleListData);
/**
* Show collect article data
*
* @param position Position
* @param feedArticleData FeedArticleData
* @param feedArticleListData FeedArticleListData
*/
void showCollectArticleData(int position, FeedArticleData feedArticleData, FeedArticleListData feedArticleListData);
/**
* Show cancel collect article data
*
* @param position Position
* @param feedArticleData FeedArticleData
* @param feedArticleListData FeedArticleListData
*/
void showCancelCollectArticleData(int position, FeedArticleData feedArticleData, FeedArticleListData feedArticleListData);
}
interface Presenter extends AbstractPresenter<SearchListContract.View> {
/**
* 搜索
* @param page page
* @param k POST search key
* @param isShowError If show error
*/
void getSearchList(int page, String k, boolean isShowError);
/**
* Add collect article
*
* @param position Position
* @param feedArticleData FeedArticleData
*/
void addCollectArticle(int position, FeedArticleData feedArticleData);
/**
* Cancel collect article
*
* @param position Position
* @param feedArticleData FeedArticleData
*/
void cancelCollectArticle(int position, FeedArticleData feedArticleData);
}
}
| 859 |
2,989 | package com.linkedin.databus.bootstrap.monitoring.server.mbean;
/*
*
* Copyright 2013 LinkedIn Corp. All rights reserved
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*/
import com.linkedin.databus.core.Checkpoint;
/**
* MBean interface for the collector for Bootstrap HTTP monitoring mbeans.
*/
public interface DbusBootstrapHttpStatsMBean
{
/**
* Reset object
*/
void reset();
/**
* Metric collection enabled or not
* */
boolean isEnabled();
/** enable/disable metric collection */
void setEnabled(boolean enabled);
/** number of successful bootstrap requests (snapshot+catchup) */
long getNumReqBootstrap() ;
/** number of successful snapshot bootstrap requests */
long getNumReqSnapshot();
/** number of successful catchup bootstrap requests */
long getNumReqCatchup();
/** number of erroneous bootstrap requests */
long getNumErrReqBootstrap();
/** number of requests where bootstrap db is too old */
long getNumErrReqDatabaseTooOld();
/** number of erroneous requests due to sql exception */
long getNumErrSqlException();
/** number of successful startSCN requests */
long getNumReqStartSCN();
/** number of successful targetSCN requests */
long getNumReqTargetSCN();
/** number of erroneous targetSCN requests */
long getNumErrStartSCN();
/** number of erroneous targetSCN requests */
long getNumErrTargetSCN();
/** time taken by successful snapshot bootstrap requests */
long getLatencySnapshot();
/** time taken by successful catchup bootstrap requests */
long getLatencyCatchup();
/** time taken by successful startSCN requests */
long getLatencyStartSCN();
/** time taken by successful targetSCN requests */
long getLatencyTargetSCN();
/** requested batch size in bootstrap requests */
long getSizeBatch();
/** minimum scn seen in bootstrap requests */
long getMinBootstrapSCN();
/** maximum scn seen in bootstrap requests */
long getMaxBootstrapSCN();
/** set metrics pertaining to bootstrap call */
void registerBootStrapReq(Checkpoint cp,long latency,long size) ;
void registerStartSCNReq(long latency);
void registerTargetSCNReq(long latency);
/** set metrics pertaining to err bootstrap req */
void registerErrBootstrap();
void registerErrStartSCN();
void registerErrTargetSCN();
void registerErrSqlException();
void registerErrDatabaseTooOld();
}
| 858 |
316 | <filename>ArgusCore/src/test/java/com/salesforce/dva/argus/TestUtils.java
/*
* Copyright (c) 2016, Salesforce.com, Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. Neither the name of Salesforce.com nor the names of its contributors may
* be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
package com.salesforce.dva.argus;
import com.salesforce.dva.argus.entity.Alert;
import com.salesforce.dva.argus.entity.Annotation;
import com.salesforce.dva.argus.entity.Histogram;
import com.salesforce.dva.argus.entity.HistogramBucket;
import com.salesforce.dva.argus.entity.History;
import com.salesforce.dva.argus.entity.Metric;
import com.salesforce.dva.argus.entity.Notification;
import com.salesforce.dva.argus.entity.PrincipalUser;
import com.salesforce.dva.argus.entity.Trigger;
import com.salesforce.dva.argus.system.SystemConfiguration;
import com.salesforce.dva.argus.system.SystemException;
import com.salesforce.dva.argus.system.SystemMain;
import org.powermock.reflect.Whitebox;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.math.BigInteger;
import java.security.SecureRandom;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.TreeMap;
import static org.junit.Assert.fail;
public class TestUtils {
public static final SecureRandom random = new SecureRandom();
private static final String scopeNameTemplate = "MetricGenerator.{0,number,#}";
private static final String metricNameTemplate = "app_record_count.{0,number,#}";
protected static final Map<String, String> tags;
static private Properties props;
static {
tags = new HashMap<>();
tags.put("source", "unittest");
props = new Properties();
props.put("system.property.mail.enabled", "false");
props.put("system.property.admin.email", "<EMAIL>");
props.put("system.property.log.level", "ERROR");
props.put("service.binding.cache", "com.salesforce.dva.argus.service.cache.NoOperationCacheService");
props.put("service.binding.tsdb", "com.salesforce.dva.argus.service.tsdb.DefaultTSDBService");
props.put("service.binding.audit", "com.salesforce.dva.argus.service.audit.DefaultAuditService");
props.put("service.property.mq.connection.count", "2");
props.put("service.property.mq.endpoint", "vm://localhost?broker.persistent=false");
props.put("service.property.auth.ldap.authtype", "simple");
props.put("service.property.auth.ldap.endpoint", "ldaps://ldaps.mycomany.com:636");
props.put("service.property.auth.ldap.searchbase", "OU=active,OU=users,DC=mycompany,DC=com:OU=active,OU=robot,DC=mycompany,DC=com");
props.put("service.property.auth.ldap.searchdn", "CN=argus_service,OU=active,OU=users,DC=mycompany,DC=com");
props.put("service.property.auth.ldap.searchpwd", "<PASSWORD>");
props.put("service.property.auth.ldap.usernamefield", "sAMAccountName");
props.put("service.property.mail.alerturl.template", "https://localhost:8443/argus/#/alerts/$alertid$");
props.put("service.property.mail.metricurl.template", "https://localhost:8443/argus/#/viewmetrics?expression=$expression$");
props.put("service.property.mail.smtp.auth", "false");
props.put("service.property.mail.smtp.host", "smtprelay.mycompany.com");
props.put("service.property.mail.smtp.starttls.enable", "false");
props.put("service.property.tsdb.connection.count", "2");
props.put("service.property.tsdb.endpoint.read", "http://tsdbread.mycompany.com:4466");
props.put("service.property.tsdb.endpoint.timeout", "10000");
props.put("service.property.tsdb.endpoint.write", "http://tsdbwrite.mycompany.com:4477");
props.put("service.property.tsdb.phoenix.jdbc.url", "${service.property.tsdb.phoenix.jdbc.url}");
props.put("service.property.cache.redis.cluster", "redis0.mycompany.com:6379,redis1.mycompany.com:6389");
}
static public SystemConfiguration getConfiguration() {
Properties config = new Properties();
InputStream is = null;
try {
is = TestUtils.class.getResourceAsStream("/argus.properties");
config.load(is);
} catch (IOException ex) {
throw new SystemException(ex);
} finally {
if (is != null) {
try {
is.close();
} catch (IOException ex) {
assert false : "This should never occur.";
}
}
}
return new SystemConfiguration(config);
}
static public SystemMain getInstance() {
Properties config = new Properties();
InputStream is = null;
try {
is = TestUtils.class.getResourceAsStream("/argus.properties");
config.load(is);
} catch (IOException ex) {
throw new SystemException(ex);
} finally {
if (is != null) {
try {
is.close();
} catch (IOException ex) {
assert false : "This should never occur.";
}
}
}
return SystemMain.getInstance(config);
}
static public SystemMain getInstanceWithInMemProps() {
long start = System.currentTimeMillis();
SystemMain system = SystemMain.getInstance(props);
long end = System.currentTimeMillis();
// System.out.println("getInstanceWithInMemProps " + (end - start) + " milliseconds");
return system;
}
public static String createRandomName() {
return createRandomName(TestUtils.class.getSimpleName());
}
public static String createRandomName(String name) {
String className = name;
Long randomTime = random.nextLong();
Long systemTime = System.currentTimeMillis();
return MessageFormat.format("{0}-{1}-{2}", className, Long.toHexString(systemTime), Long.toHexString(randomTime));
}
public static List<Metric> createRandomMetrics(String className, String scope, String metric, int count) {
List<Metric> result = new ArrayList<>(count);
scope = scope == null ? createRandomName(className) : scope;
String tag = createRandomName(className);
for (int i = 0; i < count; i++) {
String metricName = metric == null ? createRandomName(className) : metric;
Metric met = new Metric(scope, metricName);
int datapointCount = random.nextInt(25) + 1;
Map<Long, Double> datapoints = new HashMap<>();
long start = System.currentTimeMillis() - 60000L;
for (int j = 0; j < datapointCount; j++) {
datapoints.put(start - (j * 60000L), (double)(random.nextInt(100) + 1));
}
met.setDatapoints(datapoints);
met.setDisplayName(createRandomName(className));
met.setUnits(createRandomName(className));
met.setTag(tag, String.valueOf(i));
result.add(met);
}
return result;
}
public static Metric createMetric() {
return createMetric(((int) (random.nextDouble() * 500)) + 1);
}
public static Metric createMetric(int datapointCount) {
int scopeIndex = ((int) (random.nextDouble() * 100));
int metricIndex = ((int) (random.nextDouble() * 10));
String scope = MessageFormat.format(scopeNameTemplate, scopeIndex);
String metric = MessageFormat.format(metricNameTemplate, metricIndex);
Metric result = new Metric(scope, metric);
Map<Long, Double> datapoints = new TreeMap<>();
for (int i = 0; i < datapointCount; i++) {
datapoints.put(System.currentTimeMillis(), random.nextDouble() * 500);
}
result.setDatapoints(datapoints);
result.setTags(tags);
return result;
}
public static Annotation createAnnotation() {
int scopeIndex = ((int) (random.nextDouble() * 100));
int metricIndex = ((int) (random.nextDouble() * 10));
String scope = MessageFormat.format(scopeNameTemplate, scopeIndex);
String metric = MessageFormat.format(metricNameTemplate, metricIndex);
long timestamp = System.currentTimeMillis();
Annotation result = new Annotation("unittest", Long.toHexString(timestamp), "unittest", scope, metric, timestamp);
result.setTags(tags);
return result;
}
public static Histogram createHistogram(int numHistogramBuckets) {
int scopeIndex = ((int) (random.nextDouble() * 100));
int metricIndex = ((int) (random.nextDouble() * 10));
String scope = MessageFormat.format(scopeNameTemplate, scopeIndex);
String metric = MessageFormat.format(metricNameTemplate, metricIndex);
long timestamp = System.currentTimeMillis();
Histogram result = new Histogram(scope, metric);
Map<HistogramBucket, Long> buckets = new HashMap<>();
float lowerBound = 0;
float upperBound = 50;
for (int i = 0; i < numHistogramBuckets; i++) {
HistogramBucket histogramBucket= new HistogramBucket(lowerBound, upperBound);
buckets.put(histogramBucket, random.nextLong());
lowerBound = upperBound;
upperBound = upperBound + 100;
}
result.setBuckets(buckets);
result.setTimestamp(timestamp);;
result.setTags(tags);
return result;
}
public static Histogram createHistogramWrongBounds(int numHistogramBuckets) {
int scopeIndex = ((int) (random.nextDouble() * 100));
int metricIndex = ((int) (random.nextDouble() * 10));
String scope = MessageFormat.format(scopeNameTemplate, scopeIndex);
String metric = MessageFormat.format(metricNameTemplate, metricIndex);
long timestamp = System.currentTimeMillis();
Histogram result = new Histogram(scope, metric);
Map<HistogramBucket, Long> buckets = new HashMap<>();
float lowerBound = 2;
float upperBound = 1;
for (int i = 0; i < numHistogramBuckets; i++) {
HistogramBucket histogramBucket= new HistogramBucket(lowerBound, upperBound);
buckets.put(histogramBucket, random.nextLong());
lowerBound = upperBound;
upperBound = upperBound + 100;
}
result.setBuckets(buckets);
result.setTimestamp(timestamp);;
result.setTags(tags);
return result;
}
public static Alert generateAlert(String alertName, PrincipalUser user, String expression) {
Alert alert = new Alert(user, user, alertName, expression, "* * * * *");
return alert;
}
public static Notification generateNotification(String notificationName, Alert alert, List<Trigger> triggers) {
Notification notification = new Notification(notificationName, alert, "notifier-name", new ArrayList<String>(), 5000L);
notification.setAlert(alert);
notification.setTriggers(triggers);
return notification;
}
public static Trigger generateTrigger(String triggerName, Alert alert) {
Trigger trigger = new Trigger(alert, Trigger.TriggerType.GREATER_THAN, triggerName, 0.95, 5000L);
trigger.setAlert(alert);
return trigger;
}
public static void setStaticField(Class<?> clazz, String fieldName, Object value) {
try {
Field field = clazz.getDeclaredField(fieldName);
field.setAccessible(true);
Field modifiers = Field.class.getDeclaredField("modifiers");
modifiers.setAccessible(true);
modifiers.set(field, field.getModifiers() & ~Modifier.FINAL);
field.set(null, value);
} catch (Exception ex) {
fail(ex.getMessage());
}
}
public static void setField(Object obj, String fieldName, Object value) {
try {
Whitebox.setInternalState(obj, fieldName, value);
} catch (Exception ex) {
fail(ex.getMessage());
}
}
public static Notification getNotification(String notificationName, String notifierName, Alert alert, List<String> subscriptionList) {
Notification notification = new Notification(notificationName, alert, notifierName,
subscriptionList, 5000L);
notification.setSeverityLevel(4);
return notification;
}
public static History getHistory() {
return new History("TEST HISTORY MESSAGE", "TEST_HOST", new BigInteger("100002"),
History.JobStatus.STARTED, 10, System.currentTimeMillis() - 86400000);
}
public static Metric getMetric() {
SecureRandom random = new SecureRandom();
return createMetric(((int) (random.nextDouble() * 500)) + 1);
}
public static Trigger getTrigger(Alert alert, Trigger.TriggerType triggerType, String triggerName, String triggerThreshold, String triggerInertiaMillis) {
return new Trigger(alert, triggerType, triggerName, Double.parseDouble(triggerThreshold), Long.parseLong(triggerInertiaMillis));
}
}
| 5,613 |
10,225 | <gh_stars>1000+
package io.quarkus.bootstrap.workspace;
import java.io.File;
import java.io.Serializable;
import java.util.Collections;
import java.util.Iterator;
import java.util.Map;
import java.util.Objects;
public class DefaultProcessedSources implements ProcessedSources, Serializable {
private final File srcDir;
private final File destinationDir;
private final Map<Object, Object> data;
public DefaultProcessedSources(File srcDir, File destinationDir) {
this(srcDir, destinationDir, Collections.emptyMap());
}
public DefaultProcessedSources(File srcDir, File destinationDir, Map<Object, Object> data) {
this.srcDir = srcDir;
this.destinationDir = destinationDir;
this.data = data;
}
@Override
public File getSourceDir() {
return srcDir;
}
@Override
public File getDestinationDir() {
return destinationDir;
}
public <T> T getValue(Object key, Class<T> type) {
final Object o = data.get(key);
return o == null ? null : type.cast(o);
}
@Override
public int hashCode() {
return Objects.hash(data, destinationDir, srcDir);
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
DefaultProcessedSources other = (DefaultProcessedSources) obj;
return Objects.equals(data, other.data) && Objects.equals(destinationDir, other.destinationDir)
&& Objects.equals(srcDir, other.srcDir);
}
@Override
public String toString() {
final StringBuilder buf = new StringBuilder();
buf.append(srcDir).append(" -> ").append(destinationDir);
if (!data.isEmpty()) {
final Iterator<Map.Entry<Object, Object>> i = data.entrySet().iterator();
Map.Entry<Object, Object> e = i.next();
buf.append(" ").append(e.getKey()).append("=").append(e.getValue());
while (i.hasNext()) {
e = i.next();
buf.append(",").append(e.getKey()).append("=").append(e.getValue());
}
}
return buf.toString();
}
}
| 925 |
870 | <filename>test/src/main/java/org/apache/accumulo/test/rpc/SimpleThriftServiceHandler.java
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.accumulo.test.rpc;
import org.apache.accumulo.test.rpc.thrift.SimpleThriftService;
import org.apache.thrift.TException;
public class SimpleThriftServiceHandler implements SimpleThriftService.Iface {
private void setProp(String method, String value) {
System.setProperty(this.getClass().getSimpleName() + "." + method, value);
}
@Override
public String echoFail(String value) throws TException {
setProp("echoFail", value);
throw new TException(new UnsupportedOperationException(value));
}
@Override
public String echoRuntimeFail(String value) {
setProp("echoRuntimeFail", value);
throw new UnsupportedOperationException(value);
}
@Override
public String echoPass(String value) {
setProp("echoPass", value);
return value;
}
@Override
public void onewayFail(String value) throws TException {
setProp("onewayFail", value);
throw new TException(new UnsupportedOperationException(value));
}
@Override
public void onewayRuntimeFail(String value) {
setProp("onewayRuntimeFail", value);
throw new UnsupportedOperationException(value);
}
@Override
public void onewayPass(String value) {
setProp("onewayPass", value);
}
}
| 606 |
618 | <reponame>keunhong/scanner<filename>scanner/video/intel/intel_video_decoder.h<gh_stars>100-1000
/* Copyright 2016 <NAME> University
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include "scanner/eval/evaluator.h"
#include "scanner/video/video_decoder.h"
extern "C" {
#include "libavcodec/avcodec.h"
#include "libavfilter/avfilter.h"
#include "libavformat/avformat.h"
#include "libavformat/avio.h"
#include "libavutil/error.h"
#include "libavutil/opt.h"
#include "libavutil/pixdesc.h"
#include "libswscale/swscale.h"
}
#include <deque>
#include <vector>
namespace scanner {
///////////////////////////////////////////////////////////////////////////////
/// IntelVideoDecoder
class IntelVideoDecoder : public VideoDecoder {
public:
IntelVideoDecoder(int device_id, DeviceType output_type);
~IntelVideoDecoder();
void configure(const InputFormat& metadata) override;
bool feed(const u8* encoded_buffer, size_t encoded_size,
bool discontinuity = false) override;
bool discard_frame() override;
bool get_frame(u8* decoded_buffer, size_t decoded_size) override;
int decoded_frames_buffered() override;
void wait_until_frames_copied() override;
private:
int device_id_;
DeviceType output_type_;
AVPacket packet_;
AVCodec* codec_;
AVCodecContext* cc_;
InputFormat metadata_;
std::vector<u8> conversion_buffer_;
bool reset_context_;
SwsContext* sws_context_;
std::vector<AVFrame*> frame_pool_;
std::deque<AVFrame*> decoded_frame_queue_;
};
}
| 659 |
335 | {
"word": "Fence",
"definitions": [
"A barrier, railing, or other upright structure, typically of wood or wire, enclosing an area of ground to prevent or control access or escape.",
"A large upright obstacle in steeplechasing, showjumping, or cross-country.",
"A guard or guide on a plane, saw, or other tool.",
"A person who deals in stolen goods."
],
"parts-of-speech": "Noun"
} | 150 |
5,169 | <reponame>Gantios/Specs<gh_stars>1000+
{
"name": "HWIFileDownload",
"version": "3.5",
"license": {
"type": "zlib",
"file": "LICENCE.md"
},
"summary": "Simplified file download integration based on NSURLSession.",
"homepage": "https://github.com/Heikowi/HWIFileDownload",
"authors": "<NAME>",
"social_media_url": "https://twitter.com/heikowi",
"source": {
"git": "https://github.com/Heikowi/HWIFileDownload.git",
"tag": "3.5"
},
"source_files": [
"HWIBackgroundSessionCompletionHandlerBlock.h",
"HWIFileDownloadDelegate.h",
"HWIFileDownloader.{h,m}",
"HWIFileDownloadItem.{h,m}",
"HWIFileDownloadProgress.{h,m}"
],
"requires_arc": true,
"platforms": {
"ios": "6.0"
}
}
| 326 |
1,724 | <reponame>HoutanSadafi/mongo-java-driver
/*
* Copyright 2008-present MongoDB, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.bson.internal;
import org.bson.BSONException;
import org.bson.BsonBinarySubType;
import org.bson.BsonSerializationException;
import org.bson.UuidRepresentation;
import java.util.Arrays;
import java.util.UUID;
/**
* Utilities for encoding and decoding UUID into binary.
*/
public final class UuidHelper {
private static void writeLongToArrayBigEndian(final byte[] bytes, final int offset, final long x) {
bytes[offset + 7] = (byte) (0xFFL & (x));
bytes[offset + 6] = (byte) (0xFFL & (x >> 8));
bytes[offset + 5] = (byte) (0xFFL & (x >> 16));
bytes[offset + 4] = (byte) (0xFFL & (x >> 24));
bytes[offset + 3] = (byte) (0xFFL & (x >> 32));
bytes[offset + 2] = (byte) (0xFFL & (x >> 40));
bytes[offset + 1] = (byte) (0xFFL & (x >> 48));
bytes[offset] = (byte) (0xFFL & (x >> 56));
}
private static long readLongFromArrayBigEndian(final byte[] bytes, final int offset) {
long x = 0;
x |= (0xFFL & bytes[offset + 7]);
x |= (0xFFL & bytes[offset + 6]) << 8;
x |= (0xFFL & bytes[offset + 5]) << 16;
x |= (0xFFL & bytes[offset + 4]) << 24;
x |= (0xFFL & bytes[offset + 3]) << 32;
x |= (0xFFL & bytes[offset + 2]) << 40;
x |= (0xFFL & bytes[offset + 1]) << 48;
x |= (0xFFL & bytes[offset]) << 56;
return x;
}
// reverse elements in the subarray data[start:start+length]
private static void reverseByteArray(final byte[] data, final int start, final int length) {
for (int left = start, right = start + length - 1; left < right; left++, right--) {
// swap the values at the left and right indices
byte temp = data[left];
data[left] = data[right];
data[right] = temp;
}
}
public static byte[] encodeUuidToBinary(final UUID uuid, final UuidRepresentation uuidRepresentation) {
byte[] binaryData = new byte[16];
writeLongToArrayBigEndian(binaryData, 0, uuid.getMostSignificantBits());
writeLongToArrayBigEndian(binaryData, 8, uuid.getLeastSignificantBits());
switch(uuidRepresentation) {
case C_SHARP_LEGACY:
reverseByteArray(binaryData, 0, 4);
reverseByteArray(binaryData, 4, 2);
reverseByteArray(binaryData, 6, 2);
break;
case JAVA_LEGACY:
reverseByteArray(binaryData, 0, 8);
reverseByteArray(binaryData, 8, 8);
break;
case PYTHON_LEGACY:
case STANDARD:
break;
default:
throw new BSONException("Unexpected UUID representation: " + uuidRepresentation);
}
return binaryData;
}
// This method will NOT modify the contents of the byte array
public static UUID decodeBinaryToUuid(final byte[] data, final byte type, final UuidRepresentation uuidRepresentation) {
if (data.length != 16) {
throw new BsonSerializationException(String.format("Expected length to be 16, not %d.", data.length));
}
byte[] localData = data;
if (type == BsonBinarySubType.UUID_LEGACY.getValue()) {
switch(uuidRepresentation) {
case C_SHARP_LEGACY:
localData = Arrays.copyOf(data, 16);
reverseByteArray(localData, 0, 4);
reverseByteArray(localData, 4, 2);
reverseByteArray(localData, 6, 2);
break;
case JAVA_LEGACY:
localData = Arrays.copyOf(data, 16);
reverseByteArray(localData, 0, 8);
reverseByteArray(localData, 8, 8);
break;
case PYTHON_LEGACY:
break;
case STANDARD:
throw new BSONException("Can not decode a subtype 3 (UUID legacy) BSON binary when the decoder is configured to use "
+ "the standard UUID representation");
default:
throw new BSONException("Unexpected UUID representation: " + uuidRepresentation);
}
}
return new UUID(readLongFromArrayBigEndian(localData, 0), readLongFromArrayBigEndian(localData, 8));
}
private UuidHelper() {
}
}
| 2,236 |
384 | <reponame>psmware-ltd/nautobot
from django import template
register = template.Library()
def _check_permission(user, instance, action):
return user.has_perm(
perm=f"{instance._meta.app_label}.{action}_{instance._meta.model_name}",
obj=instance,
)
@register.filter()
def can_view(user, instance):
return _check_permission(user, instance, "view")
@register.filter()
def can_add(user, instance):
return _check_permission(user, instance, "add")
@register.filter()
def can_change(user, instance):
return _check_permission(user, instance, "change")
@register.filter()
def can_delete(user, instance):
return _check_permission(user, instance, "delete")
| 248 |
460 | /*
* Copyright 2009-2012 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License i distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.paoding.rose.jade.statement;
import java.util.Collection;
import java.util.LinkedList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.apache.commons.lang.math.NumberUtils;
import org.springframework.beans.BeanWrapper;
import org.springframework.beans.BeanWrapperImpl;
/**
*
* @author 廖涵 [<EMAIL>]
*/
//NOTE: 这是一个最简单的解释器（没有表达式功能的解释器），实际并未启用
public class SimpleInterpreter implements Interpreter {
private static final Pattern NAMED_PARAM_PATTERN = Pattern.compile("(\\:([a-zA-Z0-9_\\.]+))");
@Override
public void interpret(StatementRuntime runtime) {
final List<Object> parametersAsList = new LinkedList<Object>();
// 匹配符合 :name 格式的参数
Matcher matcher = NAMED_PARAM_PATTERN.matcher(runtime.getSQL());
if (!matcher.find()) {
return;
}
final StringBuilder builder = new StringBuilder();
int index = 0;
do {
// 提取参数名称
String name = matcher.group(1);
if (NumberUtils.isDigits(name)) {
name = matcher.group();//把冒号包含进去
}
Object value = null;
// 解析 a.b.c 类型的名称
int find = name.indexOf('.');
if (find >= 0) {
// 用 BeanWrapper 获取属性值
Object bean = runtime.getParameters().get(name.substring(0, find));
if (bean != null) {
BeanWrapper beanWrapper = new BeanWrapperImpl(bean);
value = beanWrapper.getPropertyValue(name.substring(find + 1));
}
} else {
// 直接获取值
value = runtime.getParameters().get(name);
}
// 拼装查询语句
builder.append(runtime.getSQL().substring(index, matcher.start()));
if (value instanceof Collection<?>) {
// 拼装 IN (...) 的查询条件
builder.append('(');
Collection<?> collection = (Collection<?>) value;
if (collection.isEmpty()) {
builder.append("NULL");
} else {
builder.append('?');
}
for (int i = 1; i < collection.size(); i++) {
builder.append(", ?");
}
builder.append(')');
// 保存参数值
parametersAsList.addAll(collection);
} else {
// 拼装普通的查询条件
builder.append('?');
// 保存参数值
parametersAsList.add(value);
}
index = matcher.end();
} while (matcher.find());
// 拼装查询语句
builder.append(runtime.getSQL().substring(index));
runtime.setSQL(builder.toString());
runtime.setArgs(parametersAsList.toArray());
}
}
| 1,944 |
707 | <gh_stars>100-1000
#ifdef __OBJC__
#import <UIKit/UIKit.h>
#else
#ifndef FOUNDATION_EXPORT
#if defined(__cplusplus)
#define FOUNDATION_EXPORT extern "C"
#else
#define FOUNDATION_EXPORT extern
#endif
#endif
#endif
#import "InstagramEngine.h"
#import "InstagramKit.h"
#import "InstagramKitConstants.h"
#import "InstagramComment.h"
#import "InstagramLocation.h"
#import "InstagramMedia.h"
#import "InstagramModel.h"
#import "InstagramPaginationInfo.h"
#import "InstagramTag.h"
#import "InstagramUser.h"
#import "UserInPhoto.h"
FOUNDATION_EXPORT double InstagramKitVersionNumber;
FOUNDATION_EXPORT const unsigned char InstagramKitVersionString[];
| 236 |
578 | /*
* Copyright (c) Facebook, Inc. and its affiliates.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <folly/Range.h>
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#include <folly/stats/QuantileEstimator.h>
#pragma GCC diagnostic pop
#include <folly/logging/xlog.h>
#include "cachelib/common/Utils.h"
namespace facebook {
namespace cachelib {
namespace util {
using CounterVisitor =
std::function<void(folly::StringPiece name, double count)>;
class PercentileStats {
public:
struct Estimates {
uint64_t avg;
uint64_t p0;
uint64_t p5;
uint64_t p10;
uint64_t p25;
uint64_t p50;
uint64_t p75;
uint64_t p90;
uint64_t p95;
uint64_t p99;
uint64_t p999;
uint64_t p9999;
uint64_t p99999;
uint64_t p999999;
uint64_t p100;
};
PercentileStats() : estimator_{std::chrono::seconds{kDefaultWindowSize}} {}
PercentileStats(std::chrono::seconds windowSize) : estimator_{windowSize} {}
// track latency by taking the value of duration directly.
void trackValue(double value,
std::chrono::time_point<std::chrono::steady_clock> tp =
std::chrono::steady_clock::now()) {
estimator_.addValue(value, tp);
}
// Return the estimates for stat. This is not cheap so do not
// call frequently. The cost is roughly number of quantiles we
// pass in multiplied by cost of estimating an individual quantile
Estimates estimate();
// visit each latency estimate using the visitor.
// @param visitor the stat visitor
// @param rst the estimates to be visited
// @param prefix prefix for the stat name.
void visitQuantileEstimator(const CounterVisitor& visitor,
folly::StringPiece statPrefix) {
auto rst = estimate();
visitQuantileEstimates(visitor, rst, statPrefix);
}
// visit each latency estimate using the visitor.
// @param visitor the stat visitor
// @param rst the estimates to be visited
// @param prefix prefix for the stat name.
static void visitQuantileEstimates(const CounterVisitor& visitor,
const Estimates& rst,
folly::StringPiece prefix);
private:
static const std::array<double, 14> kQuantiles;
static constexpr int kDefaultWindowSize = 1;
folly::SlidingWindowQuantileEstimator<> estimator_;
};
class LatencyTracker {
public:
explicit LatencyTracker(PercentileStats& stats)
: stats_(&stats), begin_(std::chrono::steady_clock::now()) {}
LatencyTracker() {}
~LatencyTracker() {
if (stats_) {
auto tp = std::chrono::steady_clock::now();
auto diffNanos =
std::chrono::duration_cast<std::chrono::nanoseconds>(tp - begin_)
.count();
stats_->trackValue(static_cast<double>(diffNanos), tp);
}
}
LatencyTracker(const LatencyTracker&) = delete;
LatencyTracker& operator=(const LatencyTracker&) = delete;
LatencyTracker(LatencyTracker&& rhs) noexcept
: stats_(rhs.stats_), begin_(rhs.begin_) {
rhs.stats_ = nullptr;
}
LatencyTracker& operator=(LatencyTracker&& rhs) noexcept {
if (this != &rhs) {
this->~LatencyTracker();
new (this) LatencyTracker(std::move(rhs));
}
return *this;
}
private:
PercentileStats* stats_{nullptr};
std::chrono::time_point<std::chrono::steady_clock> begin_;
};
} // namespace util
} // namespace cachelib
} // namespace facebook
| 1,471 |
590 | package hype.interfaces;
public interface HRotatable {
float rotationRad();
float rotationXRad();
float rotationYRad();
float rotationZRad();
HRotatable rotationRad(float rad); //retained for backwards compatibility
HRotatable rotationXRad(float radx);
HRotatable rotationYRad(float rady);
HRotatable rotationZRad(float radz);
}
| 100 |
589 | <reponame>ClaudioWaldvogel/inspectIT<gh_stars>100-1000
package rocks.inspectit.ui.rcp.editor.table.input;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Date;
import java.util.EnumSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.viewers.DoubleClickEvent;
import org.eclipse.jface.viewers.IBaseLabelProvider;
import org.eclipse.jface.viewers.IContentProvider;
import org.eclipse.jface.viewers.IStructuredContentProvider;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.StyledString;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.jface.viewers.TableViewerColumn;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerComparator;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PlatformUI;
import rocks.inspectit.shared.all.cmr.model.MethodIdent;
import rocks.inspectit.shared.all.cmr.service.ICachedDataService;
import rocks.inspectit.shared.all.communication.data.ExceptionSensorData;
import rocks.inspectit.shared.cs.cmr.service.IExceptionDataAccessService;
import rocks.inspectit.shared.cs.communication.comparator.DefaultDataComparatorEnum;
import rocks.inspectit.shared.cs.communication.comparator.IDataComparator;
import rocks.inspectit.shared.cs.communication.comparator.InvocationAwareDataComparatorEnum;
import rocks.inspectit.shared.cs.communication.comparator.MethodSensorDataComparatorEnum;
import rocks.inspectit.shared.cs.communication.comparator.ResultComparator;
import rocks.inspectit.ui.rcp.InspectIT;
import rocks.inspectit.ui.rcp.InspectITImages;
import rocks.inspectit.ui.rcp.editor.inputdefinition.InputDefinition;
import rocks.inspectit.ui.rcp.editor.inputdefinition.extra.InputDefinitionExtrasMarkerFactory;
import rocks.inspectit.ui.rcp.editor.preferences.IPreferenceGroup;
import rocks.inspectit.ui.rcp.editor.preferences.PreferenceEventCallback.PreferenceEvent;
import rocks.inspectit.ui.rcp.editor.preferences.PreferenceId;
import rocks.inspectit.ui.rcp.editor.root.IRootEditor;
import rocks.inspectit.ui.rcp.editor.table.RemoteTableViewerComparator;
import rocks.inspectit.ui.rcp.editor.viewers.StyledCellIndexLabelProvider;
import rocks.inspectit.ui.rcp.formatter.NumberFormatter;
import rocks.inspectit.ui.rcp.formatter.TextFormatter;
import rocks.inspectit.ui.rcp.preferences.PreferencesConstants;
import rocks.inspectit.ui.rcp.preferences.PreferencesUtils;
import rocks.inspectit.ui.rcp.repository.CmrRepositoryDefinition;
/**
*
* @author <NAME>
*
*/
public class UngroupedExceptionOverviewInputController extends AbstractTableInputController {
/**
* The ID of this subview / controller.
*/
public static final String ID = "inspectit.subview.table.ungroupedexceptionoverview";
/**
* The private inner enumeration used to define the used IDs which are mapped into the columns.
* The order in this enumeration represents the order of the columns. If it is reordered,
* nothing else has to be changed.
*
* @author <NAME>
*
*/
private static enum Column {
/** The count column. */
TIMESTAMP("Timestamp", 150, InspectITImages.IMG_TIMESTAMP, DefaultDataComparatorEnum.TIMESTAMP),
/** The class column. */
CLASS("Class", 250, InspectITImages.IMG_CLASS, MethodSensorDataComparatorEnum.CLASS),
/** The package column. */
PACKAGE("Package", 250, InspectITImages.IMG_PACKAGE, MethodSensorDataComparatorEnum.PACKAGE),
/** Invocation Affiliation. */
INVOCATION_AFFILLIATION("In Invocations", 120, InspectITImages.IMG_INVOCATION, InvocationAwareDataComparatorEnum.INVOCATION_AFFILIATION);
/** The name. */
private String name;
/** The width of the column. */
private int width;
/** The image descriptor. Can be <code>null</code> */
private Image image;
/** Comparator for the column. */
private IDataComparator<? super ExceptionSensorData> dataComparator;
/**
* Default constructor which creates a column enumeration object.
*
* @param name
* The name of the column.
* @param width
* The width of the column.
* @param imageName
* The name of the image. Names are defined in {@link InspectITImages}.
* @param dataComparator
* Comparator for the column.
*/
private Column(String name, int width, String imageName, IDataComparator<? super ExceptionSensorData> dataComparator) {
this.name = name;
this.width = width;
this.image = InspectIT.getDefault().getImage(imageName);
this.dataComparator = dataComparator;
}
/**
* Converts an ordinal into a column.
*
* @param i
* The ordinal.
* @return The appropriate column.
*/
public static Column fromOrd(int i) {
if ((i < 0) || (i >= Column.values().length)) {
throw new IndexOutOfBoundsException("Invalid ordinal");
}
return Column.values()[i];
}
}
/**
* Default comparator when no sorting is defined.
*/
private final ResultComparator<ExceptionSensorData> defaultComparator = new ResultComparator<>(DefaultDataComparatorEnum.TIMESTAMP, false);
/**
* The template object which is send to the server.
*/
private ExceptionSensorData template;
/**
* The list of invocation sequence data objects which is displayed.
*/
private List<ExceptionSensorData> exceptionSensorData = new ArrayList<>();
/**
* The limit of the result set.
*/
private int limit = PreferencesUtils.getIntValue(PreferencesConstants.ITEMS_COUNT_TO_SHOW);;
/**
* Indicates from which point in time data should be shown.
*/
private Date fromDate;
/**
* Indicates until which point in time data should be shown.
*/
private Date toDate;
/**
* This data access service is needed because of the ID mappings.
*/
private ICachedDataService cachedDataService;
/**
* The data access service to access the data on the CMR.
*/
private IExceptionDataAccessService dataAccessService;
/**
* Result comparator to be used on the server.
*/
private ResultComparator<ExceptionSensorData> resultComparator = defaultComparator;
/**
* {@inheritDoc}
*/
@Override
public void setInputDefinition(InputDefinition inputDefinition) {
super.setInputDefinition(inputDefinition);
template = new ExceptionSensorData();
template.setPlatformIdent(inputDefinition.getIdDefinition().getPlatformId());
template.setSensorTypeIdent(inputDefinition.getIdDefinition().getSensorTypeId());
template.setMethodIdent(inputDefinition.getIdDefinition().getMethodId());
if (inputDefinition.hasInputDefinitionExtra(InputDefinitionExtrasMarkerFactory.EXCEPTION_TYPE_EXTRAS_MARKER)) {
String throwableType = inputDefinition.getInputDefinitionExtra(InputDefinitionExtrasMarkerFactory.EXCEPTION_TYPE_EXTRAS_MARKER).getThrowableType();
template.setThrowableType(throwableType);
}
cachedDataService = inputDefinition.getRepositoryDefinition().getCachedDataService();
dataAccessService = inputDefinition.getRepositoryDefinition().getExceptionDataAccessService();
}
/**
* {@inheritDoc}
*/
@Override
public void createColumns(TableViewer tableViewer) {
for (Column column : Column.values()) {
TableViewerColumn viewerColumn = new TableViewerColumn(tableViewer, SWT.NONE);
viewerColumn.getColumn().setMoveable(true);
viewerColumn.getColumn().setResizable(true);
viewerColumn.getColumn().setText(column.name);
viewerColumn.getColumn().setWidth(column.width);
if (null != column.image) {
viewerColumn.getColumn().setImage(column.image);
}
mapTableViewerColumn(column, viewerColumn);
}
}
/**
* {@inheritDoc}
*/
@Override
public Object getTableInput() {
// this list will be filled with data
return exceptionSensorData;
}
/**
* {@inheritDoc}
*/
@Override
public IContentProvider getContentProvider() {
return new UngroupedExceptionOverviewContentProvider();
}
/**
* {@inheritDoc}
*/
@Override
public IBaseLabelProvider getLabelProvider() {
return new UngroupedExceptionOverviewLabelProvider();
}
/**
* {@inheritDoc}
*/
@Override
public ViewerComparator getComparator() {
RemoteTableViewerComparator<ExceptionSensorData> exceptionViewerComparator = new RemoteTableViewerComparator<ExceptionSensorData>() {
@Override
protected void sortRemotely(ResultComparator<ExceptionSensorData> resultComparator) {
if (null != resultComparator) {
UngroupedExceptionOverviewInputController.this.resultComparator = resultComparator;
} else {
UngroupedExceptionOverviewInputController.this.resultComparator = defaultComparator;
}
loadDataFromService();
}
};
for (Column column : Column.values()) {
// since it is remote sorting we do not provide local cached data service
ResultComparator<ExceptionSensorData> resultComparator = new ResultComparator<>(column.dataComparator);
exceptionViewerComparator.addColumn(getMappedTableViewerColumn(column).getColumn(), resultComparator);
}
return exceptionViewerComparator;
}
/**
* {@inheritDoc}
*/
@Override
public Set<PreferenceId> getPreferenceIds() {
Set<PreferenceId> preferences = EnumSet.noneOf(PreferenceId.class);
if (getInputDefinition().getRepositoryDefinition() instanceof CmrRepositoryDefinition) {
preferences.add(PreferenceId.CLEAR_BUFFER);
preferences.add(PreferenceId.LIVEMODE);
}
preferences.add(PreferenceId.UPDATE);
preferences.add(PreferenceId.ITEMCOUNT);
preferences.add(PreferenceId.TIMELINE);
return preferences;
}
/**
* {@inheritDoc}
*/
@Override
public boolean canOpenInput(List<? extends Object> data) {
if (data.isEmpty()) {
return true;
}
return false;
}
/**
* {@inheritDoc}
*/
@Override
public void setLimit(int limit) {
this.limit = limit;
}
/**
* {@inheritDoc}
*/
@Override
public void preferenceEventFired(PreferenceEvent preferenceEvent) {
switch (preferenceEvent.getPreferenceId()) {
case TIMELINE:
Map<IPreferenceGroup, Object> preferenceMap = preferenceEvent.getPreferenceMap();
if (preferenceMap.containsKey(PreferenceId.TimeLine.FROM_DATE_ID)) {
fromDate = (Date) preferenceMap.get(PreferenceId.TimeLine.FROM_DATE_ID);
}
if (preferenceMap.containsKey(PreferenceId.TimeLine.TO_DATE_ID)) {
toDate = (Date) preferenceMap.get(PreferenceId.TimeLine.TO_DATE_ID);
}
break;
default:
break;
}
}
/**
* {@inheritDoc}
*/
@Override
public void doRefresh(IProgressMonitor monitor, IRootEditor rootEditor) {
monitor.beginTask("Updating the Ungrouped Exception Overview", IProgressMonitor.UNKNOWN);
monitor.subTask("Retrieving the Ungrouped Exception Overview");
loadDataFromService();
monitor.done();
}
/**
* Reloads the data from the service.
*/
private void loadDataFromService() {
List<ExceptionSensorData> exData = null;
// if fromDate and toDate are set, then we retrieve only the data for
// this time interval
if ((null != fromDate) && (null != toDate)) {
exData = dataAccessService.getUngroupedExceptionOverview(template, limit, fromDate, toDate, resultComparator);
} else {
exData = dataAccessService.getUngroupedExceptionOverview(template, limit, resultComparator);
}
exceptionSensorData.clear();
if (null != exData) {
exceptionSensorData.addAll(exData);
}
}
/**
* {@inheritDoc}
*/
@Override
public void doubleClick(DoubleClickEvent event) {
final StructuredSelection selection = (StructuredSelection) event.getSelection();
if (!selection.isEmpty()) {
try {
PlatformUI.getWorkbench().getProgressService().busyCursorWhile(new IRunnableWithProgress() {
@Override
public void run(final IProgressMonitor monitor) {
monitor.beginTask("Retrieving Exception Tree", IProgressMonitor.UNKNOWN);
ExceptionSensorData data = (ExceptionSensorData) selection.getFirstElement();
List<ExceptionSensorData> exceptionSensorDataList = dataAccessService.getExceptionTree(data);
final List<ExceptionSensorData> finalSensorDataList = new ArrayList<>();
finalSensorDataList.add(exceptionSensorDataList.get(0));
Display.getDefault().asyncExec(new Runnable() {
@Override
public void run() {
IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
IWorkbenchPage page = window.getActivePage();
IRootEditor rootEditor = (IRootEditor) page.getActiveEditor();
rootEditor.setDataInput(finalSensorDataList);
}
});
monitor.done();
}
});
} catch (InvocationTargetException e) {
MessageDialog.openError(Display.getDefault().getActiveShell().getShell(), "Error", e.getCause().toString());
} catch (InterruptedException e) {
MessageDialog.openInformation(Display.getDefault().getActiveShell().getShell(), "Cancelled", e.getCause().toString());
}
}
}
/**
* The label provider for this view.
*
* @author <NAME>
*
*/
private final class UngroupedExceptionOverviewLabelProvider extends StyledCellIndexLabelProvider {
/**
* {@inheritDoc}
*/
@Override
protected StyledString getStyledText(Object element, int index) {
ExceptionSensorData data = (ExceptionSensorData) element;
MethodIdent methodIdent = cachedDataService.getMethodIdentForId(data.getMethodIdent());
Column enumId = Column.fromOrd(index);
return getStyledTextForColumn(data, methodIdent, enumId);
}
}
/**
* The content provider for this view.
*
* @author <NAME>
*
*/
private static final class UngroupedExceptionOverviewContentProvider implements IStructuredContentProvider {
/**
* {@inheritDoc}
*/
@Override
@SuppressWarnings("unchecked")
public Object[] getElements(Object inputElement) {
List<ExceptionSensorData> exceptionSensorData = (List<ExceptionSensorData>) inputElement;
return exceptionSensorData.toArray();
}
/**
* {@inheritDoc}
*/
@Override
public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
}
/**
* {@inheritDoc}
*/
@Override
public void dispose() {
}
}
/**
* Returns the styled text for a specific column.
*
* @param data
* The data object to extract the information from.
* @param methodIdent
* The method ident object.
* @param enumId
* The enumeration ID.
* @return The styled string containing the information from the data object.
*/
private StyledString getStyledTextForColumn(ExceptionSensorData data, MethodIdent methodIdent, Column enumId) {
switch (enumId) {
case PACKAGE:
if ((methodIdent.getPackageName() != null) && !methodIdent.getPackageName().equals("")) {
return new StyledString(methodIdent.getPackageName());
} else {
return new StyledString("(default)");
}
case CLASS:
return new StyledString(methodIdent.getClassName());
case TIMESTAMP:
return new StyledString(NumberFormatter.formatTime(data.getTimeStamp()));
case INVOCATION_AFFILLIATION:
int percentage = (int) (data.getInvocationAffiliationPercentage() * 100);
int invocations = 0;
if (null != data.getInvocationParentsIdSet()) {
invocations = data.getInvocationParentsIdSet().size();
}
return TextFormatter.getInvocationAffilliationPercentageString(percentage, invocations);
default:
return new StyledString("error");
}
}
/**
* {@inheritDoc}
*/
@Override
public String getReadableString(Object object) {
if (object instanceof ExceptionSensorData) {
ExceptionSensorData data = (ExceptionSensorData) object;
StringBuilder sb = new StringBuilder();
MethodIdent methodIdent = cachedDataService.getMethodIdentForId(data.getMethodIdent());
for (Column column : Column.values()) {
sb.append(getStyledTextForColumn(data, methodIdent, column).toString());
sb.append('\t');
}
return sb.toString();
}
throw new RuntimeException("Could not create the human readable string!");
}
/**
* {@inheritDoc}
*/
@Override
public List<String> getColumnValues(Object object) {
if (object instanceof ExceptionSensorData) {
ExceptionSensorData data = (ExceptionSensorData) object;
MethodIdent methodIdent = cachedDataService.getMethodIdentForId(data.getMethodIdent());
List<String> values = new ArrayList<>();
for (Column column : Column.values()) {
values.add(getStyledTextForColumn(data, methodIdent, column).toString());
}
return values;
}
throw new RuntimeException("Could not create the column values!");
}
}
| 5,599 |
1,350 | /**
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for
* license information.
*
* Code generated by Microsoft (R) AutoRest Code Generator.
*/
package com.microsoft.azure.cognitiveservices.vision.faceapi.models;
import com.fasterxml.jackson.annotation.JsonProperty;
/**
* A combination of user defined name and user specified data for the person,
* personGroup, and faceList.
*/
public class NameAndUserDataContract {
/**
* User defined name, maximum length is 128.
*/
@JsonProperty(value = "name")
private String name;
/**
* User specified data. Length should not exceed 16KB.
*/
@JsonProperty(value = "userData")
private String userData;
/**
* Get the name value.
*
* @return the name value
*/
public String name() {
return this.name;
}
/**
* Set the name value.
*
* @param name the name value to set
* @return the NameAndUserDataContract object itself.
*/
public NameAndUserDataContract withName(String name) {
this.name = name;
return this;
}
/**
* Get the userData value.
*
* @return the userData value
*/
public String userData() {
return this.userData;
}
/**
* Set the userData value.
*
* @param userData the userData value to set
* @return the NameAndUserDataContract object itself.
*/
public NameAndUserDataContract withUserData(String userData) {
this.userData = userData;
return this;
}
}
| 594 |
711 | package com.java110.common.listener.applicationKey;
import com.alibaba.fastjson.JSONObject;
import com.java110.common.dao.IApplicationKeyServiceDao;
import com.java110.entity.center.Business;
import com.java110.core.event.service.AbstractBusinessServiceDataFlowListener;
import com.java110.utils.constant.ResponseConstant;
import com.java110.utils.constant.StatusConstant;
import com.java110.utils.exception.ListenerExecuteException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* 钥匙申请 服务侦听 父类
* Created by wuxw on 2018/7/4.
*/
public abstract class AbstractApplicationKeyBusinessServiceDataFlowListener extends AbstractBusinessServiceDataFlowListener {
private static Logger logger = LoggerFactory.getLogger(AbstractApplicationKeyBusinessServiceDataFlowListener.class);
/**
* 获取 DAO工具类
*
* @return
*/
public abstract IApplicationKeyServiceDao getApplicationKeyServiceDaoImpl();
/**
* 刷新 businessApplicationKeyInfo 数据
* 主要将 数据库 中字段和 接口传递字段建立关系
*
* @param businessApplicationKeyInfo
*/
protected void flushBusinessApplicationKeyInfo(Map businessApplicationKeyInfo, String statusCd) {
businessApplicationKeyInfo.put("newBId", businessApplicationKeyInfo.get("b_id"));
businessApplicationKeyInfo.put("applicationKeyId", businessApplicationKeyInfo.get("application_key_id"));
businessApplicationKeyInfo.put("idCard", businessApplicationKeyInfo.get("id_card"));
businessApplicationKeyInfo.put("sex", businessApplicationKeyInfo.get("sex"));
businessApplicationKeyInfo.put("endTime", businessApplicationKeyInfo.get("end_time"));
businessApplicationKeyInfo.put("machineId", businessApplicationKeyInfo.get("machine_id"));
businessApplicationKeyInfo.put("operate", businessApplicationKeyInfo.get("operate"));
businessApplicationKeyInfo.put("typeCd", businessApplicationKeyInfo.get("type_cd"));
businessApplicationKeyInfo.put("name", businessApplicationKeyInfo.get("name"));
businessApplicationKeyInfo.put("tel", businessApplicationKeyInfo.get("tel"));
businessApplicationKeyInfo.put("startTime", businessApplicationKeyInfo.get("start_time"));
businessApplicationKeyInfo.put("state", businessApplicationKeyInfo.get("state"));
businessApplicationKeyInfo.put("age", businessApplicationKeyInfo.get("age"));
businessApplicationKeyInfo.put("communityId", businessApplicationKeyInfo.get("community_id"));
businessApplicationKeyInfo.put("typeFlag", businessApplicationKeyInfo.get("type_flag"));
businessApplicationKeyInfo.put("pwd", businessApplicationKeyInfo.get("pwd"));
businessApplicationKeyInfo.remove("bId");
businessApplicationKeyInfo.put("statusCd", statusCd);
}
/**
* 当修改数据时，查询instance表中的数据 自动保存删除数据到business中
*
* @param businessApplicationKey 钥匙申请信息
*/
protected void autoSaveDelBusinessApplicationKey(Business business, JSONObject businessApplicationKey) {
//自动插入DEL
Map info = new HashMap();
info.put("applicationKeyId", businessApplicationKey.getString("applicationKeyId"));
info.put("statusCd", StatusConstant.STATUS_CD_VALID);
List<Map> currentApplicationKeyInfos = getApplicationKeyServiceDaoImpl().getApplicationKeyInfo(info);
if (currentApplicationKeyInfos == null || currentApplicationKeyInfos.size() != 1) {
throw new ListenerExecuteException(ResponseConstant.RESULT_PARAM_ERROR, "未找到需要修改数据信息，入参错误或数据有问题，请检查" + info);
}
Map currentApplicationKeyInfo = currentApplicationKeyInfos.get(0);
currentApplicationKeyInfo.put("bId", business.getbId());
currentApplicationKeyInfo.put("applicationKeyId", currentApplicationKeyInfo.get("application_key_id"));
currentApplicationKeyInfo.put("idCard", currentApplicationKeyInfo.get("id_card"));
currentApplicationKeyInfo.put("sex", currentApplicationKeyInfo.get("sex"));
currentApplicationKeyInfo.put("endTime", currentApplicationKeyInfo.get("end_time"));
currentApplicationKeyInfo.put("machineId", currentApplicationKeyInfo.get("machine_id"));
currentApplicationKeyInfo.put("operate", currentApplicationKeyInfo.get("operate"));
currentApplicationKeyInfo.put("typeCd", currentApplicationKeyInfo.get("type_cd"));
currentApplicationKeyInfo.put("name", currentApplicationKeyInfo.get("name"));
currentApplicationKeyInfo.put("tel", currentApplicationKeyInfo.get("tel"));
currentApplicationKeyInfo.put("startTime", currentApplicationKeyInfo.get("start_time"));
currentApplicationKeyInfo.put("state", currentApplicationKeyInfo.get("state"));
currentApplicationKeyInfo.put("age", currentApplicationKeyInfo.get("age"));
currentApplicationKeyInfo.put("communityId", currentApplicationKeyInfo.get("community_id"));
currentApplicationKeyInfo.put("typeFlag", currentApplicationKeyInfo.get("type_flag"));
currentApplicationKeyInfo.put("pwd", <PASSWORD>ApplicationKey<PASSWORD>("<PASSWORD>"));
currentApplicationKeyInfo.put("operate", StatusConstant.OPERATE_DEL);
getApplicationKeyServiceDaoImpl().saveBusinessApplicationKeyInfo(currentApplicationKeyInfo);
for (Object key : currentApplicationKeyInfo.keySet()) {
if (businessApplicationKey.get(key) == null) {
businessApplicationKey.put(key.toString(), currentApplicationKeyInfo.get(key));
}
}
}
}
| 2,033 |
647 | #ifndef HANDLE_HTTP_GET_HELLO
#define HANDLE_HTTP_GET_HELLO
#ifndef SWIG
void handle_HTTP_GET_hello(struct mg_connection *nc, struct http_message *hm);
#endif
#endif | 68 |
650 | //
// SimpleAuthFoursquareWebLoginViewController.h
// SimpleAuth
//
// Created by <NAME> on 23/01/2014.
// Copyright (c) 2014 Byliner, Inc. All rights reserved.
//
#import "SimpleAuthWebViewController.h"
@interface SimpleAuthFoursquareWebLoginViewController : SimpleAuthWebViewController
@end
| 96 |
412 | namespace some_namespace
{
class X;
};
// This is allowed, as the class tag is already there.
class some_namespace::X
{
};
// Perhaps surprisingly, the same does not seem to be true for enum tags on g++,
// but Visual studio is happy to do this.
int main()
{
}
| 84 |
1,056 | <filename>ide/libs.git/test/unit/src/org/netbeans/libs/git/jgit/commands/UnignoreTest.java
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.netbeans.libs.git.jgit.commands;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import org.eclipse.jgit.lib.ConfigConstants;
import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.lib.StoredConfig;
import org.netbeans.libs.git.GitClient;
import org.netbeans.libs.git.GitStatus.Status;
import org.netbeans.libs.git.jgit.AbstractGitTestCase;
import org.netbeans.libs.git.progress.ProgressMonitor;
/**
*
* @author ondra
*/
public class UnignoreTest extends AbstractGitTestCase {
private File workDir;
public UnignoreTest (String testName) throws IOException {
super(testName);
}
@Override
protected void setUp() throws Exception {
super.setUp();
workDir = getWorkingDirectory();
}
public void testUnignoreFileInRoot () throws Exception {
File f = new File(workDir, "file");
f.createNewFile();
File gitIgnore = new File(workDir, Constants.DOT_GIT_IGNORE);
File[] ignores = getClient(workDir).unignore(new File[] { f }, NULL_PROGRESS_MONITOR);
assertFalse(gitIgnore.exists());
assertEquals(0, ignores.length);
write(gitIgnore, "/file");
ignores = getClient(workDir).unignore(new File[] { f }, NULL_PROGRESS_MONITOR);
assertEquals("", read(gitIgnore));
assertEquals(Arrays.asList(gitIgnore), Arrays.asList(ignores));
write(gitIgnore, "f\nf2\n/file\nf3\nf4");
ignores = getClient(workDir).unignore(new File[] { f }, NULL_PROGRESS_MONITOR);
assertEquals("f\nf2\nf3\nf4", read(gitIgnore));
assertEquals(Arrays.asList(gitIgnore), Arrays.asList(ignores));
}
public void testUnignoreFileWithStarChar () throws Exception {
if (isWindows()) {
// win do not allow '*' in filename
return;
}
File f = new File(workDir, "fi*le");
f.createNewFile();
File gitIgnore = new File(workDir, Constants.DOT_GIT_IGNORE);
File[] ignores = getClient(workDir).ignore(new File[] { f }, NULL_PROGRESS_MONITOR);
assertEquals("/fi[*]le", read(gitIgnore));
assertEquals(Arrays.asList(gitIgnore), Arrays.asList(ignores));
ignores = getClient(workDir).unignore(new File[] { f }, NULL_PROGRESS_MONITOR);
assertEquals("", read(gitIgnore));
assertEquals(Arrays.asList(gitIgnore), Arrays.asList(ignores));
}
public void testUnignoreFileWithQuestionMark () throws Exception {
if (isWindows()) {
// win do not allow '?' in filename
return;
}
File f = new File(workDir, "fi?le");
f.createNewFile();
File gitIgnore = new File(workDir, Constants.DOT_GIT_IGNORE);
File[] ignores = getClient(workDir).ignore(new File[] { f }, NULL_PROGRESS_MONITOR);
assertEquals("/fi[?]le", read(gitIgnore));
ignores = getClient(workDir).unignore(new File[] { f }, NULL_PROGRESS_MONITOR);
assertEquals("", read(gitIgnore));
assertEquals(Arrays.asList(gitIgnore), Arrays.asList(ignores));
}
public void testUnignoreFileWithBracket () throws Exception {
File f = new File(workDir, "fi[le");
f.createNewFile();
File gitIgnore = new File(workDir, Constants.DOT_GIT_IGNORE);
File[] ignores = getClient(workDir).ignore(new File[] { f }, NULL_PROGRESS_MONITOR);
assertEquals("/fi[[]le", read(gitIgnore));
assertEquals(Arrays.asList(gitIgnore), Arrays.asList(ignores));
ignores = getClient(workDir).unignore(new File[] { f }, NULL_PROGRESS_MONITOR);
assertEquals("", read(gitIgnore));
}
public void testUnignoreFolderInRoot () throws Exception {
File f = new File(workDir, "folder");
f.mkdirs();
File gitIgnore = new File(workDir, Constants.DOT_GIT_IGNORE);
File[] ignores = getClient(workDir).unignore(new File[] { f }, NULL_PROGRESS_MONITOR);
assertFalse(gitIgnore.exists());
assertEquals(0, ignores.length);
write(gitIgnore, "/folder/");
ignores = getClient(workDir).unignore(new File[] { f }, NULL_PROGRESS_MONITOR);
assertEquals("", read(gitIgnore));
assertEquals(Arrays.asList(gitIgnore), Arrays.asList(ignores));
write(gitIgnore, "/folder");
ignores = getClient(workDir).unignore(new File[] { f }, NULL_PROGRESS_MONITOR);
assertEquals("/folder\n!/folder/", read(gitIgnore));
assertEquals(Arrays.asList(gitIgnore), Arrays.asList(ignores));
}
public void testUnignoreFileInSubfolder () throws Exception {
File f = new File(new File(new File(workDir, "sf1"), "sf2"), "file");
f.getParentFile().mkdirs();
f.createNewFile();
File gitIgnore = new File(workDir, Constants.DOT_GIT_IGNORE);
File[] ignores = getClient(workDir).unignore(new File[] { f }, NULL_PROGRESS_MONITOR);
assertFalse(gitIgnore.exists());
assertEquals(0, ignores.length);
write(gitIgnore, "/sf1/sf2/file");
ignores = getClient(workDir).unignore(new File[] { f }, NULL_PROGRESS_MONITOR);
assertEquals("", read(gitIgnore));
assertEquals(Arrays.asList(gitIgnore), Arrays.asList(ignores));
write(gitIgnore, "/sf1/sf2/file/");
ignores = getClient(workDir).unignore(new File[] { f }, NULL_PROGRESS_MONITOR);
assertEquals("/sf1/sf2/file/", read(gitIgnore));
assertEquals(0, ignores.length);
}
public void testUnignoreFolderInSubfolder () throws Exception {
File f = new File(new File(new File(workDir, "sf1"), "sf2"), "folder");
f.mkdirs();
File gitIgnore = new File(workDir, Constants.DOT_GIT_IGNORE);
File[] ignores = getClient(workDir).unignore(new File[] { f }, NULL_PROGRESS_MONITOR);
assertFalse(gitIgnore.exists());
assertEquals(0, ignores.length);
write(gitIgnore, "sf1/sf2/folder/");
ignores = getClient(workDir).unignore(new File[] { f }, NULL_PROGRESS_MONITOR);
assertEquals("", read(gitIgnore));
assertEquals(Arrays.asList(gitIgnore), Arrays.asList(ignores));
write(gitIgnore, "/sf1/sf2/folder");
ignores = getClient(workDir).unignore(new File[] { f }, NULL_PROGRESS_MONITOR);
assertEquals("/sf1/sf2/folder\n!/sf1/sf2/folder/", read(gitIgnore));
assertEquals(Arrays.asList(gitIgnore), Arrays.asList(ignores));
}
public void testUnignoreWithNegation () throws Exception {
File f = new File(new File(new File(workDir, "sf1"), "sf2"), "file");
f.getParentFile().mkdirs();
f.createNewFile();
File gitIgnore = new File(workDir, Constants.DOT_GIT_IGNORE);
write(gitIgnore, "!/sf1/sf2/file");
File[] ignores = getClient(workDir).unignore(new File[] { f }, NULL_PROGRESS_MONITOR);
assertTrue(gitIgnore.exists());
assertEquals("!/sf1/sf2/file", read(gitIgnore));
assertEquals(0, ignores.length);
write(gitIgnore, "/sf1/sf2/file\n!/sf1/sf2/file");
ignores = getClient(workDir).unignore(new File[] { f }, NULL_PROGRESS_MONITOR);
assertTrue(gitIgnore.exists());
assertEquals("!/sf1/sf2/file", read(gitIgnore));
assertEquals(Arrays.asList(gitIgnore), Arrays.asList(ignores));
write(gitIgnore, "!/sf1/sf2/file\n/sf1/sf2/file");
ignores = getClient(workDir).unignore(new File[] { f }, NULL_PROGRESS_MONITOR);
assertTrue(gitIgnore.exists());
assertEquals("!/sf1/sf2/file", read(gitIgnore));
assertEquals(Arrays.asList(gitIgnore), Arrays.asList(ignores));
write(gitIgnore, "file");
ignores = getClient(workDir).unignore(new File[] { f }, NULL_PROGRESS_MONITOR);
assertTrue(gitIgnore.exists());
assertEquals("file\n!/sf1/sf2/file", read(gitIgnore));
assertEquals(Arrays.asList(gitIgnore), Arrays.asList(ignores));
File gitIgnoreNested = new File(f.getParentFile(), Constants.DOT_GIT_IGNORE);
File gitIgnoreNested2 = new File(f.getParentFile().getParentFile(), Constants.DOT_GIT_IGNORE);
write(gitIgnoreNested, "/file");
write(gitIgnoreNested2, "/sf2/file");
write(gitIgnore, "/sf1/sf2/file");
ignores = getClient(workDir).unignore(new File[] { f }, NULL_PROGRESS_MONITOR);
assertEquals("", read(gitIgnore));
assertEquals("", read(gitIgnoreNested));
assertEquals("", read(gitIgnoreNested2));
assertEquals(Arrays.asList(gitIgnoreNested, gitIgnoreNested2, gitIgnore), Arrays.asList(ignores));
}
public void testUnignoreFolderWithNegation () throws Exception {
File f = new File(new File(new File(workDir, "sf1"), "sf2"), "folder");
f.mkdirs();
File gitIgnore = new File(workDir, Constants.DOT_GIT_IGNORE);
write(gitIgnore, "/sf1/sf2/folder/\n!/sf1/sf2/folder/");
File[] ignores = getClient(workDir).unignore(new File[] { f }, NULL_PROGRESS_MONITOR);
assertTrue(gitIgnore.exists());
assertEquals("!/sf1/sf2/folder/", read(gitIgnore));
assertEquals(Arrays.asList(gitIgnore), Arrays.asList(ignores));
write(gitIgnore, "/sf1/sf2/folder\n!/sf1/sf2/folder/");
ignores = getClient(workDir).unignore(new File[] { f }, NULL_PROGRESS_MONITOR);
assertTrue(gitIgnore.exists());
assertEquals("/sf1/sf2/folder\n!/sf1/sf2/folder/", read(gitIgnore));
assertEquals(0, ignores.length);
write(gitIgnore, "!/sf1/sf2/folder/\n/sf1/sf2/folder/");
ignores = getClient(workDir).unignore(new File[] { f }, NULL_PROGRESS_MONITOR);
assertTrue(gitIgnore.exists());
assertEquals("!/sf1/sf2/folder/", read(gitIgnore));
assertEquals(Arrays.asList(gitIgnore), Arrays.asList(ignores));
}
public void testUnignoreExcludedFile () throws Exception {
File f = new File(new File(new File(workDir, "sf1"), "sf2"), "file");
f.getParentFile().mkdirs();
f.createNewFile();
File excludeFile = new File(workDir, ".git/info/exclude");
excludeFile.getParentFile().mkdirs();
write(excludeFile, "/sf1/sf2/file");
File[] ignores = getClient(workDir).unignore(new File[] { f }, NULL_PROGRESS_MONITOR);
assertTrue(excludeFile.exists());
assertEquals("", read(excludeFile));
assertEquals(Arrays.asList(excludeFile), Arrays.asList(ignores));
write(excludeFile, "file");
ignores = getClient(workDir).unignore(new File[] { f }, NULL_PROGRESS_MONITOR);
assertTrue(excludeFile.exists());
assertEquals("file\n!/sf1/sf2/file", read(excludeFile));
assertEquals(Arrays.asList(excludeFile), Arrays.asList(ignores));
write(excludeFile, "");
ignores = getClient(workDir).unignore(new File[] { f }, NULL_PROGRESS_MONITOR);
assertTrue(excludeFile.exists());
assertEquals("", read(excludeFile));
assertEquals(0, ignores.length);
}
public void test199443_GlobalIgnoreFile () throws Exception {
File f = new File(new File(workDir, "nbproject"), "file");
f.getParentFile().mkdirs();
f.createNewFile();
File ignoreFile = new File(workDir.getParentFile(), "globalignore");
write(ignoreFile, "nbproject");
Repository repo = getRepository(getLocalGitRepository());
StoredConfig cfg = repo.getConfig();
cfg.setString(ConfigConstants.CONFIG_CORE_SECTION, null, ConfigConstants.CONFIG_KEY_EXCLUDESFILE, ignoreFile.getAbsolutePath());
cfg.save();
GitClient client = getClient(workDir);
assertEquals(Status.STATUS_IGNORED, client.getStatus(new File[] { f }, NULL_PROGRESS_MONITOR).get(f).getStatusIndexWC());
assertEquals(new File(workDir, Constants.GITIGNORE_FILENAME), client.unignore(new File[] { f }, NULL_PROGRESS_MONITOR)[0]);
write(new File(workDir, Constants.GITIGNORE_FILENAME), "/nbproject/file");
assertEquals(new File(workDir, Constants.GITIGNORE_FILENAME), client.unignore(new File[] { f }, NULL_PROGRESS_MONITOR)[0]);
assertEquals("!/nbproject/file", read(new File(workDir, Constants.GITIGNORE_FILENAME)));
}
}
| 5,651 |
515 | /*=========================================================================
Library: CTK
Copyright (c) Kitware Inc.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0.txt
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
=========================================================================*/
// Qt includes
#include <QAction>
#include <QApplication>
#include <QCheckBox>
#include <QDebug>
#include <QSettings>
#include <QStandardItemModel>
#include <QTimer>
#include <QTreeView>
// CTK includes
#include "ctkCallback.h"
#include "ctkConfig.h"
#include "ctkSettingsDialog.h"
#include "ctkSettingsPanel.h"
#include "ctkEventTranslatorPlayerWidget.h"
// QtTesting includes
#include "pqTestUtility.h"
// STD includes
#include <cstdlib>
#include <iostream>
namespace
{
//-----------------------------------------------------------------------------
void checkFinalWidgetState(void* data)
{
ctkSettingsDialog* widget = reinterpret_cast<ctkSettingsDialog*>(data);
CTKCOMPARE(widget->currentPanel()->windowTitle(), "Panel 4");
}
}
//-----------------------------------------------------------------------------
int ctkSettingsDialogEventTranslatorPlayerTest1(int argc, char * argv [] )
{
QApplication app(argc, argv);
QString xmlDirectory = CTK_SOURCE_DIR "/Libs/Widgets/Testing/Cpp/";
// ------------------------
ctkEventTranslatorPlayerWidget etpWidget;
pqTestUtility* testUtility = new pqTestUtility(&etpWidget);
etpWidget.setTestUtility(testUtility);
// Test case 1
QSettings settings(QSettings::IniFormat, QSettings::UserScope, "Common ToolKit", "CTK");
settings.remove("key 1");
ctkSettingsDialog* widget = new ctkSettingsDialog();
ctkSettingsPanel* panel1 = new ctkSettingsPanel;
widget->addPanel("Panel 1", panel1);
widget->addPanel("Panel 2", new ctkSettingsPanel);
widget->addPanel("Panel 3", new ctkSettingsPanel);
ctkSettingsPanel* panel4 = new ctkSettingsPanel;
widget->addPanel("Panel 4", panel4, panel1);
widget->setCurrentPanel("Panel 4");
QCheckBox* box = new QCheckBox(panel4);
box->setChecked(true);
QVariant boxVal = settings.value("key 1");
boxVal = settings.value("key 1");
panel4->registerProperty("key 1", box, "checked",
SIGNAL(toggled(bool)));
etpWidget.addTestCase(widget,
xmlDirectory + "ctkSettingsDialogEventTranslatorPlayerTest1.xml",
&checkFinalWidgetState);
// ------------------------
if (argc < 2 || QString(argv[1]) != "-I")
{
QTimer::singleShot(0, &etpWidget, SLOT(play()));
}
etpWidget.show();
return app.exec();
}
| 957 |
1,738 | /*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#ifndef CRYINCLUDE_EDITOR_LENSFLAREEDITOR_ILENSFLARELISTENER_H
#define CRYINCLUDE_EDITOR_LENSFLAREEDITOR_ILENSFLARELISTENER_H
#pragma once
class CLensFlareItem;
class CLensFlareElement;
class ILensFlareChangeItemListener
{
public:
virtual void OnLensFlareChangeItem(CLensFlareItem* pLensFlareItem) = 0;
virtual void OnLensFlareDeleteItem(CLensFlareItem* pLensFlareItem) = 0;
};
class ILensFlareChangeElementListener
{
public:
virtual void OnLensFlareChangeElement(CLensFlareElement* pLensFlareElement) = 0;
};
#endif // CRYINCLUDE_EDITOR_LENSFLAREEDITOR_ILENSFLARELISTENER_H
| 387 |
408 | #include <vector>
#include "caffe/filler.hpp"
#include "caffe/layer.hpp"
#include "caffe/vision_layers.hpp"
namespace caffe {
template <typename Dtype>
void DummyDataLayer<Dtype>::LayerSetUp(const vector<Blob<Dtype>*>& bottom,
vector<Blob<Dtype>*>* top) {
const int num_top = top->size();
const DummyDataParameter& param = this->layer_param_.dummy_data_param();
const int num_data_filler = param.data_filler_size();
CHECK(num_data_filler == 0 || num_data_filler == 1 ||
num_data_filler == num_top)
<< "Number of data fillers must be 0, 1 or equal to the number of tops: "
<< num_top << "; you specified " << num_data_filler << " data fillers.";
CHECK(param.num_size() == 1 || param.num_size() == num_top)
<< "Must specify either a single (1) 'num' or one for each top blob "
<< "(" << num_top << "); you specified " << param.num_size() << ".";
CHECK(param.channels_size() == 1 || param.channels_size() == num_top)
<< "Must specify either a single (1) 'channels' or one for each top blob "
<< "(" << num_top << "); you specified " << param.channels_size() << ".";
CHECK(param.height_size() == 1 || param.height_size() == num_top)
<< "Must specify either a single (1) 'height' or one for each top blob "
<< "(" << num_top << "); you specified " << param.height_size() << ".";
CHECK(param.width_size() == 1 || param.width_size() == num_top)
<< "Must specify either a single (1) 'width' or one for each top blob "
<< "(" << num_top << "); you specified " << param.width_size() << ".";
// refill_[i] tells Forward i whether or not to actually refill top Blob i.
// If refill_[i] is false, Forward does nothing for Blob i. We use this to
// avoid wastefully refilling "constant" Blobs in every forward pass.
// We first fill refill_ in with the INVERSE of its final values.
// The first time we run Forward from the LayerSetUp method, we'll fill only
// Blobs for which refill_ is normally false. These Blobs will never be
// filled again.
refill_.clear();
fillers_.clear();
if (num_data_filler <= 1) {
FillerParameter filler_param;
if (num_data_filler == 0) {
filler_param.set_type("constant");
filler_param.set_value(0);
} else {
filler_param.CopyFrom(param.data_filler(0));
}
// Refill on each iteration iff not using a constant filler,
// but use the inverse of this rule for the first run.
refill_.resize(1);
refill_[0] = (strcmp(filler_param.type().c_str(), "constant") == 0);
fillers_.resize(1);
fillers_[0].reset(GetFiller<Dtype>(filler_param));
} else {
refill_.resize(num_top);
fillers_.resize(num_top);
for (int i = 0; i < num_top; ++i) {
fillers_[i].reset(GetFiller<Dtype>(param.data_filler(i)));
// Refill on each iteration iff not using a constant filler,
// but use the inverse of this rule for the first run.
refill_[i] =
(strcmp(param.data_filler(i).type().c_str(), "constant") == 0);
}
}
for (int i = 0; i < num_top; ++i) {
const int num = (param.num_size() == 1) ? param.num(0) : param.num(i);
const int channels =
(param.channels_size() == 1) ? param.channels(0) : param.channels(i);
const int height =
(param.height_size() == 1) ? param.height(0) : param.height(i);
const int width =
(param.width_size() == 1) ? param.width(0) : param.width(i);
(*top)[i]->Reshape(num, channels, height, width);
}
// Run Forward once, with refill_ inverted, to fill the constant Blobs.
this->Forward(bottom, top);
// Invert the inverted refill_ values to refill the desired (non-constant)
// Blobs in every usual forward pass.
for (int i = 0; i < refill_.size(); ++i) {
refill_[i] = !refill_[i];
}
}
template <typename Dtype>
void DummyDataLayer<Dtype>::Forward_cpu(const vector<Blob<Dtype>*>& bottom,
vector<Blob<Dtype>*>* top) {
for (int i = 0; i < top->size(); ++i) {
const int filler_id = (fillers_.size() > 1) ? i : 0;
if (refill_[filler_id]) {
fillers_[filler_id]->Fill((*top)[i]);
}
}
}
INSTANTIATE_CLASS(DummyDataLayer);
} // namespace caffe
| 1,610 |
406 | <filename>mmdet/ops/__init__.py
from .nms import nms, soft_nms
from .roi_align import RoIAlign, roi_align
from .roi_pool import RoIPool, roi_pool
__all__ = ['nms', 'soft_nms', 'RoIAlign', 'roi_align', 'RoIPool', 'roi_pool']
| 99 |
404 | <reponame>draffensperger/go-c-cpp-examples
#ifndef ADD_HARMONIC_H
#define ADD_HARMONIC_H
double add_harmonic(double total_so_far, long i);
#endif
| 66 |
826 | <filename>eventuate-tram-sagas-reactive-orchestration-simple-dsl/src/main/java/io/eventuate/tram/sagas/reactive/simpledsl/SimpleReactiveSagaDsl.java<gh_stars>100-1000
package io.eventuate.tram.sagas.reactive.simpledsl;
public interface SimpleReactiveSagaDsl<Data> {
default ReactiveStepBuilder<Data> step() {
SimpleReactiveSagaDefinitionBuilder<Data> builder = new SimpleReactiveSagaDefinitionBuilder<>();
return new ReactiveStepBuilder<>(builder);
}
} | 164 |
1,428 | ##!/usr/bin/env python
'''
<NAME>
'''
def main():
world = 'World!'
print(f'Hello, {world}')
if __name__ == '__main__':
main()
| 65 |
340 | <reponame>cxsper/saleor
from .models import Foo
| 18 |
322 |
//
// Warning: don't edit - generated by generate_ecu_code.pl processing ../dev/sme_i1.json: SME 07: Battery management electronics
// This generated code makes it easier to process CANBUS messages from the SME ecu in a BMW i3
//
case I3_PID_SME_ALTERUNG_INNENWIDERSTAND_TS: { // 0x6334
if (datalen < 4) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_ALTERUNG_INNENWIDERSTAND_TS", 4);
break;
}
unsigned long STAT_ALTERUNG_INNENWIDERSTAND_WERT = (RXBUF_UINT32(0));
// Aging of the internal resistance in percent: Internal resistance of the storage tank when new is related to
// the current value of the internal resistance (R_neu / R_akt) * 100 (100% = new condition, decreases with
// aging) / Alterung des Innenwiderstands in Prozent: Innenwiderstand des Speichers im Neuzustand auf den
// aktuellen Wert des Innenwiderstands bezogen (R_neu /R_akt) *100 (100% = Neuzustand, sinkt mit Alterung)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ALTERUNG_INNENWIDERSTAND_TS", "STAT_ALTERUNG_INNENWIDERSTAND_WERT", STAT_ALTERUNG_INNENWIDERSTAND_WERT, "\"%\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_ALTERUNG_KAPAZITAET_TS: { // 0x6335
if (datalen < 4) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_ALTERUNG_KAPAZITAET_TS", 4);
break;
}
unsigned long STAT_ALTERUNG_KAPAZITAET_WERT = (RXBUF_UINT32(0));
// Remaining capacity of the memory / Restkapazitaet des Speichers
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ALTERUNG_KAPAZITAET_TS", "STAT_ALTERUNG_KAPAZITAET_WERT", STAT_ALTERUNG_KAPAZITAET_WERT, "\"%\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME__ST_SYM_MODUS: { // 0x6516
if (datalen < 1) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME__ST_SYM_MODUS", 1);
break;
}
unsigned char STAT_SYM_MODUS = (RXBUF_UCHAR(0));
// Status of the balancing / Status der Symmetrierung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "_ST_SYM_MODUS", "STAT_SYM_MODUS", STAT_SYM_MODUS, "\"0-n\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME__UEBERLAST_ZAHELER: { // 0x651D
if (datalen < 16) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME__UEBERLAST_ZAHELER", 16);
break;
}
unsigned short STAT_OVERLOAD_K1_WERT = (RXBUF_UINT(0));
// Overload counter contactor K1 / Überlastzähler Schütz K1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "_UEBERLAST_ZAHELER", "STAT_OVERLOAD_K1_WERT", STAT_OVERLOAD_K1_WERT, "");
unsigned short STAT_OVERLOAD_K2_WERT = (RXBUF_UINT(2));
// Overload counter contactor K2 / Überlastzähler Schütz K2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "_UEBERLAST_ZAHELER", "STAT_OVERLOAD_K2_WERT", STAT_OVERLOAD_K2_WERT, "");
unsigned short STAT_OVERLOAD_K3_WERT = (RXBUF_UINT(4));
// Overload counter contactor K3 / Überlastzähler Schütz K3
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "_UEBERLAST_ZAHELER", "STAT_OVERLOAD_K3_WERT", STAT_OVERLOAD_K3_WERT, "");
unsigned short STAT_OVERLOAD_COOLING_VALVE_WERT = (RXBUF_UINT(6));
// Overload counter cooling valve / Überlastzähler Kühlventil
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "_UEBERLAST_ZAHELER", "STAT_OVERLOAD_COOLING_VALVE_WERT", STAT_OVERLOAD_COOLING_VALVE_WERT, "");
unsigned short STAT_OVERLOAD_CSC_SUPPLY_WERT = (RXBUF_UINT(8));
// Overload counter CSC supply / Überlastzähler CSC Versorgung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "_UEBERLAST_ZAHELER", "STAT_OVERLOAD_CSC_SUPPLY_WERT", STAT_OVERLOAD_CSC_SUPPLY_WERT, "");
unsigned short STAT_OVERLOAD_ISENS_WERT = (RXBUF_UINT(10));
// Overload counter current sensor / Überlastzähler Stromsensor
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "_UEBERLAST_ZAHELER", "STAT_OVERLOAD_ISENS_WERT", STAT_OVERLOAD_ISENS_WERT, "");
unsigned short STAT_OVERLOAD_COOLING_PUMP_WERT = (RXBUF_UINT(12));
// Coolant pump overload counter / Überlastzähler Kühlmittelpumpe
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "_UEBERLAST_ZAHELER", "STAT_OVERLOAD_COOLING_PUMP_WERT", STAT_OVERLOAD_COOLING_PUMP_WERT, "");
unsigned short STAT_OVERLOAD_HEATING_WERT = (RXBUF_UINT(14));
// Overload counter heating / Überlastzähler Heizung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "_UEBERLAST_ZAHELER", "STAT_OVERLOAD_HEATING_WERT", STAT_OVERLOAD_HEATING_WERT, "");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME__STATUS_UEBERNAHME_KAPATEST_NV: { // 0x6526
if (datalen < 1) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME__STATUS_UEBERNAHME_KAPATEST_NV", 1);
break;
}
unsigned char STAT_UEBERNAHME_KAPATEST_NV = (RXBUF_UCHAR(0));
// Current setting of the transfer of the results of a capacity test to the SoH_C estimator (0: no transfer, 1:
// transfer (standard)) / Aktuelle Einstellung der Ergebnisübertragung eines Kapazitätstests in den
// SoH_C-Schätzer (0: keine Übernahme, 1: Übernahme (standard))
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "_STATUS_UEBERNAHME_KAPATEST_NV", "STAT_UEBERNAHME_KAPATEST_NV", STAT_UEBERNAHME_KAPATEST_NV, "\"0-n\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_ISOLATIONSWIDERSTAND_KOMMUNIKATION: { // 0xAD5E
if (datalen < 1) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_ISOLATIONSWIDERSTAND_KOMMUNIKATION", 1);
break;
}
unsigned char STAT_KOMMUNIKATION_AVL_ISRE = (RXBUF_UCHAR(0));
// Current send status AVL_ISRE (0 = signal is not sent, 1 = signal is sent on the vehicle bus) / Aktueller
// Sendestatus AVL_ISRE (0 = Signal wird nicht gesendet, 1 = Signal wird auf Fahrzeugbus gesendet)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "ISOLATIONSWIDERSTAND_KOMMUNIKATION", "STAT_KOMMUNIKATION_AVL_ISRE", STAT_KOMMUNIKATION_AVL_ISRE, "\"0-n\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_ISOLATION: { // 0xAD61
if (datalen < 2) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_ISOLATION", 2);
break;
}
unsigned char STAT_MESSUNG_ERFOLGREICH = (RXBUF_UCHAR(0));
// Current state of insulation measurement / aktueller Zustand Isolationsmessung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "ISOLATION", "STAT_MESSUNG_ERFOLGREICH", STAT_MESSUNG_ERFOLGREICH, "\"0-n\"");
unsigned char STAT_MESSUNG_ISOLATIONSFEHLER = (RXBUF_UCHAR(1));
// current state of the insulation fault / aktueller Zustand des Isolationsfehlers
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "ISOLATION", "STAT_MESSUNG_ISOLATIONSFEHLER", STAT_MESSUNG_ISOLATIONSFEHLER, "\"0-n\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_KAPAZITAET_BESTIMMUNG: { // 0xAD66
if (datalen < 2) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_KAPAZITAET_BESTIMMUNG", 2);
break;
}
unsigned char STAT_KAPAZITAET_WERT = (RXBUF_UCHAR(0));
// Estimated capacity value in% (value range 0-100%) based on nominal capacity / Kapazitätsschätzwert in %
// (Wertebereich 0-100%) bezogen auf Nennkapazität
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "KAPAZITAET_BESTIMMUNG", "STAT_KAPAZITAET_WERT", STAT_KAPAZITAET_WERT, "\"%\"");
unsigned char STAT_AKTUELLER_ZUSTAND_NR = (RXBUF_UCHAR(1));
// Return Determination is running, successful or ended with an error / Rückgabe Ermittlung läuft, erfolgreich
// oder mit Fehler beendet
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "KAPAZITAET_BESTIMMUNG", "STAT_AKTUELLER_ZUSTAND_NR", STAT_AKTUELLER_ZUSTAND_NR, "\"0-n\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_HEIZUNG: { // 0xAD6A
if (datalen < 1) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_HEIZUNG", 1);
break;
}
unsigned char STAT_HEIZUNG_AKTIV_NR = (RXBUF_UCHAR(0));
// State of the heating / Zustand der Heizung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "HEIZUNG", "STAT_HEIZUNG_AKTIV_NR", STAT_HEIZUNG_AKTIV_NR, "\"0-n\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_SYMMETRIERUNG: { // 0xAD6B
if (datalen < 1) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_SYMMETRIERUNG", 1);
break;
}
unsigned char STAT_SYM = (RXBUF_UCHAR(0));
// Status of the balancing / Status der Symmetrierung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "SYMMETRIERUNG", "STAT_SYM", STAT_SYM, "\"0-n\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_HEIZUNG_FUNKTION: { // 0xAD73
if (datalen < 1) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_HEIZUNG_FUNKTION", 1);
break;
}
unsigned char STAT_HEIZUNG_FUNKTION_NR = (RXBUF_UCHAR(0));
// Result of the functional heating diagnosis / Ergebniss der funktionalen Heizungsdiagnose
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "HEIZUNG_FUNKTION", "STAT_HEIZUNG_FUNKTION_NR", STAT_HEIZUNG_FUNKTION_NR, "\"0-n\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_RB_SOC_REKALIBRIERUNG: { // 0xD4C5
if (datalen < 255) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_RB_SOC_REKALIBRIERUNG", 255);
break;
}
unsigned char STAT_GRUND_REKAL_1 = (RXBUF_UCHAR(0));
// Reason for SOC recalibration-1 / Grund der SOC Rekaibrierung-1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_GRUND_REKAL_1", STAT_GRUND_REKAL_1, "\"0-n\"");
unsigned long STAT_ZEITPUNKT_REKAL_1_WERT = (RXBUF_UINT32(1));
// Time (SME time) of recalibration-1 / Zeitpunkt (SME-Zeit) der Rekalibrierung-1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_ZEITPUNKT_REKAL_1_WERT", STAT_ZEITPUNKT_REKAL_1_WERT, "\"s\"");
unsigned long STAT_HVOFFTIME_REKAL_1_WERT = (RXBUF_UINT32(5));
// Duration during which the shooters were last open-1 / Dauer, während die Schütze letzmalig geöffnet waren-1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_HVOFFTIME_REKAL_1_WERT", STAT_HVOFFTIME_REKAL_1_WERT, "\"s\"");
char STAT_TEMP_MESS_MEAN_VOR_1_WERT = (RXBUF_SCHAR(9));
// Average measuring temperature at HVS level BEFORE recalibration-1 / Mittlere Messtemperatur auf HVS-Ebene VOR
// Rekalibrierung-1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_TEMP_MESS_MEAN_VOR_1_WERT", STAT_TEMP_MESS_MEAN_VOR_1_WERT, "\"°C\"");
char STAT_TEMP_MESS_MEAN_NACH_1_WERT = (RXBUF_SCHAR(10));
// Mean measurement temperature at HVS level AFTER recalibration-1 / Mittlere Messtemperatur auf HVS-Ebene NACH
// Rekalibrierung-1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_TEMP_MESS_MEAN_NACH_1_WERT", STAT_TEMP_MESS_MEAN_NACH_1_WERT, "\"°C\"");
float STAT_UCEL_MIN_1_WERT = (RXBUF_UINT(11)/1000.0f);
// Minimum measured cell voltage. If OCV reached == U_init SONST == Uakt-1 / Minimale gemessene Zellspannung.
// Wenn OCV reached == U_init SONST == Uakt-1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_UCEL_MIN_1_WERT", STAT_UCEL_MIN_1_WERT, "\"V\"");
float STAT_UCEL_MAX_1_WERT = (RXBUF_UINT(13)/1000.0f);
// Maximum measured cell voltage. If OCV reached == U_init SONST == Uakt-1 / Maximale gemessene Zellspannung.
// Wenn OCV reached == U_init SONST == Uakt-1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_UCEL_MAX_1_WERT", STAT_UCEL_MAX_1_WERT, "\"V\"");
float STAT_UCEL_MEAN_1_WERT = (RXBUF_UINT(15)/1000.0f);
// Mean measured cell voltage. If OCV reached == U_init SONST == Uakt-1 / Mittlere gemessene Zellspannung. Wenn
// OCV reached == U_init SONST == Uakt-1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_UCEL_MEAN_1_WERT", STAT_UCEL_MEAN_1_WERT, "\"V\"");
float STAT_SOC_MIN_NENN_VOR_1_WERT = (RXBUF_UINT(17)/100.0f);
// Minimum nominal SOC BEFORE recalibration-1 / Minimaler NennSOC VOR Rekalibrierung-1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MIN_NENN_VOR_1_WERT", STAT_SOC_MIN_NENN_VOR_1_WERT, "\"%\"");
float STAT_SOC_MAX_NENN_VOR_1_WERT = (RXBUF_UINT(19)/100.0f);
// Maximum nominal SOC BEFORE recalibration-1 / Maximaler NennSOC VOR Rekalibrierung-1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MAX_NENN_VOR_1_WERT", STAT_SOC_MAX_NENN_VOR_1_WERT, "\"%\"");
float STAT_SOC_MEAN_NENN_VOR_1_WERT = (RXBUF_UINT(21)/100.0f);
// Average nominal SOC BEFORE recalibration -1 / Mittlerer NennSOC VOR Rekalibrierung-1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MEAN_NENN_VOR_1_WERT", STAT_SOC_MEAN_NENN_VOR_1_WERT, "\"%\"");
float STAT_SOC_MIN_NENN_NACH_1_WERT = (RXBUF_UINT(23)/100.0f);
// Minimum nominal SOC AFTER recalibration-1 / Minimaler NennSOC NACH Rekalibrierung-1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MIN_NENN_NACH_1_WERT", STAT_SOC_MIN_NENN_NACH_1_WERT, "\"%\"");
float STAT_SOC_MAX_NENN_NACH_1_WERT = (RXBUF_UINT(25)/100.0f);
// Maximum nominal SOC AFTER recalibration-1 / Maximaler NennSOC NACH Rekalibrierung-1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MAX_NENN_NACH_1_WERT", STAT_SOC_MAX_NENN_NACH_1_WERT, "\"%\"");
float STAT_SOC_MEAN_NENN_NACH_1_WERT = (RXBUF_UINT(27)/100.0f);
// Average nominal SOC AFTER recalibration -1 / Mittlerer NennSOC NACH Rekalibrierung-1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MEAN_NENN_NACH_1_WERT", STAT_SOC_MEAN_NENN_NACH_1_WERT, "\"%\"");
float STAT_SOC_MIN_AKT_VOR_1_WERT = (RXBUF_UINT(29)/100.0f);
// Minimum AktSOC BEFORE recalibration-1 / Minimaler AktSOC VOR Rekalibrierung-1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MIN_AKT_VOR_1_WERT", STAT_SOC_MIN_AKT_VOR_1_WERT, "\"%\"");
float STAT_SOC_MAX_AKT_VOR_1_WERT = (RXBUF_UINT(31)/100.0f);
// Maximum AktSOC BEFORE recalibration-1 / Maximaler AktSOC VOR Rekalibrierung-1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MAX_AKT_VOR_1_WERT", STAT_SOC_MAX_AKT_VOR_1_WERT, "\"%\"");
float STAT_SOC_MEAN_AKT_VOR_1_WERT = (RXBUF_UINT(33)/100.0f);
// Mean ActSOC BEFORE recalibration-1 / Mittlerer AktSOC VOR Rekalibrierung-1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MEAN_AKT_VOR_1_WERT", STAT_SOC_MEAN_AKT_VOR_1_WERT, "\"%\"");
float STAT_SOC_MIN_AKT_NACH_1_WERT = (RXBUF_UINT(35)/100.0f);
// Minimum AktSOC AFTER recalibration-1 / Minimaler AktSOC NACH Rekalibrierung-1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MIN_AKT_NACH_1_WERT", STAT_SOC_MIN_AKT_NACH_1_WERT, "\"%\"");
float STAT_SOC_MAX_AKT_NACH_1_WERT = (RXBUF_UINT(37)/100.0f);
// Maximum AktSOC AFTER recalibration-1 / Maximaler AktSOC NACH Rekalibrierung-1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MAX_AKT_NACH_1_WERT", STAT_SOC_MAX_AKT_NACH_1_WERT, "\"%\"");
float STAT_SOC_MEAN_AKT_NACH_1_WERT = (RXBUF_UINT(39)/100.0f);
// Mean ActSOC AFTER recalibration -1 / Mittlerer AktSOC NACH Rekalibrierung-1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MEAN_AKT_NACH_1_WERT", STAT_SOC_MEAN_AKT_NACH_1_WERT, "\"%\"");
float STAT_SOH_MIN_1_WERT = (RXBUF_UINT(41)/100.0f);
// Minimum SOH at the time of recalibration-1 / Minimaler SOH zum Zeitpunkt der Rekalibrierung-1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOH_MIN_1_WERT", STAT_SOH_MIN_1_WERT, "\"%\"");
float STAT_SOH_MAX_1_WERT = (RXBUF_UINT(43)/100.0f);
// Maximum SOH at the time of recalibration-1 / Maximaler SOH zum Zeitpunkt der Rekalibrierung-1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOH_MAX_1_WERT", STAT_SOH_MAX_1_WERT, "\"%\"");
float STAT_SOH_MEAN_1_WERT = (RXBUF_UINT(45)/100.0f);
// Mean SOH at the time of recalibration-1 / Mittlerer SOH zum Zeitpunkt der Rekalibrierung-1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOH_MEAN_1_WERT", STAT_SOH_MEAN_1_WERT, "\"%\"");
float STAT_SOC_BAND_VOR_1_WERT = (RXBUF_UINT(47)/100.0f);
// SOC bandwidth BEFORE recalibration-1 / SOC Bandbreite VOR Rekalibrierung-1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_BAND_VOR_1_WERT", STAT_SOC_BAND_VOR_1_WERT, "\"%\"");
float STAT_SOC_BAND_NACH_1_WERT = (RXBUF_UINT(49)/100.0f);
// SOC bandwidth AFTER recalibration-1 / SOC Bandbreite NACH Rekalibrierung-1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_BAND_NACH_1_WERT", STAT_SOC_BAND_NACH_1_WERT, "\"%\"");
unsigned char STAT_GRUND_REKAL_2 = (RXBUF_UCHAR(51));
// Reason for SOC recalibration-2 / Grund der SOC Rekaibrierung-2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_GRUND_REKAL_2", STAT_GRUND_REKAL_2, "\"0-n\"");
unsigned long STAT_ZEITPUNKT_REKAL_2_WERT = (RXBUF_UINT32(52));
// Time (SME time) of recalibration-2 / Zeitpunkt (SME-Zeit) der Rekalibrierung-2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_ZEITPUNKT_REKAL_2_WERT", STAT_ZEITPUNKT_REKAL_2_WERT, "\"s\"");
unsigned long STAT_HVOFFTIME_REKAL_2_WERT = (RXBUF_UINT32(56));
// Duration while the shooters were open for the last time-2 / Dauer, während die Schütze letzmalig geöffnet
// waren-2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_HVOFFTIME_REKAL_2_WERT", STAT_HVOFFTIME_REKAL_2_WERT, "\"s\"");
char STAT_TEMP_MESS_MEAN_VOR_2_WERT = (RXBUF_SCHAR(60));
// Average measuring temperature at HVS level BEFORE recalibration-2 / Mittlere Messtemperatur auf HVS-Ebene VOR
// Rekalibrierung-2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_TEMP_MESS_MEAN_VOR_2_WERT", STAT_TEMP_MESS_MEAN_VOR_2_WERT, "\"°C\"");
char STAT_TEMP_MESS_MEAN_NACH_2_WERT = (RXBUF_SCHAR(61));
// Mean measurement temperature at HVS level AFTER recalibration-2 / Mittlere Messtemperatur auf HVS-Ebene NACH
// Rekalibrierung-2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_TEMP_MESS_MEAN_NACH_2_WERT", STAT_TEMP_MESS_MEAN_NACH_2_WERT, "\"°C\"");
float STAT_UCEL_MIN_2_WERT = (RXBUF_UINT(62)/1000.0f);
// Minimum measured cell voltage. If OCV reached == U_init SONST == Uakt-2 / Minimale gemessene Zellspannung.
// Wenn OCV reached == U_init SONST == Uakt-2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_UCEL_MIN_2_WERT", STAT_UCEL_MIN_2_WERT, "\"V\"");
float STAT_UCEL_MAX_2_WERT = (RXBUF_UINT(64)/1000.0f);
// Maximum measured cell voltage. If OCV reached == U_init SONST == Uakt-2 / Maximale gemessene Zellspannung.
// Wenn OCV reached == U_init SONST == Uakt-2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_UCEL_MAX_2_WERT", STAT_UCEL_MAX_2_WERT, "\"V\"");
float STAT_UCEL_MEAN_2_WERT = (RXBUF_UINT(66)/1000.0f);
// Mean measured cell voltage. If OCV reached == U_init SONST == Uakt-2 / Mittlere gemessene Zellspannung. Wenn
// OCV reached == U_init SONST == Uakt-2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_UCEL_MEAN_2_WERT", STAT_UCEL_MEAN_2_WERT, "\"V\"");
float STAT_SOC_MIN_NENN_VOR_2_WERT = (RXBUF_UINT(68)/100.0f);
// Minimum nominal SOC BEFORE recalibration-2 / Minimaler NennSOC VOR Rekalibrierung-2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MIN_NENN_VOR_2_WERT", STAT_SOC_MIN_NENN_VOR_2_WERT, "\"%\"");
float STAT_SOC_MAX_NENN_VOR_2_WERT = (RXBUF_UINT(70)/100.0f);
// Maximum nominal SOC BEFORE recalibration-2 / Maximaler NennSOC VOR Rekalibrierung-2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MAX_NENN_VOR_2_WERT", STAT_SOC_MAX_NENN_VOR_2_WERT, "\"%\"");
float STAT_SOC_MEAN_NENN_VOR_2_WERT = (RXBUF_UINT(72)/100.0f);
// Average nominal SOC BEFORE recalibration-2 / Mittlerer NennSOC VOR Rekalibrierung-2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MEAN_NENN_VOR_2_WERT", STAT_SOC_MEAN_NENN_VOR_2_WERT, "\"%\"");
float STAT_SOC_MIN_NENN_NACH_2_WERT = (RXBUF_UINT(74)/100.0f);
// Minimum nominal SOC AFTER recalibration-2 / Minimaler NennSOC NACH Rekalibrierung-2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MIN_NENN_NACH_2_WERT", STAT_SOC_MIN_NENN_NACH_2_WERT, "\"%\"");
float STAT_SOC_MAX_NENN_NACH_2_WERT = (RXBUF_UINT(76)/100.0f);
// Maximum nominal SOC AFTER recalibration-2 / Maximaler NennSOC NACH Rekalibrierung-2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MAX_NENN_NACH_2_WERT", STAT_SOC_MAX_NENN_NACH_2_WERT, "\"%\"");
float STAT_SOC_MEAN_NENN_NACH_2_WERT = (RXBUF_UINT(78)/100.0f);
// Average nominal SOC AFTER recalibration-2 / Mittlerer NennSOC NACH Rekalibrierung-2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MEAN_NENN_NACH_2_WERT", STAT_SOC_MEAN_NENN_NACH_2_WERT, "\"%\"");
float STAT_SOC_MIN_AKT_VOR_2_WERT = (RXBUF_UINT(80)/100.0f);
// Minimum AktSOC BEFORE recalibration-2 / Minimaler AktSOC VOR Rekalibrierung-2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MIN_AKT_VOR_2_WERT", STAT_SOC_MIN_AKT_VOR_2_WERT, "\"%\"");
float STAT_SOC_MAX_AKT_VOR_2_WERT = (RXBUF_UINT(82)/100.0f);
// Maximum AktSOC BEFORE recalibration-2 / Maximaler AktSOC VOR Rekalibrierung-2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MAX_AKT_VOR_2_WERT", STAT_SOC_MAX_AKT_VOR_2_WERT, "\"%\"");
float STAT_SOC_MEAN_AKT_VOR_2_WERT = (RXBUF_UINT(84)/100.0f);
// Mean ActSOC BEFORE recalibration-2 / Mittlerer AktSOC VOR Rekalibrierung-2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MEAN_AKT_VOR_2_WERT", STAT_SOC_MEAN_AKT_VOR_2_WERT, "\"%\"");
float STAT_SOC_MIN_AKT_NACH_2_WERT = (RXBUF_UINT(86)/100.0f);
// Minimum AktSOC AFTER recalibration-2 / Minimaler AktSOC NACH Rekalibrierung-2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MIN_AKT_NACH_2_WERT", STAT_SOC_MIN_AKT_NACH_2_WERT, "\"%\"");
float STAT_SOC_MAX_AKT_NACH_2_WERT = (RXBUF_UINT(88)/100.0f);
// Maximum AktSOC AFTER recalibration-2 / Maximaler AktSOC NACH Rekalibrierung-2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MAX_AKT_NACH_2_WERT", STAT_SOC_MAX_AKT_NACH_2_WERT, "\"%\"");
float STAT_SOC_MEAN_AKT_NACH_2_WERT = (RXBUF_UINT(90)/100.0f);
// Mean ActSOC AFTER recalibration-2 / Mittlerer AktSOC NACH Rekalibrierung-2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MEAN_AKT_NACH_2_WERT", STAT_SOC_MEAN_AKT_NACH_2_WERT, "\"%\"");
float STAT_SOH_MIN_2_WERT = (RXBUF_UINT(92)/100.0f);
// Minimum SOH at the time of recalibration-2 / Minimaler SOH zum Zeitpunkt der Rekalibrierung-2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOH_MIN_2_WERT", STAT_SOH_MIN_2_WERT, "\"%\"");
float STAT_SOH_MAX_2_WERT = (RXBUF_UINT(94)/100.0f);
// Maximum SOH at the time of recalibration-2 / Maximaler SOH zum Zeitpunkt der Rekalibrierung-2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOH_MAX_2_WERT", STAT_SOH_MAX_2_WERT, "\"%\"");
float STAT_SOH_MEAN_2_WERT = (RXBUF_UINT(96)/100.0f);
// Mean SOH at the time of recalibration-2 / Mittlerer SOH zum Zeitpunkt der Rekalibrierung-2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOH_MEAN_2_WERT", STAT_SOH_MEAN_2_WERT, "\"%\"");
float STAT_SOC_BAND_VOR_2_WERT = (RXBUF_UINT(98)/100.0f);
// SOC bandwidth BEFORE recalibration-2 / SOC Bandbreite VOR Rekalibrierung-2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_BAND_VOR_2_WERT", STAT_SOC_BAND_VOR_2_WERT, "\"%\"");
float STAT_SOC_BAND_NACH_2_WERT = (RXBUF_UINT(100)/100.0f);
// SOC bandwidth AFTER recalibration-2 / SOC Bandbreite NACH Rekalibrierung-2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_BAND_NACH_2_WERT", STAT_SOC_BAND_NACH_2_WERT, "\"%\"");
unsigned char STAT_GRUND_REKAL_3 = (RXBUF_UCHAR(102));
// Reason for SOC recalibration-3 / Grund der SOC Rekaibrierung-3
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_GRUND_REKAL_3", STAT_GRUND_REKAL_3, "\"0-n\"");
unsigned long STAT_ZEITPUNKT_REKAL_3_WERT = (RXBUF_UINT32(103));
// Time (SME time) of recalibration-3 / Zeitpunkt (SME-Zeit) der Rekalibrierung-3
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_ZEITPUNKT_REKAL_3_WERT", STAT_ZEITPUNKT_REKAL_3_WERT, "\"s\"");
unsigned long STAT_HVOFFTIME_REKAL_3_WERT = (RXBUF_UINT32(107));
// Duration while the shooters were open for the last time -3 / Dauer, während die Schütze letzmalig geöffnet
// waren-3
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_HVOFFTIME_REKAL_3_WERT", STAT_HVOFFTIME_REKAL_3_WERT, "\"s\"");
char STAT_TEMP_MESS_MEAN_VOR_3_WERT = (RXBUF_SCHAR(111));
// Average measuring temperature at HVS level BEFORE recalibration-3 / Mittlere Messtemperatur auf HVS-Ebene VOR
// Rekalibrierung-3
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_TEMP_MESS_MEAN_VOR_3_WERT", STAT_TEMP_MESS_MEAN_VOR_3_WERT, "\"°C\"");
char STAT_TEMP_MESS_MEAN_NACH_3_WERT = (RXBUF_SCHAR(112));
// Average measurement temperature at HVS level AFTER recalibration-3 / Mittlere Messtemperatur auf HVS-Ebene
// NACH Rekalibrierung-3
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_TEMP_MESS_MEAN_NACH_3_WERT", STAT_TEMP_MESS_MEAN_NACH_3_WERT, "\"°C\"");
float STAT_UCEL_MIN_3_WERT = (RXBUF_UINT(113)/1000.0f);
// Minimum measured cell voltage. If OCV reached == U_init SONST == Uakt-3 / Minimale gemessene Zellspannung.
// Wenn OCV reached == U_init SONST == Uakt-3
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_UCEL_MIN_3_WERT", STAT_UCEL_MIN_3_WERT, "\"V\"");
float STAT_UCEL_MAX_3_WERT = (RXBUF_UINT(115)/1000.0f);
// Maximum measured cell voltage. If OCV reached == U_init SONST == Uakt-3 / Maximale gemessene Zellspannung.
// Wenn OCV reached == U_init SONST == Uakt-3
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_UCEL_MAX_3_WERT", STAT_UCEL_MAX_3_WERT, "\"V\"");
float STAT_UCEL_MEAN_3_WERT = (RXBUF_UINT(117)/1000.0f);
// Mean measured cell voltage. If OCV reached == U_init SONST == Uakt-3 / Mittlere gemessene Zellspannung. Wenn
// OCV reached == U_init SONST == Uakt-3
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_UCEL_MEAN_3_WERT", STAT_UCEL_MEAN_3_WERT, "\"V\"");
float STAT_SOC_MIN_NENN_VOR_3_WERT = (RXBUF_UINT(119)/100.0f);
// Minimum nominal SOC BEFORE recalibration -3 / Minimaler NennSOC VOR Rekalibrierung-3
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MIN_NENN_VOR_3_WERT", STAT_SOC_MIN_NENN_VOR_3_WERT, "\"%\"");
float STAT_SOC_MAX_NENN_VOR_3_WERT = (RXBUF_UINT(121)/100.0f);
// Maximum nominal SOC BEFORE recalibration -3 / Maximaler NennSOC VOR Rekalibrierung-3
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MAX_NENN_VOR_3_WERT", STAT_SOC_MAX_NENN_VOR_3_WERT, "\"%\"");
float STAT_SOC_MEAN_NENN_VOR_3_WERT = (RXBUF_UINT(123)/100.0f);
// Average nominal SOC BEFORE recalibration -3 / Mittlerer NennSOC VOR Rekalibrierung-3
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MEAN_NENN_VOR_3_WERT", STAT_SOC_MEAN_NENN_VOR_3_WERT, "\"%\"");
float STAT_SOC_MIN_NENN_NACH_3_WERT = (RXBUF_UINT(125)/100.0f);
// Minimum nominal SOC AFTER recalibration -3 / Minimaler NennSOC NACH Rekalibrierung-3
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MIN_NENN_NACH_3_WERT", STAT_SOC_MIN_NENN_NACH_3_WERT, "\"%\"");
float STAT_SOC_MAX_NENN_NACH_3_WERT = (RXBUF_UINT(127)/100.0f);
// Maximum nominal SOC AFTER recalibration -3 / Maximaler NennSOC NACH Rekalibrierung-3
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MAX_NENN_NACH_3_WERT", STAT_SOC_MAX_NENN_NACH_3_WERT, "\"%\"");
float STAT_SOC_MEAN_NENN_NACH_3_WERT = (RXBUF_UINT(129)/100.0f);
// Average nominal SOC AFTER recalibration -3 / Mittlerer NennSOC NACH Rekalibrierung-3
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MEAN_NENN_NACH_3_WERT", STAT_SOC_MEAN_NENN_NACH_3_WERT, "\"%\"");
float STAT_SOC_MIN_AKT_VOR_3_WERT = (RXBUF_UINT(131)/100.0f);
// Minimum AktSOC BEFORE recalibration-3 / Minimaler AktSOC VOR Rekalibrierung-3
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MIN_AKT_VOR_3_WERT", STAT_SOC_MIN_AKT_VOR_3_WERT, "\"%\"");
float STAT_SOC_MAX_AKT_VOR_3_WERT = (RXBUF_UINT(133)/100.0f);
// Maximum AktSOC BEFORE recalibration -3 / Maximaler AktSOC VOR Rekalibrierung-3
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MAX_AKT_VOR_3_WERT", STAT_SOC_MAX_AKT_VOR_3_WERT, "\"%\"");
float STAT_SOC_MEAN_AKT_VOR_3_WERT = (RXBUF_UINT(135)/100.0f);
// Mean ActSOC BEFORE recalibration -3 / Mittlerer AktSOC VOR Rekalibrierung-3
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MEAN_AKT_VOR_3_WERT", STAT_SOC_MEAN_AKT_VOR_3_WERT, "\"%\"");
float STAT_SOC_MIN_AKT_NACH_3_WERT = (RXBUF_UINT(137)/100.0f);
// Minimum AktSOC AFTER recalibration-3 / Minimaler AktSOC NACH Rekalibrierung-3
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MIN_AKT_NACH_3_WERT", STAT_SOC_MIN_AKT_NACH_3_WERT, "\"%\"");
float STAT_SOC_MAX_AKT_NACH_3_WERT = (RXBUF_UINT(139)/100.0f);
// Maximum AktSOC AFTER recalibration -3 / Maximaler AktSOC NACH Rekalibrierung-3
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MAX_AKT_NACH_3_WERT", STAT_SOC_MAX_AKT_NACH_3_WERT, "\"%\"");
float STAT_SOC_MEAN_AKT_NACH_3_WERT = (RXBUF_UINT(141)/100.0f);
// Mean ActSOC AFTER recalibration -3 / Mittlerer AktSOC NACH Rekalibrierung-3
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MEAN_AKT_NACH_3_WERT", STAT_SOC_MEAN_AKT_NACH_3_WERT, "\"%\"");
float STAT_SOH_MIN_3_WERT = (RXBUF_UINT(143)/100.0f);
// Minimum SOH at the time of recalibration -3 / Minimaler SOH zum Zeitpunkt der Rekalibrierung-3
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOH_MIN_3_WERT", STAT_SOH_MIN_3_WERT, "\"%\"");
float STAT_SOH_MAX_3_WERT = (RXBUF_UINT(145)/100.0f);
// Maximum SOH at the time of recalibration -3 / Maximaler SOH zum Zeitpunkt der Rekalibrierung-3
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOH_MAX_3_WERT", STAT_SOH_MAX_3_WERT, "\"%\"");
float STAT_SOH_MEAN_3_WERT = (RXBUF_UINT(147)/100.0f);
// Mean SOH at the time of recalibration -3 / Mittlerer SOH zum Zeitpunkt der Rekalibrierung-3
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOH_MEAN_3_WERT", STAT_SOH_MEAN_3_WERT, "\"%\"");
float STAT_SOC_BAND_VOR_3_WERT = (RXBUF_UINT(149)/100.0f);
// SOC bandwidth BEFORE recalibration-3 / SOC Bandbreite VOR Rekalibrierung-3
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_BAND_VOR_3_WERT", STAT_SOC_BAND_VOR_3_WERT, "\"%\"");
float STAT_SOC_BAND_NACH_3_WERT = (RXBUF_UINT(151)/100.0f);
// SOC bandwidth AFTER recalibration-3 / SOC Bandbreite NACH Rekalibrierung-3
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_BAND_NACH_3_WERT", STAT_SOC_BAND_NACH_3_WERT, "\"%\"");
unsigned char STAT_GRUND_REKAL_4 = (RXBUF_UCHAR(153));
// Reason for SOC recalibration-4 / Grund der SOC Rekaibrierung-4
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_GRUND_REKAL_4", STAT_GRUND_REKAL_4, "\"0-n\"");
unsigned long STAT_ZEITPUNKT_REKAL_4_WERT = (RXBUF_UINT32(154));
// Time (SME time) of recalibration-4 / Zeitpunkt (SME-Zeit) der Rekalibrierung-4
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_ZEITPUNKT_REKAL_4_WERT", STAT_ZEITPUNKT_REKAL_4_WERT, "\"s\"");
unsigned long STAT_HVOFFTIME_REKAL_4_WERT = (RXBUF_UINT32(158));
// Duration while the shooters were open for the last time-4 / Dauer, während die Schütze letzmalig geöffnet
// waren-4
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_HVOFFTIME_REKAL_4_WERT", STAT_HVOFFTIME_REKAL_4_WERT, "\"s\"");
char STAT_TEMP_MESS_MEAN_VOR_4_WERT = (RXBUF_SCHAR(162));
// Average measuring temperature at HVS level BEFORE recalibration-4 / Mittlere Messtemperatur auf HVS-Ebene VOR
// Rekalibrierung-4
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_TEMP_MESS_MEAN_VOR_4_WERT", STAT_TEMP_MESS_MEAN_VOR_4_WERT, "\"°C\"");
char STAT_TEMP_MESS_MEAN_NACH_4_WERT = (RXBUF_SCHAR(163));
// Mean measurement temperature at HVS level AFTER recalibration-4 / Mittlere Messtemperatur auf HVS-Ebene NACH
// Rekalibrierung-4
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_TEMP_MESS_MEAN_NACH_4_WERT", STAT_TEMP_MESS_MEAN_NACH_4_WERT, "\"°C\"");
float STAT_UCEL_MIN_4_WERT = (RXBUF_UINT(164)/1000.0f);
// Minimum measured cell voltage. If OCV reached == U_init SONST == Uakt-4 / Minimale gemessene Zellspannung.
// Wenn OCV reached == U_init SONST == Uakt-4
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_UCEL_MIN_4_WERT", STAT_UCEL_MIN_4_WERT, "\"V\"");
float STAT_UCEL_MAX_4_WERT = (RXBUF_UINT(166)/1000.0f);
// Maximum measured cell voltage. If OCV reached == U_init SONST == Uakt-4 / Maximale gemessene Zellspannung.
// Wenn OCV reached == U_init SONST == Uakt-4
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_UCEL_MAX_4_WERT", STAT_UCEL_MAX_4_WERT, "\"V\"");
float STAT_UCEL_MEAN_4_WERT = (RXBUF_UINT(168)/1000.0f);
// Mean measured cell voltage. If OCV reached == U_init SONST == Uakt-4 / Mittlere gemessene Zellspannung. Wenn
// OCV reached == U_init SONST == Uakt-4
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_UCEL_MEAN_4_WERT", STAT_UCEL_MEAN_4_WERT, "\"V\"");
float STAT_SOC_MIN_NENN_VOR_4_WERT = (RXBUF_UINT(170)/100.0f);
// Minimum nominal SOC BEFORE recalibration-4 / Minimaler NennSOC VOR Rekalibrierung-4
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MIN_NENN_VOR_4_WERT", STAT_SOC_MIN_NENN_VOR_4_WERT, "\"%\"");
float STAT_SOC_MAX_NENN_VOR_4_WERT = (RXBUF_UINT(172)/100.0f);
// Maximum nominal SOC BEFORE recalibration -4 / Maximaler NennSOC VOR Rekalibrierung-4
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MAX_NENN_VOR_4_WERT", STAT_SOC_MAX_NENN_VOR_4_WERT, "\"%\"");
float STAT_SOC_MEAN_NENN_VOR_4_WERT = (RXBUF_UINT(174)/100.0f);
// Average nominal SOC BEFORE recalibration-4 / Mittlerer NennSOC VOR Rekalibrierung-4
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MEAN_NENN_VOR_4_WERT", STAT_SOC_MEAN_NENN_VOR_4_WERT, "\"%\"");
float STAT_SOC_MIN_NENN_NACH_4_WERT = (RXBUF_UINT(176)/100.0f);
// Minimum nominal SOC AFTER recalibration-4 / Minimaler NennSOC NACH Rekalibrierung-4
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MIN_NENN_NACH_4_WERT", STAT_SOC_MIN_NENN_NACH_4_WERT, "\"%\"");
float STAT_SOC_MAX_NENN_NACH_4_WERT = (RXBUF_UINT(178)/100.0f);
// Maximum nominal SOC AFTER recalibration -4 / Maximaler NennSOC NACH Rekalibrierung-4
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MAX_NENN_NACH_4_WERT", STAT_SOC_MAX_NENN_NACH_4_WERT, "\"%\"");
float STAT_SOC_MEAN_NENN_NACH_4_WERT = (RXBUF_UINT(180)/100.0f);
// Average nominal SOC AFTER recalibration -4 / Mittlerer NennSOC NACH Rekalibrierung-4
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MEAN_NENN_NACH_4_WERT", STAT_SOC_MEAN_NENN_NACH_4_WERT, "\"%\"");
float STAT_SOC_MIN_AKT_VOR_4_WERT = (RXBUF_UINT(182)/100.0f);
// Minimum AktSOC BEFORE recalibration-4 / Minimaler AktSOC VOR Rekalibrierung-4
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MIN_AKT_VOR_4_WERT", STAT_SOC_MIN_AKT_VOR_4_WERT, "\"%\"");
float STAT_SOC_MAX_AKT_VOR_4_WERT = (RXBUF_UINT(184)/100.0f);
// Maximum AktSOC BEFORE recalibration -4 / Maximaler AktSOC VOR Rekalibrierung-4
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MAX_AKT_VOR_4_WERT", STAT_SOC_MAX_AKT_VOR_4_WERT, "\"%\"");
float STAT_SOC_MEAN_AKT_VOR_4_WERT = (RXBUF_UINT(186)/100.0f);
// Mean ActSOC BEFORE recalibration -4 / Mittlerer AktSOC VOR Rekalibrierung-4
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MEAN_AKT_VOR_4_WERT", STAT_SOC_MEAN_AKT_VOR_4_WERT, "\"%\"");
float STAT_SOC_MIN_AKT_NACH_4_WERT = (RXBUF_UINT(188)/100.0f);
// Minimum AktSOC AFTER recalibration-4 / Minimaler AktSOC NACH Rekalibrierung-4
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MIN_AKT_NACH_4_WERT", STAT_SOC_MIN_AKT_NACH_4_WERT, "\"%\"");
float STAT_SOC_MAX_AKT_NACH_4_WERT = (RXBUF_UINT(190)/100.0f);
// Maximum AktSOC AFTER recalibration -4 / Maximaler AktSOC NACH Rekalibrierung-4
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MAX_AKT_NACH_4_WERT", STAT_SOC_MAX_AKT_NACH_4_WERT, "\"%\"");
float STAT_SOC_MEAN_AKT_NACH_4_WERT = (RXBUF_UINT(192)/100.0f);
// Mean ActSOC AFTER recalibration -4 / Mittlerer AktSOC NACH Rekalibrierung-4
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MEAN_AKT_NACH_4_WERT", STAT_SOC_MEAN_AKT_NACH_4_WERT, "\"%\"");
float STAT_SOH_MIN_4_WERT = (RXBUF_UINT(194)/100.0f);
// Minimum SOH at the time of recalibration -4 / Minimaler SOH zum Zeitpunkt der Rekalibrierung-4
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOH_MIN_4_WERT", STAT_SOH_MIN_4_WERT, "\"%\"");
float STAT_SOH_MAX_4_WERT = (RXBUF_UINT(196)/100.0f);
// Maximum SOH at the time of recalibration-4 / Maximaler SOH zum Zeitpunkt der Rekalibrierung-4
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOH_MAX_4_WERT", STAT_SOH_MAX_4_WERT, "\"%\"");
float STAT_SOH_MEAN_4_WERT = (RXBUF_UINT(198)/100.0f);
// Mean SOH at the time of recalibration -4 / Mittlerer SOH zum Zeitpunkt der Rekalibrierung-4
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOH_MEAN_4_WERT", STAT_SOH_MEAN_4_WERT, "\"%\"");
float STAT_SOC_BAND_VOR_4_WERT = (RXBUF_UINT(200)/100.0f);
// SOC bandwidth BEFORE recalibration-4 / SOC Bandbreite VOR Rekalibrierung-4
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_BAND_VOR_4_WERT", STAT_SOC_BAND_VOR_4_WERT, "\"%\"");
float STAT_SOC_BAND_NACH_4_WERT = (RXBUF_UINT(202)/100.0f);
// SOC bandwidth AFTER recalibration-4 / SOC Bandbreite NACH Rekalibrierung-4
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_BAND_NACH_4_WERT", STAT_SOC_BAND_NACH_4_WERT, "\"%\"");
unsigned char STAT_GRUND_REKAL_5 = (RXBUF_UCHAR(204));
// Reason for SOC recalibration-5 / Grund der SOC Rekaibrierung-5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_GRUND_REKAL_5", STAT_GRUND_REKAL_5, "\"0-n\"");
unsigned long STAT_ZEITPUNKT_REKAL_5_WERT = (RXBUF_UINT32(205));
// Time (SME time) of the recalibration-5 / Zeitpunkt (SME-Zeit) der Rekalibrierung-5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_ZEITPUNKT_REKAL_5_WERT", STAT_ZEITPUNKT_REKAL_5_WERT, "\"s\"");
unsigned long STAT_HVOFFTIME_REKAL_5_WERT = (RXBUF_UINT32(209));
// Duration while the shooters were open for the last time -5 / Dauer, während die Schütze letzmalig geöffnet
// waren-5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_HVOFFTIME_REKAL_5_WERT", STAT_HVOFFTIME_REKAL_5_WERT, "\"s\"");
char STAT_TEMP_MESS_MEAN_VOR_5_WERT = (RXBUF_SCHAR(213));
// Average measuring temperature at HVS level BEFORE recalibration-5 / Mittlere Messtemperatur auf HVS-Ebene VOR
// Rekalibrierung-5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_TEMP_MESS_MEAN_VOR_5_WERT", STAT_TEMP_MESS_MEAN_VOR_5_WERT, "\"°C\"");
char STAT_TEMP_MESS_MEAN_NACH_5_WERT = (RXBUF_SCHAR(214));
// Mean measurement temperature at HVS level AFTER recalibration-5 / Mittlere Messtemperatur auf HVS-Ebene NACH
// Rekalibrierung-5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_TEMP_MESS_MEAN_NACH_5_WERT", STAT_TEMP_MESS_MEAN_NACH_5_WERT, "\"°C\"");
float STAT_UCEL_MIN_5_WERT = (RXBUF_UINT(215)/1000.0f);
// Minimum measured cell voltage. If OCV reached == U_init SONST == Uakt-5 / Minimale gemessene Zellspannung.
// Wenn OCV reached == U_init SONST == Uakt-5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_UCEL_MIN_5_WERT", STAT_UCEL_MIN_5_WERT, "\"V\"");
float STAT_UCEL_MAX_5_WERT = (RXBUF_UINT(217)/1000.0f);
// Maximum measured cell voltage. If OCV reached == U_init SONST == Uakt-5 / Maximale gemessene Zellspannung.
// Wenn OCV reached == U_init SONST == Uakt-5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_UCEL_MAX_5_WERT", STAT_UCEL_MAX_5_WERT, "\"V\"");
float STAT_UCEL_MEAN_5_WERT = (RXBUF_UINT(219)/1000.0f);
// Mean measured cell voltage. If OCV reached == U_init SONST == Uakt-5 / Mittlere gemessene Zellspannung. Wenn
// OCV reached == U_init SONST == Uakt-5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_UCEL_MEAN_5_WERT", STAT_UCEL_MEAN_5_WERT, "\"V\"");
float STAT_SOC_MIN_NENN_VOR_5_WERT = (RXBUF_UINT(221)/100.0f);
// Minimum nominal SOC BEFORE recalibration -5 / Minimaler NennSOC VOR Rekalibrierung-5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MIN_NENN_VOR_5_WERT", STAT_SOC_MIN_NENN_VOR_5_WERT, "\"%\"");
float STAT_SOC_MAX_NENN_VOR_5_WERT = (RXBUF_UINT(223)/100.0f);
// Maximum nominal SOC BEFORE recalibration -5 / Maximaler NennSOC VOR Rekalibrierung-5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MAX_NENN_VOR_5_WERT", STAT_SOC_MAX_NENN_VOR_5_WERT, "\"%\"");
float STAT_SOC_MEAN_NENN_VOR_5_WERT = (RXBUF_UINT(225)/100.0f);
// Average nominal SOC BEFORE recalibration -5 / Mittlerer NennSOC VOR Rekalibrierung-5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MEAN_NENN_VOR_5_WERT", STAT_SOC_MEAN_NENN_VOR_5_WERT, "\"%\"");
float STAT_SOC_MIN_NENN_NACH_5_WERT = (RXBUF_UINT(227)/100.0f);
// Minimum nominal SOC AFTER recalibration -5 / Minimaler NennSOC NACH Rekalibrierung-5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MIN_NENN_NACH_5_WERT", STAT_SOC_MIN_NENN_NACH_5_WERT, "\"%\"");
float STAT_SOC_MAX_NENN_NACH_5_WERT = (RXBUF_UINT(229)/100.0f);
// Maximum nominal SOC AFTER recalibration -5 / Maximaler NennSOC NACH Rekalibrierung-5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MAX_NENN_NACH_5_WERT", STAT_SOC_MAX_NENN_NACH_5_WERT, "\"%\"");
float STAT_SOC_MEAN_NENN_NACH_5_WERT = (RXBUF_UINT(231)/100.0f);
// Average nominal SOC AFTER recalibration -5 / Mittlerer NennSOC NACH Rekalibrierung-5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MEAN_NENN_NACH_5_WERT", STAT_SOC_MEAN_NENN_NACH_5_WERT, "\"%\"");
float STAT_SOC_MIN_AKT_VOR_5_WERT = (RXBUF_UINT(233)/100.0f);
// Minimum AktSOC BEFORE recalibration -5 / Minimaler AktSOC VOR Rekalibrierung-5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MIN_AKT_VOR_5_WERT", STAT_SOC_MIN_AKT_VOR_5_WERT, "\"%\"");
float STAT_SOC_MAX_AKT_VOR_5_WERT = (RXBUF_UINT(235)/100.0f);
// Maximum AktSOC BEFORE recalibration -5 / Maximaler AktSOC VOR Rekalibrierung-5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MAX_AKT_VOR_5_WERT", STAT_SOC_MAX_AKT_VOR_5_WERT, "\"%\"");
float STAT_SOC_MEAN_AKT_VOR_5_WERT = (RXBUF_UINT(237)/100.0f);
// Mean ActSOC BEFORE recalibration -5 / Mittlerer AktSOC VOR Rekalibrierung-5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MEAN_AKT_VOR_5_WERT", STAT_SOC_MEAN_AKT_VOR_5_WERT, "\"%\"");
float STAT_SOC_MIN_AKT_NACH_5_WERT = (RXBUF_UINT(239)/100.0f);
// Minimum AktSOC AFTER recalibration -5 / Minimaler AktSOC NACH Rekalibrierung-5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MIN_AKT_NACH_5_WERT", STAT_SOC_MIN_AKT_NACH_5_WERT, "\"%\"");
float STAT_SOC_MAX_AKT_NACH_5_WERT = (RXBUF_UINT(241)/100.0f);
// Maximum AktSOC AFTER recalibration -5 / Maximaler AktSOC NACH Rekalibrierung-5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MAX_AKT_NACH_5_WERT", STAT_SOC_MAX_AKT_NACH_5_WERT, "\"%\"");
float STAT_SOC_MEAN_AKT_NACH_5_WERT = (RXBUF_UINT(243)/100.0f);
// Mean ActSOC AFTER recalibration -5 / Mittlerer AktSOC NACH Rekalibrierung-5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_MEAN_AKT_NACH_5_WERT", STAT_SOC_MEAN_AKT_NACH_5_WERT, "\"%\"");
float STAT_SOH_MIN_5_WERT = (RXBUF_UINT(245)/100.0f);
// Minimum SOH at the time of recalibration -5 / Minimaler SOH zum Zeitpunkt der Rekalibrierung-5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOH_MIN_5_WERT", STAT_SOH_MIN_5_WERT, "\"%\"");
float STAT_SOH_MAX_5_WERT = (RXBUF_UINT(247)/100.0f);
// Maximum SOH at the time of recalibration -5 / Maximaler SOH zum Zeitpunkt der Rekalibrierung-5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOH_MAX_5_WERT", STAT_SOH_MAX_5_WERT, "\"%\"");
float STAT_SOH_MEAN_5_WERT = (RXBUF_UINT(249)/100.0f);
// Mean SOH at the time of recalibration -5 / Mittlerer SOH zum Zeitpunkt der Rekalibrierung-5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOH_MEAN_5_WERT", STAT_SOH_MEAN_5_WERT, "\"%\"");
float STAT_SOC_BAND_VOR_5_WERT = (RXBUF_UINT(251)/100.0f);
// SOC bandwidth BEFORE recalibration -5 / SOC Bandbreite VOR Rekalibrierung-5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_BAND_VOR_5_WERT", STAT_SOC_BAND_VOR_5_WERT, "\"%\"");
float STAT_SOC_BAND_NACH_5_WERT = (RXBUF_UINT(253)/100.0f);
// SOC bandwidth AFTER recalibration-5 / SOC Bandbreite NACH Rekalibrierung-5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_REKALIBRIERUNG", "STAT_SOC_BAND_NACH_5_WERT", STAT_SOC_BAND_NACH_5_WERT, "\"%\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_SOC_GUETE: { // 0xD4C7
if (datalen < 1) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_SOC_GUETE", 1);
break;
}
unsigned char STAT_SOC_GUETE_WERT = (RXBUF_UCHAR(0));
// Reading out the current SOC quality value based on the SOC estimate (1 == best quality,> 30 == worst quality)
// / Auslesen des aktuellen SOC Gütewertes auf Basis der SOC Schätzung (1 == beste Güte, >30 == schlechteste
// Güte )
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "SOC_GUETE", "STAT_SOC_GUETE_WERT", STAT_SOC_GUETE_WERT, "");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_HIS_SOC_GUETE: { // 0xD4C8
if (datalen < 20) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_HIS_SOC_GUETE", 20);
break;
}
unsigned long STAT_HIS_SOC_GUETE_1_WERT = (RXBUF_UINT32(0));
// Length of stay of the SOC quality value in the class: 0 <= GW <3 / Aufenthaltsdauer des SOC Gütewertes in der
// Klasse: 0 <= GW < 3
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_SOC_GUETE", "STAT_HIS_SOC_GUETE_1_WERT", STAT_HIS_SOC_GUETE_1_WERT, "");
unsigned long STAT_HIS_SOC_GUETE_2_WERT = (RXBUF_UINT32(4));
// Duration of the SOC quality value in the class: 3 <= GW <7 / Aufenthaltsdauer des SOC Gütewertes in der
// Klasse: 3 <= GW < 7
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_SOC_GUETE", "STAT_HIS_SOC_GUETE_2_WERT", STAT_HIS_SOC_GUETE_2_WERT, "");
unsigned long STAT_HIS_SOC_GUETE_3_WERT = (RXBUF_UINT32(8));
// Duration of the SOC quality value in the class: 7 <= GW <20 / Aufenthaltsdauer des SOC Gütewertes in der
// Klasse: 7 <= GW < 20
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_SOC_GUETE", "STAT_HIS_SOC_GUETE_3_WERT", STAT_HIS_SOC_GUETE_3_WERT, "");
unsigned long STAT_HIS_SOC_GUETE_4_WERT = (RXBUF_UINT32(12));
// Duration of the SOC quality value in the class: 20 <= GW <30 / Aufenthaltsdauer des SOC Gütewertes in der
// Klasse: 20 <= GW < 30
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_SOC_GUETE", "STAT_HIS_SOC_GUETE_4_WERT", STAT_HIS_SOC_GUETE_4_WERT, "");
unsigned long STAT_HIS_SOC_GUETE_5_WERT = (RXBUF_UINT32(16));
// Duration of the SOC quality value in the class: GW> 30 / Aufenthaltsdauer des SOC Gütewertes in der Klasse:
// GW > 30
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_SOC_GUETE", "STAT_HIS_SOC_GUETE_5_WERT", STAT_HIS_SOC_GUETE_5_WERT, "");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_ANZAHL_OCV_SOC_REKAL: { // 0xD4C9
if (datalen < 4) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_ANZAHL_OCV_SOC_REKAL", 4);
break;
}
unsigned long STAT_ANZAHL_OCV_SOC_REKAL_WERT = (RXBUF_UINT32(0));
// Number of OCV-SOC recalibrations / Anzahl der OCV-SOC Rekalibrierungen
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ANZAHL_OCV_SOC_REKAL", "STAT_ANZAHL_OCV_SOC_REKAL_WERT", STAT_ANZAHL_OCV_SOC_REKAL_WERT, "");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_ANZAHL_LADEENDE_REKAL: { // 0xD4CA
if (datalen < 4) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_ANZAHL_LADEENDE_REKAL", 4);
break;
}
unsigned long STAT_ANZAHL_LADEENDE_REKAL_WERT = (RXBUF_UINT32(0));
// Number of SoC recalibrations at the end of charging / Anzahl der SoC Rekalibrierungen am Ladeende
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ANZAHL_LADEENDE_REKAL", "STAT_ANZAHL_LADEENDE_REKAL_WERT", STAT_ANZAHL_LADEENDE_REKAL_WERT, "");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_RB_SOC_VOLLADEENDE: { // 0xD4CB
if (datalen < 50) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_RB_SOC_VOLLADEENDE", 50);
break;
}
float STAT_SOC_MIN_NENN_1_WERT = (RXBUF_UINT(0)/100.0f);
// Minimum nominal SOC after U / I full charge end-1 / Minimaler NennSOC nach U/I Vollladeende-1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_VOLLADEENDE", "STAT_SOC_MIN_NENN_1_WERT", STAT_SOC_MIN_NENN_1_WERT, "\"%\"");
float STAT_SOC_MIN_NENN_WENN_VOLL_1_WERT = (RXBUF_UINT(2)/100.0f);
// Forecast value of the minimum nominal SOC after U / I full charge end-1 / Prognosewert des minimalen NennSOC
// nach U/I Vollladeende-1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_VOLLADEENDE", "STAT_SOC_MIN_NENN_WENN_VOLL_1_WERT", STAT_SOC_MIN_NENN_WENN_VOLL_1_WERT, "\"%\"");
float STAT_SOC_MAX_AKT_1_WERT = (RXBUF_UINT(4)/100.0f);
// Maximum AktSOC after U / I full charge end-1 / Maximaler AktSOC nach U/I Vollladeende-1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_VOLLADEENDE", "STAT_SOC_MAX_AKT_1_WERT", STAT_SOC_MAX_AKT_1_WERT, "\"%\"");
float STAT_SOC_MAX_AKT_WENN_VOLL_1_WERT = (RXBUF_UINT(6)/100.0f);
// Forecast value of the maximum AktSOC after U / I full charge end-1 / Prognosewert des maximalen AktSOC nach
// U/I Vollladeende-1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_VOLLADEENDE", "STAT_SOC_MAX_AKT_WENN_VOLL_1_WERT", STAT_SOC_MAX_AKT_WENN_VOLL_1_WERT, "\"%\"");
char STAT_TEMP_LADEBEGINN_1_WERT = (RXBUF_SCHAR(8));
// Average measurement temperature at HVS level at start of charging -1 / Mittlere Messtemperatur auf HVS-Ebene
// zu Ladebeginn-1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_SOC_VOLLADEENDE", "STAT_TEMP_LADEBEGINN_1_WERT", STAT_TEMP_LADEBEGINN_1_WERT, "\"°C\"");
char STAT_TEMP_LADEENDE_1_WERT = (RXBUF_SCHAR(9));
// Average measurement temperature at HVS level at the end of charging-1 / Mittlere Messtemperatur auf HVS-Ebene
// zu Ladeende-1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_SOC_VOLLADEENDE", "STAT_TEMP_LADEENDE_1_WERT", STAT_TEMP_LADEENDE_1_WERT, "\"°C\"");
float STAT_SOC_MIN_NENN_2_WERT = (RXBUF_UINT(10)/100.0f);
// Minimum nominal SOC after U / I full charge end-2 / Minimaler NennSOC nach U/I Vollladeende-2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_VOLLADEENDE", "STAT_SOC_MIN_NENN_2_WERT", STAT_SOC_MIN_NENN_2_WERT, "\"%\"");
float STAT_SOC_MIN_NENN_WENN_VOLL_2_WERT = (RXBUF_UINT(12)/100.0f);
// Forecast value of the minimum nominal SOC after U / I full charge end-2 / Prognosewert des minimalen NennSOC
// nach U/I Vollladeende-2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_VOLLADEENDE", "STAT_SOC_MIN_NENN_WENN_VOLL_2_WERT", STAT_SOC_MIN_NENN_WENN_VOLL_2_WERT, "\"%\"");
float STAT_SOC_MAX_AKT_2_WERT = (RXBUF_UINT(14)/100.0f);
// Maximum AktSOC after U / I full charge end-2 / Maximaler AktSOC nach U/I Vollladeende-2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_VOLLADEENDE", "STAT_SOC_MAX_AKT_2_WERT", STAT_SOC_MAX_AKT_2_WERT, "\"%\"");
float STAT_SOC_MAX_AKT_WENN_VOLL_2_WERT = (RXBUF_UINT(16)/100.0f);
// Forecast value of the maximum AktSOC after U / I full charge end-2 / Prognosewert des maximalen AktSOC nach
// U/I Vollladeende-2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_VOLLADEENDE", "STAT_SOC_MAX_AKT_WENN_VOLL_2_WERT", STAT_SOC_MAX_AKT_WENN_VOLL_2_WERT, "\"%\"");
char STAT_TEMP_LADEBEGINN_2_WERT = (RXBUF_SCHAR(18));
// Average measurement temperature at HVS level at the start of charging-2 / Mittlere Messtemperatur auf
// HVS-Ebene zu Ladebeginn-2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_SOC_VOLLADEENDE", "STAT_TEMP_LADEBEGINN_2_WERT", STAT_TEMP_LADEBEGINN_2_WERT, "\"°C\"");
char STAT_TEMP_LADEENDE_2_WERT = (RXBUF_SCHAR(19));
// Average measurement temperature at HVS level at the end of charging-2 / Mittlere Messtemperatur auf HVS-Ebene
// zu Ladeende-2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_SOC_VOLLADEENDE", "STAT_TEMP_LADEENDE_2_WERT", STAT_TEMP_LADEENDE_2_WERT, "\"°C\"");
float STAT_SOC_MIN_NENN_3_WERT = (RXBUF_UINT(20)/100.0f);
// Minimum nominal SOC after U / I full charge end-3 / Minimaler NennSOC nach U/I Vollladeende-3
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_VOLLADEENDE", "STAT_SOC_MIN_NENN_3_WERT", STAT_SOC_MIN_NENN_3_WERT, "\"%\"");
float STAT_SOC_MIN_NENN_WENN_VOLL_3_WERT = (RXBUF_UINT(22)/100.0f);
// Forecast value of the minimum nominal SOC after U / I full charge end-3 / Prognosewert des minimalen NennSOC
// nach U/I Vollladeende-3
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_VOLLADEENDE", "STAT_SOC_MIN_NENN_WENN_VOLL_3_WERT", STAT_SOC_MIN_NENN_WENN_VOLL_3_WERT, "\"%\"");
float STAT_SOC_MAX_AKT_3_WERT = (RXBUF_UINT(24)/100.0f);
// Maximum AktSOC after U / I full charge end-3 / Maximaler AktSOC nach U/I Vollladeende-3
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_VOLLADEENDE", "STAT_SOC_MAX_AKT_3_WERT", STAT_SOC_MAX_AKT_3_WERT, "\"%\"");
float STAT_SOC_MAX_AKT_WENN_VOLL_3_WERT = (RXBUF_UINT(26)/100.0f);
// Forecast value of the maximum AktSOC after U / I full charge end-3 / Prognosewert des maximalen AktSOC nach
// U/I Vollladeende-3
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_VOLLADEENDE", "STAT_SOC_MAX_AKT_WENN_VOLL_3_WERT", STAT_SOC_MAX_AKT_WENN_VOLL_3_WERT, "\"%\"");
char STAT_TEMP_LADEBEGINN_3_WERT = (RXBUF_SCHAR(28));
// Average measurement temperature at HVS level at the start of charging -3 / Mittlere Messtemperatur auf
// HVS-Ebene zu Ladebeginn-3
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_SOC_VOLLADEENDE", "STAT_TEMP_LADEBEGINN_3_WERT", STAT_TEMP_LADEBEGINN_3_WERT, "\"°C\"");
char STAT_TEMP_LADEENDE_3_WERT = (RXBUF_SCHAR(29));
// Average measuring temperature at HVS level at the end of charging -3 / Mittlere Messtemperatur auf HVS-Ebene
// zu Ladeende-3
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_SOC_VOLLADEENDE", "STAT_TEMP_LADEENDE_3_WERT", STAT_TEMP_LADEENDE_3_WERT, "\"°C\"");
float STAT_SOC_MIN_NENN_4_WERT = (RXBUF_UINT(30)/100.0f);
// Minimum nominal SOC after U / I full charge end-4 / Minimaler NennSOC nach U/I Vollladeende-4
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_VOLLADEENDE", "STAT_SOC_MIN_NENN_4_WERT", STAT_SOC_MIN_NENN_4_WERT, "\"%\"");
float STAT_SOC_MIN_NENN_WENN_VOLL_4_WERT = (RXBUF_UINT(32)/100.0f);
// Forecast value of the minimum nominal SOC after U / I full charge end-4 / Prognosewert des minimalen NennSOC
// nach U/I Vollladeende-4
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_VOLLADEENDE", "STAT_SOC_MIN_NENN_WENN_VOLL_4_WERT", STAT_SOC_MIN_NENN_WENN_VOLL_4_WERT, "\"%\"");
float STAT_SOC_MAX_AKT_4_WERT = (RXBUF_UINT(34)/100.0f);
// Maximum AktSOC after U / I full charge end-4 / Maximaler AktSOC nach U/I Vollladeende-4
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_VOLLADEENDE", "STAT_SOC_MAX_AKT_4_WERT", STAT_SOC_MAX_AKT_4_WERT, "\"%\"");
float STAT_SOC_MAX_AKT_WENN_VOLL_4_WERT = (RXBUF_UINT(36)/100.0f);
// Forecast value of the maximum AktSOC after U / I full charge end-4 / Prognosewert des maximalen AktSOC nach
// U/I Vollladeende-4
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_VOLLADEENDE", "STAT_SOC_MAX_AKT_WENN_VOLL_4_WERT", STAT_SOC_MAX_AKT_WENN_VOLL_4_WERT, "\"%\"");
char STAT_TEMP_LADEBEGINN_4_WERT = (RXBUF_SCHAR(38));
// Average measurement temperature at HVS level at the start of charging -4 / Mittlere Messtemperatur auf
// HVS-Ebene zu Ladebeginn-4
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_SOC_VOLLADEENDE", "STAT_TEMP_LADEBEGINN_4_WERT", STAT_TEMP_LADEBEGINN_4_WERT, "\"°C\"");
char STAT_TEMP_LADEENDE_4_WERT = (RXBUF_SCHAR(39));
// Average measurement temperature at HVS level at the end of charging-4 / Mittlere Messtemperatur auf HVS-Ebene
// zu Ladeende-4
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_SOC_VOLLADEENDE", "STAT_TEMP_LADEENDE_4_WERT", STAT_TEMP_LADEENDE_4_WERT, "\"°C\"");
float STAT_SOC_MIN_NENN_5_WERT = (RXBUF_UINT(40)/100.0f);
// Minimum nominal SOC after U / I full charge end-5 / Minimaler NennSOC nach U/I Vollladeende-5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_VOLLADEENDE", "STAT_SOC_MIN_NENN_5_WERT", STAT_SOC_MIN_NENN_5_WERT, "\"%\"");
float STAT_SOC_MIN_NENN_WENN_VOLL_5_WERT = (RXBUF_UINT(42)/100.0f);
// Forecast value of the minimum nominal SOC after U / I full charge end-5 / Prognosewert des minimalen NennSOC
// nach U/I Vollladeende-5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_VOLLADEENDE", "STAT_SOC_MIN_NENN_WENN_VOLL_5_WERT", STAT_SOC_MIN_NENN_WENN_VOLL_5_WERT, "\"%\"");
float STAT_SOC_MAX_AKT_5_WERT = (RXBUF_UINT(44)/100.0f);
// Maximum AktSOC after U / I full charge end-5 / Maximaler AktSOC nach U/I Vollladeende-5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_VOLLADEENDE", "STAT_SOC_MAX_AKT_5_WERT", STAT_SOC_MAX_AKT_5_WERT, "\"%\"");
float STAT_SOC_MAX_AKT_WENN_VOLL_5_WERT = (RXBUF_UINT(46)/100.0f);
// Forecast value of the maximum AktSOC after U / I full charge end-5 / Prognosewert des maximalen AktSOC nach
// U/I Vollladeende-5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOC_VOLLADEENDE", "STAT_SOC_MAX_AKT_WENN_VOLL_5_WERT", STAT_SOC_MAX_AKT_WENN_VOLL_5_WERT, "\"%\"");
char STAT_TEMP_LADEBEGINN_5_WERT = (RXBUF_SCHAR(48));
// Average measurement temperature at HVS level at the start of charging -5 / Mittlere Messtemperatur auf
// HVS-Ebene zu Ladebeginn-5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_SOC_VOLLADEENDE", "STAT_TEMP_LADEBEGINN_5_WERT", STAT_TEMP_LADEBEGINN_5_WERT, "\"°C\"");
char STAT_TEMP_LADEENDE_5_WERT = (RXBUF_SCHAR(49));
// Average measuring temperature at HVS level at the end of charging -5 / Mittlere Messtemperatur auf HVS-Ebene
// zu Ladeende-5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_SOC_VOLLADEENDE", "STAT_TEMP_LADEENDE_5_WERT", STAT_TEMP_LADEENDE_5_WERT, "\"°C\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_KUEHLDAUER_HVB: { // 0xD4CC
if (datalen < 9) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_KUEHLDAUER_HVB", 9);
break;
}
unsigned char STAT_KUEHLDAUER_MAX_WERT = (RXBUF_UCHAR(0));
// Predefined maximum cooling duration [tmax] (project-specific) / Vordefinierte maximale Kühldauer [tmax]
// (projektspezifisch)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "KUEHLDAUER_HVB", "STAT_KUEHLDAUER_MAX_WERT", STAT_KUEHLDAUER_MAX_WERT, "\"min\"");
unsigned short STAT_KUEHLDAUER_1_WERT = (RXBUF_UINT(1));
// Number of duration class: 0 <t <= tmax * 0.25 / Anzahl Dauerklasse: 0 < t <= tmax*0.25
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "KUEHLDAUER_HVB", "STAT_KUEHLDAUER_1_WERT", STAT_KUEHLDAUER_1_WERT, "");
unsigned short STAT_KUEHLDAUER_2_WERT = (RXBUF_UINT(3));
// Number of duration class: 0.25 * tmax <t <= tmax * 0.5 / Anzahl Dauerklasse: 0.25*tmax < t <= tmax*0.5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "KUEHLDAUER_HVB", "STAT_KUEHLDAUER_2_WERT", STAT_KUEHLDAUER_2_WERT, "");
unsigned short STAT_KUEHLDAUER_3_WERT = (RXBUF_UINT(5));
// Number of duration class: 0.5 * tmax <t <= tmax / Anzahl Dauerklasse: 0.5*tmax < t <= tmax
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "KUEHLDAUER_HVB", "STAT_KUEHLDAUER_3_WERT", STAT_KUEHLDAUER_3_WERT, "");
unsigned short STAT_KUEHLDAUER_4_WERT = (RXBUF_UINT(7));
// Number of duration classes: t> tmax / Anzahl Dauerklasse: t > tmax
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "KUEHLDAUER_HVB", "STAT_KUEHLDAUER_4_WERT", STAT_KUEHLDAUER_4_WERT, "");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_LADUNGSVERLUST_ZELLE: { // 0xD67F
if (datalen < 22) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_LADUNGSVERLUST_ZELLE", 22);
break;
}
float STAT_SOC_MIN_NENN_01_WERT = (RXBUF_UINT(0)/10.0f);
// Minimum charge level of all cells based on nominal capacity / Minimaler Ladezustand aller Zellen bezogen auf
// Nennkapazität
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "LADUNGSVERLUST_ZELLE", "STAT_SOC_MIN_NENN_01_WERT", STAT_SOC_MIN_NENN_01_WERT, "\"%\"");
float STAT_DIFF_SOC_01_WERT = (RXBUF_UINT(2)/10.0f);
// Difference between the average and minimum charge status of all cells based on nominal capacity / Differenz
// zwischen dem mittleren und minimalen Ladezsustand aller Zellen bezogen auf Nennkapazität
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "LADUNGSVERLUST_ZELLE", "STAT_DIFF_SOC_01_WERT", STAT_DIFF_SOC_01_WERT, "\"%\"");
float STAT_SOC_MIN_NENN_02_WERT = (RXBUF_UINT(4)/10.0f);
// Minimum charge level of all cells based on nominal capacity / Minimaler Ladezustand aller Zellen bezogen auf
// Nennkapazität
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "LADUNGSVERLUST_ZELLE", "STAT_SOC_MIN_NENN_02_WERT", STAT_SOC_MIN_NENN_02_WERT, "\"%\"");
float STAT_DIFF_SOC_02_WERT = (RXBUF_UINT(6)/10.0f);
// Difference between the average and minimum charge status of all cells based on nominal capacity / Differenz
// zwischen dem mittleren und minimalen Ladezsustand aller Zellen bezogen auf Nennkapazität
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "LADUNGSVERLUST_ZELLE", "STAT_DIFF_SOC_02_WERT", STAT_DIFF_SOC_02_WERT, "\"%\"");
float STAT_SOC_MIN_NENN_03_WERT = (RXBUF_UINT(8)/10.0f);
// Minimum charge level of all cells based on nominal capacity / Minimaler Ladezustand aller Zellen bezogen auf
// Nennkapazität
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "LADUNGSVERLUST_ZELLE", "STAT_SOC_MIN_NENN_03_WERT", STAT_SOC_MIN_NENN_03_WERT, "\"%\"");
float STAT_DIFF_SOC_03_WERT = (RXBUF_UINT(10)/10.0f);
// Difference between the average and minimum charge status of all cells based on nominal capacity / Differenz
// zwischen dem mittleren und minimalen Ladezsustand aller Zellen bezogen auf Nennkapazität
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "LADUNGSVERLUST_ZELLE", "STAT_DIFF_SOC_03_WERT", STAT_DIFF_SOC_03_WERT, "\"%\"");
float STAT_SOC_MIN_NENN_04_WERT = (RXBUF_UINT(12)/10.0f);
// Minimum charge level of all cells based on nominal capacity / Minimaler Ladezustand aller Zellen bezogen auf
// Nennkapazität
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "LADUNGSVERLUST_ZELLE", "STAT_SOC_MIN_NENN_04_WERT", STAT_SOC_MIN_NENN_04_WERT, "\"%\"");
float STAT_DIFF_SOC_04_WERT = (RXBUF_UINT(14)/10.0f);
// Difference between the average and minimum charge status of all cells based on nominal capacity / Differenz
// zwischen dem mittleren und minimalen Ladezsustand aller Zellen bezogen auf Nennkapazität
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "LADUNGSVERLUST_ZELLE", "STAT_DIFF_SOC_04_WERT", STAT_DIFF_SOC_04_WERT, "\"%\"");
float STAT_SOC_MIN_NENN_05_WERT = (RXBUF_UINT(16)/10.0f);
// Minimum charge level of all cells based on nominal capacity / Minimaler Ladezustand aller Zellen bezogen auf
// Nennkapazität
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "LADUNGSVERLUST_ZELLE", "STAT_SOC_MIN_NENN_05_WERT", STAT_SOC_MIN_NENN_05_WERT, "\"%\"");
float STAT_DIFF_SOC_05_WERT = (RXBUF_UINT(18)/10.0f);
// Difference between the average and minimum charge status of all cells based on nominal capacity / Differenz
// zwischen dem mittleren und minimalen Ladezsustand aller Zellen bezogen auf Nennkapazität
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "LADUNGSVERLUST_ZELLE", "STAT_DIFF_SOC_05_WERT", STAT_DIFF_SOC_05_WERT, "\"%\"");
unsigned char STAT_ID_ZELLE_SOC_MIN_WERT = (RXBUF_UCHAR(20));
// ID of the cell with the smallest SoC_min_nenn / ID der Zelle mit kleinstem SoC_min_nenn
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADUNGSVERLUST_ZELLE", "STAT_ID_ZELLE_SOC_MIN_WERT", STAT_ID_ZELLE_SOC_MIN_WERT, "");
unsigned char STAT_COUNTER_RG_WERT = (RXBUF_UCHAR(21));
// Counter of how often the ring buffer has been written to since the last reset / Zähler, wie oft der
// Ringspeicher seit dem letzten Reset beschrieben wurde
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADUNGSVERLUST_ZELLE", "STAT_COUNTER_RG_WERT", STAT_COUNTER_RG_WERT, "");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_STATUS_MIN_KAPAZITAET_MOD: { // 0xD681
if (datalen < 12) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_STATUS_MIN_KAPAZITAET_MOD", 12);
break;
}
unsigned char STAT_MIN_KAPA_MOD_01_WERT = (RXBUF_UCHAR(0));
// Minimum capacity in percent of MODULE 01 / Minimale Kapazität in Prozent von MODUL 01
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "STATUS_MIN_KAPAZITAET_MOD", "STAT_MIN_KAPA_MOD_01_WERT", STAT_MIN_KAPA_MOD_01_WERT, "\"%\"");
unsigned char STAT_MIN_KAPA_MOD_02_WERT = (RXBUF_UCHAR(1));
// Minimum capacity in percent of MODULE 02 / Minimale Kapazität in Prozent von MODUL 02
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "STATUS_MIN_KAPAZITAET_MOD", "STAT_MIN_KAPA_MOD_02_WERT", STAT_MIN_KAPA_MOD_02_WERT, "\"%\"");
unsigned char STAT_MIN_KAPA_MOD_03_WERT = (RXBUF_UCHAR(2));
// Minimum capacity in percent of MODULE 03 / Minimale Kapazität in Prozent von MODUL 03
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "STATUS_MIN_KAPAZITAET_MOD", "STAT_MIN_KAPA_MOD_03_WERT", STAT_MIN_KAPA_MOD_03_WERT, "\"%\"");
unsigned char STAT_MIN_KAPA_MOD_04_WERT = (RXBUF_UCHAR(3));
// Minimum capacity in percent of MODULE 04 / Minimale Kapazität in Prozent von MODUL 04
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "STATUS_MIN_KAPAZITAET_MOD", "STAT_MIN_KAPA_MOD_04_WERT", STAT_MIN_KAPA_MOD_04_WERT, "\"%\"");
unsigned char STAT_MIN_KAPA_MOD_05_WERT = (RXBUF_UCHAR(4));
// Minimum capacity in percent of MODULE 05 / Minimale Kapazität in Prozent von MODUL 05
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "STATUS_MIN_KAPAZITAET_MOD", "STAT_MIN_KAPA_MOD_05_WERT", STAT_MIN_KAPA_MOD_05_WERT, "\"%\"");
unsigned char STAT_MIN_KAPA_MOD_06_WERT = (RXBUF_UCHAR(5));
// Minimum capacity in percent of MODULE 06 / Minimale Kapazität in Prozent von MODUL 06
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "STATUS_MIN_KAPAZITAET_MOD", "STAT_MIN_KAPA_MOD_06_WERT", STAT_MIN_KAPA_MOD_06_WERT, "\"%\"");
unsigned char STAT_MIN_KAPA_MOD_07_WERT = (RXBUF_UCHAR(6));
// Minimum capacity in percent of MODULE 07 / Minimale Kapazität in Prozent von MODUL 07
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "STATUS_MIN_KAPAZITAET_MOD", "STAT_MIN_KAPA_MOD_07_WERT", STAT_MIN_KAPA_MOD_07_WERT, "\"%\"");
unsigned char STAT_MIN_KAPA_MOD_08_WERT = (RXBUF_UCHAR(7));
// Minimum capacity in percent of MODULE 08 / Minimale Kapazität in Prozent von MODUL 08
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "STATUS_MIN_KAPAZITAET_MOD", "STAT_MIN_KAPA_MOD_08_WERT", STAT_MIN_KAPA_MOD_08_WERT, "\"%\"");
unsigned char STAT_MIN_KAPA_MOD_09_WERT = (RXBUF_UCHAR(8));
// Minimum capacity in percent of MODULE 09 / Minimale Kapazität in Prozent von MODUL 09
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "STATUS_MIN_KAPAZITAET_MOD", "STAT_MIN_KAPA_MOD_09_WERT", STAT_MIN_KAPA_MOD_09_WERT, "\"%\"");
unsigned char STAT_MIN_KAPA_MOD_10_WERT = (RXBUF_UCHAR(9));
// Minimum capacity in percent of MODULE 10 / Minimale Kapazität in Prozent von MODUL 10
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "STATUS_MIN_KAPAZITAET_MOD", "STAT_MIN_KAPA_MOD_10_WERT", STAT_MIN_KAPA_MOD_10_WERT, "\"%\"");
unsigned char STAT_MIN_KAPA_MOD_11_WERT = (RXBUF_UCHAR(10));
// Minimum capacity in percent of MODULE 11 / Minimale Kapazität in Prozent von MODUL 11
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "STATUS_MIN_KAPAZITAET_MOD", "STAT_MIN_KAPA_MOD_11_WERT", STAT_MIN_KAPA_MOD_11_WERT, "\"%\"");
unsigned char STAT_MIN_KAPA_MOD_12_WERT = (RXBUF_UCHAR(11));
// Minimum capacity in percent of MODULE 12 / Minimale Kapazität in Prozent von MODUL 12
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "STATUS_MIN_KAPAZITAET_MOD", "STAT_MIN_KAPA_MOD_12_WERT", STAT_MIN_KAPA_MOD_12_WERT, "\"%\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_RB_ISO_MESS_TRG: { // 0xD6C7
if (datalen < 15) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_RB_ISO_MESS_TRG", 15);
break;
}
unsigned short STAT_R_ISO_TRG_01_WERT = (RXBUF_UINT(0));
// R_iso_ges [kOhm] VALUE 01 / R_iso_ges [kOhm] WERT 01
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "RB_ISO_MESS_TRG", "STAT_R_ISO_TRG_01_WERT", STAT_R_ISO_TRG_01_WERT, "\"kOhm\"");
unsigned char STAT_R_ISO_QAL_TRG_01_WERT = (RXBUF_UCHAR(2));
// R_iso_ges QUAL 01 / R_iso_ges QUAL 01
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_ISO_MESS_TRG", "STAT_R_ISO_QAL_TRG_01_WERT", STAT_R_ISO_QAL_TRG_01_WERT, "");
unsigned short STAT_R_ISO_TRG_02_WERT = (RXBUF_UINT(3));
// R_iso_ges [kOhm] VALUE 02 / R_iso_ges [kOhm] WERT 02
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "RB_ISO_MESS_TRG", "STAT_R_ISO_TRG_02_WERT", STAT_R_ISO_TRG_02_WERT, "\"kOhm\"");
unsigned char STAT_R_ISO_QAL_TRG_02_WERT = (RXBUF_UCHAR(5));
// R_iso_ges QUAL 02 / R_iso_ges QUAL 02
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_ISO_MESS_TRG", "STAT_R_ISO_QAL_TRG_02_WERT", STAT_R_ISO_QAL_TRG_02_WERT, "");
unsigned short STAT_R_ISO_TRG_03_WERT = (RXBUF_UINT(6));
// R_iso_ges [kOhm] VALUE 03 / R_iso_ges [kOhm] WERT 03
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "RB_ISO_MESS_TRG", "STAT_R_ISO_TRG_03_WERT", STAT_R_ISO_TRG_03_WERT, "\"kOhm\"");
unsigned char STAT_R_ISO_QAL_TRG_03_WERT = (RXBUF_UCHAR(8));
// R_iso_ges QUAL 03 / R_iso_ges QUAL 03
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_ISO_MESS_TRG", "STAT_R_ISO_QAL_TRG_03_WERT", STAT_R_ISO_QAL_TRG_03_WERT, "");
unsigned short STAT_R_ISO_TRG_04_WERT = (RXBUF_UINT(9));
// R_iso_ges [kOhm] VALUE 04 / R_iso_ges [kOhm] WERT 04
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "RB_ISO_MESS_TRG", "STAT_R_ISO_TRG_04_WERT", STAT_R_ISO_TRG_04_WERT, "\"kOhm\"");
unsigned char STAT_R_ISO_QAL_TRG_04_WERT = (RXBUF_UCHAR(11));
// R_iso_ges QUAL 04 / R_iso_ges QUAL 04
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_ISO_MESS_TRG", "STAT_R_ISO_QAL_TRG_04_WERT", STAT_R_ISO_QAL_TRG_04_WERT, "");
unsigned short STAT_R_ISO_TRG_05_WERT = (RXBUF_UINT(12));
// R_iso_ges [kOhm] VALUE 05 / R_iso_ges [kOhm] WERT 05
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "RB_ISO_MESS_TRG", "STAT_R_ISO_TRG_05_WERT", STAT_R_ISO_TRG_05_WERT, "\"kOhm\"");
unsigned char STAT_R_ISO_QAL_TRG_05_WERT = (RXBUF_UCHAR(14));
// R_iso_ges QUAL 05 / R_iso_ges QUAL 05
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_ISO_MESS_TRG", "STAT_R_ISO_QAL_TRG_05_WERT", STAT_R_ISO_QAL_TRG_05_WERT, "");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_RB_ISO_MESS_STD_IO_NIO: { // 0xD6C8
if (datalen < 70) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_RB_ISO_MESS_STD_IO_NIO", 70);
break;
}
unsigned long STAT_STD_KM_ISO_01_WERT = (RXBUF_UINT32(0));
// Mileage when the error threshold is below / exceeded in the R_iso standard measurement [km] 01 / km-Stand bei
// Fehlerschwellenunter-/-überschreitung der R_iso Standardmessung [km] 01
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "RB_ISO_MESS_STD_IO_NIO", "STAT_STD_KM_ISO_01_WERT", STAT_STD_KM_ISO_01_WERT, "\"km\"");
unsigned short STAT_STD_R_ISO_01_WERT = (RXBUF_UINT(4));
// R_iso_Value when the error threshold is below / exceeded in the R_iso standard measurement [kOhm] 01 /
// R_iso_Wert bei Fehlerschwellenunter-/-überschreitung der R_iso Standardmessung [kOhm] 01
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "RB_ISO_MESS_STD_IO_NIO", "STAT_STD_R_ISO_01_WERT", STAT_STD_R_ISO_01_WERT, "\"kOhm\"");
unsigned char STAT_STD_R_ISO_QAL_01_WERT = (RXBUF_UCHAR(6));
// R_iso_Qual if the R_iso standard measurement falls below / exceeds the error threshold [-] 01 / R_iso_Qual bei
// Fehlerschwellenunter-/-überschreitung der R_iso Standardmessung [-] 01
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_ISO_MESS_STD_IO_NIO", "STAT_STD_R_ISO_QAL_01_WERT", STAT_STD_R_ISO_QAL_01_WERT, "");
unsigned long STAT_STD_KM_ISO_02_WERT = (RXBUF_UINT32(7));
// Mileage reading when the error threshold of the R_iso standard measurement is below / exceeded [km] 02 /
// km-Stand bei Fehlerschwellenunter-/-überschreitung der R_iso Standardmessung [km] 02
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "RB_ISO_MESS_STD_IO_NIO", "STAT_STD_KM_ISO_02_WERT", STAT_STD_KM_ISO_02_WERT, "\"km\"");
unsigned short STAT_STD_R_ISO_02_WERT = (RXBUF_UINT(11));
// R_iso_Wert if the R_iso standard measurement falls below / exceeds the error threshold [kOhm] 02 / R_iso_Wert
// bei Fehlerschwellenunter-/-überschreitung der R_iso Standardmessung [kOhm] 02
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "RB_ISO_MESS_STD_IO_NIO", "STAT_STD_R_ISO_02_WERT", STAT_STD_R_ISO_02_WERT, "\"kOhm\"");
unsigned char STAT_STD_R_ISO_QAL_02_WERT = (RXBUF_UCHAR(13));
// R_iso_Qual if the R_iso standard measurement falls below / exceeds the error threshold [-] 02 / R_iso_Qual bei
// Fehlerschwellenunter-/-überschreitung der R_iso Standardmessung [-] 02
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_ISO_MESS_STD_IO_NIO", "STAT_STD_R_ISO_QAL_02_WERT", STAT_STD_R_ISO_QAL_02_WERT, "");
unsigned long STAT_STD_KM_ISO_03_WERT = (RXBUF_UINT32(14));
// Mileage in case of failure threshold of the R_iso standard measurement [km] 03 / km-Stand bei
// Fehlerschwellenunter-/-überschreitung der R_iso Standardmessung [km] 03
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "RB_ISO_MESS_STD_IO_NIO", "STAT_STD_KM_ISO_03_WERT", STAT_STD_KM_ISO_03_WERT, "\"km\"");
unsigned short STAT_STD_R_ISO_03_WERT = (RXBUF_UINT(18));
// R_iso_Wert if the R_iso standard measurement falls below / exceeds the error threshold [kOhm] 03 / R_iso_Wert
// bei Fehlerschwellenunter-/-überschreitung der R_iso Standardmessung [kOhm] 03
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "RB_ISO_MESS_STD_IO_NIO", "STAT_STD_R_ISO_03_WERT", STAT_STD_R_ISO_03_WERT, "\"kOhm\"");
unsigned char STAT_STD_R_ISO_QAL_03_WERT = (RXBUF_UCHAR(20));
// R_iso_Qual if the R_iso standard measurement falls below / exceeds the error threshold [-] 03 / R_iso_Qual bei
// Fehlerschwellenunter-/-überschreitung der R_iso Standardmessung [-] 03
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_ISO_MESS_STD_IO_NIO", "STAT_STD_R_ISO_QAL_03_WERT", STAT_STD_R_ISO_QAL_03_WERT, "");
unsigned long STAT_STD_KM_ISO_04_WERT = (RXBUF_UINT32(21));
// Mileage when the error threshold is below / exceeded in the R_iso standard measurement [km] 04 / km-Stand bei
// Fehlerschwellenunter-/-überschreitung der R_iso Standardmessung [km] 04
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "RB_ISO_MESS_STD_IO_NIO", "STAT_STD_KM_ISO_04_WERT", STAT_STD_KM_ISO_04_WERT, "\"km\"");
unsigned short STAT_STD_R_ISO_04_WERT = (RXBUF_UINT(25));
// R_iso_Value when the error threshold falls below / exceeds the R_iso standard measurement [kOhm] 04 /
// R_iso_Wert bei Fehlerschwellenunter-/-überschreitung der R_iso Standardmessung [kOhm] 04
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "RB_ISO_MESS_STD_IO_NIO", "STAT_STD_R_ISO_04_WERT", STAT_STD_R_ISO_04_WERT, "\"kOhm\"");
unsigned char STAT_STD_R_ISO_QAL_04_WERT = (RXBUF_UCHAR(27));
// R_iso_Qual if the R_iso standard measurement falls below / exceeds the error threshold [-] 04 / R_iso_Qual bei
// Fehlerschwellenunter-/-überschreitung der R_iso Standardmessung [-] 04
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_ISO_MESS_STD_IO_NIO", "STAT_STD_R_ISO_QAL_04_WERT", STAT_STD_R_ISO_QAL_04_WERT, "");
unsigned long STAT_STD_KM_ISO_05_WERT = (RXBUF_UINT32(28));
// Mileage in case of failure threshold of the R_iso standard measurement [km] 05 / km-Stand bei
// Fehlerschwellenunter-/-überschreitung der R_iso Standardmessung [km] 05
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "RB_ISO_MESS_STD_IO_NIO", "STAT_STD_KM_ISO_05_WERT", STAT_STD_KM_ISO_05_WERT, "\"km\"");
unsigned short STAT_STD_R_ISO_05_WERT = (RXBUF_UINT(32));
// R_iso_Value if the R_iso standard measurement falls below / exceeds the error threshold [kOhm] 05 / R_iso_Wert
// bei Fehlerschwellenunter-/-überschreitung der R_iso Standardmessung [kOhm] 05
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "RB_ISO_MESS_STD_IO_NIO", "STAT_STD_R_ISO_05_WERT", STAT_STD_R_ISO_05_WERT, "\"kOhm\"");
unsigned char STAT_STD_R_ISO_QAL_05_WERT = (RXBUF_UCHAR(34));
// R_iso_Qual if the R_iso standard measurement falls below / exceeds the error threshold [-] 05 / R_iso_Qual bei
// Fehlerschwellenunter-/-überschreitung der R_iso Standardmessung [-] 05
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_ISO_MESS_STD_IO_NIO", "STAT_STD_R_ISO_QAL_05_WERT", STAT_STD_R_ISO_QAL_05_WERT, "");
unsigned long STAT_STD_KM_ISO_06_WERT = (RXBUF_UINT32(35));
// Mileage when the error threshold is below / exceeded in the R_iso standard measurement [km] 06 / km-Stand bei
// Fehlerschwellenunter-/-überschreitung der R_iso Standardmessung [km] 06
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "RB_ISO_MESS_STD_IO_NIO", "STAT_STD_KM_ISO_06_WERT", STAT_STD_KM_ISO_06_WERT, "\"km\"");
unsigned short STAT_STD_R_ISO_06_WERT = (RXBUF_UINT(39));
// R_iso_Wert if the R_iso standard measurement falls below / exceeds the error threshold [kOhm] 06 / R_iso_Wert
// bei Fehlerschwellenunter-/-überschreitung der R_iso Standardmessung [kOhm] 06
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "RB_ISO_MESS_STD_IO_NIO", "STAT_STD_R_ISO_06_WERT", STAT_STD_R_ISO_06_WERT, "\"kOhm\"");
unsigned char STAT_STD_R_ISO_QAL_06_WERT = (RXBUF_UCHAR(41));
// R_iso_Qual if the R_iso standard measurement falls below / exceeds the error threshold [-] 06 / R_iso_Qual bei
// Fehlerschwellenunter-/-überschreitung der R_iso Standardmessung [-] 06
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_ISO_MESS_STD_IO_NIO", "STAT_STD_R_ISO_QAL_06_WERT", STAT_STD_R_ISO_QAL_06_WERT, "");
unsigned long STAT_STD_KM_ISO_07_WERT = (RXBUF_UINT32(42));
// Mileage in case of failure threshold of the R_iso standard measurement [km] 07 / km-Stand bei
// Fehlerschwellenunter-/-überschreitung der R_iso Standardmessung [km] 07
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "RB_ISO_MESS_STD_IO_NIO", "STAT_STD_KM_ISO_07_WERT", STAT_STD_KM_ISO_07_WERT, "\"km\"");
unsigned short STAT_STD_R_ISO_07_WERT = (RXBUF_UINT(46));
// R_iso_Value if the R_iso standard measurement falls below / exceeds the error threshold [kOhm] 07 / R_iso_Wert
// bei Fehlerschwellenunter-/-überschreitung der R_iso Standardmessung [kOhm] 07
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "RB_ISO_MESS_STD_IO_NIO", "STAT_STD_R_ISO_07_WERT", STAT_STD_R_ISO_07_WERT, "\"kOhm\"");
unsigned char STAT_STD_R_ISO_QAL_07_WERT = (RXBUF_UCHAR(48));
// R_iso_Qual if the R_iso standard measurement falls below / exceeds the error threshold [-] 07 / R_iso_Qual bei
// Fehlerschwellenunter-/-überschreitung der R_iso Standardmessung [-] 07
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_ISO_MESS_STD_IO_NIO", "STAT_STD_R_ISO_QAL_07_WERT", STAT_STD_R_ISO_QAL_07_WERT, "");
unsigned long STAT_STD_KM_ISO_08_WERT = (RXBUF_UINT32(49));
// Mileage in case of failure threshold of the R_iso standard measurement [km] 08 / km-Stand bei
// Fehlerschwellenunter-/-überschreitung der R_iso Standardmessung [km] 08
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "RB_ISO_MESS_STD_IO_NIO", "STAT_STD_KM_ISO_08_WERT", STAT_STD_KM_ISO_08_WERT, "\"km\"");
unsigned short STAT_STD_R_ISO_08_WERT = (RXBUF_UINT(53));
// R_iso_Wert if the R_iso standard measurement falls below / exceeds the error threshold [kOhm] 08 / R_iso_Wert
// bei Fehlerschwellenunter-/-überschreitung der R_iso Standardmessung [kOhm] 08
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "RB_ISO_MESS_STD_IO_NIO", "STAT_STD_R_ISO_08_WERT", STAT_STD_R_ISO_08_WERT, "\"kOhm\"");
unsigned char STAT_STD_R_ISO_QAL_08_WERT = (RXBUF_UCHAR(55));
// R_iso_Qual if the R_iso standard measurement falls below / exceeds the error threshold [-] 08 / R_iso_Qual bei
// Fehlerschwellenunter-/-überschreitung der R_iso Standardmessung [-] 08
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_ISO_MESS_STD_IO_NIO", "STAT_STD_R_ISO_QAL_08_WERT", STAT_STD_R_ISO_QAL_08_WERT, "");
unsigned long STAT_STD_KM_ISO_09_WERT = (RXBUF_UINT32(56));
// Mileage in case of failure threshold of the R_iso standard measurement [km] 09 / km-Stand bei
// Fehlerschwellenunter-/-überschreitung der R_iso Standardmessung [km] 09
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "RB_ISO_MESS_STD_IO_NIO", "STAT_STD_KM_ISO_09_WERT", STAT_STD_KM_ISO_09_WERT, "\"km\"");
unsigned short STAT_STD_R_ISO_09_WERT = (RXBUF_UINT(60));
// R_iso_Value when the error threshold of the R_iso standard measurement is below / exceeded [kOhm] 09 /
// R_iso_Wert bei Fehlerschwellenunter-/-überschreitung der R_iso Standardmessung [kOhm] 09
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "RB_ISO_MESS_STD_IO_NIO", "STAT_STD_R_ISO_09_WERT", STAT_STD_R_ISO_09_WERT, "\"kOhm\"");
unsigned char STAT_STD_R_ISO_QAL_09_WERT = (RXBUF_UCHAR(62));
// R_iso_Qual if the R_iso standard measurement falls below / exceeds the error threshold [-] 09 / R_iso_Qual bei
// Fehlerschwellenunter-/-überschreitung der R_iso Standardmessung [-] 09
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_ISO_MESS_STD_IO_NIO", "STAT_STD_R_ISO_QAL_09_WERT", STAT_STD_R_ISO_QAL_09_WERT, "");
unsigned long STAT_STD_KM_ISO_10_WERT = (RXBUF_UINT32(63));
// Mileage when the error threshold is exceeded or not reached in the R_iso standard measurement [km] 10 /
// km-Stand bei Fehlerschwellenunter-/-überschreitung der R_iso Standardmessung [km] 10
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "RB_ISO_MESS_STD_IO_NIO", "STAT_STD_KM_ISO_10_WERT", STAT_STD_KM_ISO_10_WERT, "\"km\"");
unsigned short STAT_STD_R_ISO_10_WERT = (RXBUF_UINT(67));
// R_iso_Wert if the R_iso standard measurement falls below / exceeds the error threshold [kOhm] 10 / R_iso_Wert
// bei Fehlerschwellenunter-/-überschreitung der R_iso Standardmessung [kOhm] 10
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "RB_ISO_MESS_STD_IO_NIO", "STAT_STD_R_ISO_10_WERT", STAT_STD_R_ISO_10_WERT, "\"kOhm\"");
unsigned char STAT_STD_R_ISO_QAL_10_WERT = (RXBUF_UCHAR(69));
// R_iso_Qual if the R_iso standard measurement falls below / exceeds the error threshold [-] 10 / R_iso_Qual bei
// Fehlerschwellenunter-/-überschreitung der R_iso Standardmessung [-] 10
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_ISO_MESS_STD_IO_NIO", "STAT_STD_R_ISO_QAL_10_WERT", STAT_STD_R_ISO_QAL_10_WERT, "");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_RB_ISO_MESS_TRG_IO_NIO: { // 0xD6C9
if (datalen < 70) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_RB_ISO_MESS_TRG_IO_NIO", 70);
break;
}
unsigned long STAT_TRG_KM_ISO_01_WERT = (RXBUF_UINT32(0));
// Mileage when the error threshold is below / exceeded in the R_iso lag measurement [km] 01 / km-Stand bei
// Fehlerschwellenunter-/-überschreitung der R_iso Nachlaufmessung [km] 01
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "RB_ISO_MESS_TRG_IO_NIO", "STAT_TRG_KM_ISO_01_WERT", STAT_TRG_KM_ISO_01_WERT, "\"km\"");
unsigned short STAT_TRG_R_ISO_01_WERT = (RXBUF_UINT(4));
// R_iso_Wert if the R_iso lag measurement falls below / exceeds the error threshold [kOhm] 01 / R_iso_Wert bei
// Fehlerschwellenunter-/-überschreitung der R_iso Nachlaufmessung [kOhm] 01
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "RB_ISO_MESS_TRG_IO_NIO", "STAT_TRG_R_ISO_01_WERT", STAT_TRG_R_ISO_01_WERT, "\"kOhm\"");
unsigned char STAT_TRG_R_ISO_QAL_01_WERT = (RXBUF_UCHAR(6));
// R_iso_Qual if the R_iso lag measurement falls below / exceeds the error threshold [-] 01 / R_iso_Qual bei
// Fehlerschwellenunter-/-überschreitung der R_iso Nachlaufmessung [-] 01
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_ISO_MESS_TRG_IO_NIO", "STAT_TRG_R_ISO_QAL_01_WERT", STAT_TRG_R_ISO_QAL_01_WERT, "");
unsigned long STAT_TRG_KM_ISO_02_WERT = (RXBUF_UINT32(7));
// Mileage in case of error threshold under / overrun of the R_iso follow-up measurement [km] 02 / km-Stand bei
// Fehlerschwellenunter-/-überschreitung der R_iso Nachlaufmessung [km] 02
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "RB_ISO_MESS_TRG_IO_NIO", "STAT_TRG_KM_ISO_02_WERT", STAT_TRG_KM_ISO_02_WERT, "\"km\"");
unsigned short STAT_TRG_R_ISO_02_WERT = (RXBUF_UINT(11));
// R_iso_Wert if the R_iso lag measurement falls below / exceeds the error threshold [kOhm] 02 / R_iso_Wert bei
// Fehlerschwellenunter-/-überschreitung der R_iso Nachlaufmessung [kOhm] 02
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "RB_ISO_MESS_TRG_IO_NIO", "STAT_TRG_R_ISO_02_WERT", STAT_TRG_R_ISO_02_WERT, "\"kOhm\"");
unsigned char STAT_TRG_R_ISO_QAL_02_WERT = (RXBUF_UCHAR(13));
// R_iso_Qual if the R_iso lag measurement falls below / exceeds the error threshold [-] 02 / R_iso_Qual bei
// Fehlerschwellenunter-/-überschreitung der R_iso Nachlaufmessung [-] 02
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_ISO_MESS_TRG_IO_NIO", "STAT_TRG_R_ISO_QAL_02_WERT", STAT_TRG_R_ISO_QAL_02_WERT, "");
unsigned long STAT_TRG_KM_ISO_03_WERT = (RXBUF_UINT32(14));
// Mileage when the error threshold is below / exceeded in the R_iso lag measurement [km] 03 / km-Stand bei
// Fehlerschwellenunter-/-überschreitung der R_iso Nachlaufmessung [km] 03
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "RB_ISO_MESS_TRG_IO_NIO", "STAT_TRG_KM_ISO_03_WERT", STAT_TRG_KM_ISO_03_WERT, "\"km\"");
unsigned short STAT_TRG_R_ISO_03_WERT = (RXBUF_UINT(18));
// R_iso_Value when the R_iso lag measurement falls below / exceeds the error threshold [kOhm] 03 / R_iso_Wert
// bei Fehlerschwellenunter-/-überschreitung der R_iso Nachlaufmessung [kOhm] 03
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "RB_ISO_MESS_TRG_IO_NIO", "STAT_TRG_R_ISO_03_WERT", STAT_TRG_R_ISO_03_WERT, "\"kOhm\"");
unsigned char STAT_TRG_R_ISO_QAL_03_WERT = (RXBUF_UCHAR(20));
// R_iso_Qual if the R_iso lag measurement falls below / exceeds the error threshold [-] 03 / R_iso_Qual bei
// Fehlerschwellenunter-/-überschreitung der R_iso Nachlaufmessung [-] 03
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_ISO_MESS_TRG_IO_NIO", "STAT_TRG_R_ISO_QAL_03_WERT", STAT_TRG_R_ISO_QAL_03_WERT, "");
unsigned long STAT_TRG_KM_ISO_04_WERT = (RXBUF_UINT32(21));
// Mileage in case of error threshold under / overrun of the R_iso lag measurement [km] 04 / km-Stand bei
// Fehlerschwellenunter-/-überschreitung der R_iso Nachlaufmessung [km] 04
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "RB_ISO_MESS_TRG_IO_NIO", "STAT_TRG_KM_ISO_04_WERT", STAT_TRG_KM_ISO_04_WERT, "\"km\"");
unsigned short STAT_TRG_R_ISO_04_WERT = (RXBUF_UINT(25));
// R_iso_Wert if the R_iso lag measurement falls below / exceeds the error threshold [kOhm] 04 / R_iso_Wert bei
// Fehlerschwellenunter-/-überschreitung der R_iso Nachlaufmessung [kOhm] 04
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "RB_ISO_MESS_TRG_IO_NIO", "STAT_TRG_R_ISO_04_WERT", STAT_TRG_R_ISO_04_WERT, "\"kOhm\"");
unsigned char STAT_TRG_R_ISO_QAL_04_WERT = (RXBUF_UCHAR(27));
// R_iso_Qual if the R_iso lag measurement falls below / exceeds the error threshold [-] 04 / R_iso_Qual bei
// Fehlerschwellenunter-/-überschreitung der R_iso Nachlaufmessung [-] 04
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_ISO_MESS_TRG_IO_NIO", "STAT_TRG_R_ISO_QAL_04_WERT", STAT_TRG_R_ISO_QAL_04_WERT, "");
unsigned long STAT_TRG_KM_ISO_05_WERT = (RXBUF_UINT32(28));
// Mileage when the error threshold is below / exceeded in the R_iso lag measurement [km] 05 / km-Stand bei
// Fehlerschwellenunter-/-überschreitung der R_iso Nachlaufmessung [km] 05
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "RB_ISO_MESS_TRG_IO_NIO", "STAT_TRG_KM_ISO_05_WERT", STAT_TRG_KM_ISO_05_WERT, "\"km\"");
unsigned short STAT_TRG_R_ISO_05_WERT = (RXBUF_UINT(32));
// R_iso_Wert if the R_iso lag measurement falls below / exceeds the error threshold [kOhm] 05 / R_iso_Wert bei
// Fehlerschwellenunter-/-überschreitung der R_iso Nachlaufmessung [kOhm] 05
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "RB_ISO_MESS_TRG_IO_NIO", "STAT_TRG_R_ISO_05_WERT", STAT_TRG_R_ISO_05_WERT, "\"kOhm\"");
unsigned char STAT_TRG_R_ISO_QAL_05_WERT = (RXBUF_UCHAR(34));
// R_iso_Qual if the R_iso lag measurement falls below / exceeds the error threshold [-] 05 / R_iso_Qual bei
// Fehlerschwellenunter-/-überschreitung der R_iso Nachlaufmessung [-] 05
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_ISO_MESS_TRG_IO_NIO", "STAT_TRG_R_ISO_QAL_05_WERT", STAT_TRG_R_ISO_QAL_05_WERT, "");
unsigned long STAT_TRG_KM_ISO_06_WERT = (RXBUF_UINT32(35));
// Mileage in case of error threshold under / overrun of the R_iso follow-up measurement [km] 06 / km-Stand bei
// Fehlerschwellenunter-/-überschreitung der R_iso Nachlaufmessung [km] 06
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "RB_ISO_MESS_TRG_IO_NIO", "STAT_TRG_KM_ISO_06_WERT", STAT_TRG_KM_ISO_06_WERT, "\"km\"");
unsigned short STAT_TRG_R_ISO_06_WERT = (RXBUF_UINT(39));
// R_iso_Wert if the R_iso lag measurement falls below / exceeds the error threshold [kOhm] 06 / R_iso_Wert bei
// Fehlerschwellenunter-/-überschreitung der R_iso Nachlaufmessung [kOhm] 06
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "RB_ISO_MESS_TRG_IO_NIO", "STAT_TRG_R_ISO_06_WERT", STAT_TRG_R_ISO_06_WERT, "\"kOhm\"");
unsigned char STAT_TRG_R_ISO_QAL_06_WERT = (RXBUF_UCHAR(41));
// R_iso_Qual if the R_iso lag measurement falls below / exceeds the error threshold [-] 06 / R_iso_Qual bei
// Fehlerschwellenunter-/-überschreitung der R_iso Nachlaufmessung [-] 06
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_ISO_MESS_TRG_IO_NIO", "STAT_TRG_R_ISO_QAL_06_WERT", STAT_TRG_R_ISO_QAL_06_WERT, "");
unsigned long STAT_TRG_KM_ISO_07_WERT = (RXBUF_UINT32(42));
// Mileage in case of error threshold under / overrun of the R_iso follow-up measurement [km] 07 / km-Stand bei
// Fehlerschwellenunter-/-überschreitung der R_iso Nachlaufmessung [km] 07
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "RB_ISO_MESS_TRG_IO_NIO", "STAT_TRG_KM_ISO_07_WERT", STAT_TRG_KM_ISO_07_WERT, "\"km\"");
unsigned short STAT_TRG_R_ISO_07_WERT = (RXBUF_UINT(46));
// R_iso_Wert when the R_iso lag measurement falls below / exceeds the error threshold [kOhm] 07 / R_iso_Wert bei
// Fehlerschwellenunter-/-überschreitung der R_iso Nachlaufmessung [kOhm] 07
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "RB_ISO_MESS_TRG_IO_NIO", "STAT_TRG_R_ISO_07_WERT", STAT_TRG_R_ISO_07_WERT, "\"kOhm\"");
unsigned char STAT_TRG_R_ISO_QAL_07_WERT = (RXBUF_UCHAR(48));
// R_iso_Qual if the R_iso lag measurement falls below / exceeds the error threshold [-] 07 / R_iso_Qual bei
// Fehlerschwellenunter-/-überschreitung der R_iso Nachlaufmessung [-] 07
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_ISO_MESS_TRG_IO_NIO", "STAT_TRG_R_ISO_QAL_07_WERT", STAT_TRG_R_ISO_QAL_07_WERT, "");
unsigned long STAT_TRG_KM_ISO_08_WERT = (RXBUF_UINT32(49));
// Mileage when the error threshold is below / exceeded in the R_iso follow-up measurement [km] 08 / km-Stand bei
// Fehlerschwellenunter-/-überschreitung der R_iso Nachlaufmessung [km] 08
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "RB_ISO_MESS_TRG_IO_NIO", "STAT_TRG_KM_ISO_08_WERT", STAT_TRG_KM_ISO_08_WERT, "\"km\"");
unsigned short STAT_TRG_R_ISO_08_WERT = (RXBUF_UINT(53));
// R_iso_Wert if the R_iso lag measurement falls below / exceeds the error threshold [kOhm] 08 / R_iso_Wert bei
// Fehlerschwellenunter-/-überschreitung der R_iso Nachlaufmessung [kOhm] 08
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "RB_ISO_MESS_TRG_IO_NIO", "STAT_TRG_R_ISO_08_WERT", STAT_TRG_R_ISO_08_WERT, "\"kOhm\"");
unsigned char STAT_TRG_R_ISO_QAL_08_WERT = (RXBUF_UCHAR(55));
// R_iso_Qual if the R_iso lag measurement falls below / exceeds the error threshold [-] 08 / R_iso_Qual bei
// Fehlerschwellenunter-/-überschreitung der R_iso Nachlaufmessung [-] 08
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_ISO_MESS_TRG_IO_NIO", "STAT_TRG_R_ISO_QAL_08_WERT", STAT_TRG_R_ISO_QAL_08_WERT, "");
unsigned long STAT_TRG_KM_ISO_09_WERT = (RXBUF_UINT32(56));
// Mileage in case of error threshold under / overrun of the R_iso follow-up measurement [km] 09 / km-Stand bei
// Fehlerschwellenunter-/-überschreitung der R_iso Nachlaufmessung [km] 09
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "RB_ISO_MESS_TRG_IO_NIO", "STAT_TRG_KM_ISO_09_WERT", STAT_TRG_KM_ISO_09_WERT, "\"km\"");
unsigned short STAT_TRG_R_ISO_09_WERT = (RXBUF_UINT(60));
// R_iso_Wert if the R_iso lag measurement falls below / exceeds the error threshold [kOhm] 09 / R_iso_Wert bei
// Fehlerschwellenunter-/-überschreitung der R_iso Nachlaufmessung [kOhm] 09
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "RB_ISO_MESS_TRG_IO_NIO", "STAT_TRG_R_ISO_09_WERT", STAT_TRG_R_ISO_09_WERT, "\"kOhm\"");
unsigned char STAT_TRG_R_ISO_QAL_09_WERT = (RXBUF_UCHAR(62));
// R_iso_Qual if the R_iso lag measurement falls below / exceeds the error threshold [-] 09 / R_iso_Qual bei
// Fehlerschwellenunter-/-überschreitung der R_iso Nachlaufmessung [-] 09
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_ISO_MESS_TRG_IO_NIO", "STAT_TRG_R_ISO_QAL_09_WERT", STAT_TRG_R_ISO_QAL_09_WERT, "");
unsigned long STAT_TRG_KM_ISO_10_WERT = (RXBUF_UINT32(63));
// Mileage in case of failure threshold of the R_iso follow-up measurement [km] 10 / km-Stand bei
// Fehlerschwellenunter-/-überschreitung der R_iso Nachlaufmessung [km] 10
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "RB_ISO_MESS_TRG_IO_NIO", "STAT_TRG_KM_ISO_10_WERT", STAT_TRG_KM_ISO_10_WERT, "\"km\"");
unsigned short STAT_TRG_R_ISO_10_WERT = (RXBUF_UINT(67));
// R_iso_Value if the R_iso lag measurement falls below / exceeds the error threshold [kOhm] 10 / R_iso_Wert bei
// Fehlerschwellenunter-/-überschreitung der R_iso Nachlaufmessung [kOhm] 10
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "RB_ISO_MESS_TRG_IO_NIO", "STAT_TRG_R_ISO_10_WERT", STAT_TRG_R_ISO_10_WERT, "\"kOhm\"");
unsigned char STAT_TRG_R_ISO_QAL_10_WERT = (RXBUF_UCHAR(69));
// R_iso_Qual if the R_iso lag measurement falls below / exceeds the error threshold [-] 10 / R_iso_Qual bei
// Fehlerschwellenunter-/-überschreitung der R_iso Nachlaufmessung [-] 10
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_ISO_MESS_TRG_IO_NIO", "STAT_TRG_R_ISO_QAL_10_WERT", STAT_TRG_R_ISO_QAL_10_WERT, "");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_ISODIAG_INPUT_ISTWERTE: { // 0xD6CA
if (datalen < 15) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_ISODIAG_INPUT_ISTWERTE", 15);
break;
}
float STAT_INPUT_ISO_01_WERT = (RXBUF_UINT(0)/100.0f);
// LI: Ubat01 [V] / LI: Ubat01 [V]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ISODIAG_INPUT_ISTWERTE", "STAT_INPUT_ISO_01_WERT", STAT_INPUT_ISO_01_WERT, "\"V\"");
unsigned char STAT_INPUT_ISO_02_WERT = (RXBUF_UCHAR(2));
// LI: Ubat01_QUAL / LI: Ubat01_QUAL
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "ISODIAG_INPUT_ISTWERTE", "STAT_INPUT_ISO_02_WERT", STAT_INPUT_ISO_02_WERT, "");
float STAT_INPUT_ISO_03_WERT = (RXBUF_UINT(3)/100.0f);
// LI: Ubat02 [V] / LI: Ubat02 [V]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ISODIAG_INPUT_ISTWERTE", "STAT_INPUT_ISO_03_WERT", STAT_INPUT_ISO_03_WERT, "\"V\"");
unsigned char STAT_INPUT_ISO_04_WERT = (RXBUF_UCHAR(5));
// LI: Ubat02_QUAL / LI: Ubat02_QUAL
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "ISODIAG_INPUT_ISTWERTE", "STAT_INPUT_ISO_04_WERT", STAT_INPUT_ISO_04_WERT, "");
float STAT_INPUT_ISO_05_WERT = (RXBUF_UINT(6)/100.0f);
// LI: Uiso01 [V] / LI: Uiso01 [V]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ISODIAG_INPUT_ISTWERTE", "STAT_INPUT_ISO_05_WERT", STAT_INPUT_ISO_05_WERT, "\"V\"");
unsigned char STAT_INPUT_ISO_06_WERT = (RXBUF_UCHAR(8));
// LI: Uiso01_QUAL / LI: Uiso01_QUAL
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "ISODIAG_INPUT_ISTWERTE", "STAT_INPUT_ISO_06_WERT", STAT_INPUT_ISO_06_WERT, "");
float STAT_INPUT_ISO_07_WERT = (RXBUF_UINT(9)/100.0f);
// LI: Uiso02 [V] / LI: Uiso02 [V]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ISODIAG_INPUT_ISTWERTE", "STAT_INPUT_ISO_07_WERT", STAT_INPUT_ISO_07_WERT, "\"V\"");
unsigned char STAT_INPUT_ISO_08_WERT = (RXBUF_UCHAR(11));
// LI: Uiso02_QUAL / LI: Uiso02_QUAL
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "ISODIAG_INPUT_ISTWERTE", "STAT_INPUT_ISO_08_WERT", STAT_INPUT_ISO_08_WERT, "");
float STAT_INPUT_ISO_09_WERT = (RXBUF_UINT(12)/100.0f);
// LI: Uoffset [V] / LI: Uoffset [V]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ISODIAG_INPUT_ISTWERTE", "STAT_INPUT_ISO_09_WERT", STAT_INPUT_ISO_09_WERT, "\"V\"");
unsigned char STAT_INPUT_ISO_10_WERT = (RXBUF_UCHAR(14));
// LI: Uoffset_QUAL / LI: Uoffset_QUAL
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "ISODIAG_INPUT_ISTWERTE", "STAT_INPUT_ISO_10_WERT", STAT_INPUT_ISO_10_WERT, "");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_ISO_ERR_STD_FZ1_2: { // 0xD6CB
if (datalen < 52) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_ISO_ERR_STD_FZ1_2", 52);
break;
}
unsigned long STAT_FEHLERZAEHLER_STD_WERT = (RXBUF_UINT32(0));
// LI: Counter of all errors that have occurred in the standard measurement / LI: Zähler aller aufgetretenen
// Fehler der Standardmessung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ISO_ERR_STD_FZ1_2", "STAT_FEHLERZAEHLER_STD_WERT", STAT_FEHLERZAEHLER_STD_WERT, "");
float STAT_INPUT_ISO_STD_FZ1_01_WERT = (RXBUF_UINT(4)/100.0f);
// LI: first error time Ubat01 [V] / LI: erstmaliger Fehlerzeitpunkt Ubat01 [V]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ISO_ERR_STD_FZ1_2", "STAT_INPUT_ISO_STD_FZ1_01_WERT", STAT_INPUT_ISO_STD_FZ1_01_WERT, "\"V\"");
unsigned char STAT_INPUT_ISO_STD_FZ1_02_WERT = (RXBUF_UCHAR(6));
// LI: first error time Ubat01_QUAL / LI: erstmaliger Fehlerzeitpunkt Ubat01_QUAL
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "ISO_ERR_STD_FZ1_2", "STAT_INPUT_ISO_STD_FZ1_02_WERT", STAT_INPUT_ISO_STD_FZ1_02_WERT, "");
float STAT_INPUT_ISO_STD_FZ1_03_WERT = (RXBUF_UINT(7)/100.0f);
// LI: first error time Ubat02 [V] / LI: erstmaliger Fehlerzeitpunkt Ubat02 [V]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ISO_ERR_STD_FZ1_2", "STAT_INPUT_ISO_STD_FZ1_03_WERT", STAT_INPUT_ISO_STD_FZ1_03_WERT, "\"V\"");
unsigned char STAT_INPUT_ISO_STD_FZ1_04_WERT = (RXBUF_UCHAR(9));
// LI: first error time Ubat02_QUAL / LI: erstmaliger Fehlerzeitpunkt Ubat02_QUAL
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "ISO_ERR_STD_FZ1_2", "STAT_INPUT_ISO_STD_FZ1_04_WERT", STAT_INPUT_ISO_STD_FZ1_04_WERT, "");
float STAT_INPUT_ISO_STD_FZ1_05_WERT = (RXBUF_UINT(10)/100.0f);
// LI: first error time Uiso01 [V] / LI: erstmaliger Fehlerzeitpunkt Uiso01 [V]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ISO_ERR_STD_FZ1_2", "STAT_INPUT_ISO_STD_FZ1_05_WERT", STAT_INPUT_ISO_STD_FZ1_05_WERT, "\"V\"");
unsigned char STAT_INPUT_ISO_STD_FZ1_06_WERT = (RXBUF_UCHAR(12));
// LI: first time error Uiso01_QUAL / LI: erstmaliger Fehlerzeitpunkt Uiso01_QUAL
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "ISO_ERR_STD_FZ1_2", "STAT_INPUT_ISO_STD_FZ1_06_WERT", STAT_INPUT_ISO_STD_FZ1_06_WERT, "");
float STAT_INPUT_ISO_STD_FZ1_07_WERT = (RXBUF_UINT(13)/100.0f);
// LI: first failure time Uiso02 [V] / LI: erstmaliger Fehlerzeitpunkt Uiso02 [V]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ISO_ERR_STD_FZ1_2", "STAT_INPUT_ISO_STD_FZ1_07_WERT", STAT_INPUT_ISO_STD_FZ1_07_WERT, "\"V\"");
unsigned char STAT_INPUT_ISO_STD_FZ1_08_WERT = (RXBUF_UCHAR(15));
// LI: first time error Uiso02_QUAL / LI: erstmaliger Fehlerzeitpunkt Uiso02_QUAL
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "ISO_ERR_STD_FZ1_2", "STAT_INPUT_ISO_STD_FZ1_08_WERT", STAT_INPUT_ISO_STD_FZ1_08_WERT, "");
float STAT_INPUT_ISO_STD_FZ1_09_WERT = (RXBUF_UINT(16)/100.0f);
// LI: first error time Uoffset [V] / LI: erstmaliger Fehlerzeitpunkt Uoffset [V]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ISO_ERR_STD_FZ1_2", "STAT_INPUT_ISO_STD_FZ1_09_WERT", STAT_INPUT_ISO_STD_FZ1_09_WERT, "\"V\"");
unsigned char STAT_INPUT_ISO_STD_FZ1_10_WERT = (RXBUF_UCHAR(18));
// LI: first time error Uoffset_QUAL / LI: erstmaliger Fehlerzeitpunkt Uoffset_QUAL
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "ISO_ERR_STD_FZ1_2", "STAT_INPUT_ISO_STD_FZ1_10_WERT", STAT_INPUT_ISO_STD_FZ1_10_WERT, "");
unsigned short STAT_INPUT_ISO_STD_FZ1_11_WERT = (RXBUF_UINT(19));
// LI: first error time R_iso_ges [kOhm] / LI: erstmaliger Fehlerzeitpunkt R_iso_ges [kOhm]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "ISO_ERR_STD_FZ1_2", "STAT_INPUT_ISO_STD_FZ1_11_WERT", STAT_INPUT_ISO_STD_FZ1_11_WERT, "\"kOhm\"");
unsigned char STAT_INPUT_ISO_STD_FZ1_12_WERT = (RXBUF_UCHAR(21));
// LI: first error time R_iso_gesQUAL / LI: erstmaliger Fehlerzeitpunkt R_iso_gesQUAL
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "ISO_ERR_STD_FZ1_2", "STAT_INPUT_ISO_STD_FZ1_12_WERT", STAT_INPUT_ISO_STD_FZ1_12_WERT, "");
unsigned short STAT_INPUT_ISO_STD_FZ1_13_WERT = (RXBUF_UINT(22));
// LI: first error time R_iso_plus [kOhm] / LI: erstmaliger Fehlerzeitpunkt R_iso_plus [kOhm]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "ISO_ERR_STD_FZ1_2", "STAT_INPUT_ISO_STD_FZ1_13_WERT", STAT_INPUT_ISO_STD_FZ1_13_WERT, "\"kOhm\"");
float STAT_INPUT_ISO_STD_FZ1_14_WERT = (RXBUF_UCHAR(24)/100.0f);
// LI: first error time R_iso_plus_QUAL / LI: erstmaliger Fehlerzeitpunkt R_iso_plus_QUAL
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ISO_ERR_STD_FZ1_2", "STAT_INPUT_ISO_STD_FZ1_14_WERT", STAT_INPUT_ISO_STD_FZ1_14_WERT, "");
unsigned short STAT_INPUT_ISO_STD_FZ1_15_WERT = (RXBUF_UINT(25));
// LI: first error time R_iso_minus [kOhm] / LI: erstmaliger Fehlerzeitpunkt R_iso_minus [kOhm]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "ISO_ERR_STD_FZ1_2", "STAT_INPUT_ISO_STD_FZ1_15_WERT", STAT_INPUT_ISO_STD_FZ1_15_WERT, "\"kOhm\"");
float STAT_INPUT_ISO_STD_FZ1_16_WERT = (RXBUF_UCHAR(27)/100.0f);
// LI: first error time R_iso_minus_QUAL / LI: erstmaliger Fehlerzeitpunkt R_iso_minus_QUAL
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ISO_ERR_STD_FZ1_2", "STAT_INPUT_ISO_STD_FZ1_16_WERT", STAT_INPUT_ISO_STD_FZ1_16_WERT, "");
float STAT_INPUT_ISO_STD_FZ2_01_WERT = (RXBUF_UINT(28)/100.0f);
// LI: last error time Ubat01 [V] / LI: letztmaliger Fehlerzeitpunkt Ubat01 [V]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ISO_ERR_STD_FZ1_2", "STAT_INPUT_ISO_STD_FZ2_01_WERT", STAT_INPUT_ISO_STD_FZ2_01_WERT, "\"V\"");
unsigned char STAT_INPUT_ISO_STD_FZ2_02_WERT = (RXBUF_UCHAR(30));
// LI: last time the error occurred Ubat01_QUAL / LI: letztmaliger Fehlerzeitpunkt Ubat01_QUAL
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "ISO_ERR_STD_FZ1_2", "STAT_INPUT_ISO_STD_FZ2_02_WERT", STAT_INPUT_ISO_STD_FZ2_02_WERT, "");
float STAT_INPUT_ISO_STD_FZ2_03_WERT = (RXBUF_UINT(31)/100.0f);
// LI: last error time Ubat02 [V] / LI: letztmaliger Fehlerzeitpunkt Ubat02 [V]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ISO_ERR_STD_FZ1_2", "STAT_INPUT_ISO_STD_FZ2_03_WERT", STAT_INPUT_ISO_STD_FZ2_03_WERT, "\"V\"");
unsigned char STAT_INPUT_ISO_STD_FZ2_04_WERT = (RXBUF_UCHAR(33));
// LI: last time the error occurred Ubat02_QUAL / LI: letztmaliger Fehlerzeitpunkt Ubat02_QUAL
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "ISO_ERR_STD_FZ1_2", "STAT_INPUT_ISO_STD_FZ2_04_WERT", STAT_INPUT_ISO_STD_FZ2_04_WERT, "");
float STAT_INPUT_ISO_STD_FZ2_05_WERT = (RXBUF_UINT(34)/100.0f);
// LI: last time the error occurred Uiso01 [V] / LI: letztmaliger Fehlerzeitpunkt Uiso01 [V]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ISO_ERR_STD_FZ1_2", "STAT_INPUT_ISO_STD_FZ2_05_WERT", STAT_INPUT_ISO_STD_FZ2_05_WERT, "\"V\"");
unsigned char STAT_INPUT_ISO_STD_FZ2_06_WERT = (RXBUF_UCHAR(36));
// LI: last time the error occurred Uiso01_QUAL / LI: letztmaliger Fehlerzeitpunkt Uiso01_QUAL
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "ISO_ERR_STD_FZ1_2", "STAT_INPUT_ISO_STD_FZ2_06_WERT", STAT_INPUT_ISO_STD_FZ2_06_WERT, "");
float STAT_INPUT_ISO_STD_FZ2_07_WERT = (RXBUF_UINT(37)/100.0f);
// LI: last error time Uiso02 [V] / LI: letztmaliger Fehlerzeitpunkt Uiso02 [V]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ISO_ERR_STD_FZ1_2", "STAT_INPUT_ISO_STD_FZ2_07_WERT", STAT_INPUT_ISO_STD_FZ2_07_WERT, "\"V\"");
unsigned char STAT_INPUT_ISO_STD_FZ2_08_WERT = (RXBUF_UCHAR(39));
// LI: last time the error occurred Uiso02_QUAL / LI: letztmaliger Fehlerzeitpunkt Uiso02_QUAL
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "ISO_ERR_STD_FZ1_2", "STAT_INPUT_ISO_STD_FZ2_08_WERT", STAT_INPUT_ISO_STD_FZ2_08_WERT, "");
float STAT_INPUT_ISO_STD_FZ2_09_WERT = (RXBUF_UINT(40)/100.0f);
// LI: last error time Uoffset [V] / LI: letztmaliger Fehlerzeitpunkt Uoffset [V]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ISO_ERR_STD_FZ1_2", "STAT_INPUT_ISO_STD_FZ2_09_WERT", STAT_INPUT_ISO_STD_FZ2_09_WERT, "\"V\"");
unsigned char STAT_INPUT_ISO_STD_FZ2_10_WERT = (RXBUF_UCHAR(42));
// LI: last time the error occurred Uoffset_QUAL / LI: letztmaliger Fehlerzeitpunkt Uoffset_QUAL
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "ISO_ERR_STD_FZ1_2", "STAT_INPUT_ISO_STD_FZ2_10_WERT", STAT_INPUT_ISO_STD_FZ2_10_WERT, "");
unsigned short STAT_INPUT_ISO_STD_FZ2_11_WERT = (RXBUF_UINT(43));
// LI: last time the error occurred R_iso_ges [kOhm] / LI: letztmaliger Fehlerzeitpunkt R_iso_ges [kOhm]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "ISO_ERR_STD_FZ1_2", "STAT_INPUT_ISO_STD_FZ2_11_WERT", STAT_INPUT_ISO_STD_FZ2_11_WERT, "\"kOhm\"");
unsigned char STAT_INPUT_ISO_STD_FZ2_12_WERT = (RXBUF_UCHAR(45));
// LI: last time the error occurred R_iso_gesQUAL / LI: letztmaliger Fehlerzeitpunkt R_iso_gesQUAL
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "ISO_ERR_STD_FZ1_2", "STAT_INPUT_ISO_STD_FZ2_12_WERT", STAT_INPUT_ISO_STD_FZ2_12_WERT, "");
unsigned short STAT_INPUT_ISO_STD_FZ2_13_WERT = (RXBUF_UINT(46));
// LI: last time the error occurred R_iso_plus [kOhm] / LI: letztmaliger Fehlerzeitpunkt R_iso_plus [kOhm]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "ISO_ERR_STD_FZ1_2", "STAT_INPUT_ISO_STD_FZ2_13_WERT", STAT_INPUT_ISO_STD_FZ2_13_WERT, "\"kOhm\"");
float STAT_INPUT_ISO_STD_FZ2_14_WERT = (RXBUF_UCHAR(48)/100.0f);
// LI: last time the error occurred R_iso_plus_QUAL / LI: letztmaliger Fehlerzeitpunkt R_iso_plus_QUAL
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ISO_ERR_STD_FZ1_2", "STAT_INPUT_ISO_STD_FZ2_14_WERT", STAT_INPUT_ISO_STD_FZ2_14_WERT, "");
unsigned short STAT_INPUT_ISO_STD_FZ2_15_WERT = (RXBUF_UINT(49));
// LI: last time the error occurred R_iso_minus [kOhm] / LI: letztmaliger Fehlerzeitpunkt R_iso_minus [kOhm]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "ISO_ERR_STD_FZ1_2", "STAT_INPUT_ISO_STD_FZ2_15_WERT", STAT_INPUT_ISO_STD_FZ2_15_WERT, "\"kOhm\"");
float STAT_INPUT_ISO_STD_FZ2_16_WERT = (RXBUF_UCHAR(51)/100.0f);
// LI: last time the error occurred R_iso_minus_QUAL / LI: letztmaliger Fehlerzeitpunkt R_iso_minus_QUAL
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ISO_ERR_STD_FZ1_2", "STAT_INPUT_ISO_STD_FZ2_16_WERT", STAT_INPUT_ISO_STD_FZ2_16_WERT, "");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_RB_SOH_KAPATEST: { // 0xD6CC
if (datalen < 51) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_RB_SOH_KAPATEST", 51);
break;
}
float STAT_SOH_C_MIN_ERG_TEST_1_WERT = (RXBUF_UINT(0)/100.0f);
// Minimum SoH_C (on the memory level) as the result of the first capacity test / Minimaler SoH_C (auf
// Speicherebene) als Ergebnis des ersten Kapazitätstests
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOH_KAPATEST", "STAT_SOH_C_MIN_ERG_TEST_1_WERT", STAT_SOH_C_MIN_ERG_TEST_1_WERT, "\"%\"");
float STAT_SOH_C_MIN_VOR_TEST_1_WERT = (RXBUF_UINT(2)/100.0f);
// Minimum SoH_C BEFORE the first capacity test / Minimaler SoH_C VOR erstem Kapazitätstest
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOH_KAPATEST", "STAT_SOH_C_MIN_VOR_TEST_1_WERT", STAT_SOH_C_MIN_VOR_TEST_1_WERT, "\"%\"");
float STAT_SOH_C_MAX_VOR_TEST_1_WERT = (RXBUF_UINT(4)/100.0f);
// Maximum SoH_C BEFORE the first capacity test / Maximaler SoH_C VOR erstem Kapazitätstest
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOH_KAPATEST", "STAT_SOH_C_MAX_VOR_TEST_1_WERT", STAT_SOH_C_MAX_VOR_TEST_1_WERT, "\"%\"");
float STAT_SOH_C_AVG_VOR_TEST_1_WERT = (RXBUF_UINT(6)/100.0f);
// Mean SoH_C BEFORE the first capacity test / Mittlerer SoH_C VOR erstem Kapazitätstest
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOH_KAPATEST", "STAT_SOH_C_AVG_VOR_TEST_1_WERT", STAT_SOH_C_AVG_VOR_TEST_1_WERT, "\"%\"");
char STAT_TEMP_VOR_TEST_1_WERT = (RXBUF_SCHAR(8));
// Average measured temperature at HVS level BEFORE the first capacity test / Mittlere gemessene Temperatur auf
// HVS-Ebene VOR erstem Kapazitätstest
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_SOH_KAPATEST", "STAT_TEMP_VOR_TEST_1_WERT", STAT_TEMP_VOR_TEST_1_WERT, "\"°C\"");
float STAT_MAX_DELTA_U_CELL_1_WERT = (RXBUF_UINT(9)/1000.0f);
// Maximum voltage delta of the cells BEFORE the first capacity test From I levels I15 / SP15: 18-03-i420; I01 /
// SE09: 17-11-i400; F56 / SE14: 19-11-i310 the following applies: Asymmetry potential as the voltage difference
// between the cell that was most deeply discharged during the first capacity test and Ucel_max at full charge /
// Maximales Spannungsdelta der Zellen VOR erstem Kapazitätstest Ab den I-Stufen I15/SP15: 18-03-i420; I01/SE09:
// 17-11-i400; F56/SE14: 19-11-i310 gilt: Asymmetrie-Potential als Spannungsdifferenz der während des ersten
// Kapazitätstests am tiefsten entladenen Zelle zu Ucel_max im Volllademoment
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOH_KAPATEST", "STAT_MAX_DELTA_U_CELL_1_WERT", STAT_MAX_DELTA_U_CELL_1_WERT, "\"V\"");
float STAT_MAX_DELTA_SOC_NENN_1_WERT = (RXBUF_UINT(11)/100.0f);
// Maximum SoC delta of the cells BEFORE the first capacity test From I levels I15 / SP15: 18-03-i420; I01 /
// SE09: 17-11-i400; F56 / SE14: 19-11-i310 applies: Asymmetry potential as SoC_Nenn-Percent value, which was
// determined during the first capacity test. / Maximales SoC-Delta der Zellen VOR erstem Kapazitätstest Ab den
// I-Stufen I15/SP15: 18-03-i420; I01/SE09: 17-11-i400; F56/SE14: 19-11-i310 gilt: Asymmetrie-Potential als
// SoC_Nenn-Prozent-Wert, der während des ersten Kapazitätstests ermittelt wurde.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOH_KAPATEST", "STAT_MAX_DELTA_SOC_NENN_1_WERT", STAT_MAX_DELTA_SOC_NENN_1_WERT, "\"%\"");
unsigned long STAT_ZEITPUNKT_TEST_1_WERT = (RXBUF_UINT32(13));
// Point in time (SME time) at the end of the first capacity test / Zeitpunkt (SME-Zeit) am Ende des ersten
// Kapazitätstests
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "RB_SOH_KAPATEST", "STAT_ZEITPUNKT_TEST_1_WERT", STAT_ZEITPUNKT_TEST_1_WERT, "\"s\"");
float STAT_SOH_C_MIN_ERG_TEST_2_WERT = (RXBUF_UINT(17)/100.0f);
// Minimum SoH_C (on the memory level) as the result of the second capacity test / Minimaler SoH_C (auf
// Speicherebene) als Ergebnis des zweiten Kapazitätstests
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOH_KAPATEST", "STAT_SOH_C_MIN_ERG_TEST_2_WERT", STAT_SOH_C_MIN_ERG_TEST_2_WERT, "\"%\"");
float STAT_SOH_C_MIN_VOR_TEST_2_WERT = (RXBUF_UINT(19)/100.0f);
// Minimum SoH_C BEFORE the second capacity test / Minimaler SoH_C VOR zweitem Kapazitätstest
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOH_KAPATEST", "STAT_SOH_C_MIN_VOR_TEST_2_WERT", STAT_SOH_C_MIN_VOR_TEST_2_WERT, "\"%\"");
float STAT_SOH_C_MAX_VOR_TEST_2_WERT = (RXBUF_UINT(21)/100.0f);
// Maximum SoH_C BEFORE the second capacity test / Maximaler SoH_C VOR zweitem Kapazitätstest
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOH_KAPATEST", "STAT_SOH_C_MAX_VOR_TEST_2_WERT", STAT_SOH_C_MAX_VOR_TEST_2_WERT, "\"%\"");
float STAT_SOH_C_AVG_VOR_TEST_2_WERT = (RXBUF_UINT(23)/100.0f);
// Mean SoH_C BEFORE second capacity test / Mittlerer SoH_C VOR zweitem Kapazitätstest
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOH_KAPATEST", "STAT_SOH_C_AVG_VOR_TEST_2_WERT", STAT_SOH_C_AVG_VOR_TEST_2_WERT, "\"%\"");
char STAT_TEMP_VOR_TEST_2_WERT = (RXBUF_SCHAR(25));
// Average measured temperature at HVS level BEFORE the second capacity test / Mittlere gemessene Temperatur auf
// HVS-Ebene VOR zweitem Kapazitätstest
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_SOH_KAPATEST", "STAT_TEMP_VOR_TEST_2_WERT", STAT_TEMP_VOR_TEST_2_WERT, "\"°C\"");
float STAT_MAX_DELTA_U_CELL_2_WERT = (RXBUF_UINT(26)/1000.0f);
// Maximum voltage delta of the cells BEFORE the second capacity test From I levels I15 / SP15: 18-03-i420; I01 /
// SE09: 17-11-i400; F56 / SE14: 19-11-i310 the following applies: Asymmetry potential as the voltage difference
// between the deepest cell discharged during the second capacity test and Ucel_max when fully charged /
// Maximales Spannungsdelta der Zellen VOR zweitem Kapazitätstest Ab den I-Stufen I15/SP15: 18-03-i420;
// I01/SE09: 17-11-i400; F56/SE14: 19-11-i310 gilt: Asymmetrie-Potential als Spannungsdifferenz der während des
// zweiten Kapazitätstests am tiefsten entladenen Zelle zu Ucel_max im Volllademoment
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOH_KAPATEST", "STAT_MAX_DELTA_U_CELL_2_WERT", STAT_MAX_DELTA_U_CELL_2_WERT, "\"V\"");
float STAT_MAX_DELTA_SOC_NENN_2_WERT = (RXBUF_UINT(28)/100.0f);
// Maximum SoC delta of the cells BEFORE the second capacity test From I levels I15 / SP15: 18-03-i420; I01 /
// SE09: 17-11-i400; F56 / SE14: 19-11-i310 applies: Asymmetry potential as SoC_Nenn-Percent value, which was
// determined during the second capacity test. / Maximales SoC-Delta der Zellen VOR zweitem Kapazitätstest Ab den
// I-Stufen I15/SP15: 18-03-i420; I01/SE09: 17-11-i400; F56/SE14: 19-11-i310 gilt: Asymmetrie-Potential als
// SoC_Nenn-Prozent-Wert, der während des zweiten Kapazitätstests ermittelt wurde.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOH_KAPATEST", "STAT_MAX_DELTA_SOC_NENN_2_WERT", STAT_MAX_DELTA_SOC_NENN_2_WERT, "\"%\"");
unsigned long STAT_ZEITPUNKT_TEST_2_WERT = (RXBUF_UINT32(30));
// Point in time (SME time) at the end of the second capacity test / Zeitpunkt (SME-Zeit) am Ende des zweiten
// Kapazitätstests
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "RB_SOH_KAPATEST", "STAT_ZEITPUNKT_TEST_2_WERT", STAT_ZEITPUNKT_TEST_2_WERT, "\"s\"");
float STAT_SOH_C_MIN_ERG_TEST_3_WERT = (RXBUF_UINT(34)/100.0f);
// Minimum SoH_C (on the memory level) as the result of the third capacity test / Minimaler SoH_C (auf
// Speicherebene) als Ergebnis des dritten Kapazitätstests
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOH_KAPATEST", "STAT_SOH_C_MIN_ERG_TEST_3_WERT", STAT_SOH_C_MIN_ERG_TEST_3_WERT, "\"%\"");
float STAT_SOH_C_MIN_VOR_TEST_3_WERT = (RXBUF_UINT(36)/100.0f);
// Minimum SoH_C BEFORE the third capacity test / Minimaler SoH_C VOR drittem Kapazitätstest
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOH_KAPATEST", "STAT_SOH_C_MIN_VOR_TEST_3_WERT", STAT_SOH_C_MIN_VOR_TEST_3_WERT, "\"%\"");
float STAT_SOH_C_MAX_VOR_TEST_3_WERT = (RXBUF_UINT(38)/100.0f);
// Maximum SoH_C BEFORE the third capacity test / Maximaler SoH_C VOR drittem Kapazitätstest
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOH_KAPATEST", "STAT_SOH_C_MAX_VOR_TEST_3_WERT", STAT_SOH_C_MAX_VOR_TEST_3_WERT, "\"%\"");
float STAT_SOH_C_AVG_VOR_TEST_3_WERT = (RXBUF_UINT(40)/100.0f);
// Middle SoH_C BEFORE the third capacity test / Mittlerer SoH_C VOR drittem Kapazitätstest
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOH_KAPATEST", "STAT_SOH_C_AVG_VOR_TEST_3_WERT", STAT_SOH_C_AVG_VOR_TEST_3_WERT, "\"%\"");
char STAT_TEMP_VOR_TEST_3_WERT = (RXBUF_SCHAR(42));
// Average measured temperature at HVS level BEFORE the third capacity test / Mittlere gemessene Temperatur auf
// HVS-Ebene VOR drittem Kapazitätstest
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_SOH_KAPATEST", "STAT_TEMP_VOR_TEST_3_WERT", STAT_TEMP_VOR_TEST_3_WERT, "\"°C\"");
float STAT_MAX_DELTA_U_CELL_3_WERT = (RXBUF_UINT(43)/1000.0f);
// Maximum voltage delta of the cells BEFORE the third capacity test From I levels I15 / SP15: 18-03-i420; I01 /
// SE09: 17-11-i400; F56 / SE14: 19-11-i310 the following applies: Asymmetry potential as the voltage difference
// between the deepest cell discharged during the third capacity test and Ucel_max at full charge / Maximales
// Spannungsdelta der Zellen VOR drittem Kapazitätstest Ab den I-Stufen I15/SP15: 18-03-i420; I01/SE09:
// 17-11-i400; F56/SE14: 19-11-i310 gilt: Asymmetrie-Potential als Spannungsdifferenz der während des dritten
// Kapazitätstests am tiefsten entladenen Zelle zu Ucel_max im Volllademoment
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOH_KAPATEST", "STAT_MAX_DELTA_U_CELL_3_WERT", STAT_MAX_DELTA_U_CELL_3_WERT, "\"V\"");
float STAT_MAX_DELTA_SOC_NENN_3_WERT = (RXBUF_UINT(45)/100.0f);
// Maximum SoC delta of the cells BEFORE the third capacity test From I levels I15 / SP15: 18-03-i420; I01 /
// SE09: 17-11-i400; F56 / SE14: 19-11-i310 applies: Asymmetry potential as SoC_Nenn-Percent value, which was
// determined during the third capacity test. / Maximales SoC-Delta der Zellen VOR drittem Kapazitätstest Ab den
// I-Stufen I15/SP15: 18-03-i420; I01/SE09: 17-11-i400; F56/SE14: 19-11-i310 gilt: Asymmetrie-Potential als
// SoC_Nenn-Prozent-Wert, der während des dritten Kapazitätstests ermittelt wurde.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOH_KAPATEST", "STAT_MAX_DELTA_SOC_NENN_3_WERT", STAT_MAX_DELTA_SOC_NENN_3_WERT, "\"%\"");
unsigned long STAT_ZEITPUNKT_TEST_3_WERT = (RXBUF_UINT32(47));
// Point in time (SME time) at the end of the third capacity test / Zeitpunkt (SME-Zeit) am Ende des dritten
// Kapazitätstests
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "RB_SOH_KAPATEST", "STAT_ZEITPUNKT_TEST_3_WERT", STAT_ZEITPUNKT_TEST_3_WERT, "\"s\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_REKU_VOLTAGE_LIFT: { // 0xD6CD
if (datalen < 6) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_REKU_VOLTAGE_LIFT", 6);
break;
}
unsigned short STAT_ANZAHL_REKU_VOLT_LIFT_WERT = (RXBUF_UINT(0));
// Return of the number in which the increased recuperation capacity is made available when the HVS is almost
// full / Rückgabe der Anzahl, in der erhöhte Rekuperationsleistung zur Verfügung gestellt wird bei fast vollem
// HVS
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "REKU_VOLTAGE_LIFT", "STAT_ANZAHL_REKU_VOLT_LIFT_WERT", STAT_ANZAHL_REKU_VOLT_LIFT_WERT, "");
float STAT_DAUER_REKU_VOLT_LIFT_WERT = (RXBUF_UINT32(2)/10.0f);
// Return of the duration in which the increased recuperation capacity is available when the HVS is almost full /
// Rückgabe der Dauer, in der erhöhte Rekuperationsleistung zur Verfügung gestellt wird bei fast vollem HVS
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "REKU_VOLTAGE_LIFT", "STAT_DAUER_REKU_VOLT_LIFT_WERT", STAT_DAUER_REKU_VOLT_LIFT_WERT, "\"s\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_RB_ALTERUNG_KAPA: { // 0xD6CE
if (datalen < 241) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_RB_ALTERUNG_KAPA", 241);
break;
}
unsigned short STAT_SOH_ADAPT_COUNT_1_WERT = (RXBUF_UINT(0));
// Adaptation counter of 1st adaptation / Adaptionszähler von 1. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_SOH_ADAPT_COUNT_1_WERT", STAT_SOH_ADAPT_COUNT_1_WERT, "");
unsigned char STAT_GRUND_ADAPTION_1_WERT = (RXBUF_UCHAR(2));
// Reason for triggering the ring buffer entry (0 = SoH_C estimate; 1 = KapaTest with transfer of the result to
// NV; 2 = KapaTest without transfer of the result to NV) / Auslösegrund des Ringspeicher-Eintrags (0 =
// SoH_C-Schätzung; 1 = KapaTest mit Übernahme vom Ergebnis in NV; 2 = KapaTest ohne Übernahme vom Ergebnis in
// NV)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_GRUND_ADAPTION_1_WERT", STAT_GRUND_ADAPTION_1_WERT, "");
unsigned long STAT_ZEITPUNKT_ADAP_1_WERT = (RXBUF_UINT32(3));
// Time (SME time) of the 1st adaptation / Zeitpunkt (SME-Zeit) der 1. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_ZEITPUNKT_ADAP_1_WERT", STAT_ZEITPUNKT_ADAP_1_WERT, "\"s\"");
float STAT_AH_CUM_ABS_1_WERT = (RXBUF_UINT32(7)/3600.0f);
// Absolute Ah throughput of the 1st adaptation (if adaptation reason = KapaTest: test result in Ah) / Absoluter
// Ah-Durchsatz der 1. Adaption (Wenn Adaptionsgrund = KapaTest: Testergebnis in Ah)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_AH_CUM_ABS_1_WERT", STAT_AH_CUM_ABS_1_WERT, "\"Ah\"");
float STAT_AH_INTEGRAL_1_WERT = (RXBUF_UINT32(11)/3600.0f);
// Ah stroke of the 1st adaptation (if adaptation reason = KapaTest: test result in Ah) / Ah-Hub der 1. Adaption
// (Wenn Adaptionsgrund = KapaTest: Testergebnis in Ah)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_AH_INTEGRAL_1_WERT", STAT_AH_INTEGRAL_1_WERT, "\"Ah\"");
unsigned short STAT_HVOFFTIME_ADAP_1_WERT = (RXBUF_UINT(15));
// Duration the shooter was open during the 1st adaptation / Dauer, die die Schütze während der 1. Adaption
// geöffnet war
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_HVOFFTIME_ADAP_1_WERT", STAT_HVOFFTIME_ADAP_1_WERT, "\"s\"");
char STAT_TEMP_MEAN1_1_WERT = (RXBUF_SCHAR(17));
// Average temperature at HVS level at the beginning of the 1st adaptation or at the beginning of the test /
// Mittlere Temperatur auf HVS-Ebene zu Beginn der 1. Adaption bzw. zu Beginn des Tests
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_TEMP_MEAN1_1_WERT", STAT_TEMP_MEAN1_1_WERT, "\"°C\"");
char STAT_TEMP_MEAN2_1_WERT = (RXBUF_SCHAR(18));
// Average temperature at HVS level at the end of the 1st adaptation / Mittlere Temperatur auf HVS-Ebene am Ende
// der 1. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_TEMP_MEAN2_1_WERT", STAT_TEMP_MEAN2_1_WERT, "\"°C\"");
float STAT_UCEL_MIN_INIT1_1_WERT = (RXBUF_UINT(19)/1000.0f);
// Minimum measured resting voltage of the cells at the beginning of the 1st adaptation (if the reason for
// adaptation = KapaTest: minimum measured resting voltage when waking up) / Minimale gemessene Ruhespannung der
// Zellen zu Beginn der 1. Adaption (Wenn Adaptionsgrund = KapaTest: Minimale gemessene Ruhespannung beim
// Aufwachen)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_UCEL_MIN_INIT1_1_WERT", STAT_UCEL_MIN_INIT1_1_WERT, "\"V\"");
float STAT_UCEL_MAX_INIT1_1_WERT = (RXBUF_UINT(21)/1000.0f);
// Maximum measured resting voltage of the cells at the beginning of the 1st adaptation (if adaptation reason =
// KapaTest: maximum measured resting voltage when waking up) / Maximale gemessene Ruhespannung der Zellen zu
// Beginn der 1. Adaption (Wenn Adaptionsgrund = KapaTest: Maximale gemessene Ruhespannung beim Aufwachen)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_UCEL_MAX_INIT1_1_WERT", STAT_UCEL_MAX_INIT1_1_WERT, "\"V\"");
float STAT_UCEL_MEAN_INIT1_1_WERT = (RXBUF_UINT(23)/1000.0f);
// Average measured open-circuit voltage of the cells at the beginning of the 1st adaptation (if adaptation
// reason = KapaTest: average measured open-circuit voltage when waking up) / Mittlere gemessene Ruhespannung der
// Zellen zu Beginn der 1. Adaption (Wenn Adaptionsgrund = KapaTest: Mittlere gemessene Ruhespannung beim
// Aufwachen)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_UCEL_MEAN_INIT1_1_WERT", STAT_UCEL_MEAN_INIT1_1_WERT, "\"V\"");
float STAT_UCEL_MIN_INIT2_1_WERT = (RXBUF_UINT(25)/1000.0f);
// Minimum measured open-circuit voltage of the cells at the end of the 1st adaptation / Minimale gemessene
// Ruhespannung der Zellen am Ende der 1. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_UCEL_MIN_INIT2_1_WERT", STAT_UCEL_MIN_INIT2_1_WERT, "\"V\"");
float STAT_UCEL_MAX_INIT2_1_WERT = (RXBUF_UINT(27)/1000.0f);
// Maximum measured open-circuit voltage of the cells at the end of the 1st adaptation / Maximale gemessene
// Ruhespannung der Zellen am Ende der 1. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_UCEL_MAX_INIT2_1_WERT", STAT_UCEL_MAX_INIT2_1_WERT, "\"V\"");
float STAT_UCEL_MEAN_INIT2_1_WERT = (RXBUF_UINT(29)/1000.0f);
// Mean measured open-circuit voltage of the cells at the end of the 1st adaptation / Mittlere gemessene
// Ruhespannung der Zellen am Ende der 1. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_UCEL_MEAN_INIT2_1_WERT", STAT_UCEL_MEAN_INIT2_1_WERT, "\"V\"");
float STAT_SOH_ZELLE1_VOR_ADAPT_1_WERT = (RXBUF_UINT(31)/100.0f);
// SoH_C of cell 1 BEFORE 1st adaptation / SoH_C von Zelle 1 VOR 1. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_SOH_ZELLE1_VOR_ADAPT_1_WERT", STAT_SOH_ZELLE1_VOR_ADAPT_1_WERT, "\"%\"");
float STAT_SOH_ZELLE1_NACH_ADAPT_1_WERT = (RXBUF_UINT(33)/100.0f);
// SoH_C from cell 1 AFTER 1st adaptation / SoH_C von Zelle 1 NACH 1. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_SOH_ZELLE1_NACH_ADAPT_1_WERT", STAT_SOH_ZELLE1_NACH_ADAPT_1_WERT, "\"%\"");
float STAT_OVC1_ZELLE1_1_WERT = (RXBUF_UINT(35)/1000.0f);
// OCV value of cell 1 at the beginning of the 1st adaptation / OCV Wert von Zelle 1 zu Beginn der 1. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_OVC1_ZELLE1_1_WERT", STAT_OVC1_ZELLE1_1_WERT, "\"V\"");
float STAT_OVC2_ZELLE1_1_WERT = (RXBUF_UINT(37)/1000.0f);
// OCV value of cell 1 at the end of the 1st adaptation / OCV Wert von Zelle 1 am Ende der 1. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_OVC2_ZELLE1_1_WERT", STAT_OVC2_ZELLE1_1_WERT, "\"V\"");
float STAT_SOH_GAIN_FAKTOR_ZELLE1_1_WERT = (RXBUF_UINT(39)/10000.0f);
// Gain factor of cell 1 for the first adaptation / Gain Faktor von Zelle 1 für die erste Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_SOH_GAIN_FAKTOR_ZELLE1_1_WERT", STAT_SOH_GAIN_FAKTOR_ZELLE1_1_WERT, "");
float STAT_SOH_MIN_NACH_1_WERT = (RXBUF_UINT(41)/100.0f);
// Minimal SOH AFTER the 1st adaptation / Minimaler SOH NACH der 1. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_SOH_MIN_NACH_1_WERT", STAT_SOH_MIN_NACH_1_WERT, "\"%\"");
float STAT_SOH_MAX_NACH_1_WERT = (RXBUF_UINT(43)/100.0f);
// Maximum SOH AFTER the 1st adaptation / Maximaler SOH NACH der 1. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_SOH_MAX_NACH_1_WERT", STAT_SOH_MAX_NACH_1_WERT, "\"%\"");
float STAT_SOH_MEAN_NACH_1_WERT = (RXBUF_UINT(45)/100.0f);
// Middle SOH AFTER the 1st adaptation / Mittlerer SOH NACH der 1. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_SOH_MEAN_NACH_1_WERT", STAT_SOH_MEAN_NACH_1_WERT, "\"%\"");
unsigned short STAT_SOH_ADAPT_COUNT_2_WERT = (RXBUF_UINT(47));
// Adaptation counter of 2nd adaptation / Adaptionszähler von 2. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_SOH_ADAPT_COUNT_2_WERT", STAT_SOH_ADAPT_COUNT_2_WERT, "");
unsigned char STAT_GRUND_ADAPTION_2_WERT = (RXBUF_UCHAR(49));
// Reason for triggering the ring buffer entry (0 = SoH_C estimate; 1 = KapaTest with transfer of the result to
// NV; 2 = KapaTest without transfer of the result to NV) / Auslösegrund des Ringspeicher-Eintrags (0 =
// SoH_C-Schätzung; 1 = KapaTest mit Übernahme vom Ergebnis in NV; 2 = KapaTest ohne Übernahme vom Ergebnis in
// NV)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_GRUND_ADAPTION_2_WERT", STAT_GRUND_ADAPTION_2_WERT, "");
unsigned long STAT_ZEITPUNKT_ADAP_2_WERT = (RXBUF_UINT32(50));
// Time (SME time) of the 2nd adaptation / Zeitpunkt (SME-Zeit) der 2. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_ZEITPUNKT_ADAP_2_WERT", STAT_ZEITPUNKT_ADAP_2_WERT, "\"s\"");
float STAT_AH_CUM_ABS_2_WERT = (RXBUF_UINT32(54)/3600.0f);
// Absolute Ah throughput of the 2nd adaptation (if adaptation reason = KapaTest: test result in Ah) / Absoluter
// Ah-Durchsatz der 2. Adaption (Wenn Adaptionsgrund = KapaTest: Testergebnis in Ah)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_AH_CUM_ABS_2_WERT", STAT_AH_CUM_ABS_2_WERT, "\"Ah\"");
float STAT_AH_INTEGRAL_2_WERT = (RXBUF_UINT32(58)/3600.0f);
// Ah stroke of the 2nd adaptation (if adaptation reason = KapaTest: test result in Ah) / Ah-Hub der 2. Adaption
// (Wenn Adaptionsgrund = KapaTest: Testergebnis in Ah)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_AH_INTEGRAL_2_WERT", STAT_AH_INTEGRAL_2_WERT, "\"Ah\"");
unsigned short STAT_HVOFFTIME_ADAP_2_WERT = (RXBUF_UINT(62));
// Duration that the shooter was open during the 2nd adaptation / Dauer, die die Schütze während der 2. Adaption
// geöffnet war
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_HVOFFTIME_ADAP_2_WERT", STAT_HVOFFTIME_ADAP_2_WERT, "\"s\"");
char STAT_TEMP_MEAN1_2_WERT = (RXBUF_SCHAR(64));
// Average temperature at HVS level at the beginning of the 2nd adaptation or at the beginning of the test /
// Mittlere Temperatur auf HVS-Ebene zu Beginn der 2. Adaption bzw. zu Beginn des Tests
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_TEMP_MEAN1_2_WERT", STAT_TEMP_MEAN1_2_WERT, "\"°C\"");
char STAT_TEMP_MEAN2_2_WERT = (RXBUF_SCHAR(65));
// Average temperature at HVS level at the end of the 2nd adaptation / Mittlere Temperatur auf HVS-Ebene am Ende
// der 2. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_TEMP_MEAN2_2_WERT", STAT_TEMP_MEAN2_2_WERT, "\"°C\"");
float STAT_UCEL_MIN_INIT1_2_WERT = (RXBUF_UINT(66)/1000.0f);
// Minimum measured resting voltage of the cells at the beginning of the 2nd adaptation (if adaptation reason =
// KapaTest: minimum measured resting voltage when waking up) / Minimale gemessene Ruhespannung der Zellen zu
// Beginn der 2. Adaption (Wenn Adaptionsgrund = KapaTest: Minimale gemessene Ruhespannung beim Aufwachen)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_UCEL_MIN_INIT1_2_WERT", STAT_UCEL_MIN_INIT1_2_WERT, "\"V\"");
float STAT_UCEL_MAX_INIT1_2_WERT = (RXBUF_UINT(68)/1000.0f);
// Maximum measured resting voltage of the cells at the beginning of the 2nd adaptation (if adaptation reason =
// KapaTest: maximum measured resting voltage when waking up) / Maximale gemessene Ruhespannung der Zellen zu
// Beginn der 2. Adaption (Wenn Adaptionsgrund = KapaTest: Maximale gemessene Ruhespannung beim Aufwachen)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_UCEL_MAX_INIT1_2_WERT", STAT_UCEL_MAX_INIT1_2_WERT, "\"V\"");
float STAT_UCEL_MEAN_INIT1_2_WERT = (RXBUF_UINT(70)/1000.0f);
// Mean measured open-circuit voltage of the cells at the beginning of the 2nd adaptation (if reason for
// adaptation = KapaTest: mean measured open-circuit voltage when waking up) / Mittlere gemessene Ruhespannung
// der Zellen zu Beginn der 2. Adaption (Wenn Adaptionsgrund = KapaTest: Mittlere gemessene Ruhespannung beim
// Aufwachen)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_UCEL_MEAN_INIT1_2_WERT", STAT_UCEL_MEAN_INIT1_2_WERT, "\"V\"");
float STAT_UCEL_MIN_INIT2_2_WERT = (RXBUF_UINT(72)/1000.0f);
// Minimum measured open-circuit voltage of the cells at the end of the 2nd adaptation / Minimale gemessene
// Ruhespannung der Zellen am Ende der 2. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_UCEL_MIN_INIT2_2_WERT", STAT_UCEL_MIN_INIT2_2_WERT, "\"V\"");
float STAT_UCEL_MAX_INIT2_2_WERT = (RXBUF_UINT(74)/1000.0f);
// Maximum measured open-circuit voltage of the cells at the end of the 2nd adaptation / Maximale gemessene
// Ruhespannung der Zellen am Ende der 2. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_UCEL_MAX_INIT2_2_WERT", STAT_UCEL_MAX_INIT2_2_WERT, "\"V\"");
float STAT_UCEL_MEAN_INIT2_2_WERT = (RXBUF_UINT(76)/1000.0f);
// Mean measured open-circuit voltage of the cells at the end of the 2nd adaptation / Mittlere gemessene
// Ruhespannung der Zellen am Ende der 2. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_UCEL_MEAN_INIT2_2_WERT", STAT_UCEL_MEAN_INIT2_2_WERT, "\"V\"");
float STAT_SOH_ZELLE1_VOR_ADAPT_2_WERT = (RXBUF_UINT(78)/100.0f);
// SoH_C of cell 1 BEFORE 2nd adaptation / SoH_C von Zelle 1 VOR 2. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_SOH_ZELLE1_VOR_ADAPT_2_WERT", STAT_SOH_ZELLE1_VOR_ADAPT_2_WERT, "\"%\"");
float STAT_SOH_ZELLE1_NACH_ADAPT_2_WERT = (RXBUF_UINT(80)/100.0f);
// SoH_C from cell 1 AFTER 2nd adaptation / SoH_C von Zelle 1 NACH 2. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_SOH_ZELLE1_NACH_ADAPT_2_WERT", STAT_SOH_ZELLE1_NACH_ADAPT_2_WERT, "\"%\"");
float STAT_OVC1_ZELLE1_2_WERT = (RXBUF_UINT(82)/1000.0f);
// OCV value of cell 1 at the beginning of the 2nd adaptation / OCV Wert von Zelle 1 zu Beginn der 2. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_OVC1_ZELLE1_2_WERT", STAT_OVC1_ZELLE1_2_WERT, "\"V\"");
float STAT_OVC2_ZELLE1_2_WERT = (RXBUF_UINT(84)/1000.0f);
// OCV value of cell 1 at the end of the 2nd adaptation / OCV Wert von Zelle 1 am Ende der 2. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_OVC2_ZELLE1_2_WERT", STAT_OVC2_ZELLE1_2_WERT, "\"V\"");
float STAT_SOH_GAIN_FAKTOR_ZELLE1_2_WERT = (RXBUF_UINT(86)/10000.0f);
// Gain factor of cell 1 for the second adaptation / Gain Faktor von Zelle 1 für die zweite Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_SOH_GAIN_FAKTOR_ZELLE1_2_WERT", STAT_SOH_GAIN_FAKTOR_ZELLE1_2_WERT, "");
float STAT_SOH_MIN_NACH_2_WERT = (RXBUF_UINT(88)/100.0f);
// Minimal SOH AFTER the 2nd adaptation / Minimaler SOH NACH der 2. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_SOH_MIN_NACH_2_WERT", STAT_SOH_MIN_NACH_2_WERT, "\"%\"");
float STAT_SOH_MAX_NACH_2_WERT = (RXBUF_UINT(90)/100.0f);
// Maximum SOH AFTER the 2nd adaptation / Maximaler SOH NACH der 2. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_SOH_MAX_NACH_2_WERT", STAT_SOH_MAX_NACH_2_WERT, "\"%\"");
float STAT_SOH_MEAN_NACH_2_WERT = (RXBUF_UINT(92)/100.0f);
// Middle SOH AFTER the 2nd adaptation / Mittlerer SOH NACH der 2. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_SOH_MEAN_NACH_2_WERT", STAT_SOH_MEAN_NACH_2_WERT, "\"%\"");
unsigned short STAT_SOH_ADAPT_COUNT_3_WERT = (RXBUF_UINT(94));
// Adaptation counter of 3rd adaptation / Adaptionszähler von 3. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_SOH_ADAPT_COUNT_3_WERT", STAT_SOH_ADAPT_COUNT_3_WERT, "");
unsigned char STAT_GRUND_ADAPTION_3_WERT = (RXBUF_UCHAR(96));
// Reason for triggering the ring buffer entry (0 = SoH_C estimate; 1 = KapaTest with transfer of the result to
// NV; 2 = KapaTest without transfer of the result to NV) / Auslösegrund des Ringspeicher-Eintrags (0 =
// SoH_C-Schätzung; 1 = KapaTest mit Übernahme vom Ergebnis in NV; 2 = KapaTest ohne Übernahme vom Ergebnis in
// NV)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_GRUND_ADAPTION_3_WERT", STAT_GRUND_ADAPTION_3_WERT, "");
unsigned long STAT_ZEITPUNKT_ADAP_3_WERT = (RXBUF_UINT32(97));
// Time (SME time) of the 3rd adaptation / Zeitpunkt (SME-Zeit) der 3. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_ZEITPUNKT_ADAP_3_WERT", STAT_ZEITPUNKT_ADAP_3_WERT, "\"s\"");
float STAT_AH_CUM_ABS_3_WERT = (RXBUF_UINT32(101)/3600.0f);
// Absolute Ah throughput of the 3rd adaptation (if adaptation reason = KapaTest: test result in Ah) / Absoluter
// Ah-Durchsatz der 3. Adaption (Wenn Adaptionsgrund = KapaTest: Testergebnis in Ah)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_AH_CUM_ABS_3_WERT", STAT_AH_CUM_ABS_3_WERT, "\"Ah\"");
float STAT_AH_INTEGRAL_3_WERT = (RXBUF_UINT32(105)/3600.0f);
// Ah stroke of the 3rd adaptation (if adaptation reason = KapaTest: test result in Ah) / Ah-Hub der 3. Adaption
// (Wenn Adaptionsgrund = KapaTest: Testergebnis in Ah)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_AH_INTEGRAL_3_WERT", STAT_AH_INTEGRAL_3_WERT, "\"Ah\"");
unsigned short STAT_HVOFFTIME_ADAP_3_WERT = (RXBUF_UINT(109));
// Duration that the shooter was open during the 3rd adaptation / Dauer, die die Schütze während der 3. Adaption
// geöffnet war
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_HVOFFTIME_ADAP_3_WERT", STAT_HVOFFTIME_ADAP_3_WERT, "\"s\"");
char STAT_TEMP_MEAN1_3_WERT = (RXBUF_SCHAR(111));
// Average temperature at HVS level at the beginning of the 3rd adaptation or at the beginning of the test /
// Mittlere Temperatur auf HVS-Ebene zu Beginn der 3. Adaption bzw. zu Beginn des Tests
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_TEMP_MEAN1_3_WERT", STAT_TEMP_MEAN1_3_WERT, "\"°C\"");
char STAT_TEMP_MEAN2_3_WERT = (RXBUF_SCHAR(112));
// Average temperature at HVS level at the end of the 3rd adaptation / Mittlere Temperatur auf HVS-Ebene am Ende
// der 3. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_TEMP_MEAN2_3_WERT", STAT_TEMP_MEAN2_3_WERT, "\"°C\"");
float STAT_UCEL_MIN_INIT1_3_WERT = (RXBUF_UINT(113)/1000.0f);
// Minimum measured resting voltage of the cells at the beginning of the 3rd adaptation (if adaptation reason =
// KapaTest: minimum measured resting voltage when waking up) / Minimale gemessene Ruhespannung der Zellen zu
// Beginn der 3. Adaption (Wenn Adaptionsgrund = KapaTest: Minimale gemessene Ruhespannung beim Aufwachen)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_UCEL_MIN_INIT1_3_WERT", STAT_UCEL_MIN_INIT1_3_WERT, "\"V\"");
float STAT_UCEL_MAX_INIT1_3_WERT = (RXBUF_UINT(115)/1000.0f);
// Maximum measured resting voltage of the cells at the beginning of the 3rd adaptation (if adaptation reason =
// KapaTest: maximum measured resting voltage when waking up) / Maximale gemessene Ruhespannung der Zellen zu
// Beginn der 3. Adaption (Wenn Adaptionsgrund = KapaTest: Maximale gemessene Ruhespannung beim Aufwachen)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_UCEL_MAX_INIT1_3_WERT", STAT_UCEL_MAX_INIT1_3_WERT, "\"V\"");
float STAT_UCEL_MEAN_INIT1_3_WERT = (RXBUF_UINT(117)/1000.0f);
// Mean measured open-circuit voltage of the cells at the beginning of the 3rd adaptation (if reason for
// adaptation = KapaTest: mean measured open-circuit voltage when waking up) / Mittlere gemessene Ruhespannung
// der Zellen zu Beginn der 3. Adaption (Wenn Adaptionsgrund = KapaTest: Mittlere gemessene Ruhespannung beim
// Aufwachen)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_UCEL_MEAN_INIT1_3_WERT", STAT_UCEL_MEAN_INIT1_3_WERT, "\"V\"");
float STAT_UCEL_MIN_INIT2_3_WERT = (RXBUF_UINT(119)/1000.0f);
// Minimum measured open-circuit voltage of the cells at the end of the 3rd adaptation / Minimale gemessene
// Ruhespannung der Zellen am Ende der 3. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_UCEL_MIN_INIT2_3_WERT", STAT_UCEL_MIN_INIT2_3_WERT, "\"V\"");
float STAT_UCEL_MAX_INIT2_3_WERT = (RXBUF_UINT(121)/1000.0f);
// Maximum measured open-circuit voltage of the cells at the end of the 3rd adaptation / Maximale gemessene
// Ruhespannung der Zellen am Ende der 3. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_UCEL_MAX_INIT2_3_WERT", STAT_UCEL_MAX_INIT2_3_WERT, "\"V\"");
float STAT_UCEL_MEAN_INIT2_3_WERT = (RXBUF_UINT(123)/1000.0f);
// Mean measured resting voltage of the cells at the end of the 3rd adaptation / Mittlere gemessene Ruhespannung
// der Zellen am Ende der 3. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_UCEL_MEAN_INIT2_3_WERT", STAT_UCEL_MEAN_INIT2_3_WERT, "\"V\"");
float STAT_SOH_ZELLE1_VOR_ADAPT_3_WERT = (RXBUF_UINT(125)/100.0f);
// SoH_C of cell 1 BEFORE 3rd adaptation / SoH_C von Zelle 1 VOR 3. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_SOH_ZELLE1_VOR_ADAPT_3_WERT", STAT_SOH_ZELLE1_VOR_ADAPT_3_WERT, "\"%\"");
float STAT_SOH_ZELLE1_NACH_ADAPT_3_WERT = (RXBUF_UINT(127)/100.0f);
// SoH_C from cell 1 AFTER 3rd adaptation / SoH_C von Zelle 1 NACH 3. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_SOH_ZELLE1_NACH_ADAPT_3_WERT", STAT_SOH_ZELLE1_NACH_ADAPT_3_WERT, "\"%\"");
float STAT_OVC1_ZELLE1_3_WERT = (RXBUF_UINT(129)/1000.0f);
// OCV value of cell 1 at the beginning of the 3rd adaptation / OCV Wert von Zelle 1 zu Beginn der 3. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_OVC1_ZELLE1_3_WERT", STAT_OVC1_ZELLE1_3_WERT, "\"V\"");
float STAT_OVC2_ZELLE1_3_WERT = (RXBUF_UINT(131)/1000.0f);
// OCV value of cell 1 at the end of the 3rd adaptation / OCV Wert von Zelle 1 am Ende der 3. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_OVC2_ZELLE1_3_WERT", STAT_OVC2_ZELLE1_3_WERT, "\"V\"");
float STAT_SOH_GAIN_FAKTOR_ZELLE1_3_WERT = (RXBUF_UINT(133)/10000.0f);
// Gain factor of cell 1 for the third adaptation / Gain Faktor von Zelle 1 für die dritte Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_SOH_GAIN_FAKTOR_ZELLE1_3_WERT", STAT_SOH_GAIN_FAKTOR_ZELLE1_3_WERT, "");
float STAT_SOH_MIN_NACH_3_WERT = (RXBUF_UINT(135)/100.0f);
// Minimal SOH AFTER the 3rd adaptation / Minimaler SOH NACH der 3. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_SOH_MIN_NACH_3_WERT", STAT_SOH_MIN_NACH_3_WERT, "\"%\"");
float STAT_SOH_MAX_NACH_3_WERT = (RXBUF_UINT(137)/100.0f);
// Maximum SOH AFTER the 3rd adaptation / Maximaler SOH NACH der 3. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_SOH_MAX_NACH_3_WERT", STAT_SOH_MAX_NACH_3_WERT, "\"%\"");
float STAT_SOH_MEAN_NACH_3_WERT = (RXBUF_UINT(139)/100.0f);
// Middle SOH AFTER the 3rd adaptation / Mittlerer SOH NACH der 3. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_SOH_MEAN_NACH_3_WERT", STAT_SOH_MEAN_NACH_3_WERT, "\"%\"");
unsigned short STAT_SOH_ADAPT_COUNT_4_WERT = (RXBUF_UINT(141));
// Adaptation counter of 4th adaptation / Adaptionszähler von 4. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_SOH_ADAPT_COUNT_4_WERT", STAT_SOH_ADAPT_COUNT_4_WERT, "");
unsigned char STAT_GRUND_ADAPTION_4_WERT = (RXBUF_UCHAR(143));
// Reason for triggering the ring buffer entry (0 = SoH_C estimate; 1 = KapaTest with transfer of the result to
// NV; 2 = KapaTest without transfer of the result to NV) / Auslösegrund des Ringspeicher-Eintrags (0 =
// SoH_C-Schätzung; 1 = KapaTest mit Übernahme vom Ergebnis in NV; 2 = KapaTest ohne Übernahme vom Ergebnis in
// NV)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_GRUND_ADAPTION_4_WERT", STAT_GRUND_ADAPTION_4_WERT, "");
unsigned long STAT_ZEITPUNKT_ADAP_4_WERT = (RXBUF_UINT32(144));
// Point in time (SME time) of the 4th adaptation / Zeitpunkt (SME-Zeit) der 4. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_ZEITPUNKT_ADAP_4_WERT", STAT_ZEITPUNKT_ADAP_4_WERT, "\"s\"");
float STAT_AH_CUM_ABS_4_WERT = (RXBUF_UINT32(148)/3600.0f);
// Absolute Ah throughput of the 4th adaptation (if adaptation reason = KapaTest: test result in Ah) / Absoluter
// Ah-Durchsatz der 4. Adaption (Wenn Adaptionsgrund = KapaTest: Testergebnis in Ah)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_AH_CUM_ABS_4_WERT", STAT_AH_CUM_ABS_4_WERT, "\"Ah\"");
float STAT_AH_INTEGRAL_4_WERT = (RXBUF_UINT32(152)/3600.0f);
// Ah stroke of the 4th adaptation (if adaptation reason = KapaTest: test result in Ah) / Ah-Hub der 4. Adaption
// (Wenn Adaptionsgrund = KapaTest: Testergebnis in Ah)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_AH_INTEGRAL_4_WERT", STAT_AH_INTEGRAL_4_WERT, "\"Ah\"");
unsigned short STAT_HVOFFTIME_ADAP_4_WERT = (RXBUF_UINT(156));
// Duration the shooter was open during the 4th adaptation / Dauer, die die Schütze während der 4. Adaption
// geöffnet war
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_HVOFFTIME_ADAP_4_WERT", STAT_HVOFFTIME_ADAP_4_WERT, "\"s\"");
char STAT_TEMP_MEAN1_4_WERT = (RXBUF_SCHAR(158));
// Average temperature at HVS level at the beginning of the 4th adaptation or at the beginning of the test /
// Mittlere Temperatur auf HVS-Ebene zu Beginn der 4. Adaption bzw. zu Beginn des Tests
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_TEMP_MEAN1_4_WERT", STAT_TEMP_MEAN1_4_WERT, "\"°C\"");
char STAT_TEMP_MEAN2_4_WERT = (RXBUF_SCHAR(159));
// Average temperature at HVS level at the end of the 4th adaptation / Mittlere Temperatur auf HVS-Ebene am Ende
// der 4. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_TEMP_MEAN2_4_WERT", STAT_TEMP_MEAN2_4_WERT, "\"°C\"");
float STAT_UCEL_MIN_INIT1_4_WERT = (RXBUF_UINT(160)/1000.0f);
// Minimum measured open-circuit voltage of the cells at the beginning of the 4th adaptation (if adaptation
// reason = KapaTest: minimum measured open-circuit voltage when waking up) / Minimale gemessene Ruhespannung der
// Zellen zu Beginn der 4. Adaption (Wenn Adaptionsgrund = KapaTest: Minimale gemessene Ruhespannung beim
// Aufwachen)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_UCEL_MIN_INIT1_4_WERT", STAT_UCEL_MIN_INIT1_4_WERT, "\"V\"");
float STAT_UCEL_MAX_INIT1_4_WERT = (RXBUF_UINT(162)/1000.0f);
// Maximum measured resting voltage of the cells at the beginning of the 4th adaptation (if adaptation reason =
// KapaTest: maximum measured resting voltage when waking up) / Maximale gemessene Ruhespannung der Zellen zu
// Beginn der 4. Adaption (Wenn Adaptionsgrund = KapaTest: Maximale gemessene Ruhespannung beim Aufwachen)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_UCEL_MAX_INIT1_4_WERT", STAT_UCEL_MAX_INIT1_4_WERT, "\"V\"");
float STAT_UCEL_MEAN_INIT1_4_WERT = (RXBUF_UINT(164)/1000.0f);
// Mean measured open-circuit voltage of the cells at the beginning of the 4th adaptation (if reason for
// adaptation = KapaTest: mean measured open-circuit voltage when waking up) / Mittlere gemessene Ruhespannung
// der Zellen zu Beginn der 4. Adaption (Wenn Adaptionsgrund = KapaTest: Mittlere gemessene Ruhespannung beim
// Aufwachen)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_UCEL_MEAN_INIT1_4_WERT", STAT_UCEL_MEAN_INIT1_4_WERT, "\"V\"");
float STAT_UCEL_MIN_INIT2_4_WERT = (RXBUF_UINT(166)/1000.0f);
// Minimum measured open-circuit voltage of the cells at the end of the 4th adaptation / Minimale gemessene
// Ruhespannung der Zellen am Ende der 4. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_UCEL_MIN_INIT2_4_WERT", STAT_UCEL_MIN_INIT2_4_WERT, "\"V\"");
float STAT_UCEL_MAX_INIT2_4_WERT = (RXBUF_UINT(168)/1000.0f);
// Maximum measured open-circuit voltage of the cells at the end of the 4th adaptation / Maximale gemessene
// Ruhespannung der Zellen am Ende der 4. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_UCEL_MAX_INIT2_4_WERT", STAT_UCEL_MAX_INIT2_4_WERT, "\"V\"");
float STAT_UCEL_MEAN_INIT2_4_WERT = (RXBUF_UINT(170)/1000.0f);
// Mean measured resting voltage of the cells at the end of the 4th adaptation / Mittlere gemessene Ruhespannung
// der Zellen am Ende der 4. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_UCEL_MEAN_INIT2_4_WERT", STAT_UCEL_MEAN_INIT2_4_WERT, "\"V\"");
float STAT_SOH_ZELLE1_VOR_ADAPT_4_WERT = (RXBUF_UINT(172)/100.0f);
// SoH_C of cell 1 BEFORE 4th adaptation / SoH_C von Zelle 1 VOR 4. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_SOH_ZELLE1_VOR_ADAPT_4_WERT", STAT_SOH_ZELLE1_VOR_ADAPT_4_WERT, "\"%\"");
float STAT_SOH_ZELLE1_NACH_ADAPT_4_WERT = (RXBUF_UINT(174)/100.0f);
// SoH_C from cell 1 AFTER 4th adaptation / SoH_C von Zelle 1 NACH 4. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_SOH_ZELLE1_NACH_ADAPT_4_WERT", STAT_SOH_ZELLE1_NACH_ADAPT_4_WERT, "\"%\"");
float STAT_OVC1_ZELLE1_4_WERT = (RXBUF_UINT(176)/1000.0f);
// OCV value of cell 1 at the beginning of the 4th adaptation / OCV Wert von Zelle 1 zu Beginn der 4. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_OVC1_ZELLE1_4_WERT", STAT_OVC1_ZELLE1_4_WERT, "\"V\"");
float STAT_OVC2_ZELLE1_4_WERT = (RXBUF_UINT(178)/1000.0f);
// OCV value of cell 1 at the end of the 4th adaptation / OCV Wert von Zelle 1 am Ende der 4. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_OVC2_ZELLE1_4_WERT", STAT_OVC2_ZELLE1_4_WERT, "\"V\"");
float STAT_SOH_GAIN_FAKTOR_ZELLE1_4_WERT = (RXBUF_UINT(180)/10000.0f);
// Gain factor of cell 1 for the fourth adaptation / Gain Faktor von Zelle 1 für die vierte Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_SOH_GAIN_FAKTOR_ZELLE1_4_WERT", STAT_SOH_GAIN_FAKTOR_ZELLE1_4_WERT, "");
float STAT_SOH_MIN_NACH_4_WERT = (RXBUF_UINT(182)/100.0f);
// Minimal SOH AFTER the 4th adaptation / Minimaler SOH NACH der 4. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_SOH_MIN_NACH_4_WERT", STAT_SOH_MIN_NACH_4_WERT, "\"%\"");
float STAT_SOH_MAX_NACH_4_WERT = (RXBUF_UINT(184)/100.0f);
// Maximum SOH AFTER the 4th adaptation / Maximaler SOH NACH der 4. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_SOH_MAX_NACH_4_WERT", STAT_SOH_MAX_NACH_4_WERT, "\"%\"");
float STAT_SOH_MEAN_NACH_4_WERT = (RXBUF_UINT(186)/100.0f);
// Middle SOH AFTER the 4th adaptation / Mittlerer SOH NACH der 4. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_SOH_MEAN_NACH_4_WERT", STAT_SOH_MEAN_NACH_4_WERT, "\"%\"");
unsigned short STAT_SOH_ADAPT_COUNT_5_WERT = (RXBUF_UINT(188));
// Adaptation counter of 5th adaptation / Adaptionszähler von 5. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_SOH_ADAPT_COUNT_5_WERT", STAT_SOH_ADAPT_COUNT_5_WERT, "");
unsigned char STAT_GRUND_ADAPTION_5_WERT = (RXBUF_UCHAR(190));
// Reason for triggering the ring buffer entry (0 = SoH_C estimate; 1 = KapaTest with transfer of the result to
// NV; 2 = KapaTest without transfer of the result to NV) / Auslösegrund des Ringspeicher-Eintrags (0 =
// SoH_C-Schätzung; 1 = KapaTest mit Übernahme vom Ergebnis in NV; 2 = KapaTest ohne Übernahme vom Ergebnis in
// NV)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_GRUND_ADAPTION_5_WERT", STAT_GRUND_ADAPTION_5_WERT, "");
unsigned long STAT_ZEITPUNKT_ADAP_5_WERT = (RXBUF_UINT32(191));
// Time (SME time) of the 5th adaptation / Zeitpunkt (SME-Zeit) der 5. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_ZEITPUNKT_ADAP_5_WERT", STAT_ZEITPUNKT_ADAP_5_WERT, "\"s\"");
float STAT_AH_CUM_ABS_5_WERT = (RXBUF_UINT32(195)/3600.0f);
// Absolute Ah throughput of the 5th adaptation (if adaptation reason = KapaTest: test result in Ah) / Absoluter
// Ah-Durchsatz der 5. Adaption (Wenn Adaptionsgrund = KapaTest: Testergebnis in Ah)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_AH_CUM_ABS_5_WERT", STAT_AH_CUM_ABS_5_WERT, "\"Ah\"");
float STAT_AH_INTEGRAL_5_WERT = (RXBUF_UINT32(199)/3600.0f);
// Ah stroke of the 5th adaptation (if adaptation reason = KapaTest: test result in Ah) / Ah-Hub der 5. Adaption
// (Wenn Adaptionsgrund = KapaTest: Testergebnis in Ah)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_AH_INTEGRAL_5_WERT", STAT_AH_INTEGRAL_5_WERT, "\"Ah\"");
unsigned short STAT_HVOFFTIME_ADAP_5_WERT = (RXBUF_UINT(203));
// Duration that the shooter was open during the 5th adaptation / Dauer, die die Schütze während der 5. Adaption
// geöffnet war
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_HVOFFTIME_ADAP_5_WERT", STAT_HVOFFTIME_ADAP_5_WERT, "\"s\"");
char STAT_TEMP_MEAN1_5_WERT = (RXBUF_SCHAR(205));
// Average temperature at HVS level at the beginning of the 5th adaptation or at the beginning of the test /
// Mittlere Temperatur auf HVS-Ebene zu Beginn der 5. Adaption bzw. zu Beginn des Tests
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_TEMP_MEAN1_5_WERT", STAT_TEMP_MEAN1_5_WERT, "\"°C\"");
char STAT_TEMP_MEAN2_5_WERT = (RXBUF_SCHAR(206));
// Average temperature at HVS level at the end of the 5th adaptation / Mittlere Temperatur auf HVS-Ebene am Ende
// der 5. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_TEMP_MEAN2_5_WERT", STAT_TEMP_MEAN2_5_WERT, "\"°C\"");
float STAT_UCEL_MIN_INIT1_5_WERT = (RXBUF_UINT(207)/1000.0f);
// Minimum measured resting voltage of the cells at the beginning of the 5th adaptation (if adaptation reason =
// KapaTest: minimum measured resting voltage when waking up) / Minimale gemessene Ruhespannung der Zellen zu
// Beginn der 5. Adaption (Wenn Adaptionsgrund = KapaTest: Minimale gemessene Ruhespannung beim Aufwachen)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_UCEL_MIN_INIT1_5_WERT", STAT_UCEL_MIN_INIT1_5_WERT, "\"V\"");
float STAT_UCEL_MAX_INIT1_5_WERT = (RXBUF_UINT(209)/1000.0f);
// Maximum measured resting voltage of the cells at the beginning of the 5th adaptation (if adaptation reason =
// KapaTest: maximum measured resting voltage when waking up) / Maximale gemessene Ruhespannung der Zellen zu
// Beginn der 5. Adaption (Wenn Adaptionsgrund = KapaTest: Maximale gemessene Ruhespannung beim Aufwachen)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_UCEL_MAX_INIT1_5_WERT", STAT_UCEL_MAX_INIT1_5_WERT, "\"V\"");
float STAT_UCEL_MEAN_INIT1_5_WERT = (RXBUF_UINT(211)/1000.0f);
// Mean measured open-circuit voltage of the cells at the beginning of the 5th adaptation (if reason for
// adaptation = KapaTest: mean measured open-circuit voltage when waking up) / Mittlere gemessene Ruhespannung
// der Zellen zu Beginn der 5. Adaption (Wenn Adaptionsgrund = KapaTest: Mittlere gemessene Ruhespannung beim
// Aufwachen)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_UCEL_MEAN_INIT1_5_WERT", STAT_UCEL_MEAN_INIT1_5_WERT, "\"V\"");
float STAT_UCEL_MIN_INIT2_5_WERT = (RXBUF_UINT(213)/1000.0f);
// Minimum measured open-circuit voltage of the cells at the end of the 5th adaptation / Minimale gemessene
// Ruhespannung der Zellen am Ende der 5. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_UCEL_MIN_INIT2_5_WERT", STAT_UCEL_MIN_INIT2_5_WERT, "\"V\"");
float STAT_UCEL_MAX_INIT2_5_WERT = (RXBUF_UINT(215)/1000.0f);
// Maximum measured open-circuit voltage of the cells at the end of the 5th adaptation / Maximale gemessene
// Ruhespannung der Zellen am Ende der 5. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_UCEL_MAX_INIT2_5_WERT", STAT_UCEL_MAX_INIT2_5_WERT, "\"V\"");
float STAT_UCEL_MEAN_INIT2_5_WERT = (RXBUF_UINT(217)/1000.0f);
// Mean measured resting voltage of the cells at the end of the 5th adaptation / Mittlere gemessene Ruhespannung
// der Zellen am Ende der 5. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_UCEL_MEAN_INIT2_5_WERT", STAT_UCEL_MEAN_INIT2_5_WERT, "\"V\"");
float STAT_SOH_ZELLE1_VOR_ADAPT_5_WERT = (RXBUF_UINT(219)/100.0f);
// SoH_C of cell 1 BEFORE 5th adaptation / SoH_C von Zelle 1 VOR 5. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_SOH_ZELLE1_VOR_ADAPT_5_WERT", STAT_SOH_ZELLE1_VOR_ADAPT_5_WERT, "\"%\"");
float STAT_SOH_ZELLE1_NACH_ADAPT_5_WERT = (RXBUF_UINT(221)/100.0f);
// SoH_C from cell 1 AFTER 5th adaptation / SoH_C von Zelle 1 NACH 5. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_SOH_ZELLE1_NACH_ADAPT_5_WERT", STAT_SOH_ZELLE1_NACH_ADAPT_5_WERT, "\"%\"");
float STAT_OVC1_ZELLE1_5_WERT = (RXBUF_UINT(223)/1000.0f);
// OCV value of cell 1 at the beginning of the 5th adaptation / OCV Wert von Zelle 1 zu Beginn der 5. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_OVC1_ZELLE1_5_WERT", STAT_OVC1_ZELLE1_5_WERT, "\"V\"");
float STAT_OVC2_ZELLE1_5_WERT = (RXBUF_UINT(225)/1000.0f);
// OCV value of cell 1 at the end of the 5th adaptation / OCV Wert von Zelle 1 am Ende der 5. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_OVC2_ZELLE1_5_WERT", STAT_OVC2_ZELLE1_5_WERT, "\"V\"");
float STAT_SOH_GAIN_FAKTOR_ZELLE1_5_WERT = (RXBUF_UINT(227)/10000.0f);
// Gain factor of cell 1 for the fifth adaptation / Gain Faktor von Zelle 1 für die fünfte Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_SOH_GAIN_FAKTOR_ZELLE1_5_WERT", STAT_SOH_GAIN_FAKTOR_ZELLE1_5_WERT, "");
float STAT_SOH_MIN_NACH_5_WERT = (RXBUF_UINT(229)/100.0f);
// Minimal SOH AFTER the 5th adaptation / Minimaler SOH NACH der 5. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_SOH_MIN_NACH_5_WERT", STAT_SOH_MIN_NACH_5_WERT, "\"%\"");
float STAT_SOH_MAX_NACH_5_WERT = (RXBUF_UINT(231)/100.0f);
// Maximum SOH AFTER the 5th adaptation / Maximaler SOH NACH der 5. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_SOH_MAX_NACH_5_WERT", STAT_SOH_MAX_NACH_5_WERT, "\"%\"");
float STAT_SOH_MEAN_NACH_5_WERT = (RXBUF_UINT(233)/100.0f);
// Middle SOH AFTER the 5th adaptation / Mittlerer SOH NACH der 5. Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_SOH_MEAN_NACH_5_WERT", STAT_SOH_MEAN_NACH_5_WERT, "\"%\"");
float STAT_SOH_MIN_VOR_5_WERT = (RXBUF_UINT(235)/100.0f);
// Minimal SOH BEFORE the oldest adaptation / Minimaler SOH VOR der ältesten Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_SOH_MIN_VOR_5_WERT", STAT_SOH_MIN_VOR_5_WERT, "\"%\"");
float STAT_SOH_MAX_VOR_5_WERT = (RXBUF_UINT(237)/100.0f);
// Maximum SOH BEFORE the oldest adaptation / Maximaler SOH VOR der ältesten Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_SOH_MAX_VOR_5_WERT", STAT_SOH_MAX_VOR_5_WERT, "\"%\"");
float STAT_SOH_MEAN_VOR_5_WERT = (RXBUF_UINT(239)/100.0f);
// Middle SOH BEFORE the oldest adaptation / Mittlerer SOH VOR der ältesten Adaption
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_ALTERUNG_KAPA", "STAT_SOH_MEAN_VOR_5_WERT", STAT_SOH_MEAN_VOR_5_WERT, "\"%\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_CSC_TEMPERATUREN: { // 0xD6CF
if (datalen < 24) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_CSC_TEMPERATUREN", 24);
break;
}
char STAT_MESSTEMP_CSC1_SENS1_WERT = (RXBUF_SCHAR(0));
// Current measured temperature value sensor 1 CSC 1 // 127 = Qual invalid / aktueller Temperaturmesswert Sensor
// 1 CSC 1 // 127 = Qual ungültig
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "CSC_TEMPERATUREN", "STAT_MESSTEMP_CSC1_SENS1_WERT", STAT_MESSTEMP_CSC1_SENS1_WERT, "\"°C\"");
char STAT_MESSTEMP_CSC1_SENS2_WERT = (RXBUF_SCHAR(1));
// Current measured temperature value sensor 2 CSC 1 // 127 = Qual invalid / aktueller Temperaturmesswert Sensor
// 2 CSC 1 // 127 = Qual ungültig
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "CSC_TEMPERATUREN", "STAT_MESSTEMP_CSC1_SENS2_WERT", STAT_MESSTEMP_CSC1_SENS2_WERT, "\"°C\"");
char STAT_MESSTEMP_CSC2_SENS1_WERT = (RXBUF_SCHAR(2));
// Current measured temperature value sensor 1 CSC 2 // 127 = Qual invalid / aktueller Temperaturmesswert Sensor
// 1 CSC 2 // 127 = Qual ungültig
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "CSC_TEMPERATUREN", "STAT_MESSTEMP_CSC2_SENS1_WERT", STAT_MESSTEMP_CSC2_SENS1_WERT, "\"°C\"");
char STAT_MESSTEMP_CSC2_SENS2_WERT = (RXBUF_SCHAR(3));
// Current measured temperature value sensor 2 CSC 2 // 127 = Qual invalid / aktueller Temperaturmesswert Sensor
// 2 CSC 2 // 127 = Qual ungültig
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "CSC_TEMPERATUREN", "STAT_MESSTEMP_CSC2_SENS2_WERT", STAT_MESSTEMP_CSC2_SENS2_WERT, "\"°C\"");
char STAT_MESSTEMP_CSC3_SENS1_WERT = (RXBUF_SCHAR(4));
// Current measured temperature value sensor 1 CSC 3 // 127 = Qual invalid / aktueller Temperaturmesswert Sensor
// 1 CSC 3 // 127 = Qual ungültig
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "CSC_TEMPERATUREN", "STAT_MESSTEMP_CSC3_SENS1_WERT", STAT_MESSTEMP_CSC3_SENS1_WERT, "\"°C\"");
char STAT_MESSTEMP_CSC3_SENS2_WERT = (RXBUF_SCHAR(5));
// Current measured temperature value sensor 2 CSC 3 // 127 = Qual invalid / aktueller Temperaturmesswert Sensor
// 2 CSC 3 // 127 = Qual ungültig
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "CSC_TEMPERATUREN", "STAT_MESSTEMP_CSC3_SENS2_WERT", STAT_MESSTEMP_CSC3_SENS2_WERT, "\"°C\"");
char STAT_MESSTEMP_CSC4_SENS1_WERT = (RXBUF_SCHAR(6));
// Current measured temperature value sensor 1 CSC 4 // 127 = Qual invalid / aktueller Temperaturmesswert Sensor
// 1 CSC 4 // 127 = Qual ungültig
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "CSC_TEMPERATUREN", "STAT_MESSTEMP_CSC4_SENS1_WERT", STAT_MESSTEMP_CSC4_SENS1_WERT, "\"°C\"");
char STAT_MESSTEMP_CSC4_SENS2_WERT = (RXBUF_SCHAR(7));
// Current measured temperature value sensor 2 CSC 4 // 127 = Qual invalid / aktueller Temperaturmesswert Sensor
// 2 CSC 4 // 127 = Qual ungültig
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "CSC_TEMPERATUREN", "STAT_MESSTEMP_CSC4_SENS2_WERT", STAT_MESSTEMP_CSC4_SENS2_WERT, "\"°C\"");
char STAT_MESSTEMP_CSC5_SENS1_WERT = (RXBUF_SCHAR(8));
// Current measured temperature value sensor 1 CSC 5 // 127 = Qual invalid / aktueller Temperaturmesswert Sensor
// 1 CSC 5 // 127 = Qual ungültig
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "CSC_TEMPERATUREN", "STAT_MESSTEMP_CSC5_SENS1_WERT", STAT_MESSTEMP_CSC5_SENS1_WERT, "\"°C\"");
char STAT_MESSTEMP_CSC5_SENS2_WERT = (RXBUF_SCHAR(9));
// Current measured temperature value sensor 2 CSC 5 // 127 = Qual invalid / aktueller Temperaturmesswert Sensor
// 2 CSC 5 // 127 = Qual ungültig
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "CSC_TEMPERATUREN", "STAT_MESSTEMP_CSC5_SENS2_WERT", STAT_MESSTEMP_CSC5_SENS2_WERT, "\"°C\"");
char STAT_MESSTEMP_CSC6_SENS1_WERT = (RXBUF_SCHAR(10));
// Current measured temperature value sensor 1 CSC 6 // 127 = Qual invalid / aktueller Temperaturmesswert Sensor
// 1 CSC 6 // 127 = Qual ungültig
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "CSC_TEMPERATUREN", "STAT_MESSTEMP_CSC6_SENS1_WERT", STAT_MESSTEMP_CSC6_SENS1_WERT, "\"°C\"");
char STAT_MESSTEMP_CSC6_SENS2_WERT = (RXBUF_SCHAR(11));
// Current measured temperature value sensor 2 CSC 6 // 127 = Qual invalid / aktueller Temperaturmesswert Sensor
// 2 CSC 6 // 127 = Qual ungültig
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "CSC_TEMPERATUREN", "STAT_MESSTEMP_CSC6_SENS2_WERT", STAT_MESSTEMP_CSC6_SENS2_WERT, "\"°C\"");
char STAT_MESSTEMP_CSC7_SENS1_WERT = (RXBUF_SCHAR(12));
// Current measured temperature value sensor 1 CSC 7 // 127 = Qual invalid / aktueller Temperaturmesswert Sensor
// 1 CSC 7 // 127 = Qual ungültig
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "CSC_TEMPERATUREN", "STAT_MESSTEMP_CSC7_SENS1_WERT", STAT_MESSTEMP_CSC7_SENS1_WERT, "\"°C\"");
char STAT_MESSTEMP_CSC7_SENS2_WERT = (RXBUF_SCHAR(13));
// Current measured temperature value sensor 2 CSC 7 // 127 = Qual invalid / aktueller Temperaturmesswert Sensor
// 2 CSC 7 // 127 = Qual ungültig
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "CSC_TEMPERATUREN", "STAT_MESSTEMP_CSC7_SENS2_WERT", STAT_MESSTEMP_CSC7_SENS2_WERT, "\"°C\"");
char STAT_MESSTEMP_CSC8_SENS1_WERT = (RXBUF_SCHAR(14));
// Current measured temperature value sensor 1 CSC 8 // 127 = Qual invalid / aktueller Temperaturmesswert Sensor
// 1 CSC 8 // 127 = Qual ungültig
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "CSC_TEMPERATUREN", "STAT_MESSTEMP_CSC8_SENS1_WERT", STAT_MESSTEMP_CSC8_SENS1_WERT, "\"°C\"");
char STAT_MESSTEMP_CSC8_SENS2_WERT = (RXBUF_SCHAR(15));
// Current measured temperature value sensor 2 CSC 8 // 127 = Qual invalid / aktueller Temperaturmesswert Sensor
// 2 CSC 8 // 127 = Qual ungültig
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "CSC_TEMPERATUREN", "STAT_MESSTEMP_CSC8_SENS2_WERT", STAT_MESSTEMP_CSC8_SENS2_WERT, "\"°C\"");
char STAT_MESSTEMP_CSC9_SENS1_WERT = (RXBUF_SCHAR(16));
// Current measured temperature value sensor 1 CSC 9 // 127 = Qual invalid / aktueller Temperaturmesswert Sensor
// 1 CSC 9 // 127 = Qual ungültig
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "CSC_TEMPERATUREN", "STAT_MESSTEMP_CSC9_SENS1_WERT", STAT_MESSTEMP_CSC9_SENS1_WERT, "\"°C\"");
char STAT_MESSTEMP_CSC9_SENS2_WERT = (RXBUF_SCHAR(17));
// Current measured temperature value sensor 2 CSC 9 // 127 = Qual invalid / aktueller Temperaturmesswert Sensor
// 2 CSC 9 // 127 = Qual ungültig
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "CSC_TEMPERATUREN", "STAT_MESSTEMP_CSC9_SENS2_WERT", STAT_MESSTEMP_CSC9_SENS2_WERT, "\"°C\"");
char STAT_MESSTEMP_CSC10_SENS1_WERT = (RXBUF_SCHAR(18));
// Current measured temperature value sensor 1 CSC 10 // 127 = Qual invalid / aktueller Temperaturmesswert Sensor
// 1 CSC 10 // 127 = Qual ungültig
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "CSC_TEMPERATUREN", "STAT_MESSTEMP_CSC10_SENS1_WERT", STAT_MESSTEMP_CSC10_SENS1_WERT, "\"°C\"");
char STAT_MESSTEMP_CSC10_SENS2_WERT = (RXBUF_SCHAR(19));
// Current measured temperature value sensor 2 CSC 10 // 127 = Qual invalid / aktueller Temperaturmesswert Sensor
// 2 CSC 10 // 127 = Qual ungültig
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "CSC_TEMPERATUREN", "STAT_MESSTEMP_CSC10_SENS2_WERT", STAT_MESSTEMP_CSC10_SENS2_WERT, "\"°C\"");
char STAT_MESSTEMP_CSC11_SENS1_WERT = (RXBUF_SCHAR(20));
// Current measured temperature value sensor 1 CSC 11 // 127 = Qual invalid / aktueller Temperaturmesswert Sensor
// 1 CSC 11 // 127 = Qual ungültig
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "CSC_TEMPERATUREN", "STAT_MESSTEMP_CSC11_SENS1_WERT", STAT_MESSTEMP_CSC11_SENS1_WERT, "\"°C\"");
char STAT_MESSTEMP_CSC11_SENS2_WERT = (RXBUF_SCHAR(21));
// Current measured temperature value sensor 2 CSC 11 // 127 = Qual invalid / aktueller Temperaturmesswert Sensor
// 2 CSC 11 // 127 = Qual ungültig
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "CSC_TEMPERATUREN", "STAT_MESSTEMP_CSC11_SENS2_WERT", STAT_MESSTEMP_CSC11_SENS2_WERT, "\"°C\"");
char STAT_MESSTEMP_CSC12_SENS1_WERT = (RXBUF_SCHAR(22));
// Current measured temperature value sensor 1 CSC 12 // 127 = Qual invalid / aktueller Temperaturmesswert Sensor
// 1 CSC 12 // 127 = Qual ungültig
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "CSC_TEMPERATUREN", "STAT_MESSTEMP_CSC12_SENS1_WERT", STAT_MESSTEMP_CSC12_SENS1_WERT, "\"°C\"");
char STAT_MESSTEMP_CSC12_SENS2_WERT = (RXBUF_SCHAR(23));
// Current measured temperature value sensor 2 CSC 12 // 127 = Qual invalid / aktueller Temperaturmesswert Sensor
// 2 CSC 12 // 127 = Qual ungültig
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "CSC_TEMPERATUREN", "STAT_MESSTEMP_CSC12_SENS2_WERT", STAT_MESSTEMP_CSC12_SENS2_WERT, "\"°C\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_ISO_ERR_TRG_FZ1_2: { // 0xD6D1
if (datalen < 52) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_ISO_ERR_TRG_FZ1_2", 52);
break;
}
unsigned long STAT_FEHLERZAEHLER_TRG_WERT = (RXBUF_UINT32(0));
// LI: Counter of all errors that have occurred in the overrun measurement / LI: Zähler aller aufgetretenen
// Fehler der Nachlaufmessung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ISO_ERR_TRG_FZ1_2", "STAT_FEHLERZAEHLER_TRG_WERT", STAT_FEHLERZAEHLER_TRG_WERT, "");
float STAT_INPUT_ISO_TRG_FZ1_01_WERT = (RXBUF_UINT(4)/100.0f);
// LI: first error time Ubat01 [V] / LI: erstmaliger Fehlerzeitpunkt Ubat01 [V]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ISO_ERR_TRG_FZ1_2", "STAT_INPUT_ISO_TRG_FZ1_01_WERT", STAT_INPUT_ISO_TRG_FZ1_01_WERT, "\"V\"");
unsigned char STAT_INPUT_ISO_TRG_FZ1_02_WERT = (RXBUF_UCHAR(6));
// LI: first error time Ubat01_QUAL / LI: erstmaliger Fehlerzeitpunkt Ubat01_QUAL
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "ISO_ERR_TRG_FZ1_2", "STAT_INPUT_ISO_TRG_FZ1_02_WERT", STAT_INPUT_ISO_TRG_FZ1_02_WERT, "");
float STAT_INPUT_ISO_TRG_FZ1_03_WERT = (RXBUF_UINT(7)/100.0f);
// LI: first error time Ubat02 [V] / LI: erstmaliger Fehlerzeitpunkt Ubat02 [V]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ISO_ERR_TRG_FZ1_2", "STAT_INPUT_ISO_TRG_FZ1_03_WERT", STAT_INPUT_ISO_TRG_FZ1_03_WERT, "\"V\"");
unsigned char STAT_INPUT_ISO_TRG_FZ1_04_WERT = (RXBUF_UCHAR(9));
// LI: first error time Ubat02_QUAL / LI: erstmaliger Fehlerzeitpunkt Ubat02_QUAL
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "ISO_ERR_TRG_FZ1_2", "STAT_INPUT_ISO_TRG_FZ1_04_WERT", STAT_INPUT_ISO_TRG_FZ1_04_WERT, "");
float STAT_INPUT_ISO_TRG_FZ1_05_WERT = (RXBUF_UINT(10)/100.0f);
// LI: first error time Uiso01 [V] / LI: erstmaliger Fehlerzeitpunkt Uiso01 [V]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ISO_ERR_TRG_FZ1_2", "STAT_INPUT_ISO_TRG_FZ1_05_WERT", STAT_INPUT_ISO_TRG_FZ1_05_WERT, "\"V\"");
unsigned char STAT_INPUT_ISO_TRG_FZ1_06_WERT = (RXBUF_UCHAR(12));
// LI: first time error Uiso01_QUAL / LI: erstmaliger Fehlerzeitpunkt Uiso01_QUAL
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "ISO_ERR_TRG_FZ1_2", "STAT_INPUT_ISO_TRG_FZ1_06_WERT", STAT_INPUT_ISO_TRG_FZ1_06_WERT, "");
float STAT_INPUT_ISO_TRG_FZ1_07_WERT = (RXBUF_UINT(13)/100.0f);
// LI: first failure time Uiso02 [V] / LI: erstmaliger Fehlerzeitpunkt Uiso02 [V]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ISO_ERR_TRG_FZ1_2", "STAT_INPUT_ISO_TRG_FZ1_07_WERT", STAT_INPUT_ISO_TRG_FZ1_07_WERT, "\"V\"");
unsigned char STAT_INPUT_ISO_TRG_FZ1_08_WERT = (RXBUF_UCHAR(15));
// LI: first time error Uiso02_QUAL / LI: erstmaliger Fehlerzeitpunkt Uiso02_QUAL
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "ISO_ERR_TRG_FZ1_2", "STAT_INPUT_ISO_TRG_FZ1_08_WERT", STAT_INPUT_ISO_TRG_FZ1_08_WERT, "");
float STAT_INPUT_ISO_TRG_FZ1_09_WERT = (RXBUF_UINT(16)/100.0f);
// LI: first error time Uoffset [V] / LI: erstmaliger Fehlerzeitpunkt Uoffset [V]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ISO_ERR_TRG_FZ1_2", "STAT_INPUT_ISO_TRG_FZ1_09_WERT", STAT_INPUT_ISO_TRG_FZ1_09_WERT, "\"V\"");
unsigned char STAT_INPUT_ISO_TRG_FZ1_10_WERT = (RXBUF_UCHAR(18));
// LI: first time error Uoffset_QUAL / LI: erstmaliger Fehlerzeitpunkt Uoffset_QUAL
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "ISO_ERR_TRG_FZ1_2", "STAT_INPUT_ISO_TRG_FZ1_10_WERT", STAT_INPUT_ISO_TRG_FZ1_10_WERT, "");
unsigned short STAT_INPUT_ISO_TRG_FZ1_11_WERT = (RXBUF_UINT(19));
// LI: first error time R_iso_ges [kOhm] / LI: erstmaliger Fehlerzeitpunkt R_iso_ges [kOhm]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "ISO_ERR_TRG_FZ1_2", "STAT_INPUT_ISO_TRG_FZ1_11_WERT", STAT_INPUT_ISO_TRG_FZ1_11_WERT, "\"kOhm\"");
unsigned char STAT_INPUT_ISO_TRG_FZ1_12_WERT = (RXBUF_UCHAR(21));
// LI: first error time R_iso_gesQUAL / LI: erstmaliger Fehlerzeitpunkt R_iso_gesQUAL
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "ISO_ERR_TRG_FZ1_2", "STAT_INPUT_ISO_TRG_FZ1_12_WERT", STAT_INPUT_ISO_TRG_FZ1_12_WERT, "");
unsigned short STAT_INPUT_ISO_TRG_FZ1_13_WERT = (RXBUF_UINT(22));
// LI: first error time R_iso_plus [kOhm] / LI: erstmaliger Fehlerzeitpunkt R_iso_plus [kOhm]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "ISO_ERR_TRG_FZ1_2", "STAT_INPUT_ISO_TRG_FZ1_13_WERT", STAT_INPUT_ISO_TRG_FZ1_13_WERT, "\"kOhm\"");
float STAT_INPUT_ISO_TRG_FZ1_14_WERT = (RXBUF_UCHAR(24)/100.0f);
// LI: first error time R_iso_plus_QUAL / LI: erstmaliger Fehlerzeitpunkt R_iso_plus_QUAL
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ISO_ERR_TRG_FZ1_2", "STAT_INPUT_ISO_TRG_FZ1_14_WERT", STAT_INPUT_ISO_TRG_FZ1_14_WERT, "");
unsigned short STAT_INPUT_ISO_TRG_FZ1_15_WERT = (RXBUF_UINT(25));
// LI: first error time R_iso_minus [kOhm] / LI: erstmaliger Fehlerzeitpunkt R_iso_minus [kOhm]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "ISO_ERR_TRG_FZ1_2", "STAT_INPUT_ISO_TRG_FZ1_15_WERT", STAT_INPUT_ISO_TRG_FZ1_15_WERT, "\"kOhm\"");
float STAT_INPUT_ISO_TRG_FZ1_16_WERT = (RXBUF_UCHAR(27)/100.0f);
// LI: first error time R_iso_minus_QUAL / LI: erstmaliger Fehlerzeitpunkt R_iso_minus_QUAL
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ISO_ERR_TRG_FZ1_2", "STAT_INPUT_ISO_TRG_FZ1_16_WERT", STAT_INPUT_ISO_TRG_FZ1_16_WERT, "");
float STAT_INPUT_ISO_TRG_FZ2_01_WERT = (RXBUF_UINT(28)/100.0f);
// LI: last error time Ubat01 [V] / LI: letztmaliger Fehlerzeitpunkt Ubat01 [V]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ISO_ERR_TRG_FZ1_2", "STAT_INPUT_ISO_TRG_FZ2_01_WERT", STAT_INPUT_ISO_TRG_FZ2_01_WERT, "\"V\"");
unsigned char STAT_INPUT_ISO_TRG_FZ2_02_WERT = (RXBUF_UCHAR(30));
// LI: last time the error occurred Ubat01_QUAL / LI: letztmaliger Fehlerzeitpunkt Ubat01_QUAL
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "ISO_ERR_TRG_FZ1_2", "STAT_INPUT_ISO_TRG_FZ2_02_WERT", STAT_INPUT_ISO_TRG_FZ2_02_WERT, "");
float STAT_INPUT_ISO_TRG_FZ2_03_WERT = (RXBUF_UINT(31)/100.0f);
// LI: last error time Ubat02 [V] / LI: letztmaliger Fehlerzeitpunkt Ubat02 [V]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ISO_ERR_TRG_FZ1_2", "STAT_INPUT_ISO_TRG_FZ2_03_WERT", STAT_INPUT_ISO_TRG_FZ2_03_WERT, "\"V\"");
unsigned char STAT_INPUT_ISO_TRG_FZ2_04_WERT = (RXBUF_UCHAR(33));
// LI: last time the error occurred Ubat02_QUAL / LI: letztmaliger Fehlerzeitpunkt Ubat02_QUAL
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "ISO_ERR_TRG_FZ1_2", "STAT_INPUT_ISO_TRG_FZ2_04_WERT", STAT_INPUT_ISO_TRG_FZ2_04_WERT, "");
float STAT_INPUT_ISO_TRG_FZ2_05_WERT = (RXBUF_UINT(34)/100.0f);
// LI: last time the error occurred Uiso01 [V] / LI: letztmaliger Fehlerzeitpunkt Uiso01 [V]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ISO_ERR_TRG_FZ1_2", "STAT_INPUT_ISO_TRG_FZ2_05_WERT", STAT_INPUT_ISO_TRG_FZ2_05_WERT, "\"V\"");
unsigned char STAT_INPUT_ISO_TRG_FZ2_06_WERT = (RXBUF_UCHAR(36));
// LI: last time the error occurred Uiso01_QUAL / LI: letztmaliger Fehlerzeitpunkt Uiso01_QUAL
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "ISO_ERR_TRG_FZ1_2", "STAT_INPUT_ISO_TRG_FZ2_06_WERT", STAT_INPUT_ISO_TRG_FZ2_06_WERT, "");
float STAT_INPUT_ISO_TRG_FZ2_07_WERT = (RXBUF_UINT(37)/100.0f);
// LI: last error time Uiso02 [V] / LI: letztmaliger Fehlerzeitpunkt Uiso02 [V]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ISO_ERR_TRG_FZ1_2", "STAT_INPUT_ISO_TRG_FZ2_07_WERT", STAT_INPUT_ISO_TRG_FZ2_07_WERT, "\"V\"");
unsigned char STAT_INPUT_ISO_TRG_FZ2_08_WERT = (RXBUF_UCHAR(39));
// LI: last time the error occurred Uiso02_QUAL / LI: letztmaliger Fehlerzeitpunkt Uiso02_QUAL
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "ISO_ERR_TRG_FZ1_2", "STAT_INPUT_ISO_TRG_FZ2_08_WERT", STAT_INPUT_ISO_TRG_FZ2_08_WERT, "");
float STAT_INPUT_ISO_TRG_FZ2_09_WERT = (RXBUF_UINT(40)/100.0f);
// LI: last error time Uoffset [V] / LI: letztmaliger Fehlerzeitpunkt Uoffset [V]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ISO_ERR_TRG_FZ1_2", "STAT_INPUT_ISO_TRG_FZ2_09_WERT", STAT_INPUT_ISO_TRG_FZ2_09_WERT, "\"V\"");
unsigned char STAT_INPUT_ISO_TRG_FZ2_10_WERT = (RXBUF_UCHAR(42));
// LI: last time the error occurred Uoffset_QUAL / LI: letztmaliger Fehlerzeitpunkt Uoffset_QUAL
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "ISO_ERR_TRG_FZ1_2", "STAT_INPUT_ISO_TRG_FZ2_10_WERT", STAT_INPUT_ISO_TRG_FZ2_10_WERT, "");
unsigned short STAT_INPUT_ISO_TRG_FZ2_11_WERT = (RXBUF_UINT(43));
// LI: last time the error occurred R_iso_ges [kOhm] / LI: letztmaliger Fehlerzeitpunkt R_iso_ges [kOhm]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "ISO_ERR_TRG_FZ1_2", "STAT_INPUT_ISO_TRG_FZ2_11_WERT", STAT_INPUT_ISO_TRG_FZ2_11_WERT, "\"kOhm\"");
unsigned char STAT_INPUT_ISO_TRG_FZ2_12_WERT = (RXBUF_UCHAR(45));
// LI: last time the error occurred R_iso_gesQUAL / LI: letztmaliger Fehlerzeitpunkt R_iso_gesQUAL
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "ISO_ERR_TRG_FZ1_2", "STAT_INPUT_ISO_TRG_FZ2_12_WERT", STAT_INPUT_ISO_TRG_FZ2_12_WERT, "");
unsigned short STAT_INPUT_ISO_TRG_FZ2_13_WERT = (RXBUF_UINT(46));
// LI: last time the error occurred R_iso_plus [kOhm] / LI: letztmaliger Fehlerzeitpunkt R_iso_plus [kOhm]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "ISO_ERR_TRG_FZ1_2", "STAT_INPUT_ISO_TRG_FZ2_13_WERT", STAT_INPUT_ISO_TRG_FZ2_13_WERT, "\"kOhm\"");
float STAT_INPUT_ISO_TRG_FZ2_14_WERT = (RXBUF_UCHAR(48)/100.0f);
// LI: last time the error occurred R_iso_plus_QUAL / LI: letztmaliger Fehlerzeitpunkt R_iso_plus_QUAL
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ISO_ERR_TRG_FZ1_2", "STAT_INPUT_ISO_TRG_FZ2_14_WERT", STAT_INPUT_ISO_TRG_FZ2_14_WERT, "");
unsigned short STAT_INPUT_ISO_TRG_FZ2_15_WERT = (RXBUF_UINT(49));
// LI: last time the error occurred R_iso_minus [kOhm] / LI: letztmaliger Fehlerzeitpunkt R_iso_minus [kOhm]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "ISO_ERR_TRG_FZ1_2", "STAT_INPUT_ISO_TRG_FZ2_15_WERT", STAT_INPUT_ISO_TRG_FZ2_15_WERT, "\"kOhm\"");
float STAT_INPUT_ISO_TRG_FZ2_16_WERT = (RXBUF_UCHAR(51)/100.0f);
// LI: last time the error occurred R_iso_minus_QUAL / LI: letztmaliger Fehlerzeitpunkt R_iso_minus_QUAL
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ISO_ERR_TRG_FZ1_2", "STAT_INPUT_ISO_TRG_FZ2_16_WERT", STAT_INPUT_ISO_TRG_FZ2_16_WERT, "");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_SCHUETZ_SCHALTER: { // 0xDD60
if (datalen < 1) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_SCHUETZ_SCHALTER", 1);
break;
}
unsigned char STAT_SCHUETZ_SCHALTER = (RXBUF_UCHAR(0));
// Contactor switch status: closed, open, welded contacts or not defined. For results see table
// TAB_SCHUETZ_SCHALTER / Status der Schützschalter: geschlossen, offen, verschweißte Kontakte oder nicht
// definiert. Ergebnisse siehe Tabelle TAB_SCHUETZ_SCHALTER
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "SCHUETZ_SCHALTER", "STAT_SCHUETZ_SCHALTER", STAT_SCHUETZ_SCHALTER, "\"0-n\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_SCHUETZSCHALTUNGEN_ANZAHL: { // 0xDD63
if (datalen < 8) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_SCHUETZSCHALTUNGEN_ANZAHL", 8);
break;
}
unsigned long STAT_ANZAHL_SCHALTUNGEN_WERT = (RXBUF_UINT32(0));
// Number of switchings of the contactor switch without load / Anzahl der Schaltungen der Schützschalter ohne
// Last
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "SCHUETZSCHALTUNGEN_ANZAHL", "STAT_ANZAHL_SCHALTUNGEN_WERT", STAT_ANZAHL_SCHALTUNGEN_WERT, "");
unsigned long STAT_ANZAHL_SCHALTUNGEN_LAST_WERT = (RXBUF_UINT32(4));
// Number of switchings of the contactor switch under load / Anzahl der Schaltungen der Schützschalter unter Last
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "SCHUETZSCHALTUNGEN_ANZAHL", "STAT_ANZAHL_SCHALTUNGEN_LAST_WERT", STAT_ANZAHL_SCHALTUNGEN_LAST_WERT, "");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_HVIL: { // 0xDD64
if (datalen < 1) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_HVIL", 1);
break;
}
unsigned char STAT_GUELTIG = (RXBUF_UCHAR(0));
// HVIL test result / Ergebnis HVIL-Prüfung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "HVIL", "STAT_GUELTIG", STAT_GUELTIG, "\"0-n\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_HV_SPANNUNG: { // 0xDD66
if (datalen < 2) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_HV_SPANNUNG", 2);
break;
}
float STAT_HV_SPANNUNG_WERT = (RXBUF_UINT(0)/100.0f);
// Intermediate circuit voltage to the HV connection plug, depending on the contactor status /
// Zwischenkreisspannung zum HV-Anschlussstecker, abhängig vom Schützzustand
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_SPANNUNG", "STAT_HV_SPANNUNG_WERT", STAT_HV_SPANNUNG_WERT, "\"V\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_ANZAHL_KUEHLANFORDERUNG_DRINGEND: { // 0xDD67
if (datalen < 1) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_ANZAHL_KUEHLANFORDERUNG_DRINGEND", 1);
break;
}
unsigned char STAT_ANZAHL_KUEHLANFORDERUNG_DRINGEND_WERT = (RXBUF_UCHAR(0));
// Number of consecutive wake cycles with urgent cooling requirements (service life max. Value) / Anzahl
// aufeinanderfolgenender Wachzyklen mit dringender Kühlanforderung (Lebensdauer-Max.wert)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "ANZAHL_KUEHLANFORDERUNG_DRINGEND", "STAT_ANZAHL_KUEHLANFORDERUNG_DRINGEND_WERT", STAT_ANZAHL_KUEHLANFORDERUNG_DRINGEND_WERT, "");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_HV_SPANNUNG_BERECHNET: { // 0xDD68
if (datalen < 2) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_HV_SPANNUNG_BERECHNET", 2);
break;
}
float STAT_HV_SPANNUNG_BERECHNET_WERT = (RXBUF_UINT(0)/100.0f);
// Battery voltage behind the contactors, regardless of the contactor status / Batteriespannung hinter den
// Schützen, unabhängig vom Schützzustand
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_SPANNUNG_BERECHNET", "STAT_HV_SPANNUNG_BERECHNET_WERT", STAT_HV_SPANNUNG_BERECHNET_WERT, "\"V\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_HV_STROM: { // 0xDD69
if (datalen < 4) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_HV_STROM", 4);
break;
}
float STAT_HV_STROM_WERT = (RXBUF_SINT32(0)/100.0f);
// HV current in A / HV-Strom in A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_STROM", "STAT_HV_STROM_WERT", STAT_HV_STROM_WERT, "\"A\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_ISOLATIONSWIDERSTAND: { // 0xDD6A
if (datalen < 9) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_ISOLATIONSWIDERSTAND", 9);
break;
}
unsigned short STAT_ISOWIDERSTAND_EXT_TRG_WERT = (RXBUF_UINT(0));
// Determined isoresistance from the overall system in the wake (closed contactors) / Ermittelter Isowiderstand
// vom Gesamtsystem im Nachlauf (geschlossene Schütze)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "ISOLATIONSWIDERSTAND", "STAT_ISOWIDERSTAND_EXT_TRG_WERT", STAT_ISOWIDERSTAND_EXT_TRG_WERT, "\"kOhm\"");
unsigned short STAT_ISOWIDERSTAND_EXT_STD_WERT = (RXBUF_UINT(2));
// Determined isoresistance of the overall system in operation (closed contactors) / Ermittelter Isowiderstand
// vom Gesamtsystem im Betrieb (geschlossene Schütze)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "ISOLATIONSWIDERSTAND", "STAT_ISOWIDERSTAND_EXT_STD_WERT", STAT_ISOWIDERSTAND_EXT_STD_WERT, "\"kOhm\"");
unsigned short STAT_ISOWIDERSTAND_INT_WERT = (RXBUF_UINT(4));
// Determined internal isoresistance (open contactors); is only measured on request via the STEUERN_ISOLATION
// service routine with open contactors / Ermittelter interner Isowiderstand (offene Schütze); wird nur auf
// Anfrage per Service-Routine STEUERN_ISOLATION bei offenen Schützen gemessen
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "ISOLATIONSWIDERSTAND", "STAT_ISOWIDERSTAND_INT_WERT", STAT_ISOWIDERSTAND_INT_WERT, "\"kOhm\"");
unsigned char STAT_ISOWIDERSTAND_EXT_TRG_PLAUS = (RXBUF_UCHAR(6));
// Entire system after-run: 0 = insulation resistance implausible, 1 = insulation resistance plausible /
// Gesamtsystem im Nachlauf: 0 = Isolationswiderstand nicht plausibel, 1 = Isolationswiderstand plausibel
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "ISOLATIONSWIDERSTAND", "STAT_ISOWIDERSTAND_EXT_TRG_PLAUS", STAT_ISOWIDERSTAND_EXT_TRG_PLAUS, "\"0/1\"");
unsigned char STAT_ISOWIDERSTAND_EXT_STD_PLAUS = (RXBUF_UCHAR(7));
// Overall system in operation: 0 = insulation resistance not plausible, 1 = insulation resistance plausible /
// Gesamtsystem im Betrieb: 0 = Isolationswiderstand nicht plausibel, 1 = Isolationswiderstand plausibel
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "ISOLATIONSWIDERSTAND", "STAT_ISOWIDERSTAND_EXT_STD_PLAUS", STAT_ISOWIDERSTAND_EXT_STD_PLAUS, "\"0/1\"");
unsigned char STAT_ISOWIDERSTAND_INT_PLAUS = (RXBUF_UCHAR(8));
// Internal: 0 = insulation resistance not plausible, 1 = insulation resistance plausible; is only measured on
// request via the STEUERN_ISOLATION service routine with open contactors / Intern: 0 = Isolationswiderstand
// nicht plausibel, 1 = Isolationswiderstand plausibel; wird nur auf Anfrage per Service-Routine
// STEUERN_ISOLATION bei offenen Schützen gemessen
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "ISOLATIONSWIDERSTAND", "STAT_ISOWIDERSTAND_INT_PLAUS", STAT_ISOWIDERSTAND_INT_PLAUS, "\"0/1\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_KUEHLKREISLAUF_TEMP: { // 0xDD6C
if (datalen < 2) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_KUEHLKREISLAUF_TEMP", 2);
break;
}
float STAT_TEMP_KUEHLKREISLAUF_WERT = (RXBUF_SINT(0)/100.0f);
// Temperature of the cooling medium in ° C (327.67 = implausible) / Temperatur des Kühlmediums in °C (327,67 =
// unplausibel)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "KUEHLKREISLAUF_TEMP", "STAT_TEMP_KUEHLKREISLAUF_WERT", STAT_TEMP_KUEHLKREISLAUF_WERT, "\"°C\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_AUFSTART_VERHINDERER: { // 0xDD72
if (datalen < 1) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_AUFSTART_VERHINDERER", 1);
break;
}
unsigned char STAT_AUFSTART_VERHINDERER = (RXBUF_UCHAR(0));
// Reason for not starting the HV system / Grund für nicht Aufstarten des HV-Systems
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "AUFSTART_VERHINDERER", "STAT_AUFSTART_VERHINDERER", STAT_AUFSTART_VERHINDERER, "\"0-n\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_CUMULATIVE_LADUNG: { // 0xDD73
if (datalen < 4) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_CUMULATIVE_LADUNG", 4);
break;
}
float STAT_LADUNG_AMP_STUNDEN_WERT = (RXBUF_UINT32(0)/3600.0f);
// The accumulated charge for charges in Ah / Die kumulierte Ladung für Ladevorgänge in Ah
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "CUMULATIVE_LADUNG", "STAT_LADUNG_AMP_STUNDEN_WERT", STAT_LADUNG_AMP_STUNDEN_WERT, "\"Ah\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_CUMULATIVE_ENTLADUNG: { // 0xDD74
if (datalen < 4) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_CUMULATIVE_ENTLADUNG", 4);
break;
}
float STAT_ENTLADUNG_AMP_STUNDEN_WERT = (RXBUF_UINT32(0)/3600.0f);
// The accumulated charge for discharges in Ah / Die kumulierte Ladung für Entladevorgänge in Ah
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "CUMULATIVE_ENTLADUNG", "STAT_ENTLADUNG_AMP_STUNDEN_WERT", STAT_ENTLADUNG_AMP_STUNDEN_WERT, "\"Ah\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_STATUS_KL30C_SPANNUNG: { // 0xDD76
if (datalen < 1) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_STATUS_KL30C_SPANNUNG", 1);
break;
}
float STAT_KL30C_SPANNUNG_WERT = (RXBUF_UCHAR(0)/10.0f);
// Voltage terminal 30C in V / Spannung Klemme 30C in V
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "STATUS_KL30C_SPANNUNG", "STAT_KL30C_SPANNUNG_WERT", STAT_KL30C_SPANNUNG_WERT, "\"V\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_ALTERUNG_KAPAZITAET: { // 0xDD7B
if (datalen < 1) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_ALTERUNG_KAPAZITAET", 1);
break;
}
unsigned char STAT_KAPAZITAET_WERT_0XDD7B = (RXBUF_UCHAR(0));
// Readout of the battery capacity adjustment / Auslesen der Justierung Kapazität Batterie
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "ALTERUNG_KAPAZITAET", "STAT_KAPAZITAET_WERT_0XDD7B", STAT_KAPAZITAET_WERT_0XDD7B, "\"%\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_GW_INFO: { // 0xDD7C
if (datalen < 85) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_GW_INFO", 85);
break;
}
float STAT_LEISTUNG_MAX_WERT = (RXBUF_UINT(0)*1000.0f);
// Predefined maximum power value in watts (project-specific, on the overall storage level) / Vordefinierter
// maximaler Leistungswert in Watt (projektspezifisch, auf Gesamtspeicherebene)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "GW_INFO", "STAT_LEISTUNG_MAX_WERT", STAT_LEISTUNG_MAX_WERT, "\"W\"");
unsigned long STAT_ZEIT_POWER_DCHG_1_WERT = (RXBUF_UINT32(2));
// Duration in performance class in the discharge process (on the total storage level): 0 <P <= Pmax * 0.16 /
// Dauer in Leistungsklasse im Entladevorgang (auf Gesamtspeicherebene): 0 < P <= Pmax*0.16
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "GW_INFO", "STAT_ZEIT_POWER_DCHG_1_WERT", STAT_ZEIT_POWER_DCHG_1_WERT, "\"min\"");
unsigned long STAT_ZEIT_POWER_DCHG_2_WERT = (RXBUF_UINT32(6));
// Duration in performance class in the discharge process (on the total storage level): Pmax * 0.16 <P <= Pmax *
// 0.33 / Dauer in Leistungsklasse im Entladevorgang (auf Gesamtspeicherebene): Pmax*0.16 < P <= Pmax*0.33
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "GW_INFO", "STAT_ZEIT_POWER_DCHG_2_WERT", STAT_ZEIT_POWER_DCHG_2_WERT, "\"min\"");
unsigned long STAT_ZEIT_POWER_DCHG_3_WERT = (RXBUF_UINT32(10));
// Duration in performance class in the discharge process (on total storage level): Pmax * 0.33 <P <= Pmax * 0.5
// / Dauer in Leistungsklasse im Entladevorgang (auf Gesamtspeicherebene): Pmax*0.33 < P <= Pmax*0.5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "GW_INFO", "STAT_ZEIT_POWER_DCHG_3_WERT", STAT_ZEIT_POWER_DCHG_3_WERT, "\"min\"");
unsigned long STAT_ZEIT_POWER_DCHG_4_WERT = (RXBUF_UINT32(14));
// Duration in performance class in the discharge process (on total storage level): Pmax * 0.5 <P <= Pmax * 0.66
// / Dauer in Leistungsklasse im Entladevorgang (auf Gesamtspeicherebene): Pmax*0.5 < P <= Pmax*0.66
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "GW_INFO", "STAT_ZEIT_POWER_DCHG_4_WERT", STAT_ZEIT_POWER_DCHG_4_WERT, "\"min\"");
unsigned long STAT_ZEIT_POWER_DCHG_5_WERT = (RXBUF_UINT32(18));
// Duration in performance class in the discharge process (on the total storage level): Pmax * 0.66 <P <= Pmax *
// 0.80 / Dauer in Leistungsklasse im Entladevorgang (auf Gesamtspeicherebene): Pmax*0.66 < P <= Pmax*0.80
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "GW_INFO", "STAT_ZEIT_POWER_DCHG_5_WERT", STAT_ZEIT_POWER_DCHG_5_WERT, "\"min\"");
unsigned long STAT_ZEIT_POWER_DCHG_6_WERT = (RXBUF_UINT32(22));
// Duration in performance class in the discharge process (on the total storage level): Pmax * 0.80 <P <= Pmax /
// Dauer in Leistungsklasse im Entladevorgang (auf Gesamtspeicherebene): Pmax*0.80 < P <= Pmax
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "GW_INFO", "STAT_ZEIT_POWER_DCHG_6_WERT", STAT_ZEIT_POWER_DCHG_6_WERT, "\"min\"");
unsigned long STAT_ZEIT_POWER_DCHG_7_WERT = (RXBUF_UINT32(26));
// Duration in performance class in the discharging process (on total storage level): P> Pmax / Dauer in
// Leistungsklasse im Entladevorgang (auf Gesamtspeicherebene): P > Pmax
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "GW_INFO", "STAT_ZEIT_POWER_DCHG_7_WERT", STAT_ZEIT_POWER_DCHG_7_WERT, "\"min\"");
unsigned long STAT_ZEIT_POWER_CHG_1_WERT = (RXBUF_UINT32(30));
// Duration in performance class in the charging process (on the total storage level): 0 <P <= Pmax * 0.16 /
// Dauer in Leistungsklasse im Ladevorgang (auf Gesamtspeicherebene): 0 < P <= Pmax*0.16
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "GW_INFO", "STAT_ZEIT_POWER_CHG_1_WERT", STAT_ZEIT_POWER_CHG_1_WERT, "\"min\"");
unsigned long STAT_ZEIT_POWER_CHG_2_WERT = (RXBUF_UINT32(34));
// Duration in performance class in the charging process (on total storage level): Pmax * 0.16 <P <= Pmax * 0.33
// / Dauer in Leistungsklasse im Ladevorgang (auf Gesamtspeicherebene): Pmax*0.16 < P <= Pmax*0.33
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "GW_INFO", "STAT_ZEIT_POWER_CHG_2_WERT", STAT_ZEIT_POWER_CHG_2_WERT, "\"min\"");
unsigned long STAT_ZEIT_POWER_CHG_3_WERT = (RXBUF_UINT32(38));
// Duration in performance class in the charging process (on total storage level): Pmax * 0.33 <P <= Pmax * 0.5 /
// Dauer in Leistungsklasse im Ladevorgang (auf Gesamtspeicherebene): Pmax*0.33 < P <= Pmax*0.5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "GW_INFO", "STAT_ZEIT_POWER_CHG_3_WERT", STAT_ZEIT_POWER_CHG_3_WERT, "\"min\"");
unsigned long STAT_ZEIT_POWER_CHG_4_WERT = (RXBUF_UINT32(42));
// Duration in performance class in the charging process (on total storage level): Pmax * 0.5 <P <= Pmax * 0.66 /
// Dauer in Leistungsklasse im Ladevorgang (auf Gesamtspeicherebene): Pmax*0.5 < P <= Pmax*0.66
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "GW_INFO", "STAT_ZEIT_POWER_CHG_4_WERT", STAT_ZEIT_POWER_CHG_4_WERT, "\"min\"");
unsigned long STAT_ZEIT_POWER_CHG_5_WERT = (RXBUF_UINT32(46));
// Duration in performance class in the charging process (on the total storage level): Pmax * 0.66 <P <= Pmax *
// 0.80 / Dauer in Leistungsklasse im Ladevorgang (auf Gesamtspeicherebene): Pmax*0.66 < P <= Pmax*0.80
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "GW_INFO", "STAT_ZEIT_POWER_CHG_5_WERT", STAT_ZEIT_POWER_CHG_5_WERT, "\"min\"");
unsigned long STAT_ZEIT_POWER_CHG_6_WERT = (RXBUF_UINT32(50));
// Duration in performance class in the charging process (on total storage level): Pmax * 0.80 <P <= Pmax / Dauer
// in Leistungsklasse im Ladevorgang (auf Gesamtspeicherebene): Pmax*0.80 < P <= Pmax
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "GW_INFO", "STAT_ZEIT_POWER_CHG_6_WERT", STAT_ZEIT_POWER_CHG_6_WERT, "\"min\"");
unsigned long STAT_ZEIT_POWER_CHG_7_WERT = (RXBUF_UINT32(54));
// Duration in performance class in the charging process (on the total storage level): P> Pmax / Dauer in
// Leistungsklasse im Ladevorgang (auf Gesamtspeicherebene): P > Pmax
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "GW_INFO", "STAT_ZEIT_POWER_CHG_7_WERT", STAT_ZEIT_POWER_CHG_7_WERT, "\"min\"");
unsigned char STAT_UCELLMAX_EIN = (RXBUF_UCHAR(58));
// Limit violation of the max. Single cell voltage occurred (1 = yes / 0 = no). / GW-Grenzverletzung der max.
// Einzelzellspannung eingetreten (1 = ja / 0 = nein).
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "GW_INFO", "STAT_UCELLMAX_EIN", STAT_UCELLMAX_EIN, "\"0/1\"");
unsigned char STAT_UCELLMIN_EIN = (RXBUF_UCHAR(59));
// Limit violation of the min. Single cell voltage occurred (1 = yes / 0 = no). / GW-Grenzverletzung der min.
// Einzelzellspannung eingetreten (1 = ja / 0 = nein).
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "GW_INFO", "STAT_UCELLMIN_EIN", STAT_UCELLMIN_EIN, "\"0/1\"");
unsigned long STAT_KM_STAND_WERT = (RXBUF_UINT32(60));
// Mileage / Kilometerstand
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "GW_INFO", "STAT_KM_STAND_WERT", STAT_KM_STAND_WERT, "\"km\"");
float STAT_IMAX_DCHG_WERT = (RXBUF_UINT32(64)/100.0f);
// maximum measured discharge current over lifetime / maximal gemessener Entladestrom über Lebenszeit
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "GW_INFO", "STAT_IMAX_DCHG_WERT", STAT_IMAX_DCHG_WERT, "\"A\"");
float STAT_IMAX_CHG_WERT = (RXBUF_UINT32(68)/100.0f);
// maximum measured charging current over lifetime / maximal gemessener Ladestrom über Lebenszeit
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "GW_INFO", "STAT_IMAX_CHG_WERT", STAT_IMAX_CHG_WERT, "\"A\"");
unsigned char STAT_IMAX_LAD_ERROR_EIN = (RXBUF_UCHAR(72));
// Limit violation of the maximum permitted charging current exceeded (1 = yes / 0 = no) / GW-Grenzverletzung des
// maximal erlaubten Ladestroms überschritten (1 = ja / 0 = nein)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "GW_INFO", "STAT_IMAX_LAD_ERROR_EIN", STAT_IMAX_LAD_ERROR_EIN, "\"0/1\"");
unsigned char STAT_TMAX_ERROR_OP_EIN = (RXBUF_UCHAR(73));
// maximum permitted temperature exceeded during operation (1 = yes, 0 = no) / maximal erlaubte Temperatur
// während Betrieb überschritten (1 = ja, 0 = nein)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "GW_INFO", "STAT_TMAX_ERROR_OP_EIN", STAT_TMAX_ERROR_OP_EIN, "\"0/1\"");
unsigned char STAT_TMAX_ERROR_NO_OP_EIN = (RXBUF_UCHAR(74));
// maximum allowed temperature exceeded without operation (1 = yes, 0 = no) / maximal erlaubte Temperatur ohne
// Betrieb überschritten (1 = ja, 0 = nein)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "GW_INFO", "STAT_TMAX_ERROR_NO_OP_EIN", STAT_TMAX_ERROR_NO_OP_EIN, "\"0/1\"");
unsigned char STAT_TMIN_ERROR_OP_EIN = (RXBUF_UCHAR(75));
// Minimum permitted temperature undercut during operation (1 = yes, 0 = no) / minimal erlaubte Temperatur
// während Betrieb unterschritten (1 = ja, 0 = nein)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "GW_INFO", "STAT_TMIN_ERROR_OP_EIN", STAT_TMIN_ERROR_OP_EIN, "\"0/1\"");
unsigned char STAT_TMIN_ERROR_NO_OP_EIN = (RXBUF_UCHAR(76));
// below minimum allowed temperature without operation (1 = yes, 0 = no) / minimal erlaubte Temperatur ohne
// Betrieb unterschritten (1 = ja, 0 = nein)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "GW_INFO", "STAT_TMIN_ERROR_NO_OP_EIN", STAT_TMIN_ERROR_NO_OP_EIN, "\"0/1\"");
float STAT_CUMULATIVE_ENERGIE_LADUNG_WERT = (RXBUF_UINT32(77)*36.0f);
// Value of the accumulated energy for charging processes / Wert der kumulierten Energie für Ladevorgänge
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "GW_INFO", "STAT_CUMULATIVE_ENERGIE_LADUNG_WERT", STAT_CUMULATIVE_ENERGIE_LADUNG_WERT, "\"Ws\"");
float STAT_CUMULATIVE_ENERGIE_ENTLADUNG_WERT = (RXBUF_UINT32(81)*36.0f);
// Value of the accumulated energy for discharges / Wert der kumulierten Energie für Entladevorgänge
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "GW_INFO", "STAT_CUMULATIVE_ENERGIE_ENTLADUNG_WERT", STAT_CUMULATIVE_ENERGIE_ENTLADUNG_WERT, "\"Ws\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_STROMGRENZEN: { // 0xDD7D
if (datalen < 4) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_STROMGRENZEN", 4);
break;
}
float STAT_LADESTROMGRENZE_WERT = (RXBUF_UINT(0)/10.0f);
// maximum permitted charging current / maximal erlaubter Ladestrom
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "STROMGRENZEN", "STAT_LADESTROMGRENZE_WERT", STAT_LADESTROMGRENZE_WERT, "\"A\"");
float STAT_ENTLADESTROMGRENZE_WERT = (RXBUF_UINT(2)/10.0f);
// maximum permitted discharge current / maximal erlaubter Entladesstrom
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "STROMGRENZEN", "STAT_ENTLADESTROMGRENZE_WERT", STAT_ENTLADESTROMGRENZE_WERT, "\"A\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_SPANNUNGSGRENZEN: { // 0xDD7E
if (datalen < 4) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_SPANNUNGSGRENZEN", 4);
break;
}
float STAT_LADESPANNUNGSGRENZE_WERT = (RXBUF_UINT(0)/100.0f);
// maximum allowed charging voltage / maximal erlaubte Ladespannung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "SPANNUNGSGRENZEN", "STAT_LADESPANNUNGSGRENZE_WERT", STAT_LADESPANNUNGSGRENZE_WERT, "\"V\"");
float STAT_ENTLADESPANNUNGSGRENZE_WERT = (RXBUF_UINT(2)/100.0f);
// maximum permitted discharge voltage / maximal erlaubte Entladespannung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "SPANNUNGSGRENZEN", "STAT_ENTLADESPANNUNGSGRENZE_WERT", STAT_ENTLADESPANNUNGSGRENZE_WERT, "\"V\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_HVB_HISTORIE_ZYKLEN: { // 0xDD8E
if (datalen < 116) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_HVB_HISTORIE_ZYKLEN", 116);
break;
}
unsigned long STAT_SUM_OF_SOC_CHARGE_1_WERT = (RXBUF_UINT32(0));
// obsolete, replacement: STATUS_ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB and STATUS_CUMULATIVE_LADUNG. / veraltet,
// Ersatz: STATUS_ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB und STATUS_CUMULATIVE_LADUNG.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HVB_HISTORIE_ZYKLEN", "STAT_SUM_OF_SOC_CHARGE_1_WERT", STAT_SUM_OF_SOC_CHARGE_1_WERT, "");
unsigned long STAT_SUM_OF_SOC_CHARGE_2_WERT = (RXBUF_UINT32(4));
// obsolete, replacement: STATUS_ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB and STATUS_CUMULATIVE_LADUNG. / veraltet,
// Ersatz: STATUS_ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB und STATUS_CUMULATIVE_LADUNG.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HVB_HISTORIE_ZYKLEN", "STAT_SUM_OF_SOC_CHARGE_2_WERT", STAT_SUM_OF_SOC_CHARGE_2_WERT, "");
unsigned long STAT_SUM_OF_SOC_CHARGE_3_WERT = (RXBUF_UINT32(8));
// obsolete, replacement: STATUS_ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB and STATUS_CUMULATIVE_LADUNG. / veraltet,
// Ersatz: STATUS_ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB und STATUS_CUMULATIVE_LADUNG.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HVB_HISTORIE_ZYKLEN", "STAT_SUM_OF_SOC_CHARGE_3_WERT", STAT_SUM_OF_SOC_CHARGE_3_WERT, "");
unsigned long STAT_SUM_OF_SOC_CHARGE_4_WERT = (RXBUF_UINT32(12));
// obsolete, replacement: STATUS_ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB and STATUS_CUMULATIVE_LADUNG. / veraltet,
// Ersatz: STATUS_ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB und STATUS_CUMULATIVE_LADUNG.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HVB_HISTORIE_ZYKLEN", "STAT_SUM_OF_SOC_CHARGE_4_WERT", STAT_SUM_OF_SOC_CHARGE_4_WERT, "");
unsigned long STAT_SUM_OF_SOC_CHARGE_5_WERT = (RXBUF_UINT32(16));
// obsolete, replacement: STATUS_ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB and STATUS_CUMULATIVE_LADUNG. / veraltet,
// Ersatz: STATUS_ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB und STATUS_CUMULATIVE_LADUNG.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HVB_HISTORIE_ZYKLEN", "STAT_SUM_OF_SOC_CHARGE_5_WERT", STAT_SUM_OF_SOC_CHARGE_5_WERT, "");
unsigned long STAT_SUM_OF_SOC_CHARGE_6_WERT = (RXBUF_UINT32(20));
// obsolete, replacement: STATUS_ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB and STATUS_CUMULATIVE_LADUNG. / veraltet,
// Ersatz: STATUS_ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB und STATUS_CUMULATIVE_LADUNG.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HVB_HISTORIE_ZYKLEN", "STAT_SUM_OF_SOC_CHARGE_6_WERT", STAT_SUM_OF_SOC_CHARGE_6_WERT, "");
unsigned long STAT_SUM_OF_SOC_CHARGE_7_WERT = (RXBUF_UINT32(24));
// obsolete, replacement: STATUS_ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB and STATUS_CUMULATIVE_LADUNG. / veraltet,
// Ersatz: STATUS_ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB und STATUS_CUMULATIVE_LADUNG.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HVB_HISTORIE_ZYKLEN", "STAT_SUM_OF_SOC_CHARGE_7_WERT", STAT_SUM_OF_SOC_CHARGE_7_WERT, "");
unsigned long STAT_SUM_OF_SOC_CHARGE_8_WERT = (RXBUF_UINT32(28));
// obsolete, replacement: STATUS_ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB and STATUS_CUMULATIVE_LADUNG. / veraltet,
// Ersatz: STATUS_ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB und STATUS_CUMULATIVE_LADUNG.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HVB_HISTORIE_ZYKLEN", "STAT_SUM_OF_SOC_CHARGE_8_WERT", STAT_SUM_OF_SOC_CHARGE_8_WERT, "");
unsigned long STAT_SUM_OF_SOC_CHARGE_9_WERT = (RXBUF_UINT32(32));
// obsolete, replacement: STATUS_ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB and STATUS_CUMULATIVE_LADUNG. / veraltet,
// Ersatz: STATUS_ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB und STATUS_CUMULATIVE_LADUNG.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HVB_HISTORIE_ZYKLEN", "STAT_SUM_OF_SOC_CHARGE_9_WERT", STAT_SUM_OF_SOC_CHARGE_9_WERT, "");
unsigned long STAT_SUM_OF_SOC_CHARGE_10_WERT = (RXBUF_UINT32(36));
// obsolete, replacement: STATUS_ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB and STATUS_CUMULATIVE_LADUNG. / veraltet,
// Ersatz: STATUS_ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB und STATUS_CUMULATIVE_LADUNG.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HVB_HISTORIE_ZYKLEN", "STAT_SUM_OF_SOC_CHARGE_10_WERT", STAT_SUM_OF_SOC_CHARGE_10_WERT, "");
unsigned long STAT_SUM_OF_SOC_DISCHARGE_1_WERT = (RXBUF_UINT32(40));
// obsolete, replacement: STATUS_ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB and STATUS_CUMULATIVE_ENTLADUNG. /
// veraltet, Ersatz: STATUS_ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB und STATUS_CUMULATIVE_ENTLADUNG.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HVB_HISTORIE_ZYKLEN", "STAT_SUM_OF_SOC_DISCHARGE_1_WERT", STAT_SUM_OF_SOC_DISCHARGE_1_WERT, "");
unsigned long STAT_SUM_OF_SOC_DISCHARGE_2_WERT = (RXBUF_UINT32(44));
// obsolete, replacement: STATUS_ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB and STATUS_CUMULATIVE_ENTLADUNG. /
// veraltet, Ersatz: STATUS_ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB und STATUS_CUMULATIVE_ENTLADUNG.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HVB_HISTORIE_ZYKLEN", "STAT_SUM_OF_SOC_DISCHARGE_2_WERT", STAT_SUM_OF_SOC_DISCHARGE_2_WERT, "");
unsigned long STAT_SUM_OF_SOC_DISCHARGE_3_WERT = (RXBUF_UINT32(48));
// obsolete, replacement: STATUS_ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB and STATUS_CUMULATIVE_ENTLADUNG. /
// veraltet, Ersatz: STATUS_ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB und STATUS_CUMULATIVE_ENTLADUNG.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HVB_HISTORIE_ZYKLEN", "STAT_SUM_OF_SOC_DISCHARGE_3_WERT", STAT_SUM_OF_SOC_DISCHARGE_3_WERT, "");
unsigned long STAT_SUM_OF_SOC_DISCHARGE_4_WERT = (RXBUF_UINT32(52));
// obsolete, replacement: STATUS_ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB and STATUS_CUMULATIVE_ENTLADUNG. /
// veraltet, Ersatz: STATUS_ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB und STATUS_CUMULATIVE_ENTLADUNG.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HVB_HISTORIE_ZYKLEN", "STAT_SUM_OF_SOC_DISCHARGE_4_WERT", STAT_SUM_OF_SOC_DISCHARGE_4_WERT, "");
unsigned long STAT_SUM_OF_SOC_DISCHARGE_5_WERT = (RXBUF_UINT32(56));
// obsolete, replacement: STATUS_ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB and STATUS_CUMULATIVE_ENTLADUNG. /
// veraltet, Ersatz: STATUS_ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB und STATUS_CUMULATIVE_ENTLADUNG.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HVB_HISTORIE_ZYKLEN", "STAT_SUM_OF_SOC_DISCHARGE_5_WERT", STAT_SUM_OF_SOC_DISCHARGE_5_WERT, "");
unsigned long STAT_SUM_OF_SOC_DISCHARGE_6_WERT = (RXBUF_UINT32(60));
// obsolete, replacement: STATUS_ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB and STATUS_CUMULATIVE_ENTLADUNG. /
// veraltet, Ersatz: STATUS_ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB und STATUS_CUMULATIVE_ENTLADUNG.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HVB_HISTORIE_ZYKLEN", "STAT_SUM_OF_SOC_DISCHARGE_6_WERT", STAT_SUM_OF_SOC_DISCHARGE_6_WERT, "");
unsigned long STAT_SUM_OF_SOC_DISCHARGE_7_WERT = (RXBUF_UINT32(64));
// obsolete, replacement: STATUS_ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB and STATUS_CUMULATIVE_ENTLADUNG. /
// veraltet, Ersatz: STATUS_ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB und STATUS_CUMULATIVE_ENTLADUNG.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HVB_HISTORIE_ZYKLEN", "STAT_SUM_OF_SOC_DISCHARGE_7_WERT", STAT_SUM_OF_SOC_DISCHARGE_7_WERT, "");
unsigned long STAT_SUM_OF_SOC_DISCHARGE_8_WERT = (RXBUF_UINT32(68));
// obsolete, replacement: STATUS_ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB and STATUS_CUMULATIVE_ENTLADUNG. /
// veraltet, Ersatz: STATUS_ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB und STATUS_CUMULATIVE_ENTLADUNG.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HVB_HISTORIE_ZYKLEN", "STAT_SUM_OF_SOC_DISCHARGE_8_WERT", STAT_SUM_OF_SOC_DISCHARGE_8_WERT, "");
unsigned long STAT_SUM_OF_SOC_DISCHARGE_9_WERT = (RXBUF_UINT32(72));
// obsolete, replacement: STATUS_ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB and STATUS_CUMULATIVE_ENTLADUNG. /
// veraltet, Ersatz: STATUS_ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB und STATUS_CUMULATIVE_ENTLADUNG.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HVB_HISTORIE_ZYKLEN", "STAT_SUM_OF_SOC_DISCHARGE_9_WERT", STAT_SUM_OF_SOC_DISCHARGE_9_WERT, "");
unsigned long STAT_SUM_OF_SOC_DISCHARGE_10_WERT = (RXBUF_UINT32(76));
// obsolete, replacement: STATUS_ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB and STATUS_CUMULATIVE_ENTLADUNG. /
// veraltet, Ersatz: STATUS_ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB und STATUS_CUMULATIVE_ENTLADUNG.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HVB_HISTORIE_ZYKLEN", "STAT_SUM_OF_SOC_DISCHARGE_10_WERT", STAT_SUM_OF_SOC_DISCHARGE_10_WERT, "");
float STAT_STROM_MAX_WERT = (RXBUF_SINT(80)/10.0f);
// Predefined maximum current value in amperes (project-specific) / Vorderfinierter maximaler Stromwert in Ampere
// (projektspezifisch)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HVB_HISTORIE_ZYKLEN", "STAT_STROM_MAX_WERT", STAT_STROM_MAX_WERT, "\"A\"");
float STAT_STROM_MIN_WERT = (RXBUF_SINT(82)/10.0f);
// Pre-defined minimum current value in amperes (project-specific) / Vorderfinierter minimaler Stromwert in
// Ampere (projektspezifisch)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HVB_HISTORIE_ZYKLEN", "STAT_STROM_MIN_WERT", STAT_STROM_MIN_WERT, "\"A\"");
unsigned long STAT_I_HISTO_1_WERT = (RXBUF_UINT32(84));
// Duration current class I <= Imin / Dauer Stromklasse I < =Imin
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HVB_HISTORIE_ZYKLEN", "STAT_I_HISTO_1_WERT", STAT_I_HISTO_1_WERT, "\"min\"");
unsigned long STAT_I_HISTO_2_WERT = (RXBUF_UINT32(88));
// Duration current class Imin <I <= Imin * 0.5 / Dauer Stromklasse Imin < I <= Imin*0.5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HVB_HISTORIE_ZYKLEN", "STAT_I_HISTO_2_WERT", STAT_I_HISTO_2_WERT, "\"min\"");
unsigned long STAT_I_HISTO_3_WERT = (RXBUF_UINT32(92));
// Duration current class Imin * 0.5 <I <= Imin * 0.03 / Dauer Stromklasse Imin*0.5 < I <= Imin*0.03
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HVB_HISTORIE_ZYKLEN", "STAT_I_HISTO_3_WERT", STAT_I_HISTO_3_WERT, "\"min\"");
unsigned long STAT_I_HISTO_4_WERT = (RXBUF_UINT32(96));
// Duration current class in Imin * 0.03 <I <= 0 / Dauer Stromklasse in Imin*0.03 < I <= 0
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HVB_HISTORIE_ZYKLEN", "STAT_I_HISTO_4_WERT", STAT_I_HISTO_4_WERT, "\"min\"");
unsigned long STAT_I_HISTO_5_WERT = (RXBUF_UINT32(100));
// Duration current class 0 <I <= Imax * 0.01 / Dauer Stromklasse 0 < I <= Imax*0.01
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HVB_HISTORIE_ZYKLEN", "STAT_I_HISTO_5_WERT", STAT_I_HISTO_5_WERT, "\"min\"");
unsigned long STAT_I_HISTO_6_WERT = (RXBUF_UINT32(104));
// Duration current class Imax * 0.01 <I <= Imax * 0.16 / Dauer Stromklasse Imax*0.01 < I <= Imax*0.16
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HVB_HISTORIE_ZYKLEN", "STAT_I_HISTO_6_WERT", STAT_I_HISTO_6_WERT, "\"min\"");
unsigned long STAT_I_HISTO_7_WERT = (RXBUF_UINT32(108));
// Duration current class Imax * 0.16 <I <= Imax * 0.32 / Dauer Stromklasse Imax*0.16 < I <= Imax*0.32
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HVB_HISTORIE_ZYKLEN", "STAT_I_HISTO_7_WERT", STAT_I_HISTO_7_WERT, "\"min\"");
unsigned long STAT_I_HISTO_8_WERT = (RXBUF_UINT32(112));
// Duration current class I> = Imax * 0.32 / Dauer Stromklasse I > =Imax*0.32
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HVB_HISTORIE_ZYKLEN", "STAT_I_HISTO_8_WERT", STAT_I_HISTO_8_WERT, "\"min\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_ZEIT_TEMP_HISTOGRAMM: { // 0xDD90
if (datalen < 112) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_ZEIT_TEMP_HISTOGRAMM", 112);
break;
}
unsigned long STAT_ZEIT_TEMP_TOTAL_1_WERT = (RXBUF_UINT32(0));
// Time in temperature class T <= - 25 ° C with the control unit awake and asleep / Zeit in Temperaturklasse
// T<=-25°C bei wachem und schlafenden Steuergerät
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ZEIT_TEMP_HISTOGRAMM", "STAT_ZEIT_TEMP_TOTAL_1_WERT", STAT_ZEIT_TEMP_TOTAL_1_WERT, "\"min\"");
unsigned long STAT_ZEIT_TEMP_TOTAL_2_WERT = (RXBUF_UINT32(4));
// Time in temperature class -25 ° C <T <= - 10 ° C with the control unit awake and asleep / Zeit in
// Temperaturklasse -25°C<T<=-10°C bei wachem und schlafenden Steuergerät
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ZEIT_TEMP_HISTOGRAMM", "STAT_ZEIT_TEMP_TOTAL_2_WERT", STAT_ZEIT_TEMP_TOTAL_2_WERT, "\"min\"");
unsigned long STAT_ZEIT_TEMP_TOTAL_3_WERT = (RXBUF_UINT32(8));
// Time in temperature class -10 ° C <T <= 0 ° C with the control unit awake and asleep / Zeit in
// Temperaturklasse -10°C<T<=0°C bei wachem und schlafenden Steuergerät
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ZEIT_TEMP_HISTOGRAMM", "STAT_ZEIT_TEMP_TOTAL_3_WERT", STAT_ZEIT_TEMP_TOTAL_3_WERT, "\"min\"");
unsigned long STAT_ZEIT_TEMP_TOTAL_4_WERT = (RXBUF_UINT32(12));
// Time in temperature class 0 ° C <T <= 10 ° C with the control unit awake and asleep / Zeit in Temperaturklasse
// 0°C<T<=10°C bei wachem und schlafenden Steuergerät
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ZEIT_TEMP_HISTOGRAMM", "STAT_ZEIT_TEMP_TOTAL_4_WERT", STAT_ZEIT_TEMP_TOTAL_4_WERT, "\"min\"");
unsigned long STAT_ZEIT_TEMP_TOTAL_5_WERT = (RXBUF_UINT32(16));
// Time in temperature class 10 ° C <T <= 20 ° C with the control unit awake and asleep / Zeit in
// Temperaturklasse 10°C<T<=20°C bei wachem und schlafenden Steuergerät
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ZEIT_TEMP_HISTOGRAMM", "STAT_ZEIT_TEMP_TOTAL_5_WERT", STAT_ZEIT_TEMP_TOTAL_5_WERT, "\"min\"");
unsigned long STAT_ZEIT_TEMP_TOTAL_6_WERT = (RXBUF_UINT32(20));
// Time in temperature class 20 ° C <T <= 25 ° C with the control unit awake and asleep / Zeit in
// Temperaturklasse 20°C<T<=25°C bei wachem und schlafenden Steuergerät
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ZEIT_TEMP_HISTOGRAMM", "STAT_ZEIT_TEMP_TOTAL_6_WERT", STAT_ZEIT_TEMP_TOTAL_6_WERT, "\"min\"");
unsigned long STAT_ZEIT_TEMP_TOTAL_7_WERT = (RXBUF_UINT32(24));
// Time in temperature class 25 ° C <T <= 30 ° C with the control unit awake and asleep / Zeit in
// Temperaturklasse 25°C<T<=30°C bei wachem und schlafenden Steuergerät
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ZEIT_TEMP_HISTOGRAMM", "STAT_ZEIT_TEMP_TOTAL_7_WERT", STAT_ZEIT_TEMP_TOTAL_7_WERT, "\"min\"");
unsigned long STAT_ZEIT_TEMP_TOTAL_8_WERT = (RXBUF_UINT32(28));
// Time in temperature class 30 ° C <T <= 35 ° C with the control unit awake and asleep / Zeit in
// Temperaturklasse 30°C<T<=35°C bei wachem und schlafenden Steuergerät
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ZEIT_TEMP_HISTOGRAMM", "STAT_ZEIT_TEMP_TOTAL_8_WERT", STAT_ZEIT_TEMP_TOTAL_8_WERT, "\"min\"");
unsigned long STAT_ZEIT_TEMP_TOTAL_9_WERT = (RXBUF_UINT32(32));
// Time in temperature class 35 ° C <T <= 40 ° C with the control unit awake and asleep / Zeit in
// Temperaturklasse 35°C<T<=40°C bei wachem und schlafenden Steuergerät
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ZEIT_TEMP_HISTOGRAMM", "STAT_ZEIT_TEMP_TOTAL_9_WERT", STAT_ZEIT_TEMP_TOTAL_9_WERT, "\"min\"");
unsigned long STAT_ZEIT_TEMP_TOTAL_10_WERT = (RXBUF_UINT32(36));
// Time in temperature class 40 ° C <T <= 45 ° C with the control unit awake and asleep / Zeit in
// Temperaturklasse 40°C<T<=45°C bei wachem und schlafenden Steuergerät
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ZEIT_TEMP_HISTOGRAMM", "STAT_ZEIT_TEMP_TOTAL_10_WERT", STAT_ZEIT_TEMP_TOTAL_10_WERT, "\"min\"");
unsigned long STAT_ZEIT_TEMP_TOTAL_11_WERT = (RXBUF_UINT32(40));
// Time in temperature class 45 ° C <T <= 50 ° C with the control unit awake and asleep / Zeit in
// Temperaturklasse 45°C<T<=50°C bei wachem und schlafenden Steuergerät
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ZEIT_TEMP_HISTOGRAMM", "STAT_ZEIT_TEMP_TOTAL_11_WERT", STAT_ZEIT_TEMP_TOTAL_11_WERT, "\"min\"");
unsigned long STAT_ZEIT_TEMP_TOTAL_12_WERT = (RXBUF_UINT32(44));
// Time in temperature class 50 ° C <T <= 55 ° C with the control unit awake and asleep / Zeit in
// Temperaturklasse 50°C<T<=55°C bei wachem und schlafenden Steuergerät
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ZEIT_TEMP_HISTOGRAMM", "STAT_ZEIT_TEMP_TOTAL_12_WERT", STAT_ZEIT_TEMP_TOTAL_12_WERT, "\"min\"");
unsigned long STAT_ZEIT_TEMP_TOTAL_13_WERT = (RXBUF_UINT32(48));
// Time in temperature class 55 ° C <T <= 60 ° C with the control unit awake and asleep / Zeit in
// Temperaturklasse 55°C<T<=60°C bei wachem und schlafenden Steuergerät
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ZEIT_TEMP_HISTOGRAMM", "STAT_ZEIT_TEMP_TOTAL_13_WERT", STAT_ZEIT_TEMP_TOTAL_13_WERT, "\"min\"");
unsigned long STAT_ZEIT_TEMP_TOTAL_14_WERT = (RXBUF_UINT32(52));
// Time in temperature class T> 60 ° C with the control unit awake and asleep / Zeit in Temperaturklasse T>60°C
// bei wachem und schlafenden Steuergerät
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ZEIT_TEMP_HISTOGRAMM", "STAT_ZEIT_TEMP_TOTAL_14_WERT", STAT_ZEIT_TEMP_TOTAL_14_WERT, "\"min\"");
unsigned long STAT_ZEIT_TEMP_NO_OP_1_WERT = (RXBUF_UINT32(56));
// Time in temperature class T <-25 ° C with the control unit asleep / Zeit in Temperaturklasse T<-25°C bei
// schlafendem Steuergerät
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ZEIT_TEMP_HISTOGRAMM", "STAT_ZEIT_TEMP_NO_OP_1_WERT", STAT_ZEIT_TEMP_NO_OP_1_WERT, "\"min\"");
unsigned long STAT_ZEIT_TEMP_NO_OP_2_WERT = (RXBUF_UINT32(60));
// Time in temperature class -25 ° C <T <= - 10 ° C with the control unit asleep / Zeit in Temperaturklasse
// -25°C<T<=-10°C bei schlafendem Steuergerät
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ZEIT_TEMP_HISTOGRAMM", "STAT_ZEIT_TEMP_NO_OP_2_WERT", STAT_ZEIT_TEMP_NO_OP_2_WERT, "\"min\"");
unsigned long STAT_ZEIT_TEMP_NO_OP_3_WERT = (RXBUF_UINT32(64));
// Time in temperature class -10 ° C <T <= 0 ° C with the control unit sleeping / Zeit in Temperaturklasse
// -10°C<T<=0°C bei schlafendem Steuergerät
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ZEIT_TEMP_HISTOGRAMM", "STAT_ZEIT_TEMP_NO_OP_3_WERT", STAT_ZEIT_TEMP_NO_OP_3_WERT, "\"min\"");
unsigned long STAT_ZEIT_TEMP_NO_OP_4_WERT = (RXBUF_UINT32(68));
// Time in temperature class 0 ° C <T <= 10 ° C with the control unit asleep / Zeit in Temperaturklasse
// 0°C<T<=10°C bei schlafendem Steuergerät
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ZEIT_TEMP_HISTOGRAMM", "STAT_ZEIT_TEMP_NO_OP_4_WERT", STAT_ZEIT_TEMP_NO_OP_4_WERT, "\"min\"");
unsigned long STAT_ZEIT_TEMP_NO_OP_5_WERT = (RXBUF_UINT32(72));
// Time in temperature class 10 ° C <T <= 20 ° C with the control unit sleeping / Zeit in Temperaturklasse
// 10°C<T<=20°C bei schlafendem Steuergerät
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ZEIT_TEMP_HISTOGRAMM", "STAT_ZEIT_TEMP_NO_OP_5_WERT", STAT_ZEIT_TEMP_NO_OP_5_WERT, "\"min\"");
unsigned long STAT_ZEIT_TEMP_NO_OP_6_WERT = (RXBUF_UINT32(76));
// Time in temperature class 20 ° C less than T less than or equal to 25 ° C with the control unit asleep / Zeit
// in Temperaturklasse 20°C kleiner T kleiner gleich 25°C bei schlafendem Steuergerät
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ZEIT_TEMP_HISTOGRAMM", "STAT_ZEIT_TEMP_NO_OP_6_WERT", STAT_ZEIT_TEMP_NO_OP_6_WERT, "\"min\"");
unsigned long STAT_ZEIT_TEMP_NO_OP_7_WERT = (RXBUF_UINT32(80));
// Time in temperature class 25 ° C less than T less than or equal to 30 ° C with the control unit asleep / Zeit
// in Temperaturklasse 25°C kleiner T kleiner gleich 30°C bei schlafendem Steuergerät
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ZEIT_TEMP_HISTOGRAMM", "STAT_ZEIT_TEMP_NO_OP_7_WERT", STAT_ZEIT_TEMP_NO_OP_7_WERT, "\"min\"");
unsigned long STAT_ZEIT_TEMP_NO_OP_8_WERT = (RXBUF_UINT32(84));
// Time in temperature class 30 ° C less than T less than or equal to 35 ° C with the control unit asleep / Zeit
// in Temperaturklasse 30°C kleiner T kleiner gleich 35°C bei schlafendem Steuergerät
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ZEIT_TEMP_HISTOGRAMM", "STAT_ZEIT_TEMP_NO_OP_8_WERT", STAT_ZEIT_TEMP_NO_OP_8_WERT, "\"min\"");
unsigned long STAT_ZEIT_TEMP_NO_OP_9_WERT = (RXBUF_UINT32(88));
// Time in temperature class 35 ° C less than T less than or equal to 40 ° C with the control unit sleeping /
// Zeit in Temperaturklasse 35°C kleiner T kleiner gleich 40°C bei schlafendem Steuergerät
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ZEIT_TEMP_HISTOGRAMM", "STAT_ZEIT_TEMP_NO_OP_9_WERT", STAT_ZEIT_TEMP_NO_OP_9_WERT, "\"min\"");
unsigned long STAT_ZEIT_TEMP_NO_OP_10_WERT = (RXBUF_UINT32(92));
// Time in temperature class 40 ° C less than T less than or equal to 45 ° C with the control unit asleep / Zeit
// in Temperaturklasse 40°C kleiner T kleiner gleich 45°C bei schlafendem Steuergerät
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ZEIT_TEMP_HISTOGRAMM", "STAT_ZEIT_TEMP_NO_OP_10_WERT", STAT_ZEIT_TEMP_NO_OP_10_WERT, "\"min\"");
unsigned long STAT_ZEIT_TEMP_NO_OP_11_WERT = (RXBUF_UINT32(96));
// Time in temperature class 45 ° C <T <= 50 ° C with the control unit asleep / Zeit in Temperaturklasse
// 45°C<T<=50°C bei schlafendem Steuergerät
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ZEIT_TEMP_HISTOGRAMM", "STAT_ZEIT_TEMP_NO_OP_11_WERT", STAT_ZEIT_TEMP_NO_OP_11_WERT, "\"min\"");
unsigned long STAT_ZEIT_TEMP_NO_OP_12_WERT = (RXBUF_UINT32(100));
// Time in temperature class 50 ° C <T <= 55 ° C with the control unit asleep / Zeit in Temperaturklasse
// 50°C<T<=55°C bei schlafendem Steuergerät
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ZEIT_TEMP_HISTOGRAMM", "STAT_ZEIT_TEMP_NO_OP_12_WERT", STAT_ZEIT_TEMP_NO_OP_12_WERT, "\"min\"");
unsigned long STAT_ZEIT_TEMP_NO_OP_13_WERT = (RXBUF_UINT32(104));
// Time in temperature class 55 ° C <T <= 60 ° C with the control unit asleep / Zeit in Temperaturklasse
// 55°C<T<=60°C bei schlafendem Steuergerät
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ZEIT_TEMP_HISTOGRAMM", "STAT_ZEIT_TEMP_NO_OP_13_WERT", STAT_ZEIT_TEMP_NO_OP_13_WERT, "\"min\"");
unsigned long STAT_ZEIT_TEMP_NO_OP_14_WERT = (RXBUF_UINT32(108));
// Time in temperature class T> 60 ° C with the control unit asleep / Zeit in Temperaturklasse T>60°C bei
// schlafendem Steuergerät
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ZEIT_TEMP_HISTOGRAMM", "STAT_ZEIT_TEMP_NO_OP_14_WERT", STAT_ZEIT_TEMP_NO_OP_14_WERT, "\"min\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_ZEIT_SOC_KLASSE: { // 0xDD91
if (datalen < 48) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_ZEIT_SOC_KLASSE", 48);
break;
}
unsigned long STAT_ZEIT_SOC_1_WERT = (RXBUF_UINT32(0));
// Duration in SOC class 1:% 0 <SOC <=% 10 / Dauer in SOC Klasse 1: %0 < SOC <= %10
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ZEIT_SOC_KLASSE", "STAT_ZEIT_SOC_1_WERT", STAT_ZEIT_SOC_1_WERT, "\"min\"");
unsigned long STAT_ZEIT_SOC_2_WERT = (RXBUF_UINT32(4));
// Duration in SOC class 2:% 10 <SOC <=% 20 / Dauer in SOC Klasse 2: %10 < SOC <= %20
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ZEIT_SOC_KLASSE", "STAT_ZEIT_SOC_2_WERT", STAT_ZEIT_SOC_2_WERT, "\"min\"");
unsigned long STAT_ZEIT_SOC_3_WERT = (RXBUF_UINT32(8));
// Duration in SOC class 3:% 20 <SOC <=% 30 / Dauer in SOC Klasse 3: %20 < SOC <= %30
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ZEIT_SOC_KLASSE", "STAT_ZEIT_SOC_3_WERT", STAT_ZEIT_SOC_3_WERT, "\"min\"");
unsigned long STAT_ZEIT_SOC_4_WERT = (RXBUF_UINT32(12));
// Duration in SOC class 4:% 30 <SOC <=% 40 / Dauer in SOC Klasse 4: %30 < SOC <= %40
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ZEIT_SOC_KLASSE", "STAT_ZEIT_SOC_4_WERT", STAT_ZEIT_SOC_4_WERT, "\"min\"");
unsigned long STAT_ZEIT_SOC_5_WERT = (RXBUF_UINT32(16));
// Duration in SOC class 5:% 40 <SOC <=% 50 / Dauer in SOC Klasse 5: %40 < SOC <= %50
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ZEIT_SOC_KLASSE", "STAT_ZEIT_SOC_5_WERT", STAT_ZEIT_SOC_5_WERT, "\"min\"");
unsigned long STAT_ZEIT_SOC_6_WERT = (RXBUF_UINT32(20));
// Duration in SOC class 6:% 50 <SOC <=% 60 / Dauer in SOC Klasse 6: %50 < SOC <= %60
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ZEIT_SOC_KLASSE", "STAT_ZEIT_SOC_6_WERT", STAT_ZEIT_SOC_6_WERT, "\"min\"");
unsigned long STAT_ZEIT_SOC_7_WERT = (RXBUF_UINT32(24));
// Duration in SOC class 7:% 60 <SOC <=% 70 / Dauer in SOC Klasse 7: %60 < SOC <= %70
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ZEIT_SOC_KLASSE", "STAT_ZEIT_SOC_7_WERT", STAT_ZEIT_SOC_7_WERT, "\"min\"");
unsigned long STAT_ZEIT_SOC_8_WERT = (RXBUF_UINT32(28));
// Duration in SOC class 8:% 70 <SOC <=% 80 / Dauer in SOC Klasse 8: %70 < SOC <= %80
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ZEIT_SOC_KLASSE", "STAT_ZEIT_SOC_8_WERT", STAT_ZEIT_SOC_8_WERT, "\"min\"");
unsigned long STAT_ZEIT_SOC_9_WERT = (RXBUF_UINT32(32));
// Duration in SOC class 9:% 80 <SOC <=% 85 / Dauer in SOC Klasse 9: %80 < SOC <= %85
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ZEIT_SOC_KLASSE", "STAT_ZEIT_SOC_9_WERT", STAT_ZEIT_SOC_9_WERT, "\"min\"");
unsigned long STAT_ZEIT_SOC_10_WERT = (RXBUF_UINT32(36));
// Duration in SOC class 10:% 85 <SOC <=% 90 / Dauer in SOC Klasse 10: %85 < SOC <= %90
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ZEIT_SOC_KLASSE", "STAT_ZEIT_SOC_10_WERT", STAT_ZEIT_SOC_10_WERT, "\"min\"");
unsigned long STAT_ZEIT_SOC_11_WERT = (RXBUF_UINT32(40));
// Duration in SOC class 11:% 90 <SOC <=% 95 / Dauer in SOC Klasse 11: %90 < SOC <= %95
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ZEIT_SOC_KLASSE", "STAT_ZEIT_SOC_11_WERT", STAT_ZEIT_SOC_11_WERT, "\"min\"");
unsigned long STAT_ZEIT_SOC_12_WERT = (RXBUF_UINT32(44));
// Duration in SOC class 12: SOC>% 95 / Dauer in SOC Klasse 12: SOC > %95
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ZEIT_SOC_KLASSE", "STAT_ZEIT_SOC_12_WERT", STAT_ZEIT_SOC_12_WERT, "\"min\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_HV_BATT_HIST_SOC_T1_1: { // 0xDD94
if (datalen < 160) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_HV_BATT_HIST_SOC_T1_1", 160);
break;
}
float STAT_HV_BATT_HIST_SOC1_T1_I1_WERT = (RXBUF_UINT32(0)/10.0f);
// Duration with SoC less than 10%. Temperature less than 0 ° C. Current less than -2.5xC A / Dauer bei SoC
// kleiner als 10 %. Temperatur kleiner als 0 °C. Strom kleiner als -2.5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_1", "STAT_HV_BATT_HIST_SOC1_T1_I1_WERT", STAT_HV_BATT_HIST_SOC1_T1_I1_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T1_I2_WERT = (RXBUF_UINT32(4)/10.0f);
// Duration with SoC less than 10%. Temperature less than 0 ° C. -2.5xC A less than current less than -2.0xC A /
// Dauer bei SoC kleiner als 10 %. Temperatur kleiner als 0 °C. -2,5xC A kleiner als Strom kleiner als -2,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_1", "STAT_HV_BATT_HIST_SOC1_T1_I2_WERT", STAT_HV_BATT_HIST_SOC1_T1_I2_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T1_I3_WERT = (RXBUF_UINT32(8)/10.0f);
// Duration with SoC less than 10%. Temperature less than 0 ° C. -2.0xC A less than current less than -1.5xC A /
// Dauer bei SoC kleiner als 10 %. Temperatur kleiner als 0 °C. -2,0xC A kleiner als Strom kleiner als -1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_1", "STAT_HV_BATT_HIST_SOC1_T1_I3_WERT", STAT_HV_BATT_HIST_SOC1_T1_I3_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T1_I4_WERT = (RXBUF_UINT32(12)/10.0f);
// Duration with SoC less than 10%. Temperature less than 0 ° C. -1.5xC A less than current less than -1.0xC A /
// Dauer bei SoC kleiner als 10 %. Temperatur kleiner als 0 °C. -1,5xC A kleiner als Strom kleiner als -1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_1", "STAT_HV_BATT_HIST_SOC1_T1_I4_WERT", STAT_HV_BATT_HIST_SOC1_T1_I4_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T1_I5_WERT = (RXBUF_UINT32(16)/10.0f);
// Duration with SoC less than 10%. Temperature less than 0 ° C. -1.0xC A less than current less than -0.5xC A /
// Dauer bei SoC kleiner als 10 %. Temperatur kleiner als 0 °C. -1,0xC A kleiner als Strom kleiner als -0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_1", "STAT_HV_BATT_HIST_SOC1_T1_I5_WERT", STAT_HV_BATT_HIST_SOC1_T1_I5_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T1_I6_WERT = (RXBUF_UINT32(20)/10.0f);
// Duration with SoC less than 10%. Temperature less than 0 ° C. -0.5xC A less than current less than -0.0xC A /
// Dauer bei SoC kleiner als 10 %. Temperatur kleiner als 0 °C. -0,5xC A kleiner als Strom kleiner als -0,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_1", "STAT_HV_BATT_HIST_SOC1_T1_I6_WERT", STAT_HV_BATT_HIST_SOC1_T1_I6_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T1_I7_WERT = (RXBUF_UINT32(24)/10.0f);
// Duration with SoC less than 10%. Temperature less than 0 ° C. 0.0xC A less than current less than 0.5xC A /
// Dauer bei SoC kleiner als 10 %. Temperatur kleiner als 0 °C. 0,0xC A kleiner als Strom kleiner als 0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_1", "STAT_HV_BATT_HIST_SOC1_T1_I7_WERT", STAT_HV_BATT_HIST_SOC1_T1_I7_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T1_I8_WERT = (RXBUF_UINT32(28)/10.0f);
// Duration with SoC less than 10%. Temperature less than 0 ° C. 0.5xC A less than current less than 1.0xC A /
// Dauer bei SoC kleiner als 10 %. Temperatur kleiner als 0 °C. 0,5xC A kleiner als Strom kleiner als 1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_1", "STAT_HV_BATT_HIST_SOC1_T1_I8_WERT", STAT_HV_BATT_HIST_SOC1_T1_I8_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T1_I9_WERT = (RXBUF_UINT32(32)/10.0f);
// Duration with SoC less than 10%. Temperature less than 0 ° C. 1.0xC A less than current less than 1.5xC A /
// Dauer bei SoC kleiner als 10 %. Temperatur kleiner als 0 °C. 1,0xC A kleiner als Strom kleiner als 1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_1", "STAT_HV_BATT_HIST_SOC1_T1_I9_WERT", STAT_HV_BATT_HIST_SOC1_T1_I9_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T1_I10_WERT = (RXBUF_UINT32(36)/10.0f);
// Duration with SoC less than 10%. Temperature less than 0 ° C. 1.5xC A less than current / Dauer bei SoC
// kleiner als 10 %. Temperatur kleiner als 0 °C. 1,5xC A kleiner als Strom
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_1", "STAT_HV_BATT_HIST_SOC1_T1_I10_WERT", STAT_HV_BATT_HIST_SOC1_T1_I10_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T1_I1_WERT = (RXBUF_UINT32(40)/10.0f);
// Duration at 10% less than SoC less than 30%. Temperature less than 0 ° C. Current less than -2.5xC A / Dauer
// bei 10 % kleiner als SoC kleiner als 30 %. Temperatur kleiner als 0 °C. Strom kleiner als -2,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_1", "STAT_HV_BATT_HIST_SOC2_T1_I1_WERT", STAT_HV_BATT_HIST_SOC2_T1_I1_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T1_I2_WERT = (RXBUF_UINT32(44)/10.0f);
// Duration at 10% less than SoC less than 30%. Temperature less than 0 ° C. -2.5xC A less than current less than
// -2.0xC A / Dauer bei 10 % kleiner als SoC kleiner als 30 %. Temperatur kleiner als 0 °C. -2,5xC A kleiner als
// Strom kleiner als -2,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_1", "STAT_HV_BATT_HIST_SOC2_T1_I2_WERT", STAT_HV_BATT_HIST_SOC2_T1_I2_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T1_I3_WERT = (RXBUF_UINT32(48)/10.0f);
// Duration at 10% less than SoC less than 30%. Temperature less than 0 ° C. -2.0xC A less than current less than
// -1.5xC A / Dauer bei 10 % kleiner als SoC kleiner als 30 %. Temperatur kleiner als 0 °C. -2,0xC A kleiner als
// Strom kleiner als -1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_1", "STAT_HV_BATT_HIST_SOC2_T1_I3_WERT", STAT_HV_BATT_HIST_SOC2_T1_I3_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T1_I4_WERT = (RXBUF_UINT32(52)/10.0f);
// Duration at 10% less than SoC less than 30%. Temperature less than 0 ° C. -1.5xC A less than current less than
// -1.0xC A / Dauer bei 10 % kleiner als SoC kleiner als 30 %. Temperatur kleiner als 0 °C. -1,5xC A kleiner als
// Strom kleiner als -1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_1", "STAT_HV_BATT_HIST_SOC2_T1_I4_WERT", STAT_HV_BATT_HIST_SOC2_T1_I4_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T1_I5_WERT = (RXBUF_UINT32(56)/10.0f);
// Duration at 10% less than SoC less than 30%. Temperature less than 0 ° C. -1.0xC A less than current less than
// -0.5xC A / Dauer bei 10 % kleiner als SoC kleiner als 30 %. Temperatur kleiner als 0 °C. -1,0xC A kleiner als
// Strom kleiner als -0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_1", "STAT_HV_BATT_HIST_SOC2_T1_I5_WERT", STAT_HV_BATT_HIST_SOC2_T1_I5_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T1_I6_WERT = (RXBUF_UINT32(60)/10.0f);
// Duration at 10% less than SoC less than 30%. Temperature less than 0 ° C. -0.5xC A less than current less than
// 0.0xC A / Dauer bei 10 % kleiner als SoC kleiner als 30 %. Temperatur kleiner als 0 °C. -0,5xC A kleiner als
// Strom kleiner als 0,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_1", "STAT_HV_BATT_HIST_SOC2_T1_I6_WERT", STAT_HV_BATT_HIST_SOC2_T1_I6_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T1_I7_WERT = (RXBUF_UINT32(64)/10.0f);
// Duration at 10% less than SoC less than 30%. Temperature less than 0 ° C. 0.0xC A less than current less than
// 0.5xC A / Dauer bei 10 % kleiner als SoC kleiner als 30 %. Temperatur kleiner als 0 °C. 0,0xC A kleiner als
// Strom kleiner als 0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_1", "STAT_HV_BATT_HIST_SOC2_T1_I7_WERT", STAT_HV_BATT_HIST_SOC2_T1_I7_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T1_I8_WERT = (RXBUF_UINT32(68)/10.0f);
// Duration at 10% less than SoC less than 30%. Temperature less than 0 ° C. 0.5xC A less than current less than
// 1.0xC A / Dauer bei 10 % kleiner als SoC kleiner als 30 %. Temperatur kleiner als 0 °C. 0,5xC A kleiner als
// Strom kleiner als 1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_1", "STAT_HV_BATT_HIST_SOC2_T1_I8_WERT", STAT_HV_BATT_HIST_SOC2_T1_I8_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T1_I9_WERT = (RXBUF_UINT32(72)/10.0f);
// Duration at 10% less than SoC less than 30%. Temperature less than 0 ° C. 1.0xC A less than current less than
// 1.5xC A / Dauer bei 10 % kleiner als SoC kleiner als 30 %. Temperatur kleiner als 0 °C. 1,0xC A kleiner als
// Strom kleiner als 1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_1", "STAT_HV_BATT_HIST_SOC2_T1_I9_WERT", STAT_HV_BATT_HIST_SOC2_T1_I9_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T1_I10_WERT = (RXBUF_UINT32(76)/10.0f);
// Duration at 10% less than SoC less than 30%. Temperature less than 0 ° C. 1.5xC A less than current / Dauer
// bei 10 % kleiner als SoC kleiner als 30 %. Temperatur kleiner als 0 °C. 1,5xC A kleiner als Strom
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_1", "STAT_HV_BATT_HIST_SOC2_T1_I10_WERT", STAT_HV_BATT_HIST_SOC2_T1_I10_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T1_I1_WERT = (RXBUF_UINT32(80)/10.0f);
// Duration at 30% less than SoC less than 50%. Temperature less than 0 ° C. Current less than -2.5xC A / Dauer
// bei 30 % kleiner als SoC kleiner als 50 %. Temperatur kleiner als 0 °C. Strom kleiner als -2,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_1", "STAT_HV_BATT_HIST_SOC3_T1_I1_WERT", STAT_HV_BATT_HIST_SOC3_T1_I1_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T1_I2_WERT = (RXBUF_UINT32(84)/10.0f);
// Duration at 30% less than SoC less than 50%. Temperature less than 0 ° C. -2.5xC A less than current less than
// -2.0xC A / Dauer bei 30 % kleiner als SoC kleiner als 50 %. Temperatur kleiner als 0 °C. -2,5xC A kleiner als
// Strom kleiner als -2,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_1", "STAT_HV_BATT_HIST_SOC3_T1_I2_WERT", STAT_HV_BATT_HIST_SOC3_T1_I2_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T1_I3_WERT = (RXBUF_UINT32(88)/10.0f);
// Duration at 30% less than SoC less than 50%. Temperature less than 0 ° C. -2.0xC A less than current less than
// -1.5xC A / Dauer bei 30 % kleiner als SoC kleiner als 50 %. Temperatur kleiner als 0 °C. -2,0xC A kleiner als
// Strom kleiner als -1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_1", "STAT_HV_BATT_HIST_SOC3_T1_I3_WERT", STAT_HV_BATT_HIST_SOC3_T1_I3_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T1_I4_WERT = (RXBUF_UINT32(92)/10.0f);
// Duration at 30% less than SoC less than 50%. Temperature less than 0 ° C. -1.5xC A less than current less than
// -1.0xC A / Dauer bei 30 % kleiner als SoC kleiner als 50 %. Temperatur kleiner als 0 °C. -1,5xC A kleiner als
// Strom kleiner als -1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_1", "STAT_HV_BATT_HIST_SOC3_T1_I4_WERT", STAT_HV_BATT_HIST_SOC3_T1_I4_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T1_I5_WERT = (RXBUF_UINT32(96)/10.0f);
// Duration at 30% less than SoC less than 50%. Temperature less than 0 ° C. -1.0xC A less than current less than
// -0.5xC A / Dauer bei 30 % kleiner als SoC kleiner als 50 %. Temperatur kleiner als 0 °C. -1,0xC A kleiner als
// Strom kleiner als -0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_1", "STAT_HV_BATT_HIST_SOC3_T1_I5_WERT", STAT_HV_BATT_HIST_SOC3_T1_I5_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T1_I6_WERT = (RXBUF_UINT32(100)/10.0f);
// Duration at 30% less than SoC less than 50%. Temperature less than 0 ° C. -0.5xC A less than current less than
// 0.0xC A / Dauer bei 30 % kleiner als SoC kleiner als 50 %. Temperatur kleiner als 0 °C. -0,5xC A kleiner als
// Strom kleiner als 0,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_1", "STAT_HV_BATT_HIST_SOC3_T1_I6_WERT", STAT_HV_BATT_HIST_SOC3_T1_I6_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T1_I7_WERT = (RXBUF_UINT32(104)/10.0f);
// Duration at 30% less than SoC less than 50%. Temperature less than 0 ° C. 0.0xC A less than current less than
// 0.5xC A / Dauer bei 30 % kleiner als SoC kleiner als 50 %. Temperatur kleiner als 0 °C. 0,0xC A kleiner als
// Strom kleiner als 0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_1", "STAT_HV_BATT_HIST_SOC3_T1_I7_WERT", STAT_HV_BATT_HIST_SOC3_T1_I7_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T1_I8_WERT = (RXBUF_UINT32(108)/10.0f);
// Duration at 30% less than SoC less than 50%. Temperature less than 0 ° C. 0.5xC A less than current less than
// 1.0xC A / Dauer bei 30 % kleiner als SoC kleiner als 50 %. Temperatur kleiner als 0 °C. 0,5xC A kleiner als
// Strom kleiner als 1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_1", "STAT_HV_BATT_HIST_SOC3_T1_I8_WERT", STAT_HV_BATT_HIST_SOC3_T1_I8_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T1_I9_WERT = (RXBUF_UINT32(112)/10.0f);
// Duration at 30% less than SoC less than 50%. Temperature less than 0 ° C. 1.0xC A less than current less than
// 1.5xC A / Dauer bei 30 % kleiner als SoC kleiner als 50 %. Temperatur kleiner als 0 °C. 1,0xC A kleiner als
// Strom kleiner als 1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_1", "STAT_HV_BATT_HIST_SOC3_T1_I9_WERT", STAT_HV_BATT_HIST_SOC3_T1_I9_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T1_I10_WERT = (RXBUF_UINT32(116)/10.0f);
// Duration at 30% less than SoC less than 50%. Temperature less than 0 ° C. 1.5xC A less than current / Dauer
// bei 30 % kleiner als SoC kleiner als 50 %. Temperatur kleiner als 0 °C. 1,5xC A kleiner als Strom
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_1", "STAT_HV_BATT_HIST_SOC3_T1_I10_WERT", STAT_HV_BATT_HIST_SOC3_T1_I10_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T1_I1_WERT = (RXBUF_UINT32(120)/10.0f);
// Duration at 50% less than SoC less than 70%. Temperature less than 0 ° C. Current less than -2.5xC A / Dauer
// bei 50 % kleiner als SoC kleiner als 70 %. Temperatur kleiner als 0 °C. Strom kleiner als -2,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_1", "STAT_HV_BATT_HIST_SOC4_T1_I1_WERT", STAT_HV_BATT_HIST_SOC4_T1_I1_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T1_I2_WERT = (RXBUF_UINT32(124)/10.0f);
// Duration at 50% less than SoC less than 70%. Temperature less than 0 ° C. -2.5xC A less than current less than
// -2.0xC A / Dauer bei 50 % kleiner als SoC kleiner als 70 %. Temperatur kleiner als 0 °C. -2,5xC A kleiner als
// Strom kleiner als -2,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_1", "STAT_HV_BATT_HIST_SOC4_T1_I2_WERT", STAT_HV_BATT_HIST_SOC4_T1_I2_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T1_I3_WERT = (RXBUF_UINT32(128)/10.0f);
// Duration at 50% less than SoC less than 70%. Temperature less than 0 ° C. -2.0xC A less than current less than
// -1.5xC A / Dauer bei 50 % kleiner als SoC kleiner als 70 %. Temperatur kleiner als 0 °C. -2,0xC A kleiner als
// Strom kleiner als -1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_1", "STAT_HV_BATT_HIST_SOC4_T1_I3_WERT", STAT_HV_BATT_HIST_SOC4_T1_I3_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T1_I4_WERT = (RXBUF_UINT32(132)/10.0f);
// Duration at 50% less than SoC less than 70%. Temperature less than 0 ° C. -1.5xC A less than current less than
// -1.0xC A / Dauer bei 50 % kleiner als SoC kleiner als 70 %. Temperatur kleiner als 0 °C. -1,5xC A kleiner als
// Strom kleiner als -1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_1", "STAT_HV_BATT_HIST_SOC4_T1_I4_WERT", STAT_HV_BATT_HIST_SOC4_T1_I4_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T1_I5_WERT = (RXBUF_UINT32(136)/10.0f);
// Duration at 50% less than SoC less than 70%. Temperature less than 0 ° C. -1.0xC A less than current less than
// -0.5xC A / Dauer bei 50 % kleiner als SoC kleiner als 70 %. Temperatur kleiner als 0 °C. -1,0xC A kleiner als
// Strom kleiner als -0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_1", "STAT_HV_BATT_HIST_SOC4_T1_I5_WERT", STAT_HV_BATT_HIST_SOC4_T1_I5_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T1_I6_WERT = (RXBUF_UINT32(140)/10.0f);
// Duration at 50% less than SoC less than 70%. Temperature less than 0 ° C. -0.5xC A less than current less than
// 0.0xC A / Dauer bei 50 % kleiner als SoC kleiner als 70 %. Temperatur kleiner als 0 °C. -0,5xC A kleiner als
// Strom kleiner als 0,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_1", "STAT_HV_BATT_HIST_SOC4_T1_I6_WERT", STAT_HV_BATT_HIST_SOC4_T1_I6_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T1_I7_WERT = (RXBUF_UINT32(144)/10.0f);
// Duration at 50% less than SoC less than 70%. Temperature less than 0 ° C. 0.0xC A less than current less than
// 0.5xC A / Dauer bei 50 % kleiner als SoC kleiner als 70 %. Temperatur kleiner als 0 °C. 0,0xC A kleiner als
// Strom kleiner als 0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_1", "STAT_HV_BATT_HIST_SOC4_T1_I7_WERT", STAT_HV_BATT_HIST_SOC4_T1_I7_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T1_I8_WERT = (RXBUF_UINT32(148)/10.0f);
// Duration at 50% less than SoC less than 70%. Temperature less than 0 ° C. 0.5xC A less than current less than
// 1.0xC A / Dauer bei 50 % kleiner als SoC kleiner als 70 %. Temperatur kleiner als 0 °C. 0,5xC A kleiner als
// Strom kleiner als 1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_1", "STAT_HV_BATT_HIST_SOC4_T1_I8_WERT", STAT_HV_BATT_HIST_SOC4_T1_I8_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T1_I9_WERT = (RXBUF_UINT32(152)/10.0f);
// Duration at 50% less than SoC less than 70%. Temperature less than 0 ° C. 1.0xC A less than current less than
// 1.5xC A / Dauer bei 50 % kleiner als SoC kleiner als 70 %. Temperatur kleiner als 0 °C. 1,0xC A kleiner als
// Strom kleiner als 1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_1", "STAT_HV_BATT_HIST_SOC4_T1_I9_WERT", STAT_HV_BATT_HIST_SOC4_T1_I9_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T1_I10_WERT = (RXBUF_UINT32(156)/10.0f);
// Duration at 50% less than SoC less than 70%. Temperature less than 0 ° C. 1.5xC A less than current / Dauer
// bei 50 % kleiner als SoC kleiner als 70 %. Temperatur kleiner als 0 °C. 1,5xC A kleiner als Strom
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_1", "STAT_HV_BATT_HIST_SOC4_T1_I10_WERT", STAT_HV_BATT_HIST_SOC4_T1_I10_WERT, "\"s\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_HV_BATT_HIST_SOC_T2_1: { // 0xDD95
if (datalen < 160) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_HV_BATT_HIST_SOC_T2_1", 160);
break;
}
float STAT_HV_BATT_HIST_SOC1_T2_I1_WERT = (RXBUF_UINT32(0)/10.0f);
// Duration with SoC less than 10%. 0 ° C less than temperature less than 10 ° C. Current less than -2.5xC A /
// Dauer bei SoC kleiner als 10 %. 0°C kleiner als Temperatur kleiner als 10 °C. Strom kleiner als -2,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_1", "STAT_HV_BATT_HIST_SOC1_T2_I1_WERT", STAT_HV_BATT_HIST_SOC1_T2_I1_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T2_I2_WERT = (RXBUF_UINT32(4)/10.0f);
// Duration with SoC less than 10%. 0 ° C less than temperature less than 10 ° C. -2.5xC A less than current less
// than -2.0xC A / Dauer bei SoC kleiner als 10 %. 0°C kleiner als Temperatur kleiner als 10 °C. -2,5xC A
// kleiner als Strom kleiner als -2,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_1", "STAT_HV_BATT_HIST_SOC1_T2_I2_WERT", STAT_HV_BATT_HIST_SOC1_T2_I2_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T2_I3_WERT = (RXBUF_UINT32(8)/10.0f);
// Duration with SoC less than 10%. 0 ° C less than temperature less than 10 ° C. -2.0xC A less than current less
// than -1.5xC A / Dauer bei SoC kleiner als 10 %. 0°C kleiner als Temperatur kleiner als 10 °C. -2,0xC A
// kleiner als Strom kleiner als -1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_1", "STAT_HV_BATT_HIST_SOC1_T2_I3_WERT", STAT_HV_BATT_HIST_SOC1_T2_I3_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T2_I4_WERT = (RXBUF_UINT32(12)/10.0f);
// Duration with SoC less than 10%. 0 ° C less than temperature less than 10 ° C. -1.5xC A less than current less
// than -1.0xC A / Dauer bei SoC kleiner als 10 %. 0°C kleiner als Temperatur kleiner als 10 °C. -1,5xC A
// kleiner als Strom kleiner als -1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_1", "STAT_HV_BATT_HIST_SOC1_T2_I4_WERT", STAT_HV_BATT_HIST_SOC1_T2_I4_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T2_I5_WERT = (RXBUF_UINT32(16)/10.0f);
// Duration with SoC less than 10%. 0 ° C less than temperature less than 10 ° C. -1.0xC A less than current less
// than -0.5xC A / Dauer bei SoC kleiner als 10 %. 0°C kleiner als Temperatur kleiner als 10 °C. -1,0xC A
// kleiner als Strom kleiner als -0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_1", "STAT_HV_BATT_HIST_SOC1_T2_I5_WERT", STAT_HV_BATT_HIST_SOC1_T2_I5_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T2_I6_WERT = (RXBUF_UINT32(20)/10.0f);
// Duration with SoC less than 10%. 0 ° C less than temperature less than 10 ° C. -0.5xC A less than current less
// than 0.0xC A / Dauer bei SoC kleiner als 10 %. 0°C kleiner als Temperatur kleiner als 10 °C. -0,5xC A kleiner
// als Strom kleiner als 0,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_1", "STAT_HV_BATT_HIST_SOC1_T2_I6_WERT", STAT_HV_BATT_HIST_SOC1_T2_I6_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T2_I7_WERT = (RXBUF_UINT32(24)/10.0f);
// Duration with SoC less than 10%. 0 ° C less than temperature less than 10 ° C. 0.0xC A less than current less
// than 0.5xC A / Dauer bei SoC kleiner als 10 %. 0°C kleiner als Temperatur kleiner als 10 °C. 0,0xC A kleiner
// als Strom kleiner als 0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_1", "STAT_HV_BATT_HIST_SOC1_T2_I7_WERT", STAT_HV_BATT_HIST_SOC1_T2_I7_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T2_I8_WERT = (RXBUF_UINT32(28)/10.0f);
// Duration with SoC less than 10%. 0 ° C less than temperature less than 10 ° C. 0.5xC A less than current less
// than 1.0xC A / Dauer bei SoC kleiner als 10 %. 0°C kleiner als Temperatur kleiner als 10 °C. 0,5xC A kleiner
// als Strom kleiner als 1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_1", "STAT_HV_BATT_HIST_SOC1_T2_I8_WERT", STAT_HV_BATT_HIST_SOC1_T2_I8_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T2_I9_WERT = (RXBUF_UINT32(32)/10.0f);
// Duration with SoC less than 10%. 0 ° C less than temperature less than 10 ° C. 1.0xC A less than current less
// than 1.5xC A / Dauer bei SoC kleiner als 10 %. 0°C kleiner als Temperatur kleiner als 10 °C. 1,0xC A kleiner
// als Strom kleiner als 1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_1", "STAT_HV_BATT_HIST_SOC1_T2_I9_WERT", STAT_HV_BATT_HIST_SOC1_T2_I9_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T2_I10_WERT = (RXBUF_UINT32(36)/10.0f);
// Duration with SoC less than 10%. 0 ° C less than temperature less than 10 ° C. 1.5xC A less than current /
// Dauer bei SoC kleiner als 10 %. 0°C kleiner als Temperatur kleiner als 10 °C. 1,5xC A kleiner als Strom
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_1", "STAT_HV_BATT_HIST_SOC1_T2_I10_WERT", STAT_HV_BATT_HIST_SOC1_T2_I10_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T2_I1_WERT = (RXBUF_UINT32(40)/10.0f);
// Duration at 10% less than SoC less than 30%. 0 ° C less than temperature less than 10 ° C. Current less than
// -2.5xC A / Dauer bei 10 % kleiner als SoC kleiner als 30 %. 0°C kleiner als Temperatur kleiner als 10 °C.
// Strom kleiner als -2,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_1", "STAT_HV_BATT_HIST_SOC2_T2_I1_WERT", STAT_HV_BATT_HIST_SOC2_T2_I1_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T2_I2_WERT = (RXBUF_UINT32(44)/10.0f);
// Duration at 10% less than SoC less than 30%. 0 ° C less than temperature less than 10 ° C. -2.5xC A less than
// current less than -2.0xC A / Dauer bei 10 % kleiner als SoC kleiner als 30 %. 0°C kleiner als Temperatur
// kleiner als 10 °C. -2,5xC A kleiner als Strom kleiner als -2,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_1", "STAT_HV_BATT_HIST_SOC2_T2_I2_WERT", STAT_HV_BATT_HIST_SOC2_T2_I2_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T2_I3_WERT = (RXBUF_UINT32(48)/10.0f);
// Duration at 10% less than SoC less than 30%. 0 ° C less than temperature less than 10 ° C. -2.0xC A less than
// current less than -1.5xC A / Dauer bei 10 % kleiner als SoC kleiner als 30 %. 0°C kleiner als Temperatur
// kleiner als 10 °C. -2,0xC A kleiner als Strom kleiner als -1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_1", "STAT_HV_BATT_HIST_SOC2_T2_I3_WERT", STAT_HV_BATT_HIST_SOC2_T2_I3_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T2_I4_WERT = (RXBUF_UINT32(52)/10.0f);
// Duration at 10% less than SoC less than 30%. 0 ° C less than temperature less than 10 ° C. -1.5xC A less than
// current less than -1.0xC A / Dauer bei 10 % kleiner als SoC kleiner als 30 %. 0°C kleiner als Temperatur
// kleiner als 10 °C. -1,5xC A kleiner als Strom kleiner als -1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_1", "STAT_HV_BATT_HIST_SOC2_T2_I4_WERT", STAT_HV_BATT_HIST_SOC2_T2_I4_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T2_I5_WERT = (RXBUF_UINT32(56)/10.0f);
// Duration at 10% less than SoC less than 30%. 0 ° C less than temperature less than 10 ° C. -1.0xC A less than
// current less than -0.5xC A / Dauer bei 10 % kleiner als SoC kleiner als 30 %. 0°C kleiner als Temperatur
// kleiner als 10 °C. -1,0xC A kleiner als Strom kleiner als -0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_1", "STAT_HV_BATT_HIST_SOC2_T2_I5_WERT", STAT_HV_BATT_HIST_SOC2_T2_I5_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T2_I6_WERT = (RXBUF_UINT32(60)/10.0f);
// Duration at 10% less than SoC less than 30%. 0 ° C less than temperature less than 10 ° C. -0.5xC A less than
// current less than 0.0xC A / Dauer bei 10 % kleiner als SoC kleiner als 30 %. 0°C kleiner als Temperatur
// kleiner als 10 °C. -0,5xC A kleiner als Strom kleiner als 0,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_1", "STAT_HV_BATT_HIST_SOC2_T2_I6_WERT", STAT_HV_BATT_HIST_SOC2_T2_I6_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T2_I7_WERT = (RXBUF_UINT32(64)/10.0f);
// Duration at 10% less than SoC less than 30%. 0 ° C less than temperature less than 10 ° C. 0.0xC A less than
// current less than 0.5xC A / Dauer bei 10 % kleiner als SoC kleiner als 30 %. 0°C kleiner als Temperatur
// kleiner als 10 °C. 0,0xC A kleiner als Strom kleiner als 0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_1", "STAT_HV_BATT_HIST_SOC2_T2_I7_WERT", STAT_HV_BATT_HIST_SOC2_T2_I7_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T2_I8_WERT = (RXBUF_UINT32(68)/10.0f);
// Duration at 10% less than SoC less than 30%. 0 ° C less than temperature less than 10 ° C. 0.5xC A less than
// current less than 1.0xC A / Dauer bei 10 % kleiner als SoC kleiner als 30 %. 0°C kleiner als Temperatur
// kleiner als 10 °C. 0,5xC A kleiner als Strom kleiner als 1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_1", "STAT_HV_BATT_HIST_SOC2_T2_I8_WERT", STAT_HV_BATT_HIST_SOC2_T2_I8_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T2_I9_WERT = (RXBUF_UINT32(72)/10.0f);
// Duration at 10% less than SoC less than 30%. 0 ° C less than temperature less than 10 ° C. 1.0xC A less than
// current less than 1.5xC A / Dauer bei 10 % kleiner als SoC kleiner als 30 %. 0°C kleiner als Temperatur
// kleiner als 10 °C. 1,0xC A kleiner als Strom kleiner als 1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_1", "STAT_HV_BATT_HIST_SOC2_T2_I9_WERT", STAT_HV_BATT_HIST_SOC2_T2_I9_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T2_I10_WERT = (RXBUF_UINT32(76)/10.0f);
// Duration at 10% less than SoC less than 30%. 0 ° C less than temperature less than 10 ° C. 1.5xC A less than
// current / Dauer bei 10 % kleiner als SoC kleiner als 30 %. 0°C kleiner als Temperatur kleiner als 10 °C.
// 1,5xC A kleiner als Strom
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_1", "STAT_HV_BATT_HIST_SOC2_T2_I10_WERT", STAT_HV_BATT_HIST_SOC2_T2_I10_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T2_I1_WERT = (RXBUF_UINT32(80)/10.0f);
// Duration at 30% less than SoC less than 50%. 0 ° C less than temperature less than 10 ° C. Current less than
// -2.5xC A / Dauer bei 30 % kleiner als SoC kleiner als 50 %. 0°C kleiner als Temperatur kleiner als 10 °C.
// Strom kleiner als -2,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_1", "STAT_HV_BATT_HIST_SOC3_T2_I1_WERT", STAT_HV_BATT_HIST_SOC3_T2_I1_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T2_I2_WERT = (RXBUF_UINT32(84)/10.0f);
// Duration at 30% less than SoC less than 50%. 0 ° C less than temperature less than 10 ° C. -2.5xC A less than
// current less than -2.0xC A / Dauer bei 30 % kleiner als SoC kleiner als 50 %. 0°C kleiner als Temperatur
// kleiner als 10 °C. -2,5xC A kleiner als Strom kleiner als -2,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_1", "STAT_HV_BATT_HIST_SOC3_T2_I2_WERT", STAT_HV_BATT_HIST_SOC3_T2_I2_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T2_I3_WERT = (RXBUF_UINT32(88)/10.0f);
// Duration at 30% less than SoC less than 50%. 0 ° C less than temperature less than 10 ° C. -2.0xC A less than
// current less than -1.5xC A / Dauer bei 30 % kleiner als SoC kleiner als 50 %. 0°C kleiner als Temperatur
// kleiner als 10 °C. -2,0xC A kleiner als Strom kleiner als -1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_1", "STAT_HV_BATT_HIST_SOC3_T2_I3_WERT", STAT_HV_BATT_HIST_SOC3_T2_I3_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T2_I4_WERT = (RXBUF_UINT32(92)/10.0f);
// Duration at 30% less than SoC less than 50%. 0 ° C less than temperature less than 10 ° C. -1.5xC A less than
// current less than -1.0xC A / Dauer bei 30 % kleiner als SoC kleiner als 50 %. 0°C kleiner als Temperatur
// kleiner als 10 °C. -1,5xC A kleiner als Strom kleiner als -1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_1", "STAT_HV_BATT_HIST_SOC3_T2_I4_WERT", STAT_HV_BATT_HIST_SOC3_T2_I4_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T2_I5_WERT = (RXBUF_UINT32(96)/10.0f);
// Duration at 30% less than SoC less than 50%. 0 ° C less than temperature less than 10 ° C. -1.0xC A less than
// current less than -0.5xC A / Dauer bei 30 % kleiner als SoC kleiner als 50 %. 0°C kleiner als Temperatur
// kleiner als 10 °C. -1,0xC A kleiner als Strom kleiner als -0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_1", "STAT_HV_BATT_HIST_SOC3_T2_I5_WERT", STAT_HV_BATT_HIST_SOC3_T2_I5_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T2_I6_WERT = (RXBUF_UINT32(100)/10.0f);
// Duration at 30% less than SoC less than 50%. 0 ° C less than temperature less than 10 ° C. -0.5xC A less than
// current less than 0.0xC A / Dauer bei 30 % kleiner als SoC kleiner als 50 %. 0°C kleiner als Temperatur
// kleiner als 10 °C. -0,5xC A kleiner als Strom kleiner als 0,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_1", "STAT_HV_BATT_HIST_SOC3_T2_I6_WERT", STAT_HV_BATT_HIST_SOC3_T2_I6_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T2_I7_WERT = (RXBUF_UINT32(104)/10.0f);
// Duration at 30% less than SoC less than 50%. 0 ° C less than temperature less than 10 ° C. 0.0xC A less than
// current less than 0.5xC A / Dauer bei 30 % kleiner als SoC kleiner als 50 %. 0°C kleiner als Temperatur
// kleiner als 10 °C. 0,0xC A kleiner als Strom kleiner als 0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_1", "STAT_HV_BATT_HIST_SOC3_T2_I7_WERT", STAT_HV_BATT_HIST_SOC3_T2_I7_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T2_I8_WERT = (RXBUF_UINT32(108)/10.0f);
// Duration at 30% less than SoC less than 50%. 0 ° C less than temperature less than 10 ° C. 0.5xC A less than
// current less than 1.0xC A / Dauer bei 30 % kleiner als SoC kleiner als 50 %. 0°C kleiner als Temperatur
// kleiner als 10 °C. 0,5xC A kleiner als Strom kleiner als 1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_1", "STAT_HV_BATT_HIST_SOC3_T2_I8_WERT", STAT_HV_BATT_HIST_SOC3_T2_I8_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T2_I9_WERT = (RXBUF_UINT32(112)/10.0f);
// Duration at 30% less than SoC less than 50%. 0 ° C less than temperature less than 10 ° C. 1.0xC A less than
// current less than 1.5xC A / Dauer bei 30 % kleiner als SoC kleiner als 50 %. 0°C kleiner als Temperatur
// kleiner als 10 °C. 1,0xC A kleiner als Strom kleiner als 1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_1", "STAT_HV_BATT_HIST_SOC3_T2_I9_WERT", STAT_HV_BATT_HIST_SOC3_T2_I9_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T2_I10_WERT = (RXBUF_UINT32(116)/10.0f);
// Duration at 30% less than SoC less than 50%. 0 ° C less than temperature less than 10 ° C. 1.5xC A less than
// current / Dauer bei 30 % kleiner als SoC kleiner als 50 %. 0°C kleiner als Temperatur kleiner als 10 °C.
// 1,5xC A kleiner als Strom
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_1", "STAT_HV_BATT_HIST_SOC3_T2_I10_WERT", STAT_HV_BATT_HIST_SOC3_T2_I10_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T2_I1_WERT = (RXBUF_UINT32(120)/10.0f);
// Duration at 50% less than SoC less than 70%. 0 ° C less than temperature less than 10 ° C. Current less than
// -2.5xC A / Dauer bei 50 % kleiner als SoC kleiner als 70 %. 0°C kleiner als Temperatur kleiner als 10 °C.
// Strom kleiner als -2,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_1", "STAT_HV_BATT_HIST_SOC4_T2_I1_WERT", STAT_HV_BATT_HIST_SOC4_T2_I1_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T2_I2_WERT = (RXBUF_UINT32(124)/10.0f);
// Duration at 50% less than SoC less than 70%. 0 ° C less than temperature less than 10 ° C. -2.5xC A less than
// current less than -2.0xC A / Dauer bei 50 % kleiner als SoC kleiner als 70 %. 0°C kleiner als Temperatur
// kleiner als 10 °C. -2,5xC A kleiner als Strom kleiner als -2,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_1", "STAT_HV_BATT_HIST_SOC4_T2_I2_WERT", STAT_HV_BATT_HIST_SOC4_T2_I2_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T2_I3_WERT = (RXBUF_UINT32(128)/10.0f);
// Duration at 50% less than SoC less than 70%. 0 ° C less than temperature less than 10 ° C. -2.0xC A less than
// current less than -1.5xC A / Dauer bei 50 % kleiner als SoC kleiner als 70 %. 0°C kleiner als Temperatur
// kleiner als 10 °C. -2,0xC A kleiner als Strom kleiner als -1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_1", "STAT_HV_BATT_HIST_SOC4_T2_I3_WERT", STAT_HV_BATT_HIST_SOC4_T2_I3_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T2_I4_WERT = (RXBUF_UINT32(132)/10.0f);
// Duration at 50% less than SoC less than 70%. 0 ° C less than temperature less than 10 ° C. -1.5xC A less than
// current less than -1.0xC A / Dauer bei 50 % kleiner als SoC kleiner als 70 %. 0°C kleiner als Temperatur
// kleiner als 10 °C. -1,5xC A kleiner als Strom kleiner als -1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_1", "STAT_HV_BATT_HIST_SOC4_T2_I4_WERT", STAT_HV_BATT_HIST_SOC4_T2_I4_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T2_I5_WERT = (RXBUF_UINT32(136)/10.0f);
// Duration at 50% less than SoC less than 70%. 0 ° C less than temperature less than 10 ° C. -1.0xC A less than
// current less than -0.5xC A / Dauer bei 50 % kleiner als SoC kleiner als 70 %. 0°C kleiner als Temperatur
// kleiner als 10 °C. -1,0xC A kleiner als Strom kleiner als -0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_1", "STAT_HV_BATT_HIST_SOC4_T2_I5_WERT", STAT_HV_BATT_HIST_SOC4_T2_I5_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T2_I6_WERT = (RXBUF_UINT32(140)/10.0f);
// Duration at 50% less than SoC less than 70%. 0 ° C less than temperature less than 10 ° C. -0.5xC A less than
// current less than 0.0xC A / Dauer bei 50 % kleiner als SoC kleiner als 70 %. 0°C kleiner als Temperatur
// kleiner als 10 °C. -0,5xC A kleiner als Strom kleiner als 0,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_1", "STAT_HV_BATT_HIST_SOC4_T2_I6_WERT", STAT_HV_BATT_HIST_SOC4_T2_I6_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T2_I7_WERT = (RXBUF_UINT32(144)/10.0f);
// Duration at 50% less than SoC less than 70%. 0 ° C less than temperature less than 10 ° C. 0.0xC A less than
// current less than 0.5xC A / Dauer bei 50 % kleiner als SoC kleiner als 70 %. 0°C kleiner als Temperatur
// kleiner als 10 °C. 0,0xC A kleiner als Strom kleiner als 0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_1", "STAT_HV_BATT_HIST_SOC4_T2_I7_WERT", STAT_HV_BATT_HIST_SOC4_T2_I7_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T2_I8_WERT = (RXBUF_UINT32(148)/10.0f);
// Duration at 50% less than SoC less than 70%. 0 ° C less than temperature less than 10 ° C. 0.5xC A less than
// current less than 1.0xC A / Dauer bei 50 % kleiner als SoC kleiner als 70 %. 0°C kleiner als Temperatur
// kleiner als 10 °C. 0,5xC A kleiner als Strom kleiner als 1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_1", "STAT_HV_BATT_HIST_SOC4_T2_I8_WERT", STAT_HV_BATT_HIST_SOC4_T2_I8_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T2_I9_WERT = (RXBUF_UINT32(152)/10.0f);
// Duration at 50% less than SoC less than 70%. 0 ° C less than temperature less than 10 ° C. 1.0xC A less than
// current less than 1.5xC A / Dauer bei 50 % kleiner als SoC kleiner als 70 %. 0°C kleiner als Temperatur
// kleiner als 10 °C. 1,0xC A kleiner als Strom kleiner als 1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_1", "STAT_HV_BATT_HIST_SOC4_T2_I9_WERT", STAT_HV_BATT_HIST_SOC4_T2_I9_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T2_I10_WERT = (RXBUF_UINT32(156)/10.0f);
// Duration at 50% less than SoC less than 70%. 0 ° C less than temperature less than 10 ° C. 1.5xC A less than
// current / Dauer bei 50 % kleiner als SoC kleiner als 70 %. 0°C kleiner als Temperatur kleiner als 10 °C.
// 1,5xC A kleiner als Strom
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_1", "STAT_HV_BATT_HIST_SOC4_T2_I10_WERT", STAT_HV_BATT_HIST_SOC4_T2_I10_WERT, "\"s\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_HV_BATT_HIST_SOC_T3_1: { // 0xDD96
if (datalen < 160) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_HV_BATT_HIST_SOC_T3_1", 160);
break;
}
float STAT_HV_BATT_HIST_SOC1_T3_I1_WERT = (RXBUF_UINT32(0)/10.0f);
// Duration with SoC less than 10%. 10 ° C less than temperature less than 20 ° C. Current less than -2.5xC A /
// Dauer bei SoC kleiner als 10%. 10°C kleiner als Temperatur kleiner als 20°C. Strom kleiner als -2,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_1", "STAT_HV_BATT_HIST_SOC1_T3_I1_WERT", STAT_HV_BATT_HIST_SOC1_T3_I1_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T3_I2_WERT = (RXBUF_UINT32(4)/10.0f);
// Duration with SoC less than 10%. 10 ° C less than temperature less than 20 ° C. -2.5xC A less than current
// less than -2.0xC A / Dauer bei SoC kleiner als 10%. 10°C kleiner als Temperatur kleiner als 20°C. -2,5xC A
// kleiner als Strom kleiner als -2,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_1", "STAT_HV_BATT_HIST_SOC1_T3_I2_WERT", STAT_HV_BATT_HIST_SOC1_T3_I2_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T3_I3_WERT = (RXBUF_UINT32(8)/10.0f);
// Duration with SoC less than 10%. 10 ° C less than temperature less than 20 ° C. -2.0xC A less than current
// less than -1.5xC A / Dauer bei SoC kleiner als 10%. 10°C kleiner als Temperatur kleiner als 20°C. -2,0xC A
// kleiner als Strom kleiner als -1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_1", "STAT_HV_BATT_HIST_SOC1_T3_I3_WERT", STAT_HV_BATT_HIST_SOC1_T3_I3_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T3_I4_WERT = (RXBUF_UINT32(12)/10.0f);
// Duration with SoC less than 10%. 10 ° C less than temperature less than 20 ° C. -1.5xC A less than current
// less than -1.0xC A / Dauer bei SoC kleiner als 10%. 10°C kleiner als Temperatur kleiner als 20°C. -1,5xC A
// kleiner als Strom kleiner als -1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_1", "STAT_HV_BATT_HIST_SOC1_T3_I4_WERT", STAT_HV_BATT_HIST_SOC1_T3_I4_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T3_I5_WERT = (RXBUF_UINT32(16)/10.0f);
// Duration with SoC less than 10%. 10 ° C less than temperature less than 20 ° C. -1.0xC A less than current
// less than -0.5xC A / Dauer bei SoC kleiner als 10%. 10°C kleiner als Temperatur kleiner als 20°C. -1,0xC A
// kleiner als Strom kleiner als -0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_1", "STAT_HV_BATT_HIST_SOC1_T3_I5_WERT", STAT_HV_BATT_HIST_SOC1_T3_I5_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T3_I6_WERT = (RXBUF_UINT32(20)/10.0f);
// Duration with SoC less than 10%. 10 ° C less than temperature less than 20 ° C. -0.5xC A less than current
// less than 0.0xC A / Dauer bei SoC kleiner als 10%. 10°C kleiner als Temperatur kleiner als 20°C. -0,5xC A
// kleiner als Strom kleiner als 0,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_1", "STAT_HV_BATT_HIST_SOC1_T3_I6_WERT", STAT_HV_BATT_HIST_SOC1_T3_I6_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T3_I7_WERT = (RXBUF_UINT32(24)/10.0f);
// Duration with SoC less than 10%. 10 ° C less than temperature less than 20 ° C. 0.0xC A less than current less
// than 0.5xC A / Dauer bei SoC kleiner als 10%. 10°C kleiner als Temperatur kleiner als 20°C. 0,0xC A kleiner
// als Strom kleiner als 0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_1", "STAT_HV_BATT_HIST_SOC1_T3_I7_WERT", STAT_HV_BATT_HIST_SOC1_T3_I7_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T3_I8_WERT = (RXBUF_UINT32(28)/10.0f);
// Duration with SoC less than 10%. 10 ° C less than temperature less than 20 ° C. 0.5xC A less than current less
// than 1.0xC A / Dauer bei SoC kleiner als 10%. 10°C kleiner als Temperatur kleiner als 20°C. 0,5xC A kleiner
// als Strom kleiner als 1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_1", "STAT_HV_BATT_HIST_SOC1_T3_I8_WERT", STAT_HV_BATT_HIST_SOC1_T3_I8_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T3_I9_WERT = (RXBUF_UINT32(32)/10.0f);
// Duration with SoC less than 10%. 10 ° C less than temperature less than 20 ° C. 1.0xC A less than current less
// than 1.5xC A / Dauer bei SoC kleiner als 10%. 10°C kleiner als Temperatur kleiner als 20°C. 1,0xC A kleiner
// als Strom kleiner als 1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_1", "STAT_HV_BATT_HIST_SOC1_T3_I9_WERT", STAT_HV_BATT_HIST_SOC1_T3_I9_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T3_I10_WERT = (RXBUF_UINT32(36)/10.0f);
// Duration with SoC less than 10%. 10 ° C less than temperature less than 20 ° C. 1.5xC A less than current /
// Dauer bei SoC kleiner als 10%. 10°C kleiner als Temperatur kleiner als 20°C. 1,5xC A kleiner als Strom
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_1", "STAT_HV_BATT_HIST_SOC1_T3_I10_WERT", STAT_HV_BATT_HIST_SOC1_T3_I10_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T3_I1_WERT = (RXBUF_UINT32(40)/10.0f);
// Duration at 10% less than SoC less than 30%. 10 ° C less than temperature less than 20 ° C. Current less than
// -2.5xC A / Dauer bei 10% kleiner als SoC kleiner als 30%. 10°C kleiner als Temperatur kleiner als 20°C. Strom
// kleiner als -2,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_1", "STAT_HV_BATT_HIST_SOC2_T3_I1_WERT", STAT_HV_BATT_HIST_SOC2_T3_I1_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T3_I2_WERT = (RXBUF_UINT32(44)/10.0f);
// Duration at 10% less than SoC less than 30%. 10 ° C less than temperature less than 20 ° C. -2.5xC A less than
// current less than -2.0xC A / Dauer bei 10% kleiner als SoC kleiner als 30%. 10°C kleiner als Temperatur
// kleiner als 20°C. -2,5xC A kleiner als Strom kleiner als -2,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_1", "STAT_HV_BATT_HIST_SOC2_T3_I2_WERT", STAT_HV_BATT_HIST_SOC2_T3_I2_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T3_I3_WERT = (RXBUF_UINT32(48)/10.0f);
// Duration at 10% less than SoC less than 30%. 10 ° C less than temperature less than 20 ° C. -2.0xC A less than
// current less than -1.5xC A / Dauer bei 10% kleiner als SoC kleiner als 30%. 10°C kleiner als Temperatur
// kleiner als 20°C. -2,0xC A kleiner als Strom kleiner als -1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_1", "STAT_HV_BATT_HIST_SOC2_T3_I3_WERT", STAT_HV_BATT_HIST_SOC2_T3_I3_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T3_I4_WERT = (RXBUF_UINT32(52)/10.0f);
// Duration at 10% less than SoC less than 30%. 10 ° C less than temperature less than 20 ° C. -1.5xC A less than
// current less than -1.0xC A / Dauer bei 10% kleiner als SoC kleiner als 30%. 10°C kleiner als Temperatur
// kleiner als 20°C. -1,5xC A kleiner als Strom kleiner als -1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_1", "STAT_HV_BATT_HIST_SOC2_T3_I4_WERT", STAT_HV_BATT_HIST_SOC2_T3_I4_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T3_I5_WERT = (RXBUF_UINT32(56)/10.0f);
// Duration at 10% less than SoC less than 30%. 10 ° C less than temperature less than 20 ° C. -1.0xC A less than
// current less than -0.5xC A / Dauer bei 10% kleiner als SoC kleiner als 30%. 10°C kleiner als Temperatur
// kleiner als 20°C. -1,0xC A kleiner als Strom kleiner als -0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_1", "STAT_HV_BATT_HIST_SOC2_T3_I5_WERT", STAT_HV_BATT_HIST_SOC2_T3_I5_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T3_I6_WERT = (RXBUF_UINT32(60)/10.0f);
// Duration at 10% less than SoC less than 30%. 10 ° C less than temperature less than 20 ° C. -0.5xC A less than
// current less than 0.0xC A / Dauer bei 10% kleiner als SoC kleiner als 30%. 10°C kleiner als Temperatur kleiner
// als 20°C. -0,5xC A kleiner als Strom kleiner als 0,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_1", "STAT_HV_BATT_HIST_SOC2_T3_I6_WERT", STAT_HV_BATT_HIST_SOC2_T3_I6_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T3_I7_WERT = (RXBUF_UINT32(64)/10.0f);
// Duration at 10% less than SoC less than 30%. 10 ° C less than temperature less than 20 ° C. 0.0xC A less than
// current less than 0.5xC A / Dauer bei 10% kleiner als SoC kleiner als 30%. 10°C kleiner als Temperatur kleiner
// als 20°C. 0,0xC A kleiner als Strom kleiner als 0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_1", "STAT_HV_BATT_HIST_SOC2_T3_I7_WERT", STAT_HV_BATT_HIST_SOC2_T3_I7_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T3_I8_WERT = (RXBUF_UINT32(68)/10.0f);
// Duration at 10% less than SoC less than 30%. 10 ° C less than temperature less than 20 ° C. 0.5xC A less than
// current less than 1.0xC A / Dauer bei 10% kleiner als SoC kleiner als 30%. 10°C kleiner als Temperatur kleiner
// als 20°C. 0,5xC A kleiner als Strom kleiner als 1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_1", "STAT_HV_BATT_HIST_SOC2_T3_I8_WERT", STAT_HV_BATT_HIST_SOC2_T3_I8_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T3_I9_WERT = (RXBUF_UINT32(72)/10.0f);
// Duration at 10% less than SoC less than 30%. 10 ° C less than temperature less than 20 ° C. 1.0xC A less than
// current less than 1.5xC A / Dauer bei 10% kleiner als SoC kleiner als 30%. 10°C kleiner als Temperatur kleiner
// als 20°C. 1,0xC A kleiner als Strom kleiner als 1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_1", "STAT_HV_BATT_HIST_SOC2_T3_I9_WERT", STAT_HV_BATT_HIST_SOC2_T3_I9_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T3_I10_WERT = (RXBUF_UINT32(76)/10.0f);
// Duration at 10% less than SoC less than 30%. 10 ° C less than temperature less than 20 ° C. 1.5xC A less than
// current / Dauer bei 10% kleiner als SoC kleiner als 30%. 10°C kleiner als Temperatur kleiner als 20°C. 1,5xC A
// kleiner als Strom
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_1", "STAT_HV_BATT_HIST_SOC2_T3_I10_WERT", STAT_HV_BATT_HIST_SOC2_T3_I10_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T3_I1_WERT = (RXBUF_UINT32(80)/10.0f);
// Duration at 30% less than SoC less than 50%. 10 ° C less than temperature less than 20 ° C. Current less than
// -2.5xC A / Dauer bei 30% kleiner als SoC kleiner als 50%. 10°C kleiner als Temperatur kleiner als 20°C. Strom
// kleiner als -2,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_1", "STAT_HV_BATT_HIST_SOC3_T3_I1_WERT", STAT_HV_BATT_HIST_SOC3_T3_I1_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T3_I2_WERT = (RXBUF_UINT32(84)/10.0f);
// Duration at 30% less than SoC less than 50%. 10 ° C less than temperature less than 20 ° C. -2.5xC A less than
// current less than -2.0xC A / Dauer bei 30% kleiner als SoC kleiner als 50%. 10°C kleiner als Temperatur
// kleiner als 20°C. -2,5xC A kleiner als Strom kleiner als -2,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_1", "STAT_HV_BATT_HIST_SOC3_T3_I2_WERT", STAT_HV_BATT_HIST_SOC3_T3_I2_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T3_I3_WERT = (RXBUF_UINT32(88)/10.0f);
// Duration at 30% less than SoC less than 50%. 10 ° C less than temperature less than 20 ° C. -2.0xC A less than
// current less than -1.5xC A / Dauer bei 30% kleiner als SoC kleiner als 50%. 10°C kleiner als Temperatur
// kleiner als 20°C. -2,0xC A kleiner als Strom kleiner als -1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_1", "STAT_HV_BATT_HIST_SOC3_T3_I3_WERT", STAT_HV_BATT_HIST_SOC3_T3_I3_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T3_I4_WERT = (RXBUF_UINT32(92)/10.0f);
// Duration at 30% less than SoC less than 50%. 10 ° C less than temperature less than 20 ° C. -1.5xC A less than
// current less than -1.0xC A / Dauer bei 30% kleiner als SoC kleiner als 50%. 10°C kleiner als Temperatur
// kleiner als 20°C. -1,5xC A kleiner als Strom kleiner als -1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_1", "STAT_HV_BATT_HIST_SOC3_T3_I4_WERT", STAT_HV_BATT_HIST_SOC3_T3_I4_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T3_I5_WERT = (RXBUF_UINT32(96)/10.0f);
// Duration at 30% less than SoC less than 50%. 10 ° C less than temperature less than 20 ° C. -1.0xC A less than
// current less than -0.5xC A / Dauer bei 30% kleiner als SoC kleiner als 50%. 10°C kleiner als Temperatur
// kleiner als 20°C. -1,0xC A kleiner als Strom kleiner als -0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_1", "STAT_HV_BATT_HIST_SOC3_T3_I5_WERT", STAT_HV_BATT_HIST_SOC3_T3_I5_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T3_I6_WERT = (RXBUF_UINT32(100)/10.0f);
// Duration at 30% less than SoC less than 50%. 10 ° C less than temperature less than 20 ° C. -0.5xC A less than
// current less than 0.0xC A / Dauer bei 30% kleiner als SoC kleiner als 50%. 10°C kleiner als Temperatur kleiner
// als 20°C. -0,5xC A kleiner als Strom kleiner als 0,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_1", "STAT_HV_BATT_HIST_SOC3_T3_I6_WERT", STAT_HV_BATT_HIST_SOC3_T3_I6_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T3_I7_WERT = (RXBUF_UINT32(104)/10.0f);
// Duration at 30% less than SoC less than 50%. 10 ° C less than temperature less than 20 ° C. 0.0xC A less than
// current less than 0.5xC A / Dauer bei 30% kleiner als SoC kleiner als 50%. 10°C kleiner als Temperatur kleiner
// als 20°C. 0,0xC A kleiner als Strom kleiner als 0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_1", "STAT_HV_BATT_HIST_SOC3_T3_I7_WERT", STAT_HV_BATT_HIST_SOC3_T3_I7_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T3_I8_WERT = (RXBUF_UINT32(108)/10.0f);
// Duration at 30% less than SoC less than 50%. 10 ° C less than temperature less than 20 ° C. 0.5xC A less than
// current less than 1.0xC A / Dauer bei 30% kleiner als SoC kleiner als 50%. 10°C kleiner als Temperatur kleiner
// als 20°C. 0,5xC A kleiner als Strom kleiner als 1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_1", "STAT_HV_BATT_HIST_SOC3_T3_I8_WERT", STAT_HV_BATT_HIST_SOC3_T3_I8_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T3_I9_WERT = (RXBUF_UINT32(112)/10.0f);
// Duration at 30% less than SoC less than 50%. 10 ° C less than temperature less than 20 ° C. 1.0xC A less than
// current less than 1.5xC A / Dauer bei 30% kleiner als SoC kleiner als 50%. 10°C kleiner als Temperatur kleiner
// als 20°C. 1,0xC A kleiner als Strom kleiner als 1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_1", "STAT_HV_BATT_HIST_SOC3_T3_I9_WERT", STAT_HV_BATT_HIST_SOC3_T3_I9_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T3_I10_WERT = (RXBUF_UINT32(116)/10.0f);
// Duration at 30% less than SoC less than 50%. 10 ° C less than temperature less than 20 ° C. 1.5xC A less than
// current / Dauer bei 30% kleiner als SoC kleiner als 50%. 10°C kleiner als Temperatur kleiner als 20°C. 1,5xC A
// kleiner als Strom
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_1", "STAT_HV_BATT_HIST_SOC3_T3_I10_WERT", STAT_HV_BATT_HIST_SOC3_T3_I10_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T3_I1_WERT = (RXBUF_UINT32(120)/10.0f);
// Duration at 50% less than SoC less than 70%. 10 ° C less than temperature less than 20 ° C. Current less than
// -2.5xC A / Dauer bei 50% kleiner als SoC kleiner als 70%. 10°C kleiner als Temperatur kleiner als 20°C. Strom
// kleiner als -2,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_1", "STAT_HV_BATT_HIST_SOC4_T3_I1_WERT", STAT_HV_BATT_HIST_SOC4_T3_I1_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T3_I2_WERT = (RXBUF_UINT32(124)/10.0f);
// Duration at 50% less than SoC less than 70%. 10 ° C less than temperature less than 20 ° C. -2.5xC A less than
// current less than -2.0xC A / Dauer bei 50% kleiner als SoC kleiner als 70%. 10°C kleiner als Temperatur
// kleiner als 20°C. -2,5xC A kleiner als Strom kleiner als -2,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_1", "STAT_HV_BATT_HIST_SOC4_T3_I2_WERT", STAT_HV_BATT_HIST_SOC4_T3_I2_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T3_I3_WERT = (RXBUF_UINT32(128)/10.0f);
// Duration at 50% less than SoC less than 70%. 10 ° C less than temperature less than 20 ° C. -2.0xC A less than
// current less than -1.5xC A / Dauer bei 50% kleiner als SoC kleiner als 70%. 10°C kleiner als Temperatur
// kleiner als 20°C. -2,0xC A kleiner als Strom kleiner als -1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_1", "STAT_HV_BATT_HIST_SOC4_T3_I3_WERT", STAT_HV_BATT_HIST_SOC4_T3_I3_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T3_I4_WERT = (RXBUF_UINT32(132)/10.0f);
// Duration at 50% less than SoC less than 70%. 10 ° C less than temperature less than 20 ° C. -1.5xC A less than
// current less than -1.0xC A / Dauer bei 50% kleiner als SoC kleiner als 70%. 10°C kleiner als Temperatur
// kleiner als 20°C. -1,5xC A kleiner als Strom kleiner als -1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_1", "STAT_HV_BATT_HIST_SOC4_T3_I4_WERT", STAT_HV_BATT_HIST_SOC4_T3_I4_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T3_I5_WERT = (RXBUF_UINT32(136)/10.0f);
// Duration at 50% less than SoC less than 70%. 10 ° C less than temperature less than 20 ° C. -1.0xC A less than
// current less than -0.5xC A / Dauer bei 50% kleiner als SoC kleiner als 70%. 10°C kleiner als Temperatur
// kleiner als 20°C. -1,0xC A kleiner als Strom kleiner als -0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_1", "STAT_HV_BATT_HIST_SOC4_T3_I5_WERT", STAT_HV_BATT_HIST_SOC4_T3_I5_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T3_I6_WERT = (RXBUF_UINT32(140)/10.0f);
// Duration at 50% less than SoC less than 70%. 10 ° C less than temperature less than 20 ° C. -0.5xC A less than
// current less than 0.0xC A / Dauer bei 50% kleiner als SoC kleiner als 70%. 10°C kleiner als Temperatur kleiner
// als 20°C. -0,5xC A kleiner als Strom kleiner als 0,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_1", "STAT_HV_BATT_HIST_SOC4_T3_I6_WERT", STAT_HV_BATT_HIST_SOC4_T3_I6_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T3_I7_WERT = (RXBUF_UINT32(144)/10.0f);
// Duration at 50% less than SoC less than 70%. 10 ° C less than temperature less than 20 ° C. 0.0xC A less than
// current less than 0.5xC A / Dauer bei 50% kleiner als SoC kleiner als 70%. 10°C kleiner als Temperatur kleiner
// als 20°C. 0,0xC A kleiner als Strom kleiner als 0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_1", "STAT_HV_BATT_HIST_SOC4_T3_I7_WERT", STAT_HV_BATT_HIST_SOC4_T3_I7_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T3_I8_WERT = (RXBUF_UINT32(148)/10.0f);
// Duration at 50% less than SoC less than 70%. 10 ° C less than temperature less than 20 ° C. 0.5xC A less than
// current less than 1.0xC A / Dauer bei 50% kleiner als SoC kleiner als 70%. 10°C kleiner als Temperatur kleiner
// als 20°C. 0,5xC A kleiner als Strom kleiner als 1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_1", "STAT_HV_BATT_HIST_SOC4_T3_I8_WERT", STAT_HV_BATT_HIST_SOC4_T3_I8_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T3_I9_WERT = (RXBUF_UINT32(152)/10.0f);
// Duration at 50% less than SoC less than 70%. 10 ° C less than temperature less than 20 ° C. 1.0xC A less than
// current less than 1.5xC A / Dauer bei 50% kleiner als SoC kleiner als 70%. 10°C kleiner als Temperatur kleiner
// als 20°C. 1,0xC A kleiner als Strom kleiner als 1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_1", "STAT_HV_BATT_HIST_SOC4_T3_I9_WERT", STAT_HV_BATT_HIST_SOC4_T3_I9_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T3_I10_WERT = (RXBUF_UINT32(156)/10.0f);
// Duration at 50% less than SoC less than 70%. 10 ° C less than temperature less than 20 ° C. 1.5xC A less than
// current / Dauer bei 50% kleiner als SoC kleiner als 70%. 10°C kleiner als Temperatur kleiner als 20°C. 1,5xC A
// kleiner als Strom
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_1", "STAT_HV_BATT_HIST_SOC4_T3_I10_WERT", STAT_HV_BATT_HIST_SOC4_T3_I10_WERT, "\"s\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_HV_BATT_HIST_SOC_T4_1: { // 0xDD97
if (datalen < 160) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_HV_BATT_HIST_SOC_T4_1", 160);
break;
}
float STAT_HV_BATT_HIST_SOC1_T4_I1_WERT = (RXBUF_UINT32(0)/10.0f);
// Duration with SoC less than 10%. 20 ° C less than temperature less than 27.5 ° C. Current less than -2.5xC A /
// Dauer bei SoC kleiner als 10%. 20°C kleiner als Temperatur kleiner als 27,5°C. Strom kleiner als -2,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_1", "STAT_HV_BATT_HIST_SOC1_T4_I1_WERT", STAT_HV_BATT_HIST_SOC1_T4_I1_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T4_I2_WERT = (RXBUF_UINT32(4)/10.0f);
// Duration with SoC less than 10%. 20 ° C less than temperature less than 27.5 ° C. -2.5xC A less than current
// less than -2.0xC A / Dauer bei SoC kleiner als 10%. 20°C kleiner als Temperatur kleiner als 27,5°C. -2,5xC A
// kleiner als Strom kleiner als -2,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_1", "STAT_HV_BATT_HIST_SOC1_T4_I2_WERT", STAT_HV_BATT_HIST_SOC1_T4_I2_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T4_I3_WERT = (RXBUF_UINT32(8)/10.0f);
// Duration with SoC less than 10%. 20 ° C less than temperature less than 27.5 ° C. -2.0xC A less than current
// less than -1.5xC A / Dauer bei SoC kleiner als 10%. 20°C kleiner als Temperatur kleiner als 27,5°C. -2,0xC A
// kleiner als Strom kleiner als -1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_1", "STAT_HV_BATT_HIST_SOC1_T4_I3_WERT", STAT_HV_BATT_HIST_SOC1_T4_I3_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T4_I4_WERT = (RXBUF_UINT32(12)/10.0f);
// Duration with SoC less than 10%. 20 ° C less than temperature less than 27.5 ° C. -1.5xC A less than current
// less than -1.0xC A / Dauer bei SoC kleiner als 10%. 20°C kleiner als Temperatur kleiner als 27,5°C. -1,5xC A
// kleiner als Strom kleiner als -1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_1", "STAT_HV_BATT_HIST_SOC1_T4_I4_WERT", STAT_HV_BATT_HIST_SOC1_T4_I4_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T4_I5_WERT = (RXBUF_UINT32(16)/10.0f);
// Duration with SoC less than 10%. 20 ° C less than temperature less than 27.5 ° C. -1.0xC A less than current
// less than -0.5xC A / Dauer bei SoC kleiner als 10%. 20°C kleiner als Temperatur kleiner als 27,5°C. -1,0xC A
// kleiner als Strom kleiner als -0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_1", "STAT_HV_BATT_HIST_SOC1_T4_I5_WERT", STAT_HV_BATT_HIST_SOC1_T4_I5_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T4_I6_WERT = (RXBUF_UINT32(20)/10.0f);
// Duration with SoC less than 10%. 20 ° C less than temperature less than 27.5 ° C. -0.5xC A less than current
// less than 0.0xC A / Dauer bei SoC kleiner als 10%. 20°C kleiner als Temperatur kleiner als 27,5°C. -0,5xC A
// kleiner als Strom kleiner als 0,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_1", "STAT_HV_BATT_HIST_SOC1_T4_I6_WERT", STAT_HV_BATT_HIST_SOC1_T4_I6_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T4_I7_WERT = (RXBUF_UINT32(24)/10.0f);
// Duration with SoC less than 10%. 20 ° C less than temperature less than 27.5 ° C. 0.0xC A less than current
// less than 0.5xC A / Dauer bei SoC kleiner als 10%. 20°C kleiner als Temperatur kleiner als 27,5°C. 0,0xC A
// kleiner als Strom kleiner als 0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_1", "STAT_HV_BATT_HIST_SOC1_T4_I7_WERT", STAT_HV_BATT_HIST_SOC1_T4_I7_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T4_I8_WERT = (RXBUF_UINT32(28)/10.0f);
// Duration with SoC less than 10%. 20 ° C less than temperature less than 27.5 ° C. 0.5xC A less than current
// less than 1.0xC A / Dauer bei SoC kleiner als 10%. 20°C kleiner als Temperatur kleiner als 27,5°C. 0,5xC A
// kleiner als Strom kleiner als 1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_1", "STAT_HV_BATT_HIST_SOC1_T4_I8_WERT", STAT_HV_BATT_HIST_SOC1_T4_I8_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T4_I9_WERT = (RXBUF_UINT32(32)/10.0f);
// Duration with SoC less than 10%. 20 ° C less than temperature less than 27.5 ° C. 1.0xC A less than current
// less than 1.5xC A / Dauer bei SoC kleiner als 10%. 20°C kleiner als Temperatur kleiner als 27,5°C. 1,0xC A
// kleiner als Strom kleiner als 1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_1", "STAT_HV_BATT_HIST_SOC1_T4_I9_WERT", STAT_HV_BATT_HIST_SOC1_T4_I9_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T4_I10_WERT = (RXBUF_UINT32(36)/10.0f);
// Duration with SoC less than 10%. 20 ° C less than temperature less than 27.5 ° C. 1.5xC A less than current /
// Dauer bei SoC kleiner als 10%. 20°C kleiner als Temperatur kleiner als 27,5°C. 1,5xC A kleiner als Strom
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_1", "STAT_HV_BATT_HIST_SOC1_T4_I10_WERT", STAT_HV_BATT_HIST_SOC1_T4_I10_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T4_I1_WERT = (RXBUF_UINT32(40)/10.0f);
// Duration at 10% less than SoC less than 30%. 20 ° C less than temperature less than 27.5 ° C. Current less
// than -2.5xC A / Dauer bei 10% kleiner als SoC kleiner als 30%. 20°C kleiner als Temperatur kleiner als 27,5°C.
// Strom kleiner als -2,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_1", "STAT_HV_BATT_HIST_SOC2_T4_I1_WERT", STAT_HV_BATT_HIST_SOC2_T4_I1_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T4_I2_WERT = (RXBUF_UINT32(44)/10.0f);
// Duration at 10% less than SoC less than 30%. 20 ° C less than temperature less than 27.5 ° C. -2.5xC A less
// than current less than -2.0xC A / Dauer bei 10% kleiner als SoC kleiner als 30%. 20°C kleiner als Temperatur
// kleiner als 27,5°C. -2,5xC A kleiner als Strom kleiner als -2,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_1", "STAT_HV_BATT_HIST_SOC2_T4_I2_WERT", STAT_HV_BATT_HIST_SOC2_T4_I2_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T4_I3_WERT = (RXBUF_UINT32(48)/10.0f);
// Duration at 10% less than SoC less than 30%. 20 ° C less than temperature less than 27.5 ° C. -2.0xC A less
// than current less than -1.5xC A / Dauer bei 10% kleiner als SoC kleiner als 30%. 20°C kleiner als Temperatur
// kleiner als 27,5°C. -2,0xC A kleiner als Strom kleiner als -1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_1", "STAT_HV_BATT_HIST_SOC2_T4_I3_WERT", STAT_HV_BATT_HIST_SOC2_T4_I3_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T4_I4_WERT = (RXBUF_UINT32(52)/10.0f);
// Duration at 10% less than SoC less than 30%. 20 ° C less than temperature less than 27.5 ° C. -1.5xC A less
// than current less than -1.0xC A / Dauer bei 10% kleiner als SoC kleiner als 30%. 20°C kleiner als Temperatur
// kleiner als 27,5°C. -1,5xC A kleiner als Strom kleiner als -1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_1", "STAT_HV_BATT_HIST_SOC2_T4_I4_WERT", STAT_HV_BATT_HIST_SOC2_T4_I4_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T4_I5_WERT = (RXBUF_UINT32(56)/10.0f);
// Duration at 10% less than SoC less than 30%. 20 ° C less than temperature less than 27.5 ° C. -1.0xC A less
// than current less than -0.5xC A / Dauer bei 10% kleiner als SoC kleiner als 30%. 20°C kleiner als Temperatur
// kleiner als 27,5°C. -1,0xC A kleiner als Strom kleiner als -0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_1", "STAT_HV_BATT_HIST_SOC2_T4_I5_WERT", STAT_HV_BATT_HIST_SOC2_T4_I5_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T4_I6_WERT = (RXBUF_UINT32(60)/10.0f);
// Duration at 10% less than SoC less than 30%. 20 ° C less than temperature less than 27.5 ° C. -0.5xC A less
// than current less than 0.0xC A / Dauer bei 10% kleiner als SoC kleiner als 30%. 20°C kleiner als Temperatur
// kleiner als 27,5°C. -0,5xC A kleiner als Strom kleiner als 0,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_1", "STAT_HV_BATT_HIST_SOC2_T4_I6_WERT", STAT_HV_BATT_HIST_SOC2_T4_I6_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T4_I7_WERT = (RXBUF_UINT32(64)/10.0f);
// Duration at 10% less than SoC less than 30%. 20 ° C less than temperature less than 27.5 ° C. 0.0xC A less
// than current less than 0.5xC A / Dauer bei 10% kleiner als SoC kleiner als 30%. 20°C kleiner als Temperatur
// kleiner als 27,5°C. 0,0xC A kleiner als Strom kleiner als 0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_1", "STAT_HV_BATT_HIST_SOC2_T4_I7_WERT", STAT_HV_BATT_HIST_SOC2_T4_I7_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T4_I8_WERT = (RXBUF_UINT32(68)/10.0f);
// Duration at 10% less than SoC less than 30%. 20 ° C less than temperature less than 27.5 ° C. 0.5xC A less
// than current less than 1.0xC A / Dauer bei 10% kleiner als SoC kleiner als 30%. 20°C kleiner als Temperatur
// kleiner als 27,5°C. 0,5xC A kleiner als Strom kleiner als 1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_1", "STAT_HV_BATT_HIST_SOC2_T4_I8_WERT", STAT_HV_BATT_HIST_SOC2_T4_I8_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T4_I9_WERT = (RXBUF_UINT32(72)/10.0f);
// Duration at 10% less than SoC less than 30%. 20 ° C less than temperature less than 27.5 ° C. 1.0xC A less
// than current less than 1.5xC A / Dauer bei 10% kleiner als SoC kleiner als 30%. 20°C kleiner als Temperatur
// kleiner als 27,5°C. 1,0xC A kleiner als Strom kleiner als 1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_1", "STAT_HV_BATT_HIST_SOC2_T4_I9_WERT", STAT_HV_BATT_HIST_SOC2_T4_I9_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T4_I10_WERT = (RXBUF_UINT32(76)/10.0f);
// Duration at 10% less than SoC less than 30%. 20 ° C less than temperature less than 27.5 ° C. 1.5xC A less
// than current / Dauer bei 10% kleiner als SoC kleiner als 30%. 20°C kleiner als Temperatur kleiner als 27,5°C.
// 1,5xC A kleiner als Strom
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_1", "STAT_HV_BATT_HIST_SOC2_T4_I10_WERT", STAT_HV_BATT_HIST_SOC2_T4_I10_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T4_I1_WERT = (RXBUF_UINT32(80)/10.0f);
// Duration at 30% less than SoC less than 50%. 20 ° C less than temperature less than 27.5 ° C. Current less
// than -2.5xC A / Dauer bei 30% kleiner als SoC kleiner als 50%. 20°C kleiner als Temperatur kleiner als 27,5°C.
// Strom kleiner als -2,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_1", "STAT_HV_BATT_HIST_SOC3_T4_I1_WERT", STAT_HV_BATT_HIST_SOC3_T4_I1_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T4_I2_WERT = (RXBUF_UINT32(84)/10.0f);
// Duration at 30% less than SoC less than 50%. 20 ° C less than temperature less than 27.5 ° C. -2.5xC A less
// than current less than -2.0xC A / Dauer bei 30% kleiner als SoC kleiner als 50%. 20°C kleiner als Temperatur
// kleiner als 27,5°C. -2,5xC A kleiner als Strom kleiner als -2,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_1", "STAT_HV_BATT_HIST_SOC3_T4_I2_WERT", STAT_HV_BATT_HIST_SOC3_T4_I2_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T4_I3_WERT = (RXBUF_UINT32(88)/10.0f);
// Duration at 30% less than SoC less than 50%. 20 ° C less than temperature less than 27.5 ° C. -2.0xC A less
// than current less than -1.5xC A / Dauer bei 30% kleiner als SoC kleiner als 50%. 20°C kleiner als Temperatur
// kleiner als 27,5°C. -2,0xC A kleiner als Strom kleiner als -1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_1", "STAT_HV_BATT_HIST_SOC3_T4_I3_WERT", STAT_HV_BATT_HIST_SOC3_T4_I3_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T4_I4_WERT = (RXBUF_UINT32(92)/10.0f);
// Duration at 30% less than SoC less than 50%. 20 ° C less than temperature less than 27.5 ° C. -1.5xC A less
// than current less than -1.0xC A / Dauer bei 30% kleiner als SoC kleiner als 50%. 20°C kleiner als Temperatur
// kleiner als 27,5°C. -1,5xC A kleiner als Strom kleiner als -1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_1", "STAT_HV_BATT_HIST_SOC3_T4_I4_WERT", STAT_HV_BATT_HIST_SOC3_T4_I4_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T4_I5_WERT = (RXBUF_UINT32(96)/10.0f);
// Duration at 30% less than SoC less than 50%. 20 ° C less than temperature less than 27.5 ° C. -1.0xC A less
// than current less than -0.5xC A / Dauer bei 30% kleiner als SoC kleiner als 50%. 20°C kleiner als Temperatur
// kleiner als 27,5°C. -1,0xC A kleiner als Strom kleiner als -0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_1", "STAT_HV_BATT_HIST_SOC3_T4_I5_WERT", STAT_HV_BATT_HIST_SOC3_T4_I5_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T4_I6_WERT = (RXBUF_UINT32(100)/10.0f);
// Duration at 30% less than SoC less than 50%. 20 ° C less than temperature less than 27.5 ° C. -0.5xC A less
// than current less than 0.0xC A / Dauer bei 30% kleiner als SoC kleiner als 50%. 20°C kleiner als Temperatur
// kleiner als 27,5°C. -0,5xC A kleiner als Strom kleiner als 0,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_1", "STAT_HV_BATT_HIST_SOC3_T4_I6_WERT", STAT_HV_BATT_HIST_SOC3_T4_I6_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T4_I7_WERT = (RXBUF_UINT32(104)/10.0f);
// Duration at 30% less than SoC less than 50%. 20 ° C less than temperature less than 27.5 ° C. 0.0xC A less
// than current less than 0.5xC A / Dauer bei 30% kleiner als SoC kleiner als 50%. 20°C kleiner als Temperatur
// kleiner als 27,5°C. 0,0xC A kleiner als Strom kleiner als 0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_1", "STAT_HV_BATT_HIST_SOC3_T4_I7_WERT", STAT_HV_BATT_HIST_SOC3_T4_I7_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T4_I8_WERT = (RXBUF_UINT32(108)/10.0f);
// Duration at 30% less than SoC less than 50%. 20 ° C less than temperature less than 27.5 ° C. 0.5xC A less
// than current less than 1.0xC A / Dauer bei 30% kleiner als SoC kleiner als 50%. 20°C kleiner als Temperatur
// kleiner als 27,5°C. 0,5xC A kleiner als Strom kleiner als 1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_1", "STAT_HV_BATT_HIST_SOC3_T4_I8_WERT", STAT_HV_BATT_HIST_SOC3_T4_I8_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T4_I9_WERT = (RXBUF_UINT32(112)/10.0f);
// Duration at 30% less than SoC less than 50%. 20 ° C less than temperature less than 27.5 ° C. 1.0xC A less
// than current less than 1.5xC A / Dauer bei 30% kleiner als SoC kleiner als 50%. 20°C kleiner als Temperatur
// kleiner als 27,5°C. 1,0xC A kleiner als Strom kleiner als 1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_1", "STAT_HV_BATT_HIST_SOC3_T4_I9_WERT", STAT_HV_BATT_HIST_SOC3_T4_I9_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T4_I10_WERT = (RXBUF_UINT32(116)/10.0f);
// Duration at 30% less than SoC less than 50%. 20 ° C less than temperature less than 27.5 ° C. 1.5xC A less
// than current / Dauer bei 30% kleiner als SoC kleiner als 50%. 20°C kleiner als Temperatur kleiner als 27,5°C.
// 1,5xC A kleiner als Strom
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_1", "STAT_HV_BATT_HIST_SOC3_T4_I10_WERT", STAT_HV_BATT_HIST_SOC3_T4_I10_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T4_I1_WERT = (RXBUF_UINT32(120)/10.0f);
// Duration at 50% less than SoC less than 70%. 20 ° C less than temperature less than 27.5 ° C. Current less
// than -2.5xC A / Dauer bei 50% kleiner als SoC kleiner als 70%. 20°C kleiner als Temperatur kleiner als 27,5°C.
// Strom kleiner als -2,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_1", "STAT_HV_BATT_HIST_SOC4_T4_I1_WERT", STAT_HV_BATT_HIST_SOC4_T4_I1_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T4_I2_WERT = (RXBUF_UINT32(124)/10.0f);
// Duration at 50% less than SoC less than 70%. 20 ° C less than temperature less than 27.5 ° C. -2.5xC A less
// than current less than -2.0xC A / Dauer bei 50% kleiner als SoC kleiner als 70%. 20°C kleiner als Temperatur
// kleiner als 27,5°C. -2,5xC A kleiner als Strom kleiner als -2,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_1", "STAT_HV_BATT_HIST_SOC4_T4_I2_WERT", STAT_HV_BATT_HIST_SOC4_T4_I2_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T4_I3_WERT = (RXBUF_UINT32(128)/10.0f);
// Duration at 50% less than SoC less than 70%. 20 ° C less than temperature less than 27.5 ° C. -2.0xC A less
// than current less than -1.5xC A / Dauer bei 50% kleiner als SoC kleiner als 70%. 20°C kleiner als Temperatur
// kleiner als 27,5°C. -2,0xC A kleiner als Strom kleiner als -1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_1", "STAT_HV_BATT_HIST_SOC4_T4_I3_WERT", STAT_HV_BATT_HIST_SOC4_T4_I3_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T4_I4_WERT = (RXBUF_UINT32(132)/10.0f);
// Duration at 50% less than SoC less than 70%. 20 ° C less than temperature less than 27.5 ° C. -1.5xC A less
// than current less than -1.0xC A / Dauer bei 50% kleiner als SoC kleiner als 70%. 20°C kleiner als Temperatur
// kleiner als 27,5°C. -1,5xC A kleiner als Strom kleiner als -1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_1", "STAT_HV_BATT_HIST_SOC4_T4_I4_WERT", STAT_HV_BATT_HIST_SOC4_T4_I4_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T4_I5_WERT = (RXBUF_UINT32(136)/10.0f);
// Duration at 50% less than SoC less than 70%. 20 ° C less than temperature less than 27.5 ° C. -1.0xC A less
// than current less than -0.5xC A / Dauer bei 50% kleiner als SoC kleiner als 70%. 20°C kleiner als Temperatur
// kleiner als 27,5°C. -1,0xC A kleiner als Strom kleiner als -0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_1", "STAT_HV_BATT_HIST_SOC4_T4_I5_WERT", STAT_HV_BATT_HIST_SOC4_T4_I5_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T4_I6_WERT = (RXBUF_UINT32(140)/10.0f);
// Duration at 50% less than SoC less than 70%. 20 ° C less than temperature less than 27.5 ° C. -0.5xC A less
// than current less than 0.0xC A / Dauer bei 50% kleiner als SoC kleiner als 70%. 20°C kleiner als Temperatur
// kleiner als 27,5°C. -0,5xC A kleiner als Strom kleiner als 0,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_1", "STAT_HV_BATT_HIST_SOC4_T4_I6_WERT", STAT_HV_BATT_HIST_SOC4_T4_I6_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T4_I7_WERT = (RXBUF_UINT32(144)/10.0f);
// Duration at 50% less than SoC less than 70%. 20 ° C less than temperature less than 27.5 ° C. 0.0xC A less
// than current less than 0.5xC A / Dauer bei 50% kleiner als SoC kleiner als 70%. 20°C kleiner als Temperatur
// kleiner als 27,5°C. 0,0xC A kleiner als Strom kleiner als 0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_1", "STAT_HV_BATT_HIST_SOC4_T4_I7_WERT", STAT_HV_BATT_HIST_SOC4_T4_I7_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T4_I8_WERT = (RXBUF_UINT32(148)/10.0f);
// Duration at 50% less than SoC less than 70%. 20 ° C less than temperature less than 27.5 ° C. 0.5xC A less
// than current less than 1.0xC A / Dauer bei 50% kleiner als SoC kleiner als 70%. 20°C kleiner als Temperatur
// kleiner als 27,5°C. 0,5xC A kleiner als Strom kleiner als 1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_1", "STAT_HV_BATT_HIST_SOC4_T4_I8_WERT", STAT_HV_BATT_HIST_SOC4_T4_I8_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T4_I9_WERT = (RXBUF_UINT32(152)/10.0f);
// Duration at 50% less than SoC less than 70%. 20 ° C less than temperature less than 27.5 ° C. 1.0xC A less
// than current less than 1.5xC A / Dauer bei 50% kleiner als SoC kleiner als 70%. 20°C kleiner als Temperatur
// kleiner als 27,5°C. 1,0xC A kleiner als Strom kleiner als 1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_1", "STAT_HV_BATT_HIST_SOC4_T4_I9_WERT", STAT_HV_BATT_HIST_SOC4_T4_I9_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T4_I10_WERT = (RXBUF_UINT32(156)/10.0f);
// Duration at 50% less than SoC less than 70%. 20 ° C less than temperature less than 27.5 ° C. 1.5xC A less
// than current / Dauer bei 50% kleiner als SoC kleiner als 70%. 20°C kleiner als Temperatur kleiner als 27,5°C.
// 1,5xC A kleiner als Strom
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_1", "STAT_HV_BATT_HIST_SOC4_T4_I10_WERT", STAT_HV_BATT_HIST_SOC4_T4_I10_WERT, "\"s\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_HV_BATT_HIST_SOC_T5_1: { // 0xDD98
if (datalen < 160) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_HV_BATT_HIST_SOC_T5_1", 160);
break;
}
float STAT_HV_BATT_HIST_SOC1_T5_I1_WERT = (RXBUF_UINT32(0)/10.0f);
// Duration with SoC less than 10%. 27.5 ° C less than temperature less than 32.5 ° C. Current less than -2.5xC
// A. / Dauer bei SoC kleiner als 10%. 27,5°C kleiner als Temperatur kleiner als 32,5°C. Strom kleiner als -2,5xC
// A.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_1", "STAT_HV_BATT_HIST_SOC1_T5_I1_WERT", STAT_HV_BATT_HIST_SOC1_T5_I1_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T5_I2_WERT = (RXBUF_UINT32(4)/10.0f);
// Duration with SoC less than 10%. 27.5 ° C less than temperature less than 32.5 ° C. -2.5xC A less than current
// less than -2.0xC A. / Dauer bei SoC kleiner als 10%. 27,5°C kleiner als Temperatur kleiner als 32,5°C. -2,5xC
// A kleiner als Strom kleiner als -2,0xC A.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_1", "STAT_HV_BATT_HIST_SOC1_T5_I2_WERT", STAT_HV_BATT_HIST_SOC1_T5_I2_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T5_I3_WERT = (RXBUF_UINT32(8)/10.0f);
// Duration with SoC less than 10%. 27.5 ° C less than temperature less than 32.5 ° C. -2.0xC A less than current
// less than -1.5xC A. / Dauer bei SoC kleiner als 10%. 27,5°C kleiner als Temperatur kleiner als 32,5°C. -2,0xC
// A kleiner als Strom kleiner als -1,5xC A.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_1", "STAT_HV_BATT_HIST_SOC1_T5_I3_WERT", STAT_HV_BATT_HIST_SOC1_T5_I3_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T5_I4_WERT = (RXBUF_UINT32(12)/10.0f);
// Duration with SoC less than 10%. 27.5 ° C less than temperature less than 32.5 ° C. -1.5xC A less than current
// less than -1.0xC A. / Dauer bei SoC kleiner als 10%. 27,5°C kleiner als Temperatur kleiner als 32,5°C. -1,5xC
// A kleiner als Strom kleiner als -1,0xC A.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_1", "STAT_HV_BATT_HIST_SOC1_T5_I4_WERT", STAT_HV_BATT_HIST_SOC1_T5_I4_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T5_I5_WERT = (RXBUF_UINT32(16)/10.0f);
// Duration with SoC less than 10%. 27.5 ° C less than temperature less than 32.5 ° C. -1.0xC A less than current
// less than -0.5xC A. / Dauer bei SoC kleiner als 10%. 27,5°C kleiner als Temperatur kleiner als 32,5°C. -1,0xC
// A kleiner als Strom kleiner als -0,5xC A.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_1", "STAT_HV_BATT_HIST_SOC1_T5_I5_WERT", STAT_HV_BATT_HIST_SOC1_T5_I5_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T5_I6_WERT = (RXBUF_UINT32(20)/10.0f);
// Duration with SoC less than 10%. 27.5 ° C less than temperature less than 32.5 ° C. -0.5xC A less than current
// less than 0.0xC A. / Dauer bei SoC kleiner als 10%. 27,5°C kleiner als Temperatur kleiner als 32,5°C. -0,5xC A
// kleiner als Strom kleiner als 0,0xC A.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_1", "STAT_HV_BATT_HIST_SOC1_T5_I6_WERT", STAT_HV_BATT_HIST_SOC1_T5_I6_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T5_I7_WERT = (RXBUF_UINT32(24)/10.0f);
// Duration with SoC less than 10%. 27.5 ° C less than temperature less than 32.5 ° C. 0.0xC A less than current
// less than 0.5xC A. / Dauer bei SoC kleiner als 10%. 27,5°C kleiner als Temperatur kleiner als 32,5°C. 0,0xC A
// kleiner als Strom kleiner als 0,5xC A.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_1", "STAT_HV_BATT_HIST_SOC1_T5_I7_WERT", STAT_HV_BATT_HIST_SOC1_T5_I7_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T5_I8_WERT = (RXBUF_UINT32(28)/10.0f);
// Duration with SoC less than 10%. 27.5 ° C less than temperature less than 32.5 ° C. 0.5xC A less than current
// less than 1.0xC A. / Dauer bei SoC kleiner als 10%. 27,5°C kleiner als Temperatur kleiner als 32,5°C. 0,5xC A
// kleiner als Strom kleiner als 1,0xC A.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_1", "STAT_HV_BATT_HIST_SOC1_T5_I8_WERT", STAT_HV_BATT_HIST_SOC1_T5_I8_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T5_I9_WERT = (RXBUF_UINT32(32)/10.0f);
// Duration with SoC less than 10%. 27.5 ° C less than temperature less than 32.5 ° C. 1.0xC A less than current
// less than 1.5xC A. / Dauer bei SoC kleiner als 10%. 27,5°C kleiner als Temperatur kleiner als 32,5°C. 1,0xC A
// kleiner als Strom kleiner als 1,5xC A.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_1", "STAT_HV_BATT_HIST_SOC1_T5_I9_WERT", STAT_HV_BATT_HIST_SOC1_T5_I9_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T5_I10_WERT = (RXBUF_UINT32(36)/10.0f);
// Duration with SoC less than 10%. 27.5 ° C less than temperature less than 32.5 ° C. 1.5xC A less than current
// / Dauer bei SoC kleiner als 10%. 27,5°C kleiner als Temperatur kleiner als 32,5°C. 1,5xC A kleiner als Strom
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_1", "STAT_HV_BATT_HIST_SOC1_T5_I10_WERT", STAT_HV_BATT_HIST_SOC1_T5_I10_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T5_I1_WERT = (RXBUF_UINT32(40)/10.0f);
// Duration at 10% less than SoC less than 30%. 27.5 ° C less than temperature less than 32.5 ° C. Current less
// than -2.5xC A / Dauer bei 10% kleiner als SoC kleiner als 30%. 27,5°C kleiner als Temperatur kleiner als
// 32,5°C. Strom kleiner als -2,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_1", "STAT_HV_BATT_HIST_SOC2_T5_I1_WERT", STAT_HV_BATT_HIST_SOC2_T5_I1_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T5_I2_WERT = (RXBUF_UINT32(44)/10.0f);
// Duration at 10% less than SoC less than 30%. 27.5 ° C less than temperature less than 32.5 ° C. -2.5xC A less
// than current less than -2.0xC A / Dauer bei 10% kleiner als SoC kleiner als 30%. 27,5°C kleiner als Temperatur
// kleiner als 32,5°C. -2,5xC A kleiner als Strom kleiner als -2,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_1", "STAT_HV_BATT_HIST_SOC2_T5_I2_WERT", STAT_HV_BATT_HIST_SOC2_T5_I2_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T5_I3_WERT = (RXBUF_UINT32(48)/10.0f);
// Duration at 10% less than SoC less than 30%. 27.5 ° C less than temperature less than 32.5 ° C. -2.0xC A less
// than current less than -1.5xC A / Dauer bei 10% kleiner als SoC kleiner als 30%. 27,5°C kleiner als Temperatur
// kleiner als 32,5°C. -2,0xC A kleiner als Strom kleiner als -1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_1", "STAT_HV_BATT_HIST_SOC2_T5_I3_WERT", STAT_HV_BATT_HIST_SOC2_T5_I3_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T5_I4_WERT = (RXBUF_UINT32(52)/10.0f);
// Duration at 10% less than SoC less than 30%. 27.5 ° C less than temperature less than 32.5 ° C. -1.5xC A less
// than current less than -1.0xC A / Dauer bei 10% kleiner als SoC kleiner als 30%. 27,5°C kleiner als Temperatur
// kleiner als 32,5°C. -1,5xC A kleiner als Strom kleiner als -1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_1", "STAT_HV_BATT_HIST_SOC2_T5_I4_WERT", STAT_HV_BATT_HIST_SOC2_T5_I4_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T5_I5_WERT = (RXBUF_UINT32(56)/10.0f);
// Duration at 10% less than SoC less than 30%. 27.5 ° C less than temperature less than 32.5 ° C. -1.0xC A less
// than current less than -0.5xC A / Dauer bei 10% kleiner als SoC kleiner als 30%. 27,5°C kleiner als Temperatur
// kleiner als 32,5°C. -1,0xC A kleiner als Strom kleiner als -0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_1", "STAT_HV_BATT_HIST_SOC2_T5_I5_WERT", STAT_HV_BATT_HIST_SOC2_T5_I5_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T5_I6_WERT = (RXBUF_UINT32(60)/10.0f);
// Duration at 10% less than SoC less than 30%. 27.5 ° C less than temperature less than 32.5 ° C. -0.5xC A less
// than current less than 0.0xC A / Dauer bei 10% kleiner als SoC kleiner als 30%. 27,5°C kleiner als Temperatur
// kleiner als 32,5°C. -0,5xC A kleiner als Strom kleiner als 0,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_1", "STAT_HV_BATT_HIST_SOC2_T5_I6_WERT", STAT_HV_BATT_HIST_SOC2_T5_I6_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T5_I7_WERT = (RXBUF_UINT32(64)/10.0f);
// Duration at 10% less than SoC less than 30%. 27.5 ° C less than temperature less than 32.5 ° C. 0.0xC A less
// than current less than 0.5xC A / Dauer bei 10% kleiner als SoC kleiner als 30%. 27,5°C kleiner als Temperatur
// kleiner als 32,5°C. 0,0xC A kleiner als Strom kleiner als 0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_1", "STAT_HV_BATT_HIST_SOC2_T5_I7_WERT", STAT_HV_BATT_HIST_SOC2_T5_I7_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T5_I8_WERT = (RXBUF_UINT32(68)/10.0f);
// Duration at 10% less than SoC less than 30%. 27.5 ° C less than temperature less than 32.5 ° C. 0.5xC A less
// than current less than 1.0xC A / Dauer bei 10% kleiner als SoC kleiner als 30%. 27,5°C kleiner als Temperatur
// kleiner als 32,5°C. 0,5xC A kleiner als Strom kleiner als 1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_1", "STAT_HV_BATT_HIST_SOC2_T5_I8_WERT", STAT_HV_BATT_HIST_SOC2_T5_I8_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T5_I9_WERT = (RXBUF_UINT32(72)/10.0f);
// Duration at 10% less than SoC less than 30%. 27.5 ° C less than temperature less than 32.5 ° C. 1.0xC A less
// than current less than 1.5xC A / Dauer bei 10% kleiner als SoC kleiner als 30%. 27,5°C kleiner als Temperatur
// kleiner als 32,5°C. 1,0xC A kleiner als Strom kleiner als 1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_1", "STAT_HV_BATT_HIST_SOC2_T5_I9_WERT", STAT_HV_BATT_HIST_SOC2_T5_I9_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T5_I10_WERT = (RXBUF_UINT32(76)/10.0f);
// Duration at 10% less than SoC less than 30%. 27.5 ° C less than temperature less than 32.5 ° C. 1.5xC A less
// than current / Dauer bei 10% kleiner als SoC kleiner als 30%. 27,5°C kleiner als Temperatur kleiner als
// 32,5°C. 1,5xC A kleiner als Strom
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_1", "STAT_HV_BATT_HIST_SOC2_T5_I10_WERT", STAT_HV_BATT_HIST_SOC2_T5_I10_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T5_I1_WERT = (RXBUF_UINT32(80)/10.0f);
// Duration at 30% less than SoC less than 50%. 27.5 ° C less than temperature less than 32.5 ° C. Current less
// than -2.5xC A / Dauer bei 30% kleiner als SoC kleiner als 50%. 27,5°C kleiner als Temperatur kleiner als
// 32,5°C. Strom kleiner als -2,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_1", "STAT_HV_BATT_HIST_SOC3_T5_I1_WERT", STAT_HV_BATT_HIST_SOC3_T5_I1_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T5_I2_WERT = (RXBUF_UINT32(84)/10.0f);
// Duration at 30% less than SoC less than 50%. 27.5 ° C less than temperature less than 32.5 ° C. -2.5xC A less
// than current less than -2.0xC A / Dauer bei 30% kleiner als SoC kleiner als 50%. 27,5°C kleiner als Temperatur
// kleiner als 32,5°C. -2,5xC A kleiner als Strom kleiner als -2,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_1", "STAT_HV_BATT_HIST_SOC3_T5_I2_WERT", STAT_HV_BATT_HIST_SOC3_T5_I2_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T5_I3_WERT = (RXBUF_UINT32(88)/10.0f);
// Duration at 30% less than SoC less than 50%. 27.5 ° C less than temperature less than 32.5 ° C. -2.0xC A less
// than current less than -1.5xC A / Dauer bei 30% kleiner als SoC kleiner als 50%. 27,5°C kleiner als Temperatur
// kleiner als 32,5°C. -2,0xC A kleiner als Strom kleiner als -1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_1", "STAT_HV_BATT_HIST_SOC3_T5_I3_WERT", STAT_HV_BATT_HIST_SOC3_T5_I3_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T5_I4_WERT = (RXBUF_UINT32(92)/10.0f);
// Duration at 30% less than SoC less than 50%. 27.5 ° C less than temperature less than 32.5 ° C. -1.5xC A less
// than current less than -1.0xC A / Dauer bei 30% kleiner als SoC kleiner als 50%. 27,5°C kleiner als Temperatur
// kleiner als 32,5°C. -1,5xC A kleiner als Strom kleiner als -1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_1", "STAT_HV_BATT_HIST_SOC3_T5_I4_WERT", STAT_HV_BATT_HIST_SOC3_T5_I4_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T5_I5_WERT = (RXBUF_UINT32(96)/10.0f);
// Duration at 30% less than SoC less than 50%. 27.5 ° C less than temperature less than 32.5 ° C. -1.0xC A less
// than current less than -0.5xC A / Dauer bei 30% kleiner als SoC kleiner als 50%. 27,5°C kleiner als Temperatur
// kleiner als 32,5°C. -1,0xC A kleiner als Strom kleiner als -0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_1", "STAT_HV_BATT_HIST_SOC3_T5_I5_WERT", STAT_HV_BATT_HIST_SOC3_T5_I5_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T5_I6_WERT = (RXBUF_UINT32(100)/10.0f);
// Duration at 30% less than SoC less than 50%. 27.5 ° C less than temperature less than 32.5 ° C. -0.5xC A less
// than current less than 0.0xC A / Dauer bei 30% kleiner als SoC kleiner als 50%. 27,5°C kleiner als Temperatur
// kleiner als 32,5°C. -0,5xC A kleiner als Strom kleiner als 0,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_1", "STAT_HV_BATT_HIST_SOC3_T5_I6_WERT", STAT_HV_BATT_HIST_SOC3_T5_I6_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T5_I7_WERT = (RXBUF_UINT32(104)/10.0f);
// Duration at 30% less than SoC less than 50%. 27.5 ° C less than temperature less than 32.5 ° C. 0.0xC A less
// than current less than 0.5xC A / Dauer bei 30% kleiner als SoC kleiner als 50%. 27,5°C kleiner als Temperatur
// kleiner als 32,5°C. 0,0xC A kleiner als Strom kleiner als 0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_1", "STAT_HV_BATT_HIST_SOC3_T5_I7_WERT", STAT_HV_BATT_HIST_SOC3_T5_I7_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T5_I8_WERT = (RXBUF_UINT32(108)/10.0f);
// Duration at 30% less than SoC less than 50%. 27.5 ° C less than temperature less than 32.5 ° C. 0.5xC A less
// than current less than 1.0xC A / Dauer bei 30% kleiner als SoC kleiner als 50%. 27,5°C kleiner als Temperatur
// kleiner als 32,5°C. 0,5xC A kleiner als Strom kleiner als 1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_1", "STAT_HV_BATT_HIST_SOC3_T5_I8_WERT", STAT_HV_BATT_HIST_SOC3_T5_I8_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T5_I9_WERT = (RXBUF_UINT32(112)/10.0f);
// Duration at 30% less than SoC less than 50%. 27.5 ° C less than temperature less than 32.5 ° C. 1.0xC A less
// than current less than 1.5xC A / Dauer bei 30% kleiner als SoC kleiner als 50%. 27,5°C kleiner als Temperatur
// kleiner als 32,5°C. 1,0xC A kleiner als Strom kleiner als 1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_1", "STAT_HV_BATT_HIST_SOC3_T5_I9_WERT", STAT_HV_BATT_HIST_SOC3_T5_I9_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T5_I10_WERT = (RXBUF_UINT32(116)/10.0f);
// Duration at 30% less than SoC less than 50%. 27.5 ° C less than temperature less than 32.5 ° C. 1.5xC A less
// than current / Dauer bei 30% kleiner als SoC kleiner als 50%. 27,5°C kleiner als Temperatur kleiner als
// 32,5°C. 1,5xC A kleiner als Strom
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_1", "STAT_HV_BATT_HIST_SOC3_T5_I10_WERT", STAT_HV_BATT_HIST_SOC3_T5_I10_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T5_I1_WERT = (RXBUF_UINT32(120)/10.0f);
// Duration at 50% less than SoC less than 70%. 27.5 ° C less than temperature less than 32.5 ° C. Current less
// than -2.5xC A / Dauer bei 50% kleiner als SoC kleiner als 70%. 27,5°C kleiner als Temperatur kleiner als
// 32,5°C. Strom kleiner als -2,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_1", "STAT_HV_BATT_HIST_SOC4_T5_I1_WERT", STAT_HV_BATT_HIST_SOC4_T5_I1_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T5_I2_WERT = (RXBUF_UINT32(124)/10.0f);
// Duration at 50% less than SoC less than 70%. 27.5 ° C less than temperature less than 32.5 ° C. -2.5xC A less
// than current less than -2.0xC A / Dauer bei 50% kleiner als SoC kleiner als 70%. 27,5°C kleiner als Temperatur
// kleiner als 32,5°C. -2,5xC A kleiner als Strom kleiner als -2,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_1", "STAT_HV_BATT_HIST_SOC4_T5_I2_WERT", STAT_HV_BATT_HIST_SOC4_T5_I2_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T5_I3_WERT = (RXBUF_UINT32(128)/10.0f);
// Duration at 50% less than SoC less than 70%. 27.5 ° C less than temperature less than 32.5 ° C. -2.0xC A less
// than current less than -1.5xC A / Dauer bei 50% kleiner als SoC kleiner als 70%. 27,5°C kleiner als Temperatur
// kleiner als 32,5°C. -2,0xC A kleiner als Strom kleiner als -1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_1", "STAT_HV_BATT_HIST_SOC4_T5_I3_WERT", STAT_HV_BATT_HIST_SOC4_T5_I3_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T5_I4_WERT = (RXBUF_UINT32(132)/10.0f);
// Duration at 50% less than SoC less than 70%. 27.5 ° C less than temperature less than 32.5 ° C. -1.5xC A less
// than current less than -1.0xC A / Dauer bei 50% kleiner als SoC kleiner als 70%. 27,5°C kleiner als Temperatur
// kleiner als 32,5°C. -1,5xC A kleiner als Strom kleiner als -1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_1", "STAT_HV_BATT_HIST_SOC4_T5_I4_WERT", STAT_HV_BATT_HIST_SOC4_T5_I4_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T5_I5_WERT = (RXBUF_UINT32(136)/10.0f);
// Duration at 50% less than SoC less than 70%. 27.5 ° C less than temperature less than 32.5 ° C. -1.0xC A less
// than current less than -0.5xC A / Dauer bei 50% kleiner als SoC kleiner als 70%. 27,5°C kleiner als Temperatur
// kleiner als 32,5°C. -1,0xC A kleiner als Strom kleiner als -0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_1", "STAT_HV_BATT_HIST_SOC4_T5_I5_WERT", STAT_HV_BATT_HIST_SOC4_T5_I5_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T5_I6_WERT = (RXBUF_UINT32(140)/10.0f);
// Duration at 50% less than SoC less than 70%. 27.5 ° C less than temperature less than 32.5 ° C. -0.5xC A less
// than current less than 0.0xC A / Dauer bei 50% kleiner als SoC kleiner als 70%. 27,5°C kleiner als Temperatur
// kleiner als 32,5°C. -0,5xC A kleiner als Strom kleiner als 0,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_1", "STAT_HV_BATT_HIST_SOC4_T5_I6_WERT", STAT_HV_BATT_HIST_SOC4_T5_I6_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T5_I7_WERT = (RXBUF_UINT32(144)/10.0f);
// Duration at 50% less than SoC less than 70%. 27.5 ° C less than temperature less than 32.5 ° C. 0.0xC A less
// than current less than 0.5xC A / Dauer bei 50% kleiner als SoC kleiner als 70%. 27,5°C kleiner als Temperatur
// kleiner als 32,5°C. 0,0xC A kleiner als Strom kleiner als 0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_1", "STAT_HV_BATT_HIST_SOC4_T5_I7_WERT", STAT_HV_BATT_HIST_SOC4_T5_I7_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T5_I8_WERT = (RXBUF_UINT32(148)/10.0f);
// Duration at 50% less than SoC less than 70%. 27.5 ° C less than temperature less than 32.5 ° C. 0.5xC A less
// than current less than 1.0xC A / Dauer bei 50% kleiner als SoC kleiner als 70%. 27,5°C kleiner als Temperatur
// kleiner als 32,5°C. 0,5xC A kleiner als Strom kleiner als 1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_1", "STAT_HV_BATT_HIST_SOC4_T5_I8_WERT", STAT_HV_BATT_HIST_SOC4_T5_I8_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T5_I9_WERT = (RXBUF_UINT32(152)/10.0f);
// Duration at 50% less than SoC less than 70%. 27.5 ° C less than temperature less than 32.5 ° C. 1.0xC A less
// than current less than 1.5xC A / Dauer bei 50% kleiner als SoC kleiner als 70%. 27,5°C kleiner als Temperatur
// kleiner als 32,5°C. 1,0xC A kleiner als Strom kleiner als 1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_1", "STAT_HV_BATT_HIST_SOC4_T5_I9_WERT", STAT_HV_BATT_HIST_SOC4_T5_I9_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T5_I10_WERT = (RXBUF_UINT32(156)/10.0f);
// Duration at 50% less than SoC less than 70%. 27.5 ° C less than temperature less than 32.5 ° C. 1.5xC A less
// than current / Dauer bei 50% kleiner als SoC kleiner als 70%. 27,5°C kleiner als Temperatur kleiner als
// 32,5°C. 1,5xC A kleiner als Strom
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_1", "STAT_HV_BATT_HIST_SOC4_T5_I10_WERT", STAT_HV_BATT_HIST_SOC4_T5_I10_WERT, "\"s\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_HV_BATT_HIST_SOC_T6_1: { // 0xDD99
if (datalen < 160) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_HV_BATT_HIST_SOC_T6_1", 160);
break;
}
float STAT_HV_BATT_HIST_SOC1_T6_I1_WERT = (RXBUF_UINT32(0)/10.0f);
// Duration with SoC less than 10%. 32.5 ° C less than temperature less than 40 ° C. Current less than -2.5xC A /
// Dauer bei SoC kleiner als 10%. 32,5°C kleiner als Temperatur kleiner als 40°C. Strom kleiner als -2,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_1", "STAT_HV_BATT_HIST_SOC1_T6_I1_WERT", STAT_HV_BATT_HIST_SOC1_T6_I1_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T6_I2_WERT = (RXBUF_UINT32(4)/10.0f);
// Duration with SoC less than 10%. 32.5 ° C less than temperature less than 40 ° C. -2.5xC A less than current
// less than -2.0xC A / Dauer bei SoC kleiner als 10%. 32,5°C kleiner als Temperatur kleiner als 40°C. -2,5xC A
// kleiner als Strom kleiner als -2,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_1", "STAT_HV_BATT_HIST_SOC1_T6_I2_WERT", STAT_HV_BATT_HIST_SOC1_T6_I2_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T6_I3_WERT = (RXBUF_UINT32(8)/10.0f);
// Duration with SoC less than 10%. 32.5 ° C less than temperature less than 40 ° C. -2.0xC A less than current
// less than -1.5xC A / Dauer bei SoC kleiner als 10%. 32,5°C kleiner als Temperatur kleiner als 40°C. -2,0xC A
// kleiner als Strom kleiner als -1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_1", "STAT_HV_BATT_HIST_SOC1_T6_I3_WERT", STAT_HV_BATT_HIST_SOC1_T6_I3_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T6_I4_WERT = (RXBUF_UINT32(12)/10.0f);
// Duration with SoC less than 10%. 32.5 ° C less than temperature less than 40 ° C. -1.5xC A less than current
// less than -1.0xC A / Dauer bei SoC kleiner als 10%. 32,5°C kleiner als Temperatur kleiner als 40°C. -1,5xC A
// kleiner als Strom kleiner als -1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_1", "STAT_HV_BATT_HIST_SOC1_T6_I4_WERT", STAT_HV_BATT_HIST_SOC1_T6_I4_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T6_I5_WERT = (RXBUF_UINT32(16)/10.0f);
// Duration with SoC less than 10%. 32.5 ° C less than temperature less than 40 ° C. -1.0xC A less than current
// less than -0.5xC A / Dauer bei SoC kleiner als 10%. 32,5°C kleiner als Temperatur kleiner als 40°C. -1,0xC A
// kleiner als Strom kleiner als -0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_1", "STAT_HV_BATT_HIST_SOC1_T6_I5_WERT", STAT_HV_BATT_HIST_SOC1_T6_I5_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T6_I6_WERT = (RXBUF_UINT32(20)/10.0f);
// Duration with SoC less than 10%. 32.5 ° C less than temperature less than 40 ° C. -0.5xC A less than current
// less than 0.0xC A / Dauer bei SoC kleiner als 10%. 32,5°C kleiner als Temperatur kleiner als 40°C. -0,5xC A
// kleiner als Strom kleiner als 0,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_1", "STAT_HV_BATT_HIST_SOC1_T6_I6_WERT", STAT_HV_BATT_HIST_SOC1_T6_I6_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T6_I7_WERT = (RXBUF_UINT32(24)/10.0f);
// Duration with SoC less than 10%. 32.5 ° C less than temperature less than 40 ° C. 0.0xC A less than current
// less than 0.5xC A / Dauer bei SoC kleiner als 10%. 32,5°C kleiner als Temperatur kleiner als 40°C. 0,0xC A
// kleiner als Strom kleiner als 0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_1", "STAT_HV_BATT_HIST_SOC1_T6_I7_WERT", STAT_HV_BATT_HIST_SOC1_T6_I7_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T6_I8_WERT = (RXBUF_UINT32(28)/10.0f);
// Duration with SoC less than 10%. 32.5 ° C less than temperature less than 40 ° C. 0.5xC A less than current
// less than 1.0xC A / Dauer bei SoC kleiner als 10%. 32,5°C kleiner als Temperatur kleiner als 40°C. 0,5xC A
// kleiner als Strom kleiner als 1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_1", "STAT_HV_BATT_HIST_SOC1_T6_I8_WERT", STAT_HV_BATT_HIST_SOC1_T6_I8_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T6_I9_WERT = (RXBUF_UINT32(32)/10.0f);
// Duration with SoC less than 10%. 32.5 ° C less than temperature less than 40 ° C. 1.0xC A less than current
// less than 1.5xC A / Dauer bei SoC kleiner als 10%. 32,5°C kleiner als Temperatur kleiner als 40°C. 1,0xC A
// kleiner als Strom kleiner als 1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_1", "STAT_HV_BATT_HIST_SOC1_T6_I9_WERT", STAT_HV_BATT_HIST_SOC1_T6_I9_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T6_I10_WERT = (RXBUF_UINT32(36)/10.0f);
// Duration with SoC less than 10%. 32.5 ° C less than temperature less than 40 ° C. 1.5xC A less than current /
// Dauer bei SoC kleiner als 10%. 32,5°C kleiner als Temperatur kleiner als 40°C. 1,5xC A kleiner als Strom
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_1", "STAT_HV_BATT_HIST_SOC1_T6_I10_WERT", STAT_HV_BATT_HIST_SOC1_T6_I10_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T6_I1_WERT = (RXBUF_UINT32(40)/10.0f);
// Duration at 10% less than SoC less than 30%. 32.5 ° C less than temperature less than 40 ° C. Current less
// than -2.5xC A / Dauer bei 10% kleiner als SoC kleiner als 30%. 32,5°C kleiner als Temperatur kleiner als 40°C.
// Strom kleiner als -2,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_1", "STAT_HV_BATT_HIST_SOC2_T6_I1_WERT", STAT_HV_BATT_HIST_SOC2_T6_I1_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T6_I2_WERT = (RXBUF_UINT32(44)/10.0f);
// Duration at 10% less than SoC less than 30%. 32.5 ° C less than temperature less than 40 ° C. -2.5xC A less
// than current less than -2.0xC A / Dauer bei 10% kleiner als SoC kleiner als 30%. 32,5°C kleiner als Temperatur
// kleiner als 40°C. -2,5xC A kleiner als Strom kleiner als -2,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_1", "STAT_HV_BATT_HIST_SOC2_T6_I2_WERT", STAT_HV_BATT_HIST_SOC2_T6_I2_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T6_I3_WERT = (RXBUF_UINT32(48)/10.0f);
// Duration at 10% less than SoC less than 30%. 32.5 ° C less than temperature less than 40 ° C. -2.0xC A less
// than current less than -1.5xC A / Dauer bei 10% kleiner als SoC kleiner als 30%. 32,5°C kleiner als Temperatur
// kleiner als 40°C. -2,0xC A kleiner als Strom kleiner als -1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_1", "STAT_HV_BATT_HIST_SOC2_T6_I3_WERT", STAT_HV_BATT_HIST_SOC2_T6_I3_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T6_I4_WERT = (RXBUF_UINT32(52)/10.0f);
// Duration at 10% less than SoC less than 30%. 32.5 ° C less than temperature less than 40 ° C. -1.5xC A less
// than current less than -1.0xC A / Dauer bei 10% kleiner als SoC kleiner als 30%. 32,5°C kleiner als Temperatur
// kleiner als 40°C. -1,5xC A kleiner als Strom kleiner als -1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_1", "STAT_HV_BATT_HIST_SOC2_T6_I4_WERT", STAT_HV_BATT_HIST_SOC2_T6_I4_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T6_I5_WERT = (RXBUF_UINT32(56)/10.0f);
// Duration at 10% less than SoC less than 30%. 32.5 ° C less than temperature less than 40 ° C. -1.0xC A less
// than current less than -0.5xC A / Dauer bei 10% kleiner als SoC kleiner als 30%. 32,5°C kleiner als Temperatur
// kleiner als 40°C. -1,0xC A kleiner als Strom kleiner als -0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_1", "STAT_HV_BATT_HIST_SOC2_T6_I5_WERT", STAT_HV_BATT_HIST_SOC2_T6_I5_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T6_I6_WERT = (RXBUF_UINT32(60)/10.0f);
// Duration at 10% less than SoC less than 30%. 32.5 ° C less than temperature less than 40 ° C. -0.5xC A less
// than current less than 0.0xC A / Dauer bei 10% kleiner als SoC kleiner als 30%. 32,5°C kleiner als Temperatur
// kleiner als 40°C. -0,5xC A kleiner als Strom kleiner als 0,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_1", "STAT_HV_BATT_HIST_SOC2_T6_I6_WERT", STAT_HV_BATT_HIST_SOC2_T6_I6_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T6_I7_WERT = (RXBUF_UINT32(64)/10.0f);
// Duration at 10% less than SoC less than 30%. 32.5 ° C less than temperature less than 40 ° C. 0.0xC A less
// than current less than 0.5xC A / Dauer bei 10% kleiner als SoC kleiner als 30%. 32,5°C kleiner als Temperatur
// kleiner als 40°C. 0,0xC A kleiner als Strom kleiner als 0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_1", "STAT_HV_BATT_HIST_SOC2_T6_I7_WERT", STAT_HV_BATT_HIST_SOC2_T6_I7_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T6_I8_WERT = (RXBUF_UINT32(68)/10.0f);
// Duration at 10% less than SoC less than 30%. 32.5 ° C less than temperature less than 40 ° C. 0.5xC A less
// than current less than 1.0xC A / Dauer bei 10% kleiner als SoC kleiner als 30%. 32,5°C kleiner als Temperatur
// kleiner als 40°C. 0,5xC A kleiner als Strom kleiner als 1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_1", "STAT_HV_BATT_HIST_SOC2_T6_I8_WERT", STAT_HV_BATT_HIST_SOC2_T6_I8_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T6_I9_WERT = (RXBUF_UINT32(72)/10.0f);
// Duration at 10% less than SoC less than 30%. 32.5 ° C less than temperature less than 40 ° C. 1.0xC A less
// than current less than 1.5xC A / Dauer bei 10% kleiner als SoC kleiner als 30%. 32,5°C kleiner als Temperatur
// kleiner als 40°C. 1,0xC A kleiner als Strom kleiner als 1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_1", "STAT_HV_BATT_HIST_SOC2_T6_I9_WERT", STAT_HV_BATT_HIST_SOC2_T6_I9_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T6_I10_WERT = (RXBUF_UINT32(76)/10.0f);
// Duration at 10% less than SoC less than 30%. 32.5 ° C less than temperature less than 40 ° C. 1.5xC A less
// than current / Dauer bei 10% kleiner als SoC kleiner als 30%. 32,5°C kleiner als Temperatur kleiner als 40°C.
// 1,5xC A kleiner als Strom
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_1", "STAT_HV_BATT_HIST_SOC2_T6_I10_WERT", STAT_HV_BATT_HIST_SOC2_T6_I10_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T6_I1_WERT = (RXBUF_UINT32(80)/10.0f);
// Duration at 30% less than SoC less than 50%. 32.5 ° C less than temperature less than 40 ° C. Current less
// than -2.5xC A / Dauer bei 30% kleiner als SoC kleiner als 50%. 32,5°C kleiner als Temperatur kleiner als 40°C.
// Strom kleiner als -2,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_1", "STAT_HV_BATT_HIST_SOC3_T6_I1_WERT", STAT_HV_BATT_HIST_SOC3_T6_I1_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T6_I2_WERT = (RXBUF_UINT32(84)/10.0f);
// Duration at 30% less than SoC less than 50%. 32.5 ° C less than temperature less than 40 ° C. -2.5xC A less
// than current less than -2.0xC A / Dauer bei 30% kleiner als SoC kleiner als 50%. 32,5°C kleiner als Temperatur
// kleiner als 40°C. -2,5xC A kleiner als Strom kleiner als -2,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_1", "STAT_HV_BATT_HIST_SOC3_T6_I2_WERT", STAT_HV_BATT_HIST_SOC3_T6_I2_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T6_I3_WERT = (RXBUF_UINT32(88)/10.0f);
// Duration at 30% less than SoC less than 50%. 32.5 ° C less than temperature less than 40 ° C. -2.0xC A less
// than current less than -1.5xC A / Dauer bei 30% kleiner als SoC kleiner als 50%. 32,5°C kleiner als Temperatur
// kleiner als 40°C. -2,0xC A kleiner als Strom kleiner als -1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_1", "STAT_HV_BATT_HIST_SOC3_T6_I3_WERT", STAT_HV_BATT_HIST_SOC3_T6_I3_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T6_I4_WERT = (RXBUF_UINT32(92)/10.0f);
// Duration at 30% less than SoC less than 50%. 32.5 ° C less than temperature less than 40 ° C. -1.5xC A less
// than current less than -1.0xC A / Dauer bei 30% kleiner als SoC kleiner als 50%. 32,5°C kleiner als Temperatur
// kleiner als 40°C. -1,5xC A kleiner als Strom kleiner als -1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_1", "STAT_HV_BATT_HIST_SOC3_T6_I4_WERT", STAT_HV_BATT_HIST_SOC3_T6_I4_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T6_I5_WERT = (RXBUF_UINT32(96)/10.0f);
// Duration at 30% less than SoC less than 50%. 32.5 ° C less than temperature less than 40 ° C. -1.0xC A less
// than current less than -0.5xC A / Dauer bei 30% kleiner als SoC kleiner als 50%. 32,5°C kleiner als Temperatur
// kleiner als 40°C. -1,0xC A kleiner als Strom kleiner als -0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_1", "STAT_HV_BATT_HIST_SOC3_T6_I5_WERT", STAT_HV_BATT_HIST_SOC3_T6_I5_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T6_I6_WERT = (RXBUF_UINT32(100)/10.0f);
// Duration at 30% less than SoC less than 50%. 32.5 ° C less than temperature less than 40 ° C. -0.5xC A less
// than current less than 0.0xC A / Dauer bei 30% kleiner als SoC kleiner als 50%. 32,5°C kleiner als Temperatur
// kleiner als 40°C. -0,5xC A kleiner als Strom kleiner als 0,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_1", "STAT_HV_BATT_HIST_SOC3_T6_I6_WERT", STAT_HV_BATT_HIST_SOC3_T6_I6_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T6_I7_WERT = (RXBUF_UINT32(104)/10.0f);
// Duration at 30% less than SoC less than 50%. 32.5 ° C less than temperature less than 40 ° C. 0.0xC A less
// than current less than 0.5xC A / Dauer bei 30% kleiner als SoC kleiner als 50%. 32,5°C kleiner als Temperatur
// kleiner als 40°C. 0,0xC A kleiner als Strom kleiner als 0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_1", "STAT_HV_BATT_HIST_SOC3_T6_I7_WERT", STAT_HV_BATT_HIST_SOC3_T6_I7_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T6_I8_WERT = (RXBUF_UINT32(108)/10.0f);
// Duration at 30% less than SoC less than 50%. 32.5 ° C less than temperature less than 40 ° C. 0.5xC A less
// than current less than 1.0xC A / Dauer bei 30% kleiner als SoC kleiner als 50%. 32,5°C kleiner als Temperatur
// kleiner als 40°C. 0,5xC A kleiner als Strom kleiner als 1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_1", "STAT_HV_BATT_HIST_SOC3_T6_I8_WERT", STAT_HV_BATT_HIST_SOC3_T6_I8_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T6_I9_WERT = (RXBUF_UINT32(112)/10.0f);
// Duration at 30% less than SoC less than 50%. 32.5 ° C less than temperature less than 40 ° C. 1.0xC A less
// than current less than 1.5xC A / Dauer bei 30% kleiner als SoC kleiner als 50%. 32,5°C kleiner als Temperatur
// kleiner als 40°C. 1,0xC A kleiner als Strom kleiner als 1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_1", "STAT_HV_BATT_HIST_SOC3_T6_I9_WERT", STAT_HV_BATT_HIST_SOC3_T6_I9_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T6_I10_WERT = (RXBUF_UINT32(116)/10.0f);
// Duration at 30% less than SoC less than 50%. 32.5 ° C less than temperature less than 40 ° C. 1.5xC A less
// than current / Dauer bei 30% kleiner als SoC kleiner als 50%. 32,5°C kleiner als Temperatur kleiner als 40°C.
// 1,5xC A kleiner als Strom
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_1", "STAT_HV_BATT_HIST_SOC3_T6_I10_WERT", STAT_HV_BATT_HIST_SOC3_T6_I10_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T6_I1_WERT = (RXBUF_UINT32(120)/10.0f);
// Duration at 50% less than SoC less than 70%. 32.5 ° C less than temperature less than 40 ° C. Current less
// than -2.5xC A / Dauer bei 50% kleiner als SoC kleiner als 70%. 32,5°C kleiner als Temperatur kleiner als 40°C.
// Strom kleiner als -2,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_1", "STAT_HV_BATT_HIST_SOC4_T6_I1_WERT", STAT_HV_BATT_HIST_SOC4_T6_I1_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T6_I2_WERT = (RXBUF_UINT32(124)/10.0f);
// Duration at 50% less than SoC less than 70%. 32.5 ° C less than temperature less than 40 ° C. -2.5xC A less
// than current less than -2.0xC A / Dauer bei 50% kleiner als SoC kleiner als 70%. 32,5°C kleiner als Temperatur
// kleiner als 40°C. -2,5xC A kleiner als Strom kleiner als -2,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_1", "STAT_HV_BATT_HIST_SOC4_T6_I2_WERT", STAT_HV_BATT_HIST_SOC4_T6_I2_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T6_I3_WERT = (RXBUF_UINT32(128)/10.0f);
// Duration at 50% less than SoC less than 70%. 32.5 ° C less than temperature less than 40 ° C. -2.0xC A less
// than current less than -1.5xC A / Dauer bei 50% kleiner als SoC kleiner als 70%. 32,5°C kleiner als Temperatur
// kleiner als 40°C. -2,0xC A kleiner als Strom kleiner als -1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_1", "STAT_HV_BATT_HIST_SOC4_T6_I3_WERT", STAT_HV_BATT_HIST_SOC4_T6_I3_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T6_I4_WERT = (RXBUF_UINT32(132)/10.0f);
// Duration at 50% less than SoC less than 70%. 32.5 ° C less than temperature less than 40 ° C. -1.5xC A less
// than current less than -1.0xC A / Dauer bei 50% kleiner als SoC kleiner als 70%. 32,5°C kleiner als Temperatur
// kleiner als 40°C. -1,5xC A kleiner als Strom kleiner als -1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_1", "STAT_HV_BATT_HIST_SOC4_T6_I4_WERT", STAT_HV_BATT_HIST_SOC4_T6_I4_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T6_I5_WERT = (RXBUF_UINT32(136)/10.0f);
// Duration at 50% less than SoC less than 70%. 32.5 ° C less than temperature less than 40 ° C. -1.0xC A less
// than current less than -0.5xC A / Dauer bei 50% kleiner als SoC kleiner als 70%. 32,5°C kleiner als Temperatur
// kleiner als 40°C. -1,0xC A kleiner als Strom kleiner als -0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_1", "STAT_HV_BATT_HIST_SOC4_T6_I5_WERT", STAT_HV_BATT_HIST_SOC4_T6_I5_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T6_I6_WERT = (RXBUF_UINT32(140)/10.0f);
// Duration at 50% less than SoC less than 70%. 32.5 ° C less than temperature less than 40 ° C. -0.5xC A less
// than current less than 0.0xC A / Dauer bei 50% kleiner als SoC kleiner als 70%. 32,5°C kleiner als Temperatur
// kleiner als 40°C. -0,5xC A kleiner als Strom kleiner als 0,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_1", "STAT_HV_BATT_HIST_SOC4_T6_I6_WERT", STAT_HV_BATT_HIST_SOC4_T6_I6_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T6_I7_WERT = (RXBUF_UINT32(144)/10.0f);
// Duration at 50% less than SoC less than 70%. 32.5 ° C less than temperature less than 40 ° C. 0.0xC A less
// than current less than 0.5xC A / Dauer bei 50% kleiner als SoC kleiner als 70%. 32,5°C kleiner als Temperatur
// kleiner als 40°C. 0,0xC A kleiner als Strom kleiner als 0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_1", "STAT_HV_BATT_HIST_SOC4_T6_I7_WERT", STAT_HV_BATT_HIST_SOC4_T6_I7_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T6_I8_WERT = (RXBUF_UINT32(148)/10.0f);
// Duration at 50% less than SoC less than 70%. 32.5 ° C less than temperature less than 40 ° C. 0.5xC A less
// than current less than 1.0xC A / Dauer bei 50% kleiner als SoC kleiner als 70%. 32,5°C kleiner als Temperatur
// kleiner als 40°C. 0,5xC A kleiner als Strom kleiner als 1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_1", "STAT_HV_BATT_HIST_SOC4_T6_I8_WERT", STAT_HV_BATT_HIST_SOC4_T6_I8_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T6_I9_WERT = (RXBUF_UINT32(152)/10.0f);
// Duration at 50% less than SoC less than 70%. 32.5 ° C less than temperature less than 40 ° C. 1.0xC A less
// than current less than 1.5xC A / Dauer bei 50% kleiner als SoC kleiner als 70%. 32,5°C kleiner als Temperatur
// kleiner als 40°C. 1,0xC A kleiner als Strom kleiner als 1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_1", "STAT_HV_BATT_HIST_SOC4_T6_I9_WERT", STAT_HV_BATT_HIST_SOC4_T6_I9_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T6_I10_WERT = (RXBUF_UINT32(156)/10.0f);
// Duration at 50% less than SoC less than 70%. 32.5 ° C less than temperature less than 40 ° C. 1.5xC A less
// than current / Dauer bei 50% kleiner als SoC kleiner als 70%. 32,5°C kleiner als Temperatur kleiner als 40°C.
// 1,5xC A kleiner als Strom
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_1", "STAT_HV_BATT_HIST_SOC4_T6_I10_WERT", STAT_HV_BATT_HIST_SOC4_T6_I10_WERT, "\"s\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_HV_BATT_HIST_SOC_T7_1: { // 0xDD9A
if (datalen < 160) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_HV_BATT_HIST_SOC_T7_1", 160);
break;
}
float STAT_HV_BATT_HIST_SOC1_T7_I1_WERT = (RXBUF_UINT32(0)/10.0f);
// Duration with SoC less than 10%. 40 ° C less than temperature. Current less than -2.5xC A / Dauer bei SoC
// kleiner als 10%. 40°C kleiner als Temperatur. Strom kleiner als -2,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_1", "STAT_HV_BATT_HIST_SOC1_T7_I1_WERT", STAT_HV_BATT_HIST_SOC1_T7_I1_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T7_I2_WERT = (RXBUF_UINT32(4)/10.0f);
// Duration with SoC less than 10%. 40 ° C less than temperature. -2.5xC A less than current less than -2.0xC A /
// Dauer bei SoC kleiner als 10%. 40°C kleiner als Temperatur. -2,5xC A kleiner als Strom kleiner als -2,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_1", "STAT_HV_BATT_HIST_SOC1_T7_I2_WERT", STAT_HV_BATT_HIST_SOC1_T7_I2_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T7_I3_WERT = (RXBUF_UINT32(8)/10.0f);
// Duration with SoC less than 10%. 40 ° C less than temperature. -2.0xC A less than current less than -1.5xC A /
// Dauer bei SoC kleiner als 10%. 40°C kleiner als Temperatur. -2,0xC A kleiner als Strom kleiner als -1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_1", "STAT_HV_BATT_HIST_SOC1_T7_I3_WERT", STAT_HV_BATT_HIST_SOC1_T7_I3_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T7_I4_WERT = (RXBUF_UINT32(12)/10.0f);
// Duration with SoC less than 10%. 40 ° C less than temperature. -1.5xC A less than current less than -1.0xC A /
// Dauer bei SoC kleiner als 10%. 40°C kleiner als Temperatur. -1,5xC A kleiner als Strom kleiner als -1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_1", "STAT_HV_BATT_HIST_SOC1_T7_I4_WERT", STAT_HV_BATT_HIST_SOC1_T7_I4_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T7_I5_WERT = (RXBUF_UINT32(16)/10.0f);
// Duration with SoC less than 10%. 40 ° C less than temperature. -1.0xC A less than current less than -0.5xC A /
// Dauer bei SoC kleiner als 10%. 40°C kleiner als Temperatur. -1,0xC A kleiner als Strom kleiner als -0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_1", "STAT_HV_BATT_HIST_SOC1_T7_I5_WERT", STAT_HV_BATT_HIST_SOC1_T7_I5_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T7_I6_WERT = (RXBUF_UINT32(20)/10.0f);
// Duration with SoC less than 10%. 40 ° C less than temperature. -0.5xC A less than current less than 0.0xC A /
// Dauer bei SoC kleiner als 10%. 40°C kleiner als Temperatur. -0,5xC A kleiner als Strom kleiner als 0,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_1", "STAT_HV_BATT_HIST_SOC1_T7_I6_WERT", STAT_HV_BATT_HIST_SOC1_T7_I6_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T7_I7_WERT = (RXBUF_UINT32(24)/10.0f);
// Duration with SoC less than 10%. 40 ° C less than temperature. 0.0xC A less than current less than 0.5xC A /
// Dauer bei SoC kleiner als 10%. 40°C kleiner als Temperatur. 0,0xC A kleiner als Strom kleiner als 0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_1", "STAT_HV_BATT_HIST_SOC1_T7_I7_WERT", STAT_HV_BATT_HIST_SOC1_T7_I7_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T7_I8_WERT = (RXBUF_UINT32(28)/10.0f);
// Duration with SoC less than 10%. 40 ° C less than temperature. 0.5xC A less than current less than 1.0xC A /
// Dauer bei SoC kleiner als 10%. 40°C kleiner als Temperatur. 0,5xC A kleiner als Strom kleiner als 1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_1", "STAT_HV_BATT_HIST_SOC1_T7_I8_WERT", STAT_HV_BATT_HIST_SOC1_T7_I8_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T7_I9_WERT = (RXBUF_UINT32(32)/10.0f);
// Duration with SoC less than 10%. 40 ° C less than temperature. 1.0xC A less than current less than 1.5xC A /
// Dauer bei SoC kleiner als 10%. 40°C kleiner als Temperatur. 1,0xC A kleiner als Strom kleiner als 1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_1", "STAT_HV_BATT_HIST_SOC1_T7_I9_WERT", STAT_HV_BATT_HIST_SOC1_T7_I9_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC1_T7_I10_WERT = (RXBUF_UINT32(36)/10.0f);
// Duration with SoC less than 10%. 40 ° C less than temperature. 1.5xC A less than current / Dauer bei SoC
// kleiner als 10%. 40°C kleiner als Temperatur. 1,5xC A kleiner als Strom
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_1", "STAT_HV_BATT_HIST_SOC1_T7_I10_WERT", STAT_HV_BATT_HIST_SOC1_T7_I10_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T7_I1_WERT = (RXBUF_UINT32(40)/10.0f);
// Duration at 10% less than SoC less than 30%. 40 ° C less than temperature. Current less than -2.5xC A / Dauer
// bei 10% kleiner als SoC kleiner als 30%. 40°C kleiner als Temperatur. Strom kleiner als -2,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_1", "STAT_HV_BATT_HIST_SOC2_T7_I1_WERT", STAT_HV_BATT_HIST_SOC2_T7_I1_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T7_I2_WERT = (RXBUF_UINT32(44)/10.0f);
// Duration at 10% less than SoC less than 30%. 40 ° C less than temperature. -2.5xC A less than current less
// than -2.0xC A / Dauer bei 10% kleiner als SoC kleiner als 30%. 40°C kleiner als Temperatur. -2,5xC A kleiner
// als Strom kleiner als -2,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_1", "STAT_HV_BATT_HIST_SOC2_T7_I2_WERT", STAT_HV_BATT_HIST_SOC2_T7_I2_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T7_I3_WERT = (RXBUF_UINT32(48)/10.0f);
// Duration at 10% less than SoC less than 30%. 40 ° C less than temperature. -2.0xC A less than current less
// than -1.5xC A / Dauer bei 10% kleiner als SoC kleiner als 30%. 40°C kleiner als Temperatur. -2,0xC A kleiner
// als Strom kleiner als -1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_1", "STAT_HV_BATT_HIST_SOC2_T7_I3_WERT", STAT_HV_BATT_HIST_SOC2_T7_I3_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T7_I4_WERT = (RXBUF_UINT32(52)/10.0f);
// Duration at 10% less than SoC less than 30%. 40 ° C less than temperature. -1.5xC A less than current less
// than -1.0xC A / Dauer bei 10% kleiner als SoC kleiner als 30%. 40°C kleiner als Temperatur. -1,5xC A kleiner
// als Strom kleiner als -1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_1", "STAT_HV_BATT_HIST_SOC2_T7_I4_WERT", STAT_HV_BATT_HIST_SOC2_T7_I4_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T7_I5_WERT = (RXBUF_UINT32(56)/10.0f);
// Duration at 10% less than SoC less than 30%. 40 ° C less than temperature. -1.0xC A less than current less
// than -0.5xC A / Dauer bei 10% kleiner als SoC kleiner als 30%. 40°C kleiner als Temperatur. -1,0xC A kleiner
// als Strom kleiner als -0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_1", "STAT_HV_BATT_HIST_SOC2_T7_I5_WERT", STAT_HV_BATT_HIST_SOC2_T7_I5_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T7_I6_WERT = (RXBUF_UINT32(60)/10.0f);
// Duration at 10% less than SoC less than 30%. 40 ° C less than temperature. -0.5xC A less than current less
// than 0.0xC A / Dauer bei 10% kleiner als SoC kleiner als 30%. 40°C kleiner als Temperatur. -0,5xC A kleiner
// als Strom kleiner als 0,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_1", "STAT_HV_BATT_HIST_SOC2_T7_I6_WERT", STAT_HV_BATT_HIST_SOC2_T7_I6_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T7_I7_WERT = (RXBUF_UINT32(64)/10.0f);
// Duration at 10% less than SoC less than 30%. 40 ° C less than temperature. 0.0xC A less than current less than
// 0.5xC A / Dauer bei 10% kleiner als SoC kleiner als 30%. 40°C kleiner als Temperatur. 0,0xC A kleiner als
// Strom kleiner als 0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_1", "STAT_HV_BATT_HIST_SOC2_T7_I7_WERT", STAT_HV_BATT_HIST_SOC2_T7_I7_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T7_I8_WERT = (RXBUF_UINT32(68)/10.0f);
// Duration at 10% less than SoC less than 30%. 40 ° C less than temperature. 0.5xC A less than current less than
// 1.0xC A / Dauer bei 10% kleiner als SoC kleiner als 30%. 40°C kleiner als Temperatur. 0,5xC A kleiner als
// Strom kleiner als 1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_1", "STAT_HV_BATT_HIST_SOC2_T7_I8_WERT", STAT_HV_BATT_HIST_SOC2_T7_I8_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T7_I9_WERT = (RXBUF_UINT32(72)/10.0f);
// Duration at 10% less than SoC less than 30%. 40 ° C less than temperature. 1.0xC A less than current less than
// 1.5xC A / Dauer bei 10% kleiner als SoC kleiner als 30%. 40°C kleiner als Temperatur. 1,0xC A kleiner als
// Strom kleiner als 1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_1", "STAT_HV_BATT_HIST_SOC2_T7_I9_WERT", STAT_HV_BATT_HIST_SOC2_T7_I9_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC2_T7_I10_WERT = (RXBUF_UINT32(76)/10.0f);
// Duration at 10% less than SoC less than 30%. 40 ° C less than temperature. 1.5xC A less than current / Dauer
// bei 10% kleiner als SoC kleiner als 30%. 40°C kleiner als Temperatur. 1,5xC A kleiner als Strom
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_1", "STAT_HV_BATT_HIST_SOC2_T7_I10_WERT", STAT_HV_BATT_HIST_SOC2_T7_I10_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T7_I1_WERT = (RXBUF_UINT32(80)/10.0f);
// Duration at 30% less than SoC less than 50%. 40 ° C less than temperature. Current less than -2.5xC A / Dauer
// bei 30% kleiner als SoC kleiner als 50%. 40°C kleiner als Temperatur. Strom kleiner als -2,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_1", "STAT_HV_BATT_HIST_SOC3_T7_I1_WERT", STAT_HV_BATT_HIST_SOC3_T7_I1_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T7_I2_WERT = (RXBUF_UINT32(84)/10.0f);
// Duration at 30% less than SoC less than 50%. 40 ° C less than temperature. -2.5xC A less than current less
// than -2.0xC A / Dauer bei 30% kleiner als SoC kleiner als 50%. 40°C kleiner als Temperatur. -2,5xC A kleiner
// als Strom kleiner als -2,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_1", "STAT_HV_BATT_HIST_SOC3_T7_I2_WERT", STAT_HV_BATT_HIST_SOC3_T7_I2_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T7_I3_WERT = (RXBUF_UINT32(88)/10.0f);
// Duration at 30% less than SoC less than 50%. 40 ° C less than temperature. -2.0xC A less than current less
// than -1.5xC A / Dauer bei 30% kleiner als SoC kleiner als 50%. 40°C kleiner als Temperatur. -2,0xC A kleiner
// als Strom kleiner als -1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_1", "STAT_HV_BATT_HIST_SOC3_T7_I3_WERT", STAT_HV_BATT_HIST_SOC3_T7_I3_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T7_I4_WERT = (RXBUF_UINT32(92)/10.0f);
// Duration at 30% less than SoC less than 50%. 40 ° C less than temperature. -1.5xC A less than current less
// than -1.0xC A / Dauer bei 30% kleiner als SoC kleiner als 50%. 40°C kleiner als Temperatur. -1,5xC A kleiner
// als Strom kleiner als -1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_1", "STAT_HV_BATT_HIST_SOC3_T7_I4_WERT", STAT_HV_BATT_HIST_SOC3_T7_I4_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T7_I5_WERT = (RXBUF_UINT32(96)/10.0f);
// Duration at 30% less than SoC less than 50%. 40 ° C less than temperature. -1.0xC A less than current less
// than -0.5xC A / Dauer bei 30% kleiner als SoC kleiner als 50%. 40°C kleiner als Temperatur. -1,0xC A kleiner
// als Strom kleiner als -0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_1", "STAT_HV_BATT_HIST_SOC3_T7_I5_WERT", STAT_HV_BATT_HIST_SOC3_T7_I5_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T7_I6_WERT = (RXBUF_UINT32(100)/10.0f);
// Duration at 30% less than SoC less than 50%. 40 ° C less than temperature. -0.5xC A less than current less
// than 0.0xC A / Dauer bei 30% kleiner als SoC kleiner als 50%. 40°C kleiner als Temperatur. -0,5xC A kleiner
// als Strom kleiner als 0,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_1", "STAT_HV_BATT_HIST_SOC3_T7_I6_WERT", STAT_HV_BATT_HIST_SOC3_T7_I6_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T7_I7_WERT = (RXBUF_UINT32(104)/10.0f);
// Duration at 30% less than SoC less than 50%. 40 ° C less than temperature. 0.0xC A less than current less than
// 0.5xC A / Dauer bei 30% kleiner als SoC kleiner als 50%. 40°C kleiner als Temperatur. 0,0xC A kleiner als
// Strom kleiner als 0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_1", "STAT_HV_BATT_HIST_SOC3_T7_I7_WERT", STAT_HV_BATT_HIST_SOC3_T7_I7_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T7_I8_WERT = (RXBUF_UINT32(108)/10.0f);
// Duration at 30% less than SoC less than 50%. 40 ° C less than temperature. 0.5xC A less than current less than
// 1.0xC A / Dauer bei 30% kleiner als SoC kleiner als 50%. 40°C kleiner als Temperatur. 0,5xC A kleiner als
// Strom kleiner als 1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_1", "STAT_HV_BATT_HIST_SOC3_T7_I8_WERT", STAT_HV_BATT_HIST_SOC3_T7_I8_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T7_I9_WERT = (RXBUF_UINT32(112)/10.0f);
// Duration at 30% less than SoC less than 50%. 40 ° C less than temperature. 1.0xC A less than current less than
// 1.5xC A / Dauer bei 30% kleiner als SoC kleiner als 50%. 40°C kleiner als Temperatur. 1,0xC A kleiner als
// Strom kleiner als 1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_1", "STAT_HV_BATT_HIST_SOC3_T7_I9_WERT", STAT_HV_BATT_HIST_SOC3_T7_I9_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC3_T7_I10_WERT = (RXBUF_UINT32(116)/10.0f);
// Duration at 30% less than SoC less than 50%. 40 ° C less than temperature. 1.5xC A less than current / Dauer
// bei 30% kleiner als SoC kleiner als 50%. 40°C kleiner als Temperatur. 1,5xC A kleiner als Strom
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_1", "STAT_HV_BATT_HIST_SOC3_T7_I10_WERT", STAT_HV_BATT_HIST_SOC3_T7_I10_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T7_I1_WERT = (RXBUF_UINT32(120)/10.0f);
// Duration at 50% less than SoC less than 70%. 40 ° C less than temperature. Current less than -2.5xC A / Dauer
// bei 50% kleiner als SoC kleiner als 70%. 40°C kleiner als Temperatur. Strom kleiner als -2,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_1", "STAT_HV_BATT_HIST_SOC4_T7_I1_WERT", STAT_HV_BATT_HIST_SOC4_T7_I1_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T7_I2_WERT = (RXBUF_UINT32(124)/10.0f);
// Duration at 50% less than SoC less than 70%. 40 ° C less than temperature. -2.5xC A less than current less
// than -2.0xC A / Dauer bei 50% kleiner als SoC kleiner als 70%. 40°C kleiner als Temperatur. -2,5xC A kleiner
// als Strom kleiner als -2,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_1", "STAT_HV_BATT_HIST_SOC4_T7_I2_WERT", STAT_HV_BATT_HIST_SOC4_T7_I2_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T7_I3_WERT = (RXBUF_UINT32(128)/10.0f);
// Duration at 50% less than SoC less than 70%. 40 ° C less than temperature. -2.0xC A less than current less
// than -1.5xC A / Dauer bei 50% kleiner als SoC kleiner als 70%. 40°C kleiner als Temperatur. -2,0xC A kleiner
// als Strom kleiner als -1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_1", "STAT_HV_BATT_HIST_SOC4_T7_I3_WERT", STAT_HV_BATT_HIST_SOC4_T7_I3_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T7_I4_WERT = (RXBUF_UINT32(132)/10.0f);
// Duration at 50% less than SoC less than 70%. 40 ° C less than temperature. -1.5xC A less than current less
// than -1.0xC A / Dauer bei 50% kleiner als SoC kleiner als 70%. 40°C kleiner als Temperatur. -1,5xC A kleiner
// als Strom kleiner als -1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_1", "STAT_HV_BATT_HIST_SOC4_T7_I4_WERT", STAT_HV_BATT_HIST_SOC4_T7_I4_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T7_I5_WERT = (RXBUF_UINT32(136)/10.0f);
// Duration at 50% less than SoC less than 70%. 40 ° C less than temperature. -1.0xC A less than current less
// than -0.5xC A / Dauer bei 50% kleiner als SoC kleiner als 70%. 40°C kleiner als Temperatur. -1,0xC A kleiner
// als Strom kleiner als -0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_1", "STAT_HV_BATT_HIST_SOC4_T7_I5_WERT", STAT_HV_BATT_HIST_SOC4_T7_I5_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T7_I6_WERT = (RXBUF_UINT32(140)/10.0f);
// Duration at 50% less than SoC less than 70%. 40 ° C less than temperature. -0.5xC A less than current less
// than 0.0xC A / Dauer bei 50% kleiner als SoC kleiner als 70%. 40°C kleiner als Temperatur. -0,5xC A kleiner
// als Strom kleiner als 0,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_1", "STAT_HV_BATT_HIST_SOC4_T7_I6_WERT", STAT_HV_BATT_HIST_SOC4_T7_I6_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T7_I7_WERT = (RXBUF_UINT32(144)/10.0f);
// Duration at 50% less than SoC less than 70%. 40 ° C less than temperature. 0.0xC A less than current less than
// 0.5xC A / Dauer bei 50% kleiner als SoC kleiner als 70%. 40°C kleiner als Temperatur. 0,0xC A kleiner als
// Strom kleiner als 0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_1", "STAT_HV_BATT_HIST_SOC4_T7_I7_WERT", STAT_HV_BATT_HIST_SOC4_T7_I7_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T7_I8_WERT = (RXBUF_UINT32(148)/10.0f);
// Duration at 50% less than SoC less than 70%. 40 ° C less than temperature. 0.5xC A less than current less than
// 1.0xC A / Dauer bei 50% kleiner als SoC kleiner als 70%. 40°C kleiner als Temperatur. 0,5xC A kleiner als
// Strom kleiner als 1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_1", "STAT_HV_BATT_HIST_SOC4_T7_I8_WERT", STAT_HV_BATT_HIST_SOC4_T7_I8_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T7_I9_WERT = (RXBUF_UINT32(152)/10.0f);
// Duration at 50% less than SoC less than 70%. 40 ° C less than temperature. 1.0xC A less than current less than
// 1.5xC A / Dauer bei 50% kleiner als SoC kleiner als 70%. 40°C kleiner als Temperatur. 1,0xC A kleiner als
// Strom kleiner als 1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_1", "STAT_HV_BATT_HIST_SOC4_T7_I9_WERT", STAT_HV_BATT_HIST_SOC4_T7_I9_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC4_T7_I10_WERT = (RXBUF_UINT32(156)/10.0f);
// Duration at 50% less than SoC less than 70%. 40 ° C less than temperature. 1.5xC A less than current / Dauer
// bei 50% kleiner als SoC kleiner als 70%. 40°C kleiner als Temperatur. 1,5xC A kleiner als Strom
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_1", "STAT_HV_BATT_HIST_SOC4_T7_I10_WERT", STAT_HV_BATT_HIST_SOC4_T7_I10_WERT, "\"s\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_LADEZIELSPANNUNG_TAUSCH: { // 0xDDAB
if (datalen < 2) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_LADEZIELSPANNUNG_TAUSCH", 2);
break;
}
float STAT_LADEZIELSPANNUNG_WERT = (RXBUF_UINT(0)/100.0f);
// Output of the charging target voltage for module replacement before installing the module in the vehicle /
// Ausgabe der Ladezielspannung für Modultausch vor Einbau des Moduls ins Fahrzeug
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "LADEZIELSPANNUNG_TAUSCH", "STAT_LADEZIELSPANNUNG_WERT", STAT_LADEZIELSPANNUNG_WERT, "\"V\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_HV_SPANNUNG_BATTERIE: { // 0xDDB4
if (datalen < 2) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_HV_SPANNUNG_BATTERIE", 2);
break;
}
float STAT_HV_SPANNUNG_BATT_WERT = (RXBUF_UINT(0)/100.0f);
// Battery voltage behind the contactors, regardless of the contactor status / Batteriespannung hinter den
// Schützen, unabhängig vom Schützzustand
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_SPANNUNG_BATTERIE", "STAT_HV_SPANNUNG_BATT_WERT", STAT_HV_SPANNUNG_BATT_WERT, "\"V\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_ALTERUNG_INNENWIDERSTAND: { // 0xDDB6
if (datalen < 2) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_ALTERUNG_INNENWIDERSTAND", 2);
break;
}
float STAT_ALTERUNG_INNENWIDERSTAND_WERT_0XDDB6 = (RXBUF_UINT(0)/10.0f);
// Aging of the internal resistance in percent: Internal resistance of the storage tank when new is related to
// the current value of the internal resistance (R_neu / R_akt) * 100 (100% = new condition, decreases with
// aging) / Alterung des Innenwiderstands in Prozent: Innenwiderstand des Speichers im Neuzustand auf den
// aktuellen Wert des Innenwiderstands bezogen (R_neu /R_akt) *100 (100% = Neuzustand, sinkt mit Alterung)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ALTERUNG_INNENWIDERSTAND", "STAT_ALTERUNG_INNENWIDERSTAND_WERT_0XDDB6", STAT_ALTERUNG_INNENWIDERSTAND_WERT_0XDDB6, "\"%\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_ANZEIGE_SOC: { // 0xDDBC
if (datalen < 6) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_ANZEIGE_SOC", 6);
break;
}
float STAT_ANZEIGE_SOC_WERT = (RXBUF_UINT(0)/10.0f);
// current advertisement Soc / aktueller Anzeige Soc
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ANZEIGE_SOC", "STAT_ANZEIGE_SOC_WERT", STAT_ANZEIGE_SOC_WERT, "\"%\"");
float STAT_MAXIMALE_ANZEIGE_SOC_WERT = (RXBUF_UINT(2)/10.0f);
// upper limit of the display Soc / obere Grenze des Anzeige Soc
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ANZEIGE_SOC", "STAT_MAXIMALE_ANZEIGE_SOC_WERT", STAT_MAXIMALE_ANZEIGE_SOC_WERT, "\"%\"");
float STAT_MINIMALE_ANZEIGE_SOC_WERT = (RXBUF_UINT(4)/10.0f);
// lower limit of the display Soc / untere Grenze des Anzeige Soc
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ANZEIGE_SOC", "STAT_MINIMALE_ANZEIGE_SOC_WERT", STAT_MINIMALE_ANZEIGE_SOC_WERT, "\"%\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_SERVICE_DISCONNECT: { // 0xDDBD
if (datalen < 1) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_SERVICE_DISCONNECT", 1);
break;
}
unsigned char STAT_SERVICE_DISCONNECT = (RXBUF_UCHAR(0));
// Status Service Disconnect (0 = open, 1 = closed) / Status Service Disconnect (0 = offen, 1 = geschlossen)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "SERVICE_DISCONNECT", "STAT_SERVICE_DISCONNECT", STAT_SERVICE_DISCONNECT, "\"0/1\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_VORLADUNG: { // 0xDDBE
if (datalen < 20) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_VORLADUNG", 20);
break;
}
unsigned short STAT_ZEIT_VORLADUNG_WERT = (RXBUF_UINT(0));
// last precharge time required / zuletzt benötigte Vorladezeit
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "VORLADUNG", "STAT_ZEIT_VORLADUNG_WERT", STAT_ZEIT_VORLADUNG_WERT, "\"ms\"");
unsigned short STAT_ZEIT_VORLADUNG_1_WERT = (RXBUF_UINT(2));
// Required precharge time (1 process before) / benötigte Vorladezeit (1 Vorgang zuvor)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "VORLADUNG", "STAT_ZEIT_VORLADUNG_1_WERT", STAT_ZEIT_VORLADUNG_1_WERT, "\"ms\"");
unsigned short STAT_ZEIT_VORLADUNG_2_WERT = (RXBUF_UINT(4));
// Required pre-charging time (2 processes before) / benötigte Vorladezeit (2 Vorgänge zuvor)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "VORLADUNG", "STAT_ZEIT_VORLADUNG_2_WERT", STAT_ZEIT_VORLADUNG_2_WERT, "\"ms\"");
unsigned short STAT_ZEIT_VORLADUNG_3_WERT = (RXBUF_UINT(6));
// Required pre-charging time (3 processes before) / benötigte Vorladezeit (3 Vorgänge zuvor)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "VORLADUNG", "STAT_ZEIT_VORLADUNG_3_WERT", STAT_ZEIT_VORLADUNG_3_WERT, "\"ms\"");
unsigned short STAT_ZEIT_VORLADUNG_4_WERT = (RXBUF_UINT(8));
// Required pre-charging time (4 processes before) / benötigte Vorladezeit (4 Vorgänge zuvor)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "VORLADUNG", "STAT_ZEIT_VORLADUNG_4_WERT", STAT_ZEIT_VORLADUNG_4_WERT, "\"ms\"");
float STAT_MAX_STROM_VORLADUNG_WERT = (RXBUF_SINT(10)/100.0f);
// maximum pre-charge current (last pre-charge) / maximaler Vorladestrom (letzte Vorladung)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "VORLADUNG", "STAT_MAX_STROM_VORLADUNG_WERT", STAT_MAX_STROM_VORLADUNG_WERT, "\"A\"");
float STAT_MAX_STROM_VORLADUNG_1_WERT = (RXBUF_SINT(12)/100.0f);
// maximum precharge current (1 process before) / maximaler Vorladestrom (1 Vorgang zuvor)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "VORLADUNG", "STAT_MAX_STROM_VORLADUNG_1_WERT", STAT_MAX_STROM_VORLADUNG_1_WERT, "\"A\"");
float STAT_MAX_STROM_VORLADUNG_2_WERT = (RXBUF_SINT(14)/100.0f);
// maximum precharge current (2 processes before) / maximaler Vorladestrom (2 Vorgänge zuvor)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "VORLADUNG", "STAT_MAX_STROM_VORLADUNG_2_WERT", STAT_MAX_STROM_VORLADUNG_2_WERT, "\"A\"");
float STAT_MAX_STROM_VORLADUNG_3_WERT = (RXBUF_SINT(16)/100.0f);
// maximum precharge current (3 processes before) / maximaler Vorladestrom (3 Vorgänge zuvor)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "VORLADUNG", "STAT_MAX_STROM_VORLADUNG_3_WERT", STAT_MAX_STROM_VORLADUNG_3_WERT, "\"A\"");
float STAT_MAX_STROM_VORLADUNG_4_WERT = (RXBUF_SINT(18)/100.0f);
// maximum precharge current (4 processes before) / maximaler Vorladestrom (4 Vorgänge zuvor)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "VORLADUNG", "STAT_MAX_STROM_VORLADUNG_4_WERT", STAT_MAX_STROM_VORLADUNG_4_WERT, "\"A\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_ZELLSPANNUNGEN_MIN_MAX: { // 0xDDBF
if (datalen < 4) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_ZELLSPANNUNGEN_MIN_MAX", 4);
break;
}
float STAT_UCELL_MIN_WERT = (RXBUF_UINT(0)/1000.0f);
// minimum single cell voltage of all single cells / minimale Einzelzellspannung aller Einzelzellen
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ZELLSPANNUNGEN_MIN_MAX", "STAT_UCELL_MIN_WERT", STAT_UCELL_MIN_WERT, "\"V\"");
float STAT_UCELL_MAX_WERT = (RXBUF_UINT(2)/1000.0f);
// maximum single cell voltage of all single cells / maximale Einzelzellspannung aller Einzelzellen
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ZELLSPANNUNGEN_MIN_MAX", "STAT_UCELL_MAX_WERT", STAT_UCELL_MAX_WERT, "\"V\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_TEMPERATUREN: { // 0xDDC0
if (datalen < 6) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_TEMPERATUREN", 6);
break;
}
float STAT_TCORE_MIN_WERT = (RXBUF_SINT(0)/100.0f);
// Output of the calculated minimum cell core temperatures / Ausgabe der berechneten minimalen
// Zellkerntemperaturen
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "TEMPERATUREN", "STAT_TCORE_MIN_WERT", STAT_TCORE_MIN_WERT, "\"°C\"");
float STAT_TCORE_MAX_WERT = (RXBUF_SINT(2)/100.0f);
// Output of the calculated maximum cell core temperatures / Ausgabe der berechneten maximalen
// Zellkerntemperaturen
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "TEMPERATUREN", "STAT_TCORE_MAX_WERT", STAT_TCORE_MAX_WERT, "\"°C\"");
float STAT_TCORE_MEAN_WERT = (RXBUF_SINT(4)/100.0f);
// Output of the calculated average cell core temperatures / Ausgabe der berechneten durchschnittlichen
// Zellkerntemperaturen
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "TEMPERATUREN", "STAT_TCORE_MEAN_WERT", STAT_TCORE_MEAN_WERT, "\"°C\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_ALTERUNG_PARAMETER: { // 0xDDC2
if (datalen < 6) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_ALTERUNG_PARAMETER", 6);
break;
}
float STAT_FAKTOR_RS_WERT = (RXBUF_UINT(0)/1000.0f);
// Correction factor for the serial ohmic resistance (1.5 = increase in resistance by 50%) / Korrekturfaktor des
// seriellen ohmschen Wiederstands (1,5 = Erhöhung des Wiederstands um 50%)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ALTERUNG_PARAMETER", "STAT_FAKTOR_RS_WERT", STAT_FAKTOR_RS_WERT, "");
float STAT_FAKTOR_RP_WERT = (RXBUF_UINT(2)/1000.0f);
// Correction factor for the parallel ohmic resistance (1.5 = increase in resistance by 50%) / Korrekturfaktor
// des paralellen ohmschen Wiederstands (1,5 = Erhöhung des Wiederstands um 50%)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ALTERUNG_PARAMETER", "STAT_FAKTOR_RP_WERT", STAT_FAKTOR_RP_WERT, "");
float STAT_FAKTOR_CP_WERT = (RXBUF_UINT(4)/1000.0f);
// Correction factor of the parallel capacity (1.5 = increase in capacity by 50%) / Korrekturfaktor der
// parallelen Kapazität (1,5 = Erhöhung der Kapazität um 50%)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ALTERUNG_PARAMETER", "STAT_FAKTOR_CP_WERT", STAT_FAKTOR_CP_WERT, "");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_HISTO_SYM_DAUER: { // 0xDDC6
if (datalen < 34) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_HISTO_SYM_DAUER", 34);
break;
}
unsigned short STAT_SYM_DAUER_MAX_WERT = (RXBUF_UINT(0));
// Predefined maximum symmetry time in minutes (project-specific) / Vordefinierte maximale Symmetrierdauer in
// Minuten (projektspezifisch)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "HISTO_SYM_DAUER", "STAT_SYM_DAUER_MAX_WERT", STAT_SYM_DAUER_MAX_WERT, "\"min\"");
unsigned long STAT_HISTO_SYM_DAUER_1_WERT = (RXBUF_UINT32(2));
// Number of duration classes: 0 <t <= tmax * 0.04 / Anzahl der Dauerklasse : 0 < t <= tmax*0.04
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HISTO_SYM_DAUER", "STAT_HISTO_SYM_DAUER_1_WERT", STAT_HISTO_SYM_DAUER_1_WERT, "");
unsigned long STAT_HISTO_SYM_DAUER_2_WERT = (RXBUF_UINT32(6));
// Number of duration classes: tmax * 0.04 <t <= tmax * 0.2 / Anzahl der Dauerklasse : tmax*0.04 < t <= tmax*0.2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HISTO_SYM_DAUER", "STAT_HISTO_SYM_DAUER_2_WERT", STAT_HISTO_SYM_DAUER_2_WERT, "");
unsigned long STAT_HISTO_SYM_DAUER_3_WERT = (RXBUF_UINT32(10));
// Number of duration classes: 0.2 * tmax <t <= tmax * 0.36 / Anzahl der Dauerklasse : 0.2*tmax < t <= tmax*0.36
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HISTO_SYM_DAUER", "STAT_HISTO_SYM_DAUER_3_WERT", STAT_HISTO_SYM_DAUER_3_WERT, "");
unsigned long STAT_HISTO_SYM_DAUER_4_WERT = (RXBUF_UINT32(14));
// Number of duration classes: tmax * 0.36 <t <= tmax * 0.52 / Anzahl der Dauerklasse : tmax*0.36 < t <=
// tmax*0.52
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HISTO_SYM_DAUER", "STAT_HISTO_SYM_DAUER_4_WERT", STAT_HISTO_SYM_DAUER_4_WERT, "");
unsigned long STAT_HISTO_SYM_DAUER_5_WERT = (RXBUF_UINT32(18));
// Number of duration classes: tmax * 0.52 <t <= tmax * 0.68 / Anzahl der Dauerklasse : tmax*0.52 < t <=
// tmax*0.68
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HISTO_SYM_DAUER", "STAT_HISTO_SYM_DAUER_5_WERT", STAT_HISTO_SYM_DAUER_5_WERT, "");
unsigned long STAT_HISTO_SYM_DAUER_6_WERT = (RXBUF_UINT32(22));
// Number of duration classes: tmax * 0.68 <t <= tmax * 0.86 / Anzahl der Dauerklasse : tmax*0.68 < t <=
// tmax*0.86
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HISTO_SYM_DAUER", "STAT_HISTO_SYM_DAUER_6_WERT", STAT_HISTO_SYM_DAUER_6_WERT, "");
unsigned long STAT_HISTO_SYM_DAUER_7_WERT = (RXBUF_UINT32(26));
// Number of duration classes: tmax * 0.86 <t <= tmax / Anzahl der Dauerklasse : tmax*0.86 < t <= tmax
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HISTO_SYM_DAUER", "STAT_HISTO_SYM_DAUER_7_WERT", STAT_HISTO_SYM_DAUER_7_WERT, "");
unsigned long STAT_HISTO_SYM_DAUER_8_WERT = (RXBUF_UINT32(30));
// Number of duration classes: t> tmax / Anzahl der Dauerklasse : t > tmax
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HISTO_SYM_DAUER", "STAT_HISTO_SYM_DAUER_8_WERT", STAT_HISTO_SYM_DAUER_8_WERT, "");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_HISTO_SYM_ZELLANZAHL: { // 0xDDC7
if (datalen < 16) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_HISTO_SYM_ZELLANZAHL", 16);
break;
}
unsigned short STAT_HISTO_SYM_ZELLANZAHL_1_WERT = (RXBUF_UINT(0));
// Number of cells to be symmetrized: n = 0 / Anzahl zu symmetrierende Zellen: n = 0
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "HISTO_SYM_ZELLANZAHL", "STAT_HISTO_SYM_ZELLANZAHL_1_WERT", STAT_HISTO_SYM_ZELLANZAHL_1_WERT, "");
unsigned short STAT_HISTO_SYM_ZELLANZAHL_2_WERT = (RXBUF_UINT(2));
// Number of cells to be symmetrized: n = 1 / Anzahl zu symmetrierende Zellen: n = 1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "HISTO_SYM_ZELLANZAHL", "STAT_HISTO_SYM_ZELLANZAHL_2_WERT", STAT_HISTO_SYM_ZELLANZAHL_2_WERT, "");
unsigned short STAT_HISTO_SYM_ZELLANZAHL_3_WERT = (RXBUF_UINT(4));
// Number of cells to be symmetrized: 1 <n <= NrCellsProModul / Anzahl zu symmetrierende Zellen: 1 < n <=
// NrCellsProModul
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "HISTO_SYM_ZELLANZAHL", "STAT_HISTO_SYM_ZELLANZAHL_3_WERT", STAT_HISTO_SYM_ZELLANZAHL_3_WERT, "");
unsigned short STAT_HISTO_SYM_ZELLANZAHL_4_WERT = (RXBUF_UINT(6));
// Number of cells to be symmetrized: NrCellsProModul <n <= NrCellsTotal / 2 / Anzahl zu symmetrierende Zellen:
// NrCellsProModul < n <= NrCellsTotal/2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "HISTO_SYM_ZELLANZAHL", "STAT_HISTO_SYM_ZELLANZAHL_4_WERT", STAT_HISTO_SYM_ZELLANZAHL_4_WERT, "");
unsigned short STAT_HISTO_SYM_ZELLANZAHL_5_WERT = (RXBUF_UINT(8));
// Number of cells to be symmetrized: NrCellsTotal / 2 <n <= NrCellsTotal-NrCellsProModul / Anzahl zu
// symmetrierende Zellen: NrCellsTotal/2 < n <= NrCellsTotal-NrCellsProModul
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "HISTO_SYM_ZELLANZAHL", "STAT_HISTO_SYM_ZELLANZAHL_5_WERT", STAT_HISTO_SYM_ZELLANZAHL_5_WERT, "");
unsigned short STAT_HISTO_SYM_ZELLANZAHL_6_WERT = (RXBUF_UINT(10));
// Number of cells to be symmetrized: NrCellsTotal-NrCellsProModul <n <= NrCellsTotal-2 / Anzahl zu
// symmetrierende Zellen: NrCellsTotal-NrCellsProModul < n <= NrCellsTotal-2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "HISTO_SYM_ZELLANZAHL", "STAT_HISTO_SYM_ZELLANZAHL_6_WERT", STAT_HISTO_SYM_ZELLANZAHL_6_WERT, "");
unsigned short STAT_HISTO_SYM_ZELLANZAHL_7_WERT = (RXBUF_UINT(12));
// Number of cells to be symmetrized: n <= NrCellsTotal-1 / Anzahl zu symmetrierende Zellen: n <= NrCellsTotal-1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "HISTO_SYM_ZELLANZAHL", "STAT_HISTO_SYM_ZELLANZAHL_7_WERT", STAT_HISTO_SYM_ZELLANZAHL_7_WERT, "");
unsigned short STAT_HISTO_SYM_ZELLANZAHL_8_WERT = (RXBUF_UINT(14));
// Number of cells to be symmetrized: n = NrCellsTotal / Anzahl zu symmetrierende Zellen: n = NrCellsTotal
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "HISTO_SYM_ZELLANZAHL", "STAT_HISTO_SYM_ZELLANZAHL_8_WERT", STAT_HISTO_SYM_ZELLANZAHL_8_WERT, "");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_SYM_DELTASOC: { // 0xDDC8
if (datalen < 10) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_SYM_DELTASOC", 10);
break;
}
float STAT_SYM_DELTASOC_1_WERT = (RXBUF_UINT(0)/100.0f);
// current dSOC (last determined) / aktueller dSOC (zuletzt bestimmt)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "SYM_DELTASOC", "STAT_SYM_DELTASOC_1_WERT", STAT_SYM_DELTASOC_1_WERT, "\"%\"");
float STAT_SYM_DELTASOC_2_WERT = (RXBUF_UINT(2)/100.0f);
// dSOC before a trip / dSOC vor einer Fahrt
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "SYM_DELTASOC", "STAT_SYM_DELTASOC_2_WERT", STAT_SYM_DELTASOC_2_WERT, "\"%\"");
float STAT_SYM_DELTASOC_3_WERT = (RXBUF_UINT(4)/100.0f);
// dSOC before 2 trips / dSOC vor 2 Fahrten
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "SYM_DELTASOC", "STAT_SYM_DELTASOC_3_WERT", STAT_SYM_DELTASOC_3_WERT, "\"%\"");
float STAT_SYM_DELTASOC_4_WERT = (RXBUF_UINT(6)/100.0f);
// dSOC before 3 trips / dSOC vor 3 Fahrten
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "SYM_DELTASOC", "STAT_SYM_DELTASOC_4_WERT", STAT_SYM_DELTASOC_4_WERT, "\"%\"");
float STAT_SYM_DELTASOC_5_WERT = (RXBUF_UINT(8)/100.0f);
// dSOC before 4 trips / dSOC vor 4 Fahrten
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "SYM_DELTASOC", "STAT_SYM_DELTASOC_5_WERT", STAT_SYM_DELTASOC_5_WERT, "\"%\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_MAX_SYM_DAUER: { // 0xDDC9
if (datalen < 45) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_MAX_SYM_DAUER", 45);
break;
}
unsigned long STAT_MAX_SYM_DAUER_1_WERT = (RXBUF_UINT32(0));
// Maximum symmetrization time of the last symmetrization process / Maximale Symmetrierdauer des letzten
// Symmetriervorgangs
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "MAX_SYM_DAUER", "STAT_MAX_SYM_DAUER_1_WERT", STAT_MAX_SYM_DAUER_1_WERT, "\"s\"");
unsigned long STAT_MAX_SYM_ZEIT_1_WERT = (RXBUF_UINT32(4));
// Time stamp start of balancing process for 1 / Zeitstempel Beginn Symmetriervorgang zu 1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "MAX_SYM_DAUER", "STAT_MAX_SYM_ZEIT_1_WERT", STAT_MAX_SYM_ZEIT_1_WERT, "\"s\"");
unsigned char STAT_BAL_COMPL_1_NR = (RXBUF_UCHAR(8));
// Status balancing / Status Symmetrierung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "MAX_SYM_DAUER", "STAT_BAL_COMPL_1_NR", STAT_BAL_COMPL_1_NR, "\"0-n\"");
unsigned long STAT_MAX_SYM_DAUER_2_WERT = (RXBUF_UINT32(9));
// Maximum symmetrization duration of the symmetrization process before 1 trip / Maximale Symmetrierdauer des
// Symmetriervorgangs vor 1 Fahrt
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "MAX_SYM_DAUER", "STAT_MAX_SYM_DAUER_2_WERT", STAT_MAX_SYM_DAUER_2_WERT, "\"s\"");
unsigned long STAT_MAX_SYM_ZEIT_2_WERT = (RXBUF_UINT32(13));
// Time stamp start of balancing process for 2 / Zeitstempel Beginn Symmetriervorgang zu 2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "MAX_SYM_DAUER", "STAT_MAX_SYM_ZEIT_2_WERT", STAT_MAX_SYM_ZEIT_2_WERT, "\"s\"");
unsigned char STAT_BAL_COMPL_2_NR = (RXBUF_UCHAR(17));
// Status balancing / Status Symmetrierung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "MAX_SYM_DAUER", "STAT_BAL_COMPL_2_NR", STAT_BAL_COMPL_2_NR, "\"0-n\"");
unsigned long STAT_MAX_SYM_DAUER_3_WERT = (RXBUF_UINT32(18));
// Maximum symmetrization duration of the symmetrization process before 2 trips / Maximale Symmetrierdauer des
// Symmetriervorgangs vor 2 Fahrt
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "MAX_SYM_DAUER", "STAT_MAX_SYM_DAUER_3_WERT", STAT_MAX_SYM_DAUER_3_WERT, "\"s\"");
unsigned long STAT_MAX_SYM_ZEIT_3_WERT = (RXBUF_UINT32(22));
// Time stamp start of balancing process for 3 / Zeitstempel Beginn Symmetriervorgang zu 3
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "MAX_SYM_DAUER", "STAT_MAX_SYM_ZEIT_3_WERT", STAT_MAX_SYM_ZEIT_3_WERT, "\"s\"");
unsigned char STAT_BAL_COMPL_3_NR = (RXBUF_UCHAR(26));
// Status balancing / Status Symmetrierung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "MAX_SYM_DAUER", "STAT_BAL_COMPL_3_NR", STAT_BAL_COMPL_3_NR, "\"0-n\"");
unsigned long STAT_MAX_SYM_DAUER_4_WERT = (RXBUF_UINT32(27));
// Maximum symmetrization duration of the symmetrization process before 3 trips / Maximale Symmetrierdauer des
// Symmetriervorgangs vor 3 Fahrt
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "MAX_SYM_DAUER", "STAT_MAX_SYM_DAUER_4_WERT", STAT_MAX_SYM_DAUER_4_WERT, "\"s\"");
unsigned long STAT_MAX_SYM_ZEIT_4_WERT = (RXBUF_UINT32(31));
// Time stamp start of symmetrization process for 4 / Zeitstempel Beginn Symmetriervorgang zu 4
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "MAX_SYM_DAUER", "STAT_MAX_SYM_ZEIT_4_WERT", STAT_MAX_SYM_ZEIT_4_WERT, "\"s\"");
unsigned char STAT_BAL_COMPL_4_NR = (RXBUF_UCHAR(35));
// Status balancing / Status Symmetrierung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "MAX_SYM_DAUER", "STAT_BAL_COMPL_4_NR", STAT_BAL_COMPL_4_NR, "\"0-n\"");
unsigned long STAT_MAX_SYM_DAUER_5_WERT = (RXBUF_UINT32(36));
// Maximum duration of the symmetrization process before 4 trips / Maximale Symmetrierdauer des
// Symmetriervorgangs vor 4 Fahrten
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "MAX_SYM_DAUER", "STAT_MAX_SYM_DAUER_5_WERT", STAT_MAX_SYM_DAUER_5_WERT, "\"s\"");
unsigned long STAT_MAX_SYM_ZEIT_5_WERT = (RXBUF_UINT32(40));
// Time stamp start of symmetrization process for 5 / Zeitstempel Beginn Symmetriervorgang zu 5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "MAX_SYM_DAUER", "STAT_MAX_SYM_ZEIT_5_WERT", STAT_MAX_SYM_ZEIT_5_WERT, "\"s\"");
unsigned char STAT_BAL_COMPL_5_NR = (RXBUF_UCHAR(44));
// Status balancing / Status Symmetrierung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "MAX_SYM_DAUER", "STAT_BAL_COMPL_5_NR", STAT_BAL_COMPL_5_NR, "\"0-n\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_SERIENNUMMER_ECU: { // 0xDDCA
if (datalen < 10) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_SERIENNUMMER_ECU", 10);
break;
}
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_SOC_GRENZEN: { // 0xDDCB
if (datalen < 4) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_SOC_GRENZEN", 4);
break;
}
float STAT_MIN_SOC_GRENZE_WERT = (RXBUF_SINT(0)/100.0f);
// currently valid minimum SOC limit / aktuell gültige minimale SOC Grenze
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "SOC_GRENZEN", "STAT_MIN_SOC_GRENZE_WERT", STAT_MIN_SOC_GRENZE_WERT, "\"%\"");
float STAT_MAX_SOC_GRENZE_WERT = (RXBUF_SINT(2)/100.0f);
// currently valid maximum SOC limit / aktuell gültige maximale SOC Grenze
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "SOC_GRENZEN", "STAT_MAX_SOC_GRENZE_WERT", STAT_MAX_SOC_GRENZE_WERT, "\"%\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_DIFFERENZ_SPANNUNGEN: { // 0xDDCF
if (datalen < 2) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_DIFFERENZ_SPANNUNGEN", 2);
break;
}
float STAT_DIFF_SPANNUNG_STATISCH_WERT = (RXBUF_SINT(0)/100.0f);
// Differential voltage: total voltage HV battery - total cell voltage (static determination) /
// Differenzspannung: Gesamtspannung HV-Batterie - Summenzellspannung (statische Ermittlung)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "DIFFERENZ_SPANNUNGEN", "STAT_DIFF_SPANNUNG_STATISCH_WERT", STAT_DIFF_SPANNUNG_STATISCH_WERT, "\"V\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_ALTERUNG_KAPAZITAET_DEGRADATION: { // 0xDDE8
if (datalen < 4) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_ALTERUNG_KAPAZITAET_DEGRADATION", 4);
break;
}
unsigned short STAT_ANZAHL_DEGRADATION_GESAMT_WERT = (RXBUF_UINT(0));
// Number of age-related voltage degradations of the high-voltage storage system over the total time >> This job
// is no longer supported and has NULL data. / Anzahl der alterungsbedingten Spannungsdegradationen der
// Hochvolt-Speicher über Gesamtzeit >> Dieser Job wird nicht mehr unterstützt und ist NULL-bedatet.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "ALTERUNG_KAPAZITAET_DEGRADATION", "STAT_ANZAHL_DEGRADATION_GESAMT_WERT", STAT_ANZAHL_DEGRADATION_GESAMT_WERT, "");
unsigned short STAT_ANZAHL_DEGRADATION_LAUFENDES_JAHR_WERT = (RXBUF_UINT(2));
// Average number of age-related voltage degradations of the high-voltage storage system over the last and
// current year >> This job is no longer supported and has NULL data. / Anzahl der alterungsbedingten
// Spannungsdegradationen der Hochvolt-Speicher im Mittel über letztes und laufendes Jahr >> Dieser Job wird
// nicht mehr unterstützt und ist NULL-bedatet.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "ALTERUNG_KAPAZITAET_DEGRADATION", "STAT_ANZAHL_DEGRADATION_LAUFENDES_JAHR_WERT", STAT_ANZAHL_DEGRADATION_LAUFENDES_JAHR_WERT, "");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB: { // 0xDDE9
if (datalen < 60) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB", 60);
break;
}
unsigned short STAT_HFK_GESAMT_SOC_HUB_50_65_WERT = (RXBUF_UINT(0));
// Up to 14-03: Frequency with SoC hub between 50% and 65%, total from last year and current year From 14-07:
// Frequency with SoC hub between 70% and 74%, total from last year and current year / Bis 14-03: Häufigkeit bei
// SoC-Hub zwischen 50% und 65%, Summe letztes Jahr und laufendes Jahr Ab 14-07: Häufigkeit bei SoC-Hub zwischen
// 70% und 74%, Summe letztes Jahr und laufendes Jahr
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB", "STAT_HFK_GESAMT_SOC_HUB_50_65_WERT", STAT_HFK_GESAMT_SOC_HUB_50_65_WERT, "");
unsigned short STAT_HFK_GESAMT_SOC_HUB_65_80_WERT = (RXBUF_UINT(2));
// Up to 14-03: Frequency with SoC hub between 65% and 80%, total from last year and current year From 14-07:
// Frequency with SoC hub between 74% and 80%, total from last year and current year / Bis 14-03: Häufigkeit bei
// SoC-Hub zwischen 65% und 80%, Summe letztes Jahr und laufendes Jahr Ab 14-07: Häufigkeit bei SoC-Hub zwischen
// 74% und 80%, Summe letztes Jahr und laufendes Jahr
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB", "STAT_HFK_GESAMT_SOC_HUB_65_80_WERT", STAT_HFK_GESAMT_SOC_HUB_65_80_WERT, "");
unsigned short STAT_HFK_GESAMT_SOC_HUB_80_85_WERT = (RXBUF_UINT(4));
// Frequency with SoC hub between 80% and 85%, sum of last year and current year / Häufigkeit bei SoC-Hub
// zwischen 80% und 85%, Summe letztes Jahr und laufendes Jahr
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB", "STAT_HFK_GESAMT_SOC_HUB_80_85_WERT", STAT_HFK_GESAMT_SOC_HUB_80_85_WERT, "");
unsigned short STAT_HFK_GESAMT_SOC_HUB_85_90_WERT = (RXBUF_UINT(6));
// Frequency with SoC hub between 85% and 90%, sum of last year and current year / Häufigkeit bei SoC-Hub
// zwischen 85% und 90%, Summe letztes Jahr und laufendes Jahr
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB", "STAT_HFK_GESAMT_SOC_HUB_85_90_WERT", STAT_HFK_GESAMT_SOC_HUB_85_90_WERT, "");
unsigned short STAT_HFK_GESAMT_SOC_HUB_90_95_WERT = (RXBUF_UINT(8));
// Frequency with SoC hub between 90% and 95%, sum of last year and current year / Häufigkeit bei SoC-Hub
// zwischen 90% und 95%, Summe letztes Jahr und laufendes Jahr
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB", "STAT_HFK_GESAMT_SOC_HUB_90_95_WERT", STAT_HFK_GESAMT_SOC_HUB_90_95_WERT, "");
unsigned short STAT_HFK_GESAMT_SOC_HUB_95_100_WERT = (RXBUF_UINT(10));
// Frequency with SoC hub between 95% and 100%, sum of last year and current year / Häufigkeit bei SoC-Hub
// zwischen 95% und 100%, Summe letztes Jahr und laufendes Jahr
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB", "STAT_HFK_GESAMT_SOC_HUB_95_100_WERT", STAT_HFK_GESAMT_SOC_HUB_95_100_WERT, "");
unsigned short STAT_HFK_LAUFENDES_JAHR_SOC_HUB_50_65_WERT = (RXBUF_UINT(12));
// Frequency with SoC hub between 50% and 65%, sum of last year and current year / Häufigkeit bei SoC-Hub
// zwischen 50% und 65%, Summe letztes Jahr und laufendes Jahr
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB", "STAT_HFK_LAUFENDES_JAHR_SOC_HUB_50_65_WERT", STAT_HFK_LAUFENDES_JAHR_SOC_HUB_50_65_WERT, "");
unsigned short STAT_HFK_LAUFENDES_JAHR_SOC_HUB_65_80_WERT = (RXBUF_UINT(14));
// Frequency with SoC hub between 65% and 80%, total of last year and current year / Häufigkeit bei SoC-Hub
// zwischen 65% und 80%, Summe letztes Jahr und laufendes Jahr
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB", "STAT_HFK_LAUFENDES_JAHR_SOC_HUB_65_80_WERT", STAT_HFK_LAUFENDES_JAHR_SOC_HUB_65_80_WERT, "");
unsigned short STAT_HFK_LAUFENDES_JAHR_SOC_HUB_80_85_WERT = (RXBUF_UINT(16));
// Frequency with SoC hub between 80% and 85%, sum of last year and current year / Häufigkeit bei SoC-Hub
// zwischen 80% und 85%, Summe letztes Jahr und laufendes Jahr
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB", "STAT_HFK_LAUFENDES_JAHR_SOC_HUB_80_85_WERT", STAT_HFK_LAUFENDES_JAHR_SOC_HUB_80_85_WERT, "");
unsigned short STAT_HFK_LAUFENDES_JAHR_SOC_HUB_85_90_WERT = (RXBUF_UINT(18));
// Frequency with SoC hub between 85% and 90%, sum of last year and current year / Häufigkeit bei SoC-Hub
// zwischen 85% und 90%, Summe letztes Jahr und laufendes Jahr
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB", "STAT_HFK_LAUFENDES_JAHR_SOC_HUB_85_90_WERT", STAT_HFK_LAUFENDES_JAHR_SOC_HUB_85_90_WERT, "");
unsigned short STAT_HFK_LAUFENDES_JAHR_SOC_HUB_90_95_WERT = (RXBUF_UINT(20));
// Frequency with SoC hub between 90% and 95%, sum of last year and current year / Häufigkeit bei SoC-Hub
// zwischen 90% und 95%, Summe letztes Jahr und laufendes Jahr
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB", "STAT_HFK_LAUFENDES_JAHR_SOC_HUB_90_95_WERT", STAT_HFK_LAUFENDES_JAHR_SOC_HUB_90_95_WERT, "");
unsigned short STAT_HFK_LAUFENDES_JAHR_SOC_HUB_95_100_WERT = (RXBUF_UINT(22));
// Frequency with SoC hub between 95% and 100%, sum of last year and current year / Häufigkeit bei SoC-Hub
// zwischen 95% und 100%, Summe letztes Jahr und laufendes Jahr
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB", "STAT_HFK_LAUFENDES_JAHR_SOC_HUB_95_100_WERT", STAT_HFK_LAUFENDES_JAHR_SOC_HUB_95_100_WERT, "");
unsigned short STAT_HFK_LAUFENDES_MONAT_SOC_HUB_50_65_WERT = (RXBUF_UINT(24));
// Frequency with SoC hub between 50% and 65%, sum of the last and current month / Häufigkeit bei SoC-Hub
// zwischen 50% und 65%, Summe letzter und laufender Monat
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB", "STAT_HFK_LAUFENDES_MONAT_SOC_HUB_50_65_WERT", STAT_HFK_LAUFENDES_MONAT_SOC_HUB_50_65_WERT, "");
unsigned short STAT_HFK_LAUFENDES_MONAT_SOC_HUB_65_80_WERT = (RXBUF_UINT(26));
// Frequency with SoC hub between 65% and 80%, sum of the last and current month / Häufigkeit bei SoC-Hub
// zwischen 65% und 80%, Summe letzter und laufender Monat
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB", "STAT_HFK_LAUFENDES_MONAT_SOC_HUB_65_80_WERT", STAT_HFK_LAUFENDES_MONAT_SOC_HUB_65_80_WERT, "");
unsigned short STAT_HFK_LAUFENDES_MONAT_SOC_HUB_80_85_WERT = (RXBUF_UINT(28));
// Frequency with SoC hub between 80% and 85%, sum of the last and current month / Häufigkeit bei SoC-Hub
// zwischen 80% und 85%, Summe letzter und laufender Monat
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB", "STAT_HFK_LAUFENDES_MONAT_SOC_HUB_80_85_WERT", STAT_HFK_LAUFENDES_MONAT_SOC_HUB_80_85_WERT, "");
unsigned short STAT_HFK_LAUFENDES_MONAT_SOC_HUB_85_90_WERT = (RXBUF_UINT(30));
// Frequency with SoC hub between 85% and 90%, sum of the last and current month / Häufigkeit bei SoC-Hub
// zwischen 85% und 90%, Summe letzter und laufender Monat
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB", "STAT_HFK_LAUFENDES_MONAT_SOC_HUB_85_90_WERT", STAT_HFK_LAUFENDES_MONAT_SOC_HUB_85_90_WERT, "");
unsigned short STAT_HFK_LAUFENDES_MONAT_SOC_HUB_90_95_WERT = (RXBUF_UINT(32));
// Frequency with SoC hub between 90% and 95%, sum of the last and current month / Häufigkeit bei SoC-Hub
// zwischen 90% und 95%, Summe letzter und laufender Monat
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB", "STAT_HFK_LAUFENDES_MONAT_SOC_HUB_90_95_WERT", STAT_HFK_LAUFENDES_MONAT_SOC_HUB_90_95_WERT, "");
unsigned short STAT_HFK_LAUFENDES_MONAT_SOC_HUB_95_100_WERT = (RXBUF_UINT(34));
// Frequency with SoC hub between 95% and 100%, sum of the last and current month / Häufigkeit bei SoC-Hub
// zwischen 95% und 100%, Summe letzter und laufender Monat
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB", "STAT_HFK_LAUFENDES_MONAT_SOC_HUB_95_100_WERT", STAT_HFK_LAUFENDES_MONAT_SOC_HUB_95_100_WERT, "");
unsigned long STAT_ZEITSTEMPEL_SOC_HUB_50_65_WERT = (RXBUF_UINT32(36));
// Stamp d. Vehicle time when the SoC hub last occurred between 50% and 65% / Stempel d. Fzg.-Zeit bei letztem
// Auftreten des SoC-Hub zwischen 50% und 65%
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB", "STAT_ZEITSTEMPEL_SOC_HUB_50_65_WERT", STAT_ZEITSTEMPEL_SOC_HUB_50_65_WERT, "\"s\"");
unsigned long STAT_ZEITSTEMPEL_SOC_HUB_65_80_WERT = (RXBUF_UINT32(40));
// Stamp d. Vehicle time when the SoC hub last occurred between 65% and 80% / Stempel d. Fzg.-Zeit bei letztem
// Auftreten des SoC-Hub zwischen 65% und 80%
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB", "STAT_ZEITSTEMPEL_SOC_HUB_65_80_WERT", STAT_ZEITSTEMPEL_SOC_HUB_65_80_WERT, "\"s\"");
unsigned long STAT_ZEITSTEMPEL_SOC_HUB_80_85_WERT = (RXBUF_UINT32(44));
// Stamp d. Vehicle time when the SoC hub last occurred between 80% and 85% / Stempel d. Fzg.-Zeit bei letztem
// Auftreten des SoC-Hub zwischen 80% und 85%
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB", "STAT_ZEITSTEMPEL_SOC_HUB_80_85_WERT", STAT_ZEITSTEMPEL_SOC_HUB_80_85_WERT, "\"s\"");
unsigned long STAT_ZEITSTEMPEL_SOC_HUB_85_90_WERT = (RXBUF_UINT32(48));
// Stamp d. Vehicle time when the SoC hub last occurred between 85% and 90% / Stempel d. Fzg.-Zeit bei letztem
// Auftreten des SoC-Hub zwischen 85% und 90%
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB", "STAT_ZEITSTEMPEL_SOC_HUB_85_90_WERT", STAT_ZEITSTEMPEL_SOC_HUB_85_90_WERT, "\"s\"");
unsigned long STAT_ZEITSTEMPEL_SOC_HUB_90_95_WERT = (RXBUF_UINT32(52));
// Stamp d. Vehicle time when the SoC hub last occurred between 90% and 95% / Stempel d. Fzg.-Zeit bei letztem
// Auftreten des SoC-Hub zwischen 90% und 95%
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB", "STAT_ZEITSTEMPEL_SOC_HUB_90_95_WERT", STAT_ZEITSTEMPEL_SOC_HUB_90_95_WERT, "\"s\"");
unsigned long STAT_ZEITSTEMPEL_SOC_HUB_95_100_WERT = (RXBUF_UINT32(56));
// Stamp d. Vehicle time when the SoC hub last occurred between 95% and 100% / Stempel d. Fzg.-Zeit bei letztem
// Auftreten des SoC-Hub zwischen 95% und 100%
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ALTERUNG_KAPAZITAET_HISTOGRAMM_SOC_HUB", "STAT_ZEITSTEMPEL_SOC_HUB_95_100_WERT", STAT_ZEITSTEMPEL_SOC_HUB_95_100_WERT, "\"s\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_RINGPUFFER_LADEVORGAENGE: { // 0xDDEB
if (datalen < 60) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_RINGPUFFER_LADEVORGAENGE", 60);
break;
}
unsigned char STAT_START_SOC_1_WERT = (RXBUF_UCHAR(0));
// Value of the start SOC after completion of the loading process-1 (255 = implausible) / Wert des Start SOC nach
// Abschluss des Ladervorgang-1 (255 = unplausibel)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RINGPUFFER_LADEVORGAENGE", "STAT_START_SOC_1_WERT", STAT_START_SOC_1_WERT, "\"%\"");
unsigned char STAT_START_SOC_2_WERT = (RXBUF_UCHAR(1));
// Value of the start SOC after completion of the loading process-2 (255 = implausible) / Wert des Start SOC nach
// Abschluss des Ladervorgang-2 (255 = unplausibel)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RINGPUFFER_LADEVORGAENGE", "STAT_START_SOC_2_WERT", STAT_START_SOC_2_WERT, "\"%\"");
unsigned char STAT_START_SOC_3_WERT = (RXBUF_UCHAR(2));
// Value of the start SOC after completion of the loading process-3 (255 = implausible) / Wert des Start SOC nach
// Abschluss des Ladervorgang-3 (255 = unplausibel)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RINGPUFFER_LADEVORGAENGE", "STAT_START_SOC_3_WERT", STAT_START_SOC_3_WERT, "\"%\"");
unsigned char STAT_START_SOC_4_WERT = (RXBUF_UCHAR(3));
// Value of the start SOC after completion of the loading process-4 (255 = implausible) / Wert des Start SOC nach
// Abschluss des Ladervorgang-4 (255 = unplausibel)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RINGPUFFER_LADEVORGAENGE", "STAT_START_SOC_4_WERT", STAT_START_SOC_4_WERT, "\"%\"");
unsigned char STAT_START_SOC_5_WERT = (RXBUF_UCHAR(4));
// Value of the start SOC after completion of the loading process -5 (255 = implausible) / Wert des Start SOC
// nach Abschluss des Ladervorgang-5 (255 = unplausibel)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RINGPUFFER_LADEVORGAENGE", "STAT_START_SOC_5_WERT", STAT_START_SOC_5_WERT, "\"%\"");
unsigned char STAT_VERF_P_LADEN_1_WERT = (RXBUF_UCHAR(5));
// Value (from HVPM) of the available charging power at the beginning of charging-1 (255 = implausible). The
// output 'available charging power' must be divided by 5 in order to obtain a real value. / Wert (aus HVPM) der
// verfügbaren Ladeleistung zu Ladebeginn-1 (255 = unplausibel). Die ausgegebene 'verfügbare Ladeleistung' muss
// mit 5 dividiert werden um realen Wert zu erhalten.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RINGPUFFER_LADEVORGAENGE", "STAT_VERF_P_LADEN_1_WERT", STAT_VERF_P_LADEN_1_WERT, "\"kW\"");
unsigned char STAT_VERF_P_LADEN_2_WERT = (RXBUF_UCHAR(6));
// Value (from HVPM) of the available charging power at the start of charging-2 (255 = implausible). The output
// 'available charging power' must be divided by 5 in order to obtain a real value. / Wert (aus HVPM) der
// verfügbaren Ladeleistung zu Ladebeginn-2 (255 = unplausibel). Die ausgegebene 'verfügbare Ladeleistung' muss
// mit 5 dividiert werden um realen Wert zu erhalten.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RINGPUFFER_LADEVORGAENGE", "STAT_VERF_P_LADEN_2_WERT", STAT_VERF_P_LADEN_2_WERT, "\"kW\"");
unsigned char STAT_VERF_P_LADEN_3_WERT = (RXBUF_UCHAR(7));
// Value (from HVPM) of the available charging power at the start of charging -3 (255 = implausible). The output
// 'available charging power' must be divided by 5 in order to obtain a real value. / Wert (aus HVPM) der
// verfügbaren Ladeleistung zu Ladebeginn-3 (255 = unplausibel). Die ausgegebene 'verfügbare Ladeleistung' muss
// mit 5 dividiert werden um realen Wert zu erhalten.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RINGPUFFER_LADEVORGAENGE", "STAT_VERF_P_LADEN_3_WERT", STAT_VERF_P_LADEN_3_WERT, "\"kW\"");
unsigned char STAT_VERF_P_LADEN_4_WERT = (RXBUF_UCHAR(8));
// Value (from HVPM) of the available charging power at the start of charging-4 (255 = implausible). The output
// 'available charging power' must be divided by 5 in order to obtain a real value. / Wert (aus HVPM) der
// verfügbaren Ladeleistung zu Ladebeginn-4 (255 = unplausibel). Die ausgegebene 'verfügbare Ladeleistung' muss
// mit 5 dividiert werden um realen Wert zu erhalten.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RINGPUFFER_LADEVORGAENGE", "STAT_VERF_P_LADEN_4_WERT", STAT_VERF_P_LADEN_4_WERT, "\"kW\"");
unsigned char STAT_VERF_P_LADEN_5_WERT = (RXBUF_UCHAR(9));
// Value (from HVPM) of the available charging power at the start of charging -5 (255 = implausible). The output
// 'available charging power' must be divided by 5 in order to obtain a real value. / Wert (aus HVPM) der
// verfügbaren Ladeleistung zu Ladebeginn-5 (255 = unplausibel). Die ausgegebene 'verfügbare Ladeleistung' muss
// mit 5 dividiert werden um realen Wert zu erhalten.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RINGPUFFER_LADEVORGAENGE", "STAT_VERF_P_LADEN_5_WERT", STAT_VERF_P_LADEN_5_WERT, "\"kW\"");
unsigned char STAT_REAL_END_SOC_1_WERT = (RXBUF_UCHAR(10));
// Value of the actual SOC after completion of the charging process-1 (255 = implausible) / Wert des
// tatsächlichen SOC nach Abschluss des Ladervorgang-1 (255 = unplausibel)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RINGPUFFER_LADEVORGAENGE", "STAT_REAL_END_SOC_1_WERT", STAT_REAL_END_SOC_1_WERT, "\"%\"");
unsigned char STAT_REAL_END_SOC_2_WERT = (RXBUF_UCHAR(11));
// Value of the actual SOC after completion of the charging process-2 (255 = implausible) / Wert des
// tatsächlichen SOC nach Abschluss des Ladervorgang-2 (255 = unplausibel)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RINGPUFFER_LADEVORGAENGE", "STAT_REAL_END_SOC_2_WERT", STAT_REAL_END_SOC_2_WERT, "\"%\"");
unsigned char STAT_REAL_END_SOC_3_WERT = (RXBUF_UCHAR(12));
// Value of the actual SOC after completion of the charging process-3 (255 = implausible) / Wert des
// tatsächlichen SOC nach Abschluss des Ladervorgang-3 (255 = unplausibel)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RINGPUFFER_LADEVORGAENGE", "STAT_REAL_END_SOC_3_WERT", STAT_REAL_END_SOC_3_WERT, "\"%\"");
unsigned char STAT_REAL_END_SOC_4_WERT = (RXBUF_UCHAR(13));
// Value of the actual SOC after completion of the charging process-4 (255 = implausible) / Wert des
// tatsächlichen SOC nach Abschluss des Ladervorgang-4 (255 = unplausibel)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RINGPUFFER_LADEVORGAENGE", "STAT_REAL_END_SOC_4_WERT", STAT_REAL_END_SOC_4_WERT, "\"%\"");
unsigned char STAT_REAL_END_SOC_5_WERT = (RXBUF_UCHAR(14));
// Value of the actual SOC after completion of the loading process -5 (255 = implausible) / Wert des
// tatsächlichen SOC nach Abschluss des Ladervorgang-5 (255 = unplausibel)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RINGPUFFER_LADEVORGAENGE", "STAT_REAL_END_SOC_5_WERT", STAT_REAL_END_SOC_5_WERT, "\"%\"");
unsigned char STAT_GRUND_LADEENDE_WERT_1 = (RXBUF_UCHAR(15));
// Reason for the end of charging after completion of the charging process-1 / Grund des Ladeendes nach Abschluss
// des Ladervorgang-1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RINGPUFFER_LADEVORGAENGE", "STAT_GRUND_LADEENDE_WERT_1", STAT_GRUND_LADEENDE_WERT_1, "\"0-n\"");
unsigned char STAT_GRUND_LADEENDE_WERT_2 = (RXBUF_UCHAR(16));
// Reason for the end of charging after completion of the charging process-2 / Grund des Ladeendes nach Abschluss
// des Ladervorgang-2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RINGPUFFER_LADEVORGAENGE", "STAT_GRUND_LADEENDE_WERT_2", STAT_GRUND_LADEENDE_WERT_2, "\"0-n\"");
unsigned char STAT_GRUND_LADEENDE_WERT_3 = (RXBUF_UCHAR(17));
// Reason for the end of charging after completion of the charging process-3 / Grund des Ladeendes nach Abschluss
// des Ladervorgang-3
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RINGPUFFER_LADEVORGAENGE", "STAT_GRUND_LADEENDE_WERT_3", STAT_GRUND_LADEENDE_WERT_3, "\"0-n\"");
unsigned char STAT_GRUND_LADEENDE_WERT_4 = (RXBUF_UCHAR(18));
// Reason for the end of charging after completion of the charging process-4 / Grund des Ladeendes nach Abschluss
// des Ladervorgang-4
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RINGPUFFER_LADEVORGAENGE", "STAT_GRUND_LADEENDE_WERT_4", STAT_GRUND_LADEENDE_WERT_4, "\"0-n\"");
unsigned char STAT_GRUND_LADEENDE_WERT_5 = (RXBUF_UCHAR(19));
// Reason for the end of charging after the completion of charging-5 / Grund des Ladeendes nach Abschluss des
// Ladervorgang-5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RINGPUFFER_LADEVORGAENGE", "STAT_GRUND_LADEENDE_WERT_5", STAT_GRUND_LADEENDE_WERT_5, "\"0-n\"");
char STAT_START_TEMP_1_WERT = (RXBUF_SCHAR(20));
// Value of the start temperature after completion of the charging process-1 (127 = implausible) / Wert der Start
// Temperatur nach Abschluss des Ladervorgang-1 (127 = unplausibel)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RINGPUFFER_LADEVORGAENGE", "STAT_START_TEMP_1_WERT", STAT_START_TEMP_1_WERT, "\"°C\"");
char STAT_START_TEMP_2_WERT = (RXBUF_SCHAR(21));
// Value of the start temperature after completion of the charging process-2 (127 = implausible) / Wert der Start
// Temperatur nach Abschluss des Ladervorgang-2 (127 = unplausibel)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RINGPUFFER_LADEVORGAENGE", "STAT_START_TEMP_2_WERT", STAT_START_TEMP_2_WERT, "\"°C\"");
char STAT_START_TEMP_3_WERT = (RXBUF_SCHAR(22));
// Value of the start temperature after completion of the charging process-3 (127 = implausible) / Wert der Start
// Temperatur nach Abschluss des Ladervorgang-3 (127 = unplausibel)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RINGPUFFER_LADEVORGAENGE", "STAT_START_TEMP_3_WERT", STAT_START_TEMP_3_WERT, "\"°C\"");
char STAT_START_TEMP_4_WERT = (RXBUF_SCHAR(23));
// Value of the start temperature after completion of the charging process-4 (127 = implausible) / Wert der Start
// Temperatur nach Abschluss des Ladervorgang-4 (127 = unplausibel)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RINGPUFFER_LADEVORGAENGE", "STAT_START_TEMP_4_WERT", STAT_START_TEMP_4_WERT, "\"°C\"");
char STAT_START_TEMP_5_WERT = (RXBUF_SCHAR(24));
// Value of the start temperature after completion of the charging process -5 (127 = implausible) / Wert der
// Start Temperatur nach Abschluss des Ladervorgang-5 (127 = unplausibel)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RINGPUFFER_LADEVORGAENGE", "STAT_START_TEMP_5_WERT", STAT_START_TEMP_5_WERT, "\"°C\"");
char STAT_END_TEMP_1_WERT = (RXBUF_SCHAR(25));
// Value of the end temperature after completion of the loading process-1 (127 = implausible) / Wert der End
// Temperatur nach Abschluss des Ladervorgang-1 (127 = unplausibel)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RINGPUFFER_LADEVORGAENGE", "STAT_END_TEMP_1_WERT", STAT_END_TEMP_1_WERT, "\"°C\"");
char STAT_END_TEMP_2_WERT = (RXBUF_SCHAR(26));
// Value of the end temperature after completion of the charging process-2 (127 = implausible) / Wert der End
// Temperatur nach Abschluss des Ladervorgang-2 (127 = unplausibel)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RINGPUFFER_LADEVORGAENGE", "STAT_END_TEMP_2_WERT", STAT_END_TEMP_2_WERT, "\"°C\"");
char STAT_END_TEMP_3_WERT = (RXBUF_SCHAR(27));
// Value of the end temperature after completion of the loading process-3 (127 = implausible) / Wert der End
// Temperatur nach Abschluss des Ladervorgang-3 (127 = unplausibel)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RINGPUFFER_LADEVORGAENGE", "STAT_END_TEMP_3_WERT", STAT_END_TEMP_3_WERT, "\"°C\"");
char STAT_END_TEMP_4_WERT = (RXBUF_SCHAR(28));
// Value of the end temperature after completion of the loading process-4 (127 = implausible) / Wert der End
// Temperatur nach Abschluss des Ladervorgang-4 (127 = unplausibel)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RINGPUFFER_LADEVORGAENGE", "STAT_END_TEMP_4_WERT", STAT_END_TEMP_4_WERT, "\"°C\"");
char STAT_END_TEMP_5_WERT = (RXBUF_SCHAR(29));
// Value of the end temperature after completion of the loading process -5 (127 = implausible) / Wert der End
// Temperatur nach Abschluss des Ladervorgang-5 (127 = unplausibel)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RINGPUFFER_LADEVORGAENGE", "STAT_END_TEMP_5_WERT", STAT_END_TEMP_5_WERT, "\"°C\"");
float STAT_BEGINN_PROG_LADEZEIT_1_WERT = (RXBUF_UCHAR(30)*5.0f);
// Charging time forecast at the beginning after completion of the charging process-1 / Zu Beginn prognostizierte
// Ladezeit nach Abschluss des Ladevorgang-1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RINGPUFFER_LADEVORGAENGE", "STAT_BEGINN_PROG_LADEZEIT_1_WERT", STAT_BEGINN_PROG_LADEZEIT_1_WERT, "\"min\"");
float STAT_BEGINN_PROG_LADEZEIT_2_WERT = (RXBUF_UCHAR(31)*5.0f);
// At the beginning forecast charging time after completion of the charging process-2 / Zu Beginn prognostizierte
// Ladezeit nach Abschluss des Ladevorgang-2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RINGPUFFER_LADEVORGAENGE", "STAT_BEGINN_PROG_LADEZEIT_2_WERT", STAT_BEGINN_PROG_LADEZEIT_2_WERT, "\"min\"");
float STAT_BEGINN_PROG_LADEZEIT_3_WERT = (RXBUF_UCHAR(32)*5.0f);
// Charging time forecast at the beginning after completion of the charging process -3 / Zu Beginn
// prognostizierte Ladezeit nach Abschluss des Ladevorgang-3
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RINGPUFFER_LADEVORGAENGE", "STAT_BEGINN_PROG_LADEZEIT_3_WERT", STAT_BEGINN_PROG_LADEZEIT_3_WERT, "\"min\"");
float STAT_BEGINN_PROG_LADEZEIT_4_WERT = (RXBUF_UCHAR(33)*5.0f);
// At the beginning, the charging time is forecast after the charging process is completed-4 / Zu Beginn
// prognostizierte Ladezeit nach Abschluss des Ladevorgang-4
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RINGPUFFER_LADEVORGAENGE", "STAT_BEGINN_PROG_LADEZEIT_4_WERT", STAT_BEGINN_PROG_LADEZEIT_4_WERT, "\"min\"");
float STAT_BEGINN_PROG_LADEZEIT_5_WERT = (RXBUF_UCHAR(34)*5.0f);
// At the beginning, the charging time is forecast after the charging process is completed-5 / Zu Beginn
// prognostizierte Ladezeit nach Abschluss des Ladevorgang-5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RINGPUFFER_LADEVORGAENGE", "STAT_BEGINN_PROG_LADEZEIT_5_WERT", STAT_BEGINN_PROG_LADEZEIT_5_WERT, "\"min\"");
float STAT_REAL_LADEZEIT_1_WERT = (RXBUF_UCHAR(35)*5.0f);
// The actual charging time after charging is complete -1 / Die tatsächliche Ladezeit nach Abschluss des
// Ladevorgang-1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RINGPUFFER_LADEVORGAENGE", "STAT_REAL_LADEZEIT_1_WERT", STAT_REAL_LADEZEIT_1_WERT, "\"min\"");
float STAT_REAL_LADEZEIT_2_WERT = (RXBUF_UCHAR(36)*5.0f);
// The actual charging time after the charging process is complete-2 / Die tatsächliche Ladezeit nach Abschluss
// des Ladevorgang-2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RINGPUFFER_LADEVORGAENGE", "STAT_REAL_LADEZEIT_2_WERT", STAT_REAL_LADEZEIT_2_WERT, "\"min\"");
float STAT_REAL_LADEZEIT_3_WERT = (RXBUF_UCHAR(37)*5.0f);
// The actual charging time after charging is complete -3 / Die tatsächliche Ladezeit nach Abschluss des
// Ladevorgang-3
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RINGPUFFER_LADEVORGAENGE", "STAT_REAL_LADEZEIT_3_WERT", STAT_REAL_LADEZEIT_3_WERT, "\"min\"");
float STAT_REAL_LADEZEIT_4_WERT = (RXBUF_UCHAR(38)*5.0f);
// The actual charging time after charging is complete -4 / Die tatsächliche Ladezeit nach Abschluss des
// Ladevorgang-4
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RINGPUFFER_LADEVORGAENGE", "STAT_REAL_LADEZEIT_4_WERT", STAT_REAL_LADEZEIT_4_WERT, "\"min\"");
float STAT_REAL_LADEZEIT_5_WERT = (RXBUF_UCHAR(39)*5.0f);
// The actual charging time after charging is complete -5 / Die tatsächliche Ladezeit nach Abschluss des
// Ladevorgang-5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RINGPUFFER_LADEVORGAENGE", "STAT_REAL_LADEZEIT_5_WERT", STAT_REAL_LADEZEIT_5_WERT, "\"min\"");
unsigned long STAT_RELATIVZEIT_1_WERT = (RXBUF_UINT32(40));
// Relative time at the beginning of the charging process-1 (continuous combi system time from ACAN with start in
// the factory) / Relativzeit zu Beginn des Ladevorgang-1 (fortlaufende Kombi-System-Zeit v. ACAN mit Start im
// Werk)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "RINGPUFFER_LADEVORGAENGE", "STAT_RELATIVZEIT_1_WERT", STAT_RELATIVZEIT_1_WERT, "\"s\"");
unsigned long STAT_RELATIVZEIT_2_WERT = (RXBUF_UINT32(44));
// Relative time at the beginning of the charging process-2 (continuous combi system time from ACAN with start in
// the factory) / Relativzeit zu Beginn des Ladevorgang-2 (fortlaufende Kombi-System-Zeit v. ACAN mit Start im
// Werk)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "RINGPUFFER_LADEVORGAENGE", "STAT_RELATIVZEIT_2_WERT", STAT_RELATIVZEIT_2_WERT, "\"s\"");
unsigned long STAT_RELATIVZEIT_3_WERT = (RXBUF_UINT32(48));
// Relative time at the beginning of the charging process-3 (continuous combi system time from ACAN with start in
// the factory) / Relativzeit zu Beginn des Ladevorgang-3 (fortlaufende Kombi-System-Zeit v. ACAN mit Start im
// Werk)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "RINGPUFFER_LADEVORGAENGE", "STAT_RELATIVZEIT_3_WERT", STAT_RELATIVZEIT_3_WERT, "\"s\"");
unsigned long STAT_RELATIVZEIT_4_WERT = (RXBUF_UINT32(52));
// Relative time at the beginning of the charging process-4 (consecutive combination system time from ACAN with
// start in the factory) / Relativzeit zu Beginn des Ladevorgang-4 (fortlaufende Kombi-System-Zeit v. ACAN mit
// Start im Werk)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "RINGPUFFER_LADEVORGAENGE", "STAT_RELATIVZEIT_4_WERT", STAT_RELATIVZEIT_4_WERT, "\"s\"");
unsigned long STAT_RELATIVZEIT_5_WERT = (RXBUF_UINT32(56));
// Relative time at the beginning of the charging process -5 (continuous combination system time from ACAN with
// start in the factory) / Relativzeit zu Beginn des Ladevorgang-5 (fortlaufende Kombi-System-Zeit v. ACAN mit
// Start im Werk)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "RINGPUFFER_LADEVORGAENGE", "STAT_RELATIVZEIT_5_WERT", STAT_RELATIVZEIT_5_WERT, "\"s\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_HIS_PROG_LADEZEIT: { // 0xDDEC
if (datalen < 14) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_HIS_PROG_LADEZEIT", 14);
break;
}
unsigned short STAT_HIS_PROG_LADEZEIT_1_WERT = (RXBUF_UINT(0));
// Number in deviation class 1: fact <= -% 25 / Anzahl in der Abweichungsklasse-1: fact <= -%25
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "HIS_PROG_LADEZEIT", "STAT_HIS_PROG_LADEZEIT_1_WERT", STAT_HIS_PROG_LADEZEIT_1_WERT, "");
unsigned short STAT_HIS_PROG_LADEZEIT_2_WERT = (RXBUF_UINT(2));
// Number in deviation class 2:% -25 <fact <= -% 15 / Anzahl in der Abweichungsklasse-2: %-25 < fact <= -%15
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "HIS_PROG_LADEZEIT", "STAT_HIS_PROG_LADEZEIT_2_WERT", STAT_HIS_PROG_LADEZEIT_2_WERT, "");
unsigned short STAT_HIS_PROG_LADEZEIT_3_WERT = (RXBUF_UINT(4));
// Number in deviation class 3:% -15 <fact <= -% 5 / Anzahl in der Abweichungsklasse-3: %-15 < fact <= -%5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "HIS_PROG_LADEZEIT", "STAT_HIS_PROG_LADEZEIT_3_WERT", STAT_HIS_PROG_LADEZEIT_3_WERT, "");
unsigned short STAT_HIS_PROG_LADEZEIT_4_WERT = (RXBUF_UINT(6));
// Number in deviation class 4:% -5 <fact <=% 5 / Anzahl in der Abweichungsklasse-4: %-5 < fact <= %5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "HIS_PROG_LADEZEIT", "STAT_HIS_PROG_LADEZEIT_4_WERT", STAT_HIS_PROG_LADEZEIT_4_WERT, "");
unsigned short STAT_HIS_PROG_LADEZEIT_5_WERT = (RXBUF_UINT(8));
// Number in deviation class 5:% 5 <fact <=% 15 / Anzahl in der Abweichungsklasse-5: %5 < fact <= %15
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "HIS_PROG_LADEZEIT", "STAT_HIS_PROG_LADEZEIT_5_WERT", STAT_HIS_PROG_LADEZEIT_5_WERT, "");
unsigned short STAT_HIS_PROG_LADEZEIT_6_WERT = (RXBUF_UINT(10));
// Number in deviation class 6:% 15 <fact <=% 25 / Anzahl in der Abweichungsklasse-6: %15 < fact <= %25
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "HIS_PROG_LADEZEIT", "STAT_HIS_PROG_LADEZEIT_6_WERT", STAT_HIS_PROG_LADEZEIT_6_WERT, "");
unsigned short STAT_HIS_PROG_LADEZEIT_7_WERT = (RXBUF_UINT(12));
// Number in deviation class 7: fact>% 25 / Anzahl in der Abweichungsklasse-7: fact > %25
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "HIS_PROG_LADEZEIT", "STAT_HIS_PROG_LADEZEIT_7_WERT", STAT_HIS_PROG_LADEZEIT_7_WERT, "");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_HV_SPANNUNG_QUER: { // 0xDDEF
if (datalen < 2) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_HV_SPANNUNG_QUER", 2);
break;
}
unsigned short STAT_HV_SPANNUNG_QUER_WERT = (RXBUF_UINT(0));
// SBox, high-voltage transverse (same as battery voltage when K1 or K3 is closed) / SBox, Hochvolt-Spannung Quer
// (gleich Batteriespannung wenn K1 oder K3 geschlossen ist)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "HV_SPANNUNG_QUER", "STAT_HV_SPANNUNG_QUER_WERT", STAT_HV_SPANNUNG_QUER_WERT, "\"V\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_ALPHA_INITIAL_ALTERUNG: { // 0xDE37
if (datalen < 2) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_ALPHA_INITIAL_ALTERUNG", 2);
break;
}
float STAT_ALPHA_INIT_ALTERUNG_WERT = (RXBUF_UINT(0)/1000.0f);
// Initial value of the SOH_R calculation / Initialwert der SOH_R-Berechnung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ALPHA_INITIAL_ALTERUNG", "STAT_ALPHA_INIT_ALTERUNG_WERT", STAT_ALPHA_INIT_ALTERUNG_WERT, "");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_BETRIEBSSTUNDEN: { // 0xDF60
if (datalen < 8) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_BETRIEBSSTUNDEN", 8);
break;
}
unsigned long STAT_TIME_HV_ON_WERT = (RXBUF_UINT32(0));
// The total time with the main switches closed / Die Gesamtzeit bei geschlossenen Hauptschaltern
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "BETRIEBSSTUNDEN", "STAT_TIME_HV_ON_WERT", STAT_TIME_HV_ON_WERT, "\"h\"");
unsigned long STAT_TIME_TOTAL_WERT = (RXBUF_UINT32(4));
// The total battery life (total time with main switches closed and open) / Die gesamte Batterielebensdauer
// (Gesamtzeit bei geschlossenen und geöffneten Hauptschaltern)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "BETRIEBSSTUNDEN", "STAT_TIME_TOTAL_WERT", STAT_TIME_TOTAL_WERT, "\"h\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_COOL_DOWN: { // 0xDF62
if (datalen < 2) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_COOL_DOWN", 2);
break;
}
unsigned short STAT_ANZAHL_KUEHLVORGAENGE_WERT = (RXBUF_UINT(0));
// Number of CoolDown scenarios (departure with hot HV storage) / Anzahl der CoolDown Szenarios (Abfahrt mit
// heißem HV-Speicher)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "COOL_DOWN", "STAT_ANZAHL_KUEHLVORGAENGE_WERT", STAT_ANZAHL_KUEHLVORGAENGE_WERT, "");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_KLEMMENZYKLEN: { // 0xDF63
if (datalen < 4) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_KLEMMENZYKLEN", 4);
break;
}
unsigned long STAT_ANZAHL_KLEMMENZYKLEN_WERT = (RXBUF_UINT32(0));
// Number of terminal cycles / Anzahl der Klemmenzyklen
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "KLEMMENZYKLEN", "STAT_ANZAHL_KLEMMENZYKLEN_WERT", STAT_ANZAHL_KLEMMENZYKLEN_WERT, "");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_KUEHLDAUER: { // 0xDF64
if (datalen < 10) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_KUEHLDAUER", 10);
break;
}
unsigned short STAT_KUEHLDAUER_MAX_WERT_0XDF64 = (RXBUF_UINT(0));
// Predefined maximum cooling time (project-specific) / Vordefinierte maximale Kühldauer (projektspezifisch)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "KUEHLDAUER", "STAT_KUEHLDAUER_MAX_WERT_0XDF64", STAT_KUEHLDAUER_MAX_WERT_0XDF64, "\"min\"");
unsigned short STAT_KUEHLDAUER_1_WERT_0XDF64 = (RXBUF_UINT(2));
// Number of duration class: 0 <t <= tmax * 0.25 / Anzahl Dauerklasse: 0 < t < = tmax*0.25
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "KUEHLDAUER", "STAT_KUEHLDAUER_1_WERT_0XDF64", STAT_KUEHLDAUER_1_WERT_0XDF64, "");
unsigned short STAT_KUEHLDAUER_2_WERT_0XDF64 = (RXBUF_UINT(4));
// Number of duration class: 0.25 * tmax <t <= tmax * 0.5 / Anzahl Dauerklasse: 0.25* tmax < t < = tmax*0.5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "KUEHLDAUER", "STAT_KUEHLDAUER_2_WERT_0XDF64", STAT_KUEHLDAUER_2_WERT_0XDF64, "");
unsigned short STAT_KUEHLDAUER_3_WERT_0XDF64 = (RXBUF_UINT(6));
// Number of duration class: 0.5 * tmax <t <= tmax / Anzahl Dauerklasse: 0.5* tmax < t < = tmax
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "KUEHLDAUER", "STAT_KUEHLDAUER_3_WERT_0XDF64", STAT_KUEHLDAUER_3_WERT_0XDF64, "");
unsigned short STAT_KUEHLDAUER_4_WERT_0XDF64 = (RXBUF_UINT(8));
// Number of duration classes: t> tmax / Anzahl Dauerklasse: t > tmax
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "KUEHLDAUER", "STAT_KUEHLDAUER_4_WERT_0XDF64", STAT_KUEHLDAUER_4_WERT_0XDF64, "");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_TEMP_SPREIZUNG_SYSTEM: { // 0xDF65
if (datalen < 26) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_TEMP_SPREIZUNG_SYSTEM", 26);
break;
}
float STAT_TEMP_SPREIZUNG_MAX_WERT = (RXBUF_UINT(0)/100.0f);
// Predefined maximum temperature spread value in Celcius (project-specific) / Vorderfinierter maximaler
// Temperaturspreizungswert in Celcius (projektspezifisch)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "TEMP_SPREIZUNG_SYSTEM", "STAT_TEMP_SPREIZUNG_MAX_WERT", STAT_TEMP_SPREIZUNG_MAX_WERT, "\"°C\"");
unsigned long STAT_TEMP_SPREIZUNG_SYS_1_WERT = (RXBUF_UINT32(2));
// Time in minutes with cooling on class 1: 0 <dT <= dTmax * 0.2 / Zeit in Minuten bei Kühlung an Klasse 1: 0 <
// dT <= dTmax*0.2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "TEMP_SPREIZUNG_SYSTEM", "STAT_TEMP_SPREIZUNG_SYS_1_WERT", STAT_TEMP_SPREIZUNG_SYS_1_WERT, "\"min\"");
unsigned long STAT_TEMP_SPREIZUNG_SYS_2_WERT = (RXBUF_UINT32(6));
// Time in minutes for cooling on class 2: dTmax * 0.2 <dT <= dTmax * 0.4 / Zeit in Minuten bei Kühlung an Klasse
// 2: dTmax*0.2 < dT <= dTmax*0.4
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "TEMP_SPREIZUNG_SYSTEM", "STAT_TEMP_SPREIZUNG_SYS_2_WERT", STAT_TEMP_SPREIZUNG_SYS_2_WERT, "\"min\"");
unsigned long STAT_TEMP_SPREIZUNG_SYS_3_WERT = (RXBUF_UINT32(10));
// Time in minutes for cooling on class 3: dTmax * 0.4 <dT <= dTmax * 0.6 / Zeit in Minuten bei Kühlung an Klasse
// 3: dTmax*0.4 < dT <= dTmax*0.6
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "TEMP_SPREIZUNG_SYSTEM", "STAT_TEMP_SPREIZUNG_SYS_3_WERT", STAT_TEMP_SPREIZUNG_SYS_3_WERT, "\"min\"");
unsigned long STAT_TEMP_SPREIZUNG_SYS_4_WERT = (RXBUF_UINT32(14));
// Time in minutes for cooling on class 4: dTmax * 0.6 <dT <= dTmax * 0.8 / Zeit in Minuten bei Kühlung an Klasse
// 4: dTmax*0.6 < dT <= dTmax*0.8
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "TEMP_SPREIZUNG_SYSTEM", "STAT_TEMP_SPREIZUNG_SYS_4_WERT", STAT_TEMP_SPREIZUNG_SYS_4_WERT, "\"min\"");
unsigned long STAT_TEMP_SPREIZUNG_SYS_5_WERT = (RXBUF_UINT32(18));
// Time in minutes with cooling on class 5: dTmax * 0.8 <dT <= dTmax / Zeit in Minuten bei Kühlung an Klasse 5:
// dTmax*0.8 < dT <= dTmax
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "TEMP_SPREIZUNG_SYSTEM", "STAT_TEMP_SPREIZUNG_SYS_5_WERT", STAT_TEMP_SPREIZUNG_SYS_5_WERT, "\"min\"");
unsigned long STAT_TEMP_SPREIZUNG_SYS_6_WERT = (RXBUF_UINT32(22));
// Time in minutes with cooling on class 6: dT> dTmax / Zeit in Minuten bei Kühlung an Klasse 6: dT > dTmax
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "TEMP_SPREIZUNG_SYSTEM", "STAT_TEMP_SPREIZUNG_SYS_6_WERT", STAT_TEMP_SPREIZUNG_SYS_6_WERT, "\"min\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_TEMP_KUEHLMITTEL: { // 0xDF66
if (datalen < 26) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_TEMP_KUEHLMITTEL", 26);
break;
}
float STAT_TEMP_KUEHLMITTEL_MAX_WERT = (RXBUF_UINT(0)/10.0f);
// Predefined maximum coolant temperature (project-specific) / Vordefinierte maximale Kühlmittelstemperatur
// (projektspezifisch)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "TEMP_KUEHLMITTEL", "STAT_TEMP_KUEHLMITTEL_MAX_WERT", STAT_TEMP_KUEHLMITTEL_MAX_WERT, "\"°C\"");
unsigned long STAT_TEMP_KUEHLMITTEL_1_WERT = (RXBUF_UINT32(2));
// Duration in temperature class: T <= 0 / Dauer in Temperaturklasse: T < =0
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "TEMP_KUEHLMITTEL", "STAT_TEMP_KUEHLMITTEL_1_WERT", STAT_TEMP_KUEHLMITTEL_1_WERT, "\"min\"");
unsigned long STAT_TEMP_KUEHLMITTEL_2_WERT = (RXBUF_UINT32(6));
// Duration in temperature class: 0 <T <= Tmax * 0.25 / Dauer in Temperaturklasse: 0 < T < = Tmax*0.25
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "TEMP_KUEHLMITTEL", "STAT_TEMP_KUEHLMITTEL_2_WERT", STAT_TEMP_KUEHLMITTEL_2_WERT, "\"min\"");
unsigned long STAT_TEMP_KUEHLMITTEL_3_WERT = (RXBUF_UINT32(10));
// Duration in temperature class: Tmax * 0.25 <T <= Tmax * 0.5 / Dauer in Temperaturklasse: Tmax* 0.25 < T < =
// Tmax*0.5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "TEMP_KUEHLMITTEL", "STAT_TEMP_KUEHLMITTEL_3_WERT", STAT_TEMP_KUEHLMITTEL_3_WERT, "\"min\"");
unsigned long STAT_TEMP_KUEHLMITTEL_4_WERT = (RXBUF_UINT32(14));
// Duration in temperature class: Tmax * 0.5 <T <= Tmax * 0.75 / Dauer in Temperaturklasse: Tmax* 0.5 < T < =
// Tmax*0.75
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "TEMP_KUEHLMITTEL", "STAT_TEMP_KUEHLMITTEL_4_WERT", STAT_TEMP_KUEHLMITTEL_4_WERT, "\"min\"");
unsigned long STAT_TEMP_KUEHLMITTEL_5_WERT = (RXBUF_UINT32(18));
// Duration in temperature class: Tmax * 0.75 <T <= Tmax / Dauer in Temperaturklasse: Tmax* 0.75 < T < = Tmax
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "TEMP_KUEHLMITTEL", "STAT_TEMP_KUEHLMITTEL_5_WERT", STAT_TEMP_KUEHLMITTEL_5_WERT, "\"min\"");
unsigned long STAT_TEMP_KUEHLMITTEL_6_WERT = (RXBUF_UINT32(22));
// Duration in temperature class: T> Tmax / Dauer in Temperaturklasse: T > Tmax
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "TEMP_KUEHLMITTEL", "STAT_TEMP_KUEHLMITTEL_6_WERT", STAT_TEMP_KUEHLMITTEL_6_WERT, "\"min\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_LADUNG_KUEHLUNG: { // 0xDF67
if (datalen < 8) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_LADUNG_KUEHLUNG", 8);
break;
}
float STAT_LADUNG_KUEHLUNG_WERT = (RXBUF_UINT32(0)/3600.0f);
// Charge amount with activated cooling / Ladungsmenge bei eingeschalteter Kühlung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "LADUNG_KUEHLUNG", "STAT_LADUNG_KUEHLUNG_WERT", STAT_LADUNG_KUEHLUNG_WERT, "\"Ah\"");
float STAT_ENTLADUNG_KUEHLUNG_WERT = (RXBUF_UINT32(4)/3600.0f);
// Discharge amount with the cooling switched on / Entladungsmenge bei eingeschalteter Kühlung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "LADUNG_KUEHLUNG", "STAT_ENTLADUNG_KUEHLUNG_WERT", STAT_ENTLADUNG_KUEHLUNG_WERT, "\"Ah\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_HV_BATT_HIST_SOC_T1_2: { // 0xDF68
if (datalen < 120) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_HV_BATT_HIST_SOC_T1_2", 120);
break;
}
float STAT_HV_BATT_HIST_SOC5_T1_I1_WERT = (RXBUF_UINT32(0)/10.0f);
// Duration at 70% less than SoC less than 90%. Temperature less than 0 ° C. Current less than -2.5xC A / Dauer
// bei 70 % kleiner als SoC kleiner als 90 %. Temperatur kleiner als 0 °C. Strom kleiner als -2,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_2", "STAT_HV_BATT_HIST_SOC5_T1_I1_WERT", STAT_HV_BATT_HIST_SOC5_T1_I1_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T1_I2_WERT = (RXBUF_UINT32(4)/10.0f);
// Duration at 70% less than SoC less than 90%. Temperature less than 0 ° C. -2.5xC A less than current less than
// -2.0xC A / Dauer bei 70 % kleiner als SoC kleiner als 90 %. Temperatur kleiner als 0 °C. -2,5xC A kleiner als
// Strom kleiner als -2,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_2", "STAT_HV_BATT_HIST_SOC5_T1_I2_WERT", STAT_HV_BATT_HIST_SOC5_T1_I2_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T1_I3_WERT = (RXBUF_UINT32(8)/10.0f);
// Duration at 70% less than SoC less than 90%. Temperature less than 0 ° C. -2.0xC A less than current less than
// -1.5xC A / Dauer bei 70 % kleiner als SoC kleiner als 90 %. Temperatur kleiner als 0 °C. -2,0xC A kleiner als
// Strom kleiner als -1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_2", "STAT_HV_BATT_HIST_SOC5_T1_I3_WERT", STAT_HV_BATT_HIST_SOC5_T1_I3_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T1_I4_WERT = (RXBUF_UINT32(12)/10.0f);
// Duration at 70% less than SoC less than 90%. Temperature less than 0 ° C. -1.5xC A less than current less than
// -1.0xC A / Dauer bei 70 % kleiner als SoC kleiner als 90 %. Temperatur kleiner als 0 °C. -1,5xC A kleiner als
// Strom kleiner als -1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_2", "STAT_HV_BATT_HIST_SOC5_T1_I4_WERT", STAT_HV_BATT_HIST_SOC5_T1_I4_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T1_I5_WERT = (RXBUF_UINT32(16)/10.0f);
// Duration at 70% less than SoC less than 90%. Temperature less than 0 ° C. -1.0xC A less than current less than
// -0.5xC A / Dauer bei 70 % kleiner als SoC kleiner als 90 %. Temperatur kleiner als 0 °C. -1,0xC A kleiner als
// Strom kleiner als -0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_2", "STAT_HV_BATT_HIST_SOC5_T1_I5_WERT", STAT_HV_BATT_HIST_SOC5_T1_I5_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T1_I6_WERT = (RXBUF_UINT32(20)/10.0f);
// Duration at 70% less than SoC less than 90%. Temperature less than 0 ° C. -0.5xC A less than current less than
// 0.0xC A / Dauer bei 70 % kleiner als SoC kleiner als 90 %. Temperatur kleiner als 0 °C. -0,5xC A kleiner als
// Strom kleiner als 0,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_2", "STAT_HV_BATT_HIST_SOC5_T1_I6_WERT", STAT_HV_BATT_HIST_SOC5_T1_I6_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T1_I7_WERT = (RXBUF_UINT32(24)/10.0f);
// Duration at 70% less than SoC less than 90%. Temperature less than 0 ° C. 0.0xC A less than current less than
// 0.5xC A / Dauer bei 70 % kleiner als SoC kleiner als 90 %. Temperatur kleiner als 0 °C. 0,0xC A kleiner als
// Strom kleiner als 0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_2", "STAT_HV_BATT_HIST_SOC5_T1_I7_WERT", STAT_HV_BATT_HIST_SOC5_T1_I7_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T1_I8_WERT = (RXBUF_UINT32(28)/10.0f);
// Duration at 70% less than SoC less than 90%. Temperature less than 0 ° C. 0.5xC A less than current less than
// 1.0xC A / Dauer bei 70 % kleiner als SoC kleiner als 90 %. Temperatur kleiner als 0 °C. 0,5xC A kleiner als
// Strom kleiner als 1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_2", "STAT_HV_BATT_HIST_SOC5_T1_I8_WERT", STAT_HV_BATT_HIST_SOC5_T1_I8_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T1_I9_WERT = (RXBUF_UINT32(32)/10.0f);
// Duration at 70% less than SoC less than 90%. Temperature less than 0 ° C. 1.0xC A less than current less than
// 1.5xC A / Dauer bei 70 % kleiner als SoC kleiner als 90 %. Temperatur kleiner als 0 °C. 1,0xC A kleiner als
// Strom kleiner als 1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_2", "STAT_HV_BATT_HIST_SOC5_T1_I9_WERT", STAT_HV_BATT_HIST_SOC5_T1_I9_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T1_I10_WERT = (RXBUF_UINT32(36)/10.0f);
// Duration at 70% less than SoC less than 90%. Temperature less than 0 ° C. 1.5xC A less than current / Dauer
// bei 70 % kleiner als SoC kleiner als 90 %. Temperatur kleiner als 0 °C. 1,5xC A kleiner als Strom
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_2", "STAT_HV_BATT_HIST_SOC5_T1_I10_WERT", STAT_HV_BATT_HIST_SOC5_T1_I10_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T1_I1_WERT = (RXBUF_UINT32(40)/10.0f);
// Duration at 90% less than SoC less than 95%. Temperature less than 0 ° C. Current less than -2.5xC A / Dauer
// bei 90 % kleiner als SoC kleiner als 95 %. Temperatur kleiner als 0 °C. Strom kleiner als -2,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_2", "STAT_HV_BATT_HIST_SOC6_T1_I1_WERT", STAT_HV_BATT_HIST_SOC6_T1_I1_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T1_I2_WERT = (RXBUF_UINT32(44)/10.0f);
// Duration at 90% less than SoC less than 95%. Temperature less than 0 ° C. -2.5xC A less than current less than
// -2.0xC A / Dauer bei 90 % kleiner als SoC kleiner als 95 %. Temperatur kleiner als 0 °C. -2,5xC A kleiner als
// Strom kleiner als -2,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_2", "STAT_HV_BATT_HIST_SOC6_T1_I2_WERT", STAT_HV_BATT_HIST_SOC6_T1_I2_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T1_I3_WERT = (RXBUF_UINT32(48)/10.0f);
// Duration at 90% less than SoC less than 95%. Temperature less than 0 ° C. -2.0xC A less than current less than
// -1.5xC A / Dauer bei 90 % kleiner als SoC kleiner als 95 %. Temperatur kleiner als 0 °C. -2,0xC A kleiner als
// Strom kleiner als -1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_2", "STAT_HV_BATT_HIST_SOC6_T1_I3_WERT", STAT_HV_BATT_HIST_SOC6_T1_I3_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T1_I4_WERT = (RXBUF_UINT32(52)/10.0f);
// Duration at 90% less than SoC less than 95%. Temperature less than 0 ° C. -1.5xC A less than current less than
// -1.0xC A / Dauer bei 90 % kleiner als SoC kleiner als 95 %. Temperatur kleiner als 0 °C. -1,5xC A kleiner als
// Strom kleiner als -1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_2", "STAT_HV_BATT_HIST_SOC6_T1_I4_WERT", STAT_HV_BATT_HIST_SOC6_T1_I4_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T1_I5_WERT = (RXBUF_UINT32(56)/10.0f);
// Duration at 90% less than SoC less than 95%. Temperature less than 0 ° C. -1.0xC A less than current less than
// -0.5xC A / Dauer bei 90 % kleiner als SoC kleiner als 95 %. Temperatur kleiner als 0 °C. -1,0xC A kleiner als
// Strom kleiner als -0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_2", "STAT_HV_BATT_HIST_SOC6_T1_I5_WERT", STAT_HV_BATT_HIST_SOC6_T1_I5_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T1_I6_WERT = (RXBUF_UINT32(60)/10.0f);
// Duration at 90% less than SoC less than 95%. Temperature less than 0 ° C. -0.5xC A less than current less than
// 0.0xC A / Dauer bei 90 % kleiner als SoC kleiner als 95 %. Temperatur kleiner als 0 °C. -0,5xC A kleiner als
// Strom kleiner als 0,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_2", "STAT_HV_BATT_HIST_SOC6_T1_I6_WERT", STAT_HV_BATT_HIST_SOC6_T1_I6_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T1_I7_WERT = (RXBUF_UINT32(64)/10.0f);
// Duration at 90% less than SoC less than 95%. Temperature less than 0 ° C. 0.0xC A less than current less than
// 0.5xC A / Dauer bei 90 % kleiner als SoC kleiner als 95 %. Temperatur kleiner als 0 °C. 0,0xC A kleiner als
// Strom kleiner als 0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_2", "STAT_HV_BATT_HIST_SOC6_T1_I7_WERT", STAT_HV_BATT_HIST_SOC6_T1_I7_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T1_I8_WERT = (RXBUF_UINT32(68)/10.0f);
// Duration at 90% less than SoC less than 95%. Temperature less than 0 ° C. 0.5xC A less than current less than
// 1.0xC A / Dauer bei 90 % kleiner als SoC kleiner als 95 %. Temperatur kleiner als 0 °C. 0,5xC A kleiner als
// Strom kleiner als 1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_2", "STAT_HV_BATT_HIST_SOC6_T1_I8_WERT", STAT_HV_BATT_HIST_SOC6_T1_I8_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T1_I9_WERT = (RXBUF_UINT32(72)/10.0f);
// Duration at 90% less than SoC less than 95%. Temperature less than 0 ° C. 1.0xC A less than current less than
// 1.5xC A / Dauer bei 90 % kleiner als SoC kleiner als 95 %. Temperatur kleiner als 0 °C. 1,0xC A kleiner als
// Strom kleiner als 1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_2", "STAT_HV_BATT_HIST_SOC6_T1_I9_WERT", STAT_HV_BATT_HIST_SOC6_T1_I9_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T1_I10_WERT = (RXBUF_UINT32(76)/10.0f);
// Duration at 90% less than SoC less than 95%. Temperature less than 0 ° C. 1.5xC A less than current / Dauer
// bei 90 % kleiner als SoC kleiner als 95 %. Temperatur kleiner als 0 °C. 1,5xC A kleiner als Strom
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_2", "STAT_HV_BATT_HIST_SOC6_T1_I10_WERT", STAT_HV_BATT_HIST_SOC6_T1_I10_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T1_I1_WERT = (RXBUF_UINT32(80)/10.0f);
// Duration at 95% smaller than SoC. Temperature less than 0 ° C. Current less than -2.5xC A / Dauer bei 95 %
// kleiner als SoC. Temperatur kleiner als 0 °C. Strom kleiner als -2,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_2", "STAT_HV_BATT_HIST_SOC7_T1_I1_WERT", STAT_HV_BATT_HIST_SOC7_T1_I1_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T1_I2_WERT = (RXBUF_UINT32(84)/10.0f);
// Duration at 95% smaller than SoC. Temperature less than 0 ° C. -2.5xC A less than current less than -2.0xC A /
// Dauer bei 95 % kleiner als SoC. Temperatur kleiner als 0 °C. -2,5xC A kleiner als Strom kleiner als -2,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_2", "STAT_HV_BATT_HIST_SOC7_T1_I2_WERT", STAT_HV_BATT_HIST_SOC7_T1_I2_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T1_I3_WERT = (RXBUF_UINT32(88)/10.0f);
// Duration at 95% smaller than SoC. Temperature less than 0 ° C. -2.0xC A less than current less than -1.5xC A /
// Dauer bei 95 % kleiner als SoC. Temperatur kleiner als 0 °C. -2,0xC A kleiner als Strom kleiner als -1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_2", "STAT_HV_BATT_HIST_SOC7_T1_I3_WERT", STAT_HV_BATT_HIST_SOC7_T1_I3_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T1_I4_WERT = (RXBUF_UINT32(92)/10.0f);
// Duration at 95% smaller than SoC. Temperature less than 0 ° C. -1.5xC A less than current less than -1.0xC A /
// Dauer bei 95 % kleiner als SoC. Temperatur kleiner als 0 °C. -1,5xC A kleiner als Strom kleiner als -1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_2", "STAT_HV_BATT_HIST_SOC7_T1_I4_WERT", STAT_HV_BATT_HIST_SOC7_T1_I4_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T1_I5_WERT = (RXBUF_UINT32(96)/10.0f);
// Duration at 95% smaller than SoC. Temperature less than 0 ° C. -1.0xC A less than current less than -0.5xC A /
// Dauer bei 95 % kleiner als SoC. Temperatur kleiner als 0 °C. -1,0xC A kleiner als Strom kleiner als -0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_2", "STAT_HV_BATT_HIST_SOC7_T1_I5_WERT", STAT_HV_BATT_HIST_SOC7_T1_I5_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T1_I6_WERT = (RXBUF_UINT32(100)/10.0f);
// Duration at 95% smaller than SoC. Temperature less than 0 ° C. -0.5xC A less than current less than 0.0xC A /
// Dauer bei 95 % kleiner als SoC. Temperatur kleiner als 0 °C. -0,5xC A kleiner als Strom kleiner als 0,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_2", "STAT_HV_BATT_HIST_SOC7_T1_I6_WERT", STAT_HV_BATT_HIST_SOC7_T1_I6_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T1_I7_WERT = (RXBUF_UINT32(104)/10.0f);
// Duration at 95% smaller than SoC. Temperature less than 0 ° C. 0.0xC A less than current less than 0.5xC A /
// Dauer bei 95 % kleiner als SoC. Temperatur kleiner als 0 °C. 0,0xC A kleiner als Strom kleiner als 0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_2", "STAT_HV_BATT_HIST_SOC7_T1_I7_WERT", STAT_HV_BATT_HIST_SOC7_T1_I7_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T1_I8_WERT = (RXBUF_UINT32(108)/10.0f);
// Duration at 95% smaller than SoC. Temperature less than 0 ° C. 0.5xC A less than current less than 1.0xC A /
// Dauer bei 95 % kleiner als SoC. Temperatur kleiner als 0 °C. 0,5xC A kleiner als Strom kleiner als 1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_2", "STAT_HV_BATT_HIST_SOC7_T1_I8_WERT", STAT_HV_BATT_HIST_SOC7_T1_I8_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T1_I9_WERT = (RXBUF_UINT32(112)/10.0f);
// Duration at 95% smaller than SoC. Temperature less than 0 ° C. 1.0xC A less than current less than 1.5xC A /
// Dauer bei 95 % kleiner als SoC. Temperatur kleiner als 0 °C. 1,0xC A kleiner als Strom kleiner als 1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_2", "STAT_HV_BATT_HIST_SOC7_T1_I9_WERT", STAT_HV_BATT_HIST_SOC7_T1_I9_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T1_I10_WERT = (RXBUF_UINT32(116)/10.0f);
// Duration at 95% smaller than SoC. Temperature less than 0 ° C. 1.5xC A less than current / Dauer bei 95 %
// kleiner als SoC. Temperatur kleiner als 0 °C. 1,5xC A kleiner als Strom
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T1_2", "STAT_HV_BATT_HIST_SOC7_T1_I10_WERT", STAT_HV_BATT_HIST_SOC7_T1_I10_WERT, "\"s\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_HV_BATT_HIST_SOC_T4_2: { // 0xDF69
if (datalen < 120) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_HV_BATT_HIST_SOC_T4_2", 120);
break;
}
float STAT_HV_BATT_HIST_SOC5_T4_I1_WERT = (RXBUF_UINT32(0)/10.0f);
// Duration at 70% less than SoC less than 90%. 20 ° C less than temperature less than 27.5 ° C. Current less
// than -2.5xC A / Dauer bei 70% kleiner als SoC kleiner als 90%. 20°C kleiner als Temperatur kleiner als 27,5°C.
// Strom kleiner als -2,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_2", "STAT_HV_BATT_HIST_SOC5_T4_I1_WERT", STAT_HV_BATT_HIST_SOC5_T4_I1_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T4_I2_WERT = (RXBUF_UINT32(4)/10.0f);
// Duration at 70% less than SoC less than 90%. 20 ° C less than temperature less than 27.5 ° C. -2.5xC A less
// than current less than -2.0xC A / Dauer bei 70% kleiner als SoC kleiner als 90%. 20°C kleiner als Temperatur
// kleiner als 27,5°C. -2,5xC A kleiner als Strom kleiner als -2,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_2", "STAT_HV_BATT_HIST_SOC5_T4_I2_WERT", STAT_HV_BATT_HIST_SOC5_T4_I2_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T4_I3_WERT = (RXBUF_UINT32(8)/10.0f);
// Duration at 70% less than SoC less than 90%. 20 ° C less than temperature less than 27.5 ° C. -2.0xC A less
// than current less than -1.5xC A / Dauer bei 70% kleiner als SoC kleiner als 90%. 20°C kleiner als Temperatur
// kleiner als 27,5°C. -2,0xC A kleiner als Strom kleiner als -1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_2", "STAT_HV_BATT_HIST_SOC5_T4_I3_WERT", STAT_HV_BATT_HIST_SOC5_T4_I3_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T4_I4_WERT = (RXBUF_UINT32(12)/10.0f);
// Duration at 70% less than SoC less than 90%. 20 ° C less than temperature less than 27.5 ° C. -1.5xC A less
// than current less than -1.0xC A / Dauer bei 70% kleiner als SoC kleiner als 90%. 20°C kleiner als Temperatur
// kleiner als 27,5°C. -1,5xC A kleiner als Strom kleiner als -1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_2", "STAT_HV_BATT_HIST_SOC5_T4_I4_WERT", STAT_HV_BATT_HIST_SOC5_T4_I4_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T4_I5_WERT = (RXBUF_UINT32(16)/10.0f);
// Duration at 70% less than SoC less than 90%. 20 ° C less than temperature less than 27.5 ° C. -1.0xC A less
// than current less than -0.5xC A / Dauer bei 70% kleiner als SoC kleiner als 90%. 20°C kleiner als Temperatur
// kleiner als 27,5°C. -1,0xC A kleiner als Strom kleiner als -0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_2", "STAT_HV_BATT_HIST_SOC5_T4_I5_WERT", STAT_HV_BATT_HIST_SOC5_T4_I5_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T4_I6_WERT = (RXBUF_UINT32(20)/10.0f);
// Duration at 70% less than SoC less than 90%. 20 ° C less than temperature less than 27.5 ° C. -0.5xC A less
// than current less than 0.0xC A / Dauer bei 70% kleiner als SoC kleiner als 90%. 20°C kleiner als Temperatur
// kleiner als 27,5°C. -0,5xC A kleiner als Strom kleiner als 0,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_2", "STAT_HV_BATT_HIST_SOC5_T4_I6_WERT", STAT_HV_BATT_HIST_SOC5_T4_I6_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T4_I7_WERT = (RXBUF_UINT32(24)/10.0f);
// Duration at 70% less than SoC less than 90%. 20 ° C less than temperature less than 27.5 ° C. 0.0xC A less
// than current less than 0.5xC A / Dauer bei 70% kleiner als SoC kleiner als 90%. 20°C kleiner als Temperatur
// kleiner als 27,5°C. 0,0xC A kleiner als Strom kleiner als 0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_2", "STAT_HV_BATT_HIST_SOC5_T4_I7_WERT", STAT_HV_BATT_HIST_SOC5_T4_I7_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T4_I8_WERT = (RXBUF_UINT32(28)/10.0f);
// Duration at 70% less than SoC less than 90%. 20 ° C less than temperature less than 27.5 ° C. 0.5xC A less
// than current less than 1.0xC A / Dauer bei 70% kleiner als SoC kleiner als 90%. 20°C kleiner als Temperatur
// kleiner als 27,5°C. 0,5xC A kleiner als Strom kleiner als 1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_2", "STAT_HV_BATT_HIST_SOC5_T4_I8_WERT", STAT_HV_BATT_HIST_SOC5_T4_I8_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T4_I9_WERT = (RXBUF_UINT32(32)/10.0f);
// Duration at 70% less than SoC less than 90%. 20 ° C less than temperature less than 27.5 ° C. 1.0xC A less
// than current less than 1.5xC A / Dauer bei 70% kleiner als SoC kleiner als 90%. 20°C kleiner als Temperatur
// kleiner als 27,5°C. 1,0xC A kleiner als Strom kleiner als 1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_2", "STAT_HV_BATT_HIST_SOC5_T4_I9_WERT", STAT_HV_BATT_HIST_SOC5_T4_I9_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T4_I10_WERT = (RXBUF_UINT32(36)/10.0f);
// Duration at 70% less than SoC less than 90%. 20 ° C less than temperature less than 27.5 ° C. 1.5xC A less
// than current / Dauer bei 70% kleiner als SoC kleiner als 90%. 20°C kleiner als Temperatur kleiner als 27,5°C.
// 1,5xC A kleiner als Strom
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_2", "STAT_HV_BATT_HIST_SOC5_T4_I10_WERT", STAT_HV_BATT_HIST_SOC5_T4_I10_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T4_I1_WERT = (RXBUF_UINT32(40)/10.0f);
// Duration at 90% less than SoC less than 95%. 20 ° C less than temperature less than 27.5 ° C. Current less
// than -2.5xC A / Dauer bei 90% kleiner als SoC kleiner als 95%. 20°C kleiner als Temperatur kleiner als 27,5°C.
// Strom kleiner als -2,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_2", "STAT_HV_BATT_HIST_SOC6_T4_I1_WERT", STAT_HV_BATT_HIST_SOC6_T4_I1_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T4_I2_WERT = (RXBUF_UINT32(44)/10.0f);
// Duration at 90% less than SoC less than 95%. 20 ° C less than temperature less than 27.5 ° C. -2.5xC A less
// than current less than -2.0xC A / Dauer bei 90% kleiner als SoC kleiner als 95%. 20°C kleiner als Temperatur
// kleiner als 27,5°C. -2,5xC A kleiner als Strom kleiner als -2,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_2", "STAT_HV_BATT_HIST_SOC6_T4_I2_WERT", STAT_HV_BATT_HIST_SOC6_T4_I2_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T4_I3_WERT = (RXBUF_UINT32(48)/10.0f);
// Duration at 90% less than SoC less than 95%. 20 ° C less than temperature less than 27.5 ° C. -2.0xC A less
// than current less than -1.5xC A / Dauer bei 90% kleiner als SoC kleiner als 95%. 20°C kleiner als Temperatur
// kleiner als 27,5°C. -2,0xC A kleiner als Strom kleiner als -1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_2", "STAT_HV_BATT_HIST_SOC6_T4_I3_WERT", STAT_HV_BATT_HIST_SOC6_T4_I3_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T4_I4_WERT = (RXBUF_UINT32(52)/10.0f);
// Duration at 90% less than SoC less than 95%. 20 ° C less than temperature less than 27.5 ° C. -1.5xC A less
// than current less than -1.0xC A / Dauer bei 90% kleiner als SoC kleiner als 95%. 20°C kleiner als Temperatur
// kleiner als 27,5°C. -1,5xC A kleiner als Strom kleiner als -1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_2", "STAT_HV_BATT_HIST_SOC6_T4_I4_WERT", STAT_HV_BATT_HIST_SOC6_T4_I4_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T4_I5_WERT = (RXBUF_UINT32(56)/10.0f);
// Duration at 90% less than SoC less than 95%. 20 ° C less than temperature less than 27.5 ° C. -1.0xC A less
// than current less than -0.5xC A / Dauer bei 90% kleiner als SoC kleiner als 95%. 20°C kleiner als Temperatur
// kleiner als 27,5°C. -1,0xC A kleiner als Strom kleiner als -0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_2", "STAT_HV_BATT_HIST_SOC6_T4_I5_WERT", STAT_HV_BATT_HIST_SOC6_T4_I5_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T4_I6_WERT = (RXBUF_UINT32(60)/10.0f);
// Duration at 90% less than SoC less than 95%. 20 ° C less than temperature less than 27.5 ° C. -0.5xC A less
// than current less than 0.0xC A / Dauer bei 90% kleiner als SoC kleiner als 95%. 20°C kleiner als Temperatur
// kleiner als 27,5°C. -0,5xC A kleiner als Strom kleiner als 0,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_2", "STAT_HV_BATT_HIST_SOC6_T4_I6_WERT", STAT_HV_BATT_HIST_SOC6_T4_I6_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T4_I7_WERT = (RXBUF_UINT32(64)/10.0f);
// Duration at 90% less than SoC less than 95%. 20 ° C less than temperature less than 27.5 ° C. 0.0xC A less
// than current less than 0.5xC A / Dauer bei 90% kleiner als SoC kleiner als 95%. 20°C kleiner als Temperatur
// kleiner als 27,5°C. 0,0xC A kleiner als Strom kleiner als 0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_2", "STAT_HV_BATT_HIST_SOC6_T4_I7_WERT", STAT_HV_BATT_HIST_SOC6_T4_I7_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T4_I8_WERT = (RXBUF_UINT32(68)/10.0f);
// Duration at 90% less than SoC less than 95%. 20 ° C less than temperature less than 27.5 ° C. 0.5xC A less
// than current less than 1.0xC A / Dauer bei 90% kleiner als SoC kleiner als 95%. 20°C kleiner als Temperatur
// kleiner als 27,5°C. 0,5xC A kleiner als Strom kleiner als 1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_2", "STAT_HV_BATT_HIST_SOC6_T4_I8_WERT", STAT_HV_BATT_HIST_SOC6_T4_I8_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T4_I9_WERT = (RXBUF_UINT32(72)/10.0f);
// Duration at 90% less than SoC less than 95%. 20 ° C less than temperature less than 27.5 ° C. 1.0xC A less
// than current less than 1.5xC A / Dauer bei 90% kleiner als SoC kleiner als 95%. 20°C kleiner als Temperatur
// kleiner als 27,5°C. 1,0xC A kleiner als Strom kleiner als 1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_2", "STAT_HV_BATT_HIST_SOC6_T4_I9_WERT", STAT_HV_BATT_HIST_SOC6_T4_I9_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T4_I10_WERT = (RXBUF_UINT32(76)/10.0f);
// Duration at 90% less than SoC less than 95%. 20 ° C less than temperature less than 27.5 ° C. 1.5xC A less
// than current / Dauer bei 90% kleiner als SoC kleiner als 95%. 20°C kleiner als Temperatur kleiner als 27,5°C.
// 1,5xC A kleiner als Strom
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_2", "STAT_HV_BATT_HIST_SOC6_T4_I10_WERT", STAT_HV_BATT_HIST_SOC6_T4_I10_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T4_I1_WERT = (RXBUF_UINT32(80)/10.0f);
// Duration at 95% smaller than SoC. 20 ° C less than temperature less than 27.5 ° C. Current less than -2.5xC A
// / Dauer bei 95% kleiner als SoC. 20°C kleiner als Temperatur kleiner als 27,5°C. Strom kleiner als -2,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_2", "STAT_HV_BATT_HIST_SOC7_T4_I1_WERT", STAT_HV_BATT_HIST_SOC7_T4_I1_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T4_I2_WERT = (RXBUF_UINT32(84)/10.0f);
// Duration at 95% smaller than SoC. 20 ° C less than temperature less than 27.5 ° C. -2.5xC A less than current
// less than -2.0xC A / Dauer bei 95% kleiner als SoC. 20°C kleiner als Temperatur kleiner als 27,5°C. -2,5xC A
// kleiner als Strom kleiner als -2,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_2", "STAT_HV_BATT_HIST_SOC7_T4_I2_WERT", STAT_HV_BATT_HIST_SOC7_T4_I2_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T4_I3_WERT = (RXBUF_UINT32(88)/10.0f);
// Duration at 95% smaller than SoC. 20 ° C less than temperature less than 27.5 ° C. -2.0xC A less than current
// less than -1.5xC A / Dauer bei 95% kleiner als SoC. 20°C kleiner als Temperatur kleiner als 27,5°C. -2,0xC A
// kleiner als Strom kleiner als -1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_2", "STAT_HV_BATT_HIST_SOC7_T4_I3_WERT", STAT_HV_BATT_HIST_SOC7_T4_I3_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T4_I4_WERT = (RXBUF_UINT32(92)/10.0f);
// Duration at 95% smaller than SoC. 20 ° C less than temperature less than 27.5 ° C. -1.5xC A less than current
// less than -1.0xC A / Dauer bei 95% kleiner als SoC. 20°C kleiner als Temperatur kleiner als 27,5°C. -1,5xC A
// kleiner als Strom kleiner als -1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_2", "STAT_HV_BATT_HIST_SOC7_T4_I4_WERT", STAT_HV_BATT_HIST_SOC7_T4_I4_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T4_I5_WERT = (RXBUF_UINT32(96)/10.0f);
// Duration at 95% smaller than SoC. 20 ° C less than temperature less than 27.5 ° C. -1.0xC A less than current
// less than -0.5xC A / Dauer bei 95% kleiner als SoC. 20°C kleiner als Temperatur kleiner als 27,5°C. -1,0xC A
// kleiner als Strom kleiner als -0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_2", "STAT_HV_BATT_HIST_SOC7_T4_I5_WERT", STAT_HV_BATT_HIST_SOC7_T4_I5_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T4_I6_WERT = (RXBUF_UINT32(100)/10.0f);
// Duration at 95% smaller than SoC. 20 ° C less than temperature less than 27.5 ° C. -0.5xC A less than current
// less than 0.0xC A / Dauer bei 95% kleiner als SoC. 20°C kleiner als Temperatur kleiner als 27,5°C. -0,5xC A
// kleiner als Strom kleiner als 0,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_2", "STAT_HV_BATT_HIST_SOC7_T4_I6_WERT", STAT_HV_BATT_HIST_SOC7_T4_I6_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T4_I7_WERT = (RXBUF_UINT32(104)/10.0f);
// Duration at 95% smaller than SoC. 20 ° C less than temperature less than 27.5 ° C. 0.0xC A less than current
// less than 0.5xC A / Dauer bei 95% kleiner als SoC. 20°C kleiner als Temperatur kleiner als 27,5°C. 0,0xC A
// kleiner als Strom kleiner als 0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_2", "STAT_HV_BATT_HIST_SOC7_T4_I7_WERT", STAT_HV_BATT_HIST_SOC7_T4_I7_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T4_I8_WERT = (RXBUF_UINT32(108)/10.0f);
// Duration at 95% smaller than SoC. 20 ° C less than temperature less than 27.5 ° C. 0.5xC A less than current
// less than 1.0xC A / Dauer bei 95% kleiner als SoC. 20°C kleiner als Temperatur kleiner als 27,5°C. 0,5xC A
// kleiner als Strom kleiner als 1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_2", "STAT_HV_BATT_HIST_SOC7_T4_I8_WERT", STAT_HV_BATT_HIST_SOC7_T4_I8_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T4_I9_WERT = (RXBUF_UINT32(112)/10.0f);
// Duration at 95% smaller than SoC. 20 ° C less than temperature less than 27.5 ° C. 1.0xC A less than current
// less than 1.5xC A / Dauer bei 95% kleiner als SoC. 20°C kleiner als Temperatur kleiner als 27,5°C. 1,0xC A
// kleiner als Strom kleiner als 1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_2", "STAT_HV_BATT_HIST_SOC7_T4_I9_WERT", STAT_HV_BATT_HIST_SOC7_T4_I9_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T4_I10_WERT = (RXBUF_UINT32(116)/10.0f);
// Duration at 95% smaller than SoC. 20 ° C less than temperature less than 27.5 ° C. 1.5xC A less than current /
// Dauer bei 95% kleiner als SoC. 20°C kleiner als Temperatur kleiner als 27,5°C. 1,5xC A kleiner als Strom
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T4_2", "STAT_HV_BATT_HIST_SOC7_T4_I10_WERT", STAT_HV_BATT_HIST_SOC7_T4_I10_WERT, "\"s\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_HV_BATT_HIST_SOC_T3_2: { // 0xDF6A
if (datalen < 120) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_HV_BATT_HIST_SOC_T3_2", 120);
break;
}
float STAT_HV_BATT_HIST_SOC5_T3_I1_WERT = (RXBUF_UINT32(0)/10.0f);
// Duration at 70% less than SoC less than 90%. 10 ° C less than temperature less than 20 ° C. Current less than
// -2.5xC A / Dauer bei 70% kleiner als SoC kleiner als 90%. 10°C kleiner als Temperatur kleiner als 20°C. Strom
// kleiner als -2,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_2", "STAT_HV_BATT_HIST_SOC5_T3_I1_WERT", STAT_HV_BATT_HIST_SOC5_T3_I1_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T3_I2_WERT = (RXBUF_UINT32(4)/10.0f);
// Duration at 70% less than SoC less than 90%. 10 ° C less than temperature less than 20 ° C. -2.5xC A less than
// current less than -2.0xC A / Dauer bei 70% kleiner als SoC kleiner als 90%. 10°C kleiner als Temperatur
// kleiner als 20°C. -2,5xC A kleiner als Strom kleiner als -2,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_2", "STAT_HV_BATT_HIST_SOC5_T3_I2_WERT", STAT_HV_BATT_HIST_SOC5_T3_I2_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T3_I3_WERT = (RXBUF_UINT32(8)/10.0f);
// Duration at 70% less than SoC less than 90%. 10 ° C less than temperature less than 20 ° C. -2.0xC A less than
// current less than -1.5xC A / Dauer bei 70% kleiner als SoC kleiner als 90%. 10°C kleiner als Temperatur
// kleiner als 20°C. -2,0xC A kleiner als Strom kleiner als -1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_2", "STAT_HV_BATT_HIST_SOC5_T3_I3_WERT", STAT_HV_BATT_HIST_SOC5_T3_I3_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T3_I4_WERT = (RXBUF_UINT32(12)/10.0f);
// Duration at 70% less than SoC less than 90%. 10 ° C less than temperature less than 20 ° C. -1.5xC A less than
// current less than -1.0xC A / Dauer bei 70% kleiner als SoC kleiner als 90%. 10°C kleiner als Temperatur
// kleiner als 20°C. -1,5xC A kleiner als Strom kleiner als -1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_2", "STAT_HV_BATT_HIST_SOC5_T3_I4_WERT", STAT_HV_BATT_HIST_SOC5_T3_I4_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T3_I5_WERT = (RXBUF_UINT32(16)/10.0f);
// Duration at 70% less than SoC less than 90%. 10 ° C less than temperature less than 20 ° C. -1.0xC A less than
// current less than -0.5xC A / Dauer bei 70% kleiner als SoC kleiner als 90%. 10°C kleiner als Temperatur
// kleiner als 20°C. -1,0xC A kleiner als Strom kleiner als -0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_2", "STAT_HV_BATT_HIST_SOC5_T3_I5_WERT", STAT_HV_BATT_HIST_SOC5_T3_I5_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T3_I6_WERT = (RXBUF_UINT32(20)/10.0f);
// Duration at 70% less than SoC less than 90%. 10 ° C less than temperature less than 20 ° C. -0.5xC A less than
// current less than 0.0xC A / Dauer bei 70% kleiner als SoC kleiner als 90%. 10°C kleiner als Temperatur kleiner
// als 20°C. -0,5xC A kleiner als Strom kleiner als 0,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_2", "STAT_HV_BATT_HIST_SOC5_T3_I6_WERT", STAT_HV_BATT_HIST_SOC5_T3_I6_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T3_I7_WERT = (RXBUF_UINT32(24)/10.0f);
// Duration at 70% less than SoC less than 90%. 10 ° C less than temperature less than 20 ° C. 0.0xC A less than
// current less than 0.5xC A / Dauer bei 70% kleiner als SoC kleiner als 90%. 10°C kleiner als Temperatur kleiner
// als 20°C. 0,0xC A kleiner als Strom kleiner als 0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_2", "STAT_HV_BATT_HIST_SOC5_T3_I7_WERT", STAT_HV_BATT_HIST_SOC5_T3_I7_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T3_I8_WERT = (RXBUF_UINT32(28)/10.0f);
// Duration at 70% less than SoC less than 90%. 10 ° C less than temperature less than 20 ° C. 0.5xC A less than
// current less than 1.0xC A / Dauer bei 70% kleiner als SoC kleiner als 90%. 10°C kleiner als Temperatur kleiner
// als 20°C. 0,5xC A kleiner als Strom kleiner als 1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_2", "STAT_HV_BATT_HIST_SOC5_T3_I8_WERT", STAT_HV_BATT_HIST_SOC5_T3_I8_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T3_I9_WERT = (RXBUF_UINT32(32)/10.0f);
// Duration at 70% less than SoC less than 90%. 10 ° C less than temperature less than 20 ° C. 1.0xC A less than
// current less than 1.5xC A / Dauer bei 70% kleiner als SoC kleiner als 90%. 10°C kleiner als Temperatur kleiner
// als 20°C. 1,0xC A kleiner als Strom kleiner als 1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_2", "STAT_HV_BATT_HIST_SOC5_T3_I9_WERT", STAT_HV_BATT_HIST_SOC5_T3_I9_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T3_I10_WERT = (RXBUF_UINT32(36)/10.0f);
// Duration at 70% less than SoC less than 90%. 10 ° C less than temperature less than 20 ° C. 1.5xC A less than
// current / Dauer bei 70% kleiner als SoC kleiner als 90%. 10°C kleiner als Temperatur kleiner als 20°C. 1,5xC A
// kleiner als Strom
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_2", "STAT_HV_BATT_HIST_SOC5_T3_I10_WERT", STAT_HV_BATT_HIST_SOC5_T3_I10_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T3_I1_WERT = (RXBUF_UINT32(40)/10.0f);
// Duration at 90% less than SoC less than 95%. 10 ° C less than temperature less than 20 ° C. Current less than
// -2.5xC A / Dauer bei 90% kleiner als SoC kleiner als 95%. 10°C kleiner als Temperatur kleiner als 20°C. Strom
// kleiner als -2,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_2", "STAT_HV_BATT_HIST_SOC6_T3_I1_WERT", STAT_HV_BATT_HIST_SOC6_T3_I1_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T3_I2_WERT = (RXBUF_UINT32(44)/10.0f);
// Duration at 90% less than SoC less than 95%. 10 ° C less than temperature less than 20 ° C. -2.5xC A less than
// current less than -2.0xC A / Dauer bei 90% kleiner als SoC kleiner als 95%. 10°C kleiner als Temperatur
// kleiner als 20°C. -2,5xC A kleiner als Strom kleiner als -2,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_2", "STAT_HV_BATT_HIST_SOC6_T3_I2_WERT", STAT_HV_BATT_HIST_SOC6_T3_I2_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T3_I3_WERT = (RXBUF_UINT32(48)/10.0f);
// Duration at 90% less than SoC less than 95%. 10 ° C less than temperature less than 20 ° C. -2.0xC A less than
// current less than -1.5xC A / Dauer bei 90% kleiner als SoC kleiner als 95%. 10°C kleiner als Temperatur
// kleiner als 20°C. -2,0xC A kleiner als Strom kleiner als -1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_2", "STAT_HV_BATT_HIST_SOC6_T3_I3_WERT", STAT_HV_BATT_HIST_SOC6_T3_I3_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T3_I4_WERT = (RXBUF_UINT32(52)/10.0f);
// Duration at 90% less than SoC less than 95%. 10 ° C less than temperature less than 20 ° C. -1.5xC A less than
// current less than -1.0xC A / Dauer bei 90% kleiner als SoC kleiner als 95%. 10°C kleiner als Temperatur
// kleiner als 20°C. -1,5xC A kleiner als Strom kleiner als -1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_2", "STAT_HV_BATT_HIST_SOC6_T3_I4_WERT", STAT_HV_BATT_HIST_SOC6_T3_I4_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T3_I5_WERT = (RXBUF_UINT32(56)/10.0f);
// Duration at 90% less than SoC less than 95%. 10 ° C less than temperature less than 20 ° C. -1.0xC A less than
// current less than -0.5xC A / Dauer bei 90% kleiner als SoC kleiner als 95%. 10°C kleiner als Temperatur
// kleiner als 20°C. -1,0xC A kleiner als Strom kleiner als -0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_2", "STAT_HV_BATT_HIST_SOC6_T3_I5_WERT", STAT_HV_BATT_HIST_SOC6_T3_I5_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T3_I6_WERT = (RXBUF_UINT32(60)/10.0f);
// Duration at 90% less than SoC less than 95%. 10 ° C less than temperature less than 20 ° C. -0.5xC A less than
// current less than 0.0xC A / Dauer bei 90% kleiner als SoC kleiner als 95%. 10°C kleiner als Temperatur kleiner
// als 20°C. -0,5xC A kleiner als Strom kleiner als 0,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_2", "STAT_HV_BATT_HIST_SOC6_T3_I6_WERT", STAT_HV_BATT_HIST_SOC6_T3_I6_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T3_I7_WERT = (RXBUF_UINT32(64)/10.0f);
// Duration at 90% less than SoC less than 95%. 10 ° C less than temperature less than 20 ° C. 0.0xC A less than
// current less than 0.5xC A / Dauer bei 90% kleiner als SoC kleiner als 95%. 10°C kleiner als Temperatur kleiner
// als 20°C. 0,0xC A kleiner als Strom kleiner als 0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_2", "STAT_HV_BATT_HIST_SOC6_T3_I7_WERT", STAT_HV_BATT_HIST_SOC6_T3_I7_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T3_I8_WERT = (RXBUF_UINT32(68)/10.0f);
// Duration at 90% less than SoC less than 95%. 10 ° C less than temperature less than 20 ° C. 0.5xC A less than
// current less than 1.0xC A / Dauer bei 90% kleiner als SoC kleiner als 95%. 10°C kleiner als Temperatur kleiner
// als 20°C. 0,5xC A kleiner als Strom kleiner als 1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_2", "STAT_HV_BATT_HIST_SOC6_T3_I8_WERT", STAT_HV_BATT_HIST_SOC6_T3_I8_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T3_I9_WERT = (RXBUF_UINT32(72)/10.0f);
// Duration at 90% less than SoC less than 95%. 10 ° C less than temperature less than 20 ° C. 1.0xC A less than
// current less than 1.5xC A / Dauer bei 90% kleiner als SoC kleiner als 95%. 10°C kleiner als Temperatur kleiner
// als 20°C. 1,0xC A kleiner als Strom kleiner als 1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_2", "STAT_HV_BATT_HIST_SOC6_T3_I9_WERT", STAT_HV_BATT_HIST_SOC6_T3_I9_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T3_I10_WERT = (RXBUF_UINT32(76)/10.0f);
// Duration at 90% less than SoC less than 95%. 10 ° C less than temperature less than 20 ° C. 1.5xC A less than
// current / Dauer bei 90% kleiner als SoC kleiner als 95%. 10°C kleiner als Temperatur kleiner als 20°C. 1,5xC A
// kleiner als Strom
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_2", "STAT_HV_BATT_HIST_SOC6_T3_I10_WERT", STAT_HV_BATT_HIST_SOC6_T3_I10_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T3_I1_WERT = (RXBUF_UINT32(80)/10.0f);
// Duration at 95% smaller than SoC. 10 ° C less than temperature less than 20 ° C. Current less than -2.5xC A /
// Dauer bei 95% kleiner als SoC. 10°C kleiner als Temperatur kleiner als 20°C. Strom kleiner als -2,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_2", "STAT_HV_BATT_HIST_SOC7_T3_I1_WERT", STAT_HV_BATT_HIST_SOC7_T3_I1_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T3_I2_WERT = (RXBUF_UINT32(84)/10.0f);
// Duration at 95% smaller than SoC. 10 ° C less than temperature less than 20 ° C. -2.5xC A less than current
// less than -2.0xC A / Dauer bei 95% kleiner als SoC. 10°C kleiner als Temperatur kleiner als 20°C. -2,5xC A
// kleiner als Strom kleiner als -2,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_2", "STAT_HV_BATT_HIST_SOC7_T3_I2_WERT", STAT_HV_BATT_HIST_SOC7_T3_I2_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T3_I3_WERT = (RXBUF_UINT32(88)/10.0f);
// Duration at 95% smaller than SoC. 10 ° C less than temperature less than 20 ° C. -2.0xC A less than current
// less than -1.5xC A / Dauer bei 95% kleiner als SoC. 10°C kleiner als Temperatur kleiner als 20°C. -2,0xC A
// kleiner als Strom kleiner als -1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_2", "STAT_HV_BATT_HIST_SOC7_T3_I3_WERT", STAT_HV_BATT_HIST_SOC7_T3_I3_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T3_I4_WERT = (RXBUF_UINT32(92)/10.0f);
// Duration at 95% smaller than SoC. 10 ° C less than temperature less than 20 ° C. -1.5xC A less than current
// less than -1.0xC A / Dauer bei 95% kleiner als SoC. 10°C kleiner als Temperatur kleiner als 20°C. -1,5xC A
// kleiner als Strom kleiner als -1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_2", "STAT_HV_BATT_HIST_SOC7_T3_I4_WERT", STAT_HV_BATT_HIST_SOC7_T3_I4_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T3_I5_WERT = (RXBUF_UINT32(96)/10.0f);
// Duration at 95% smaller than SoC. 10 ° C less than temperature less than 20 ° C. -1.0xC A less than current
// less than -0.5xC A / Dauer bei 95% kleiner als SoC. 10°C kleiner als Temperatur kleiner als 20°C. -1,0xC A
// kleiner als Strom kleiner als -0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_2", "STAT_HV_BATT_HIST_SOC7_T3_I5_WERT", STAT_HV_BATT_HIST_SOC7_T3_I5_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T3_I6_WERT = (RXBUF_UINT32(100)/10.0f);
// Duration at 95% smaller than SoC. 10 ° C less than temperature less than 20 ° C. -0.5xC A less than current
// less than 0.0xC A / Dauer bei 95% kleiner als SoC. 10°C kleiner als Temperatur kleiner als 20°C. -0,5xC A
// kleiner als Strom kleiner als 0,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_2", "STAT_HV_BATT_HIST_SOC7_T3_I6_WERT", STAT_HV_BATT_HIST_SOC7_T3_I6_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T3_I7_WERT = (RXBUF_UINT32(104)/10.0f);
// Duration at 95% smaller than SoC. 10 ° C less than temperature less than 20 ° C. 0.0xC A less than current
// less than 0.5xC A / Dauer bei 95% kleiner als SoC. 10°C kleiner als Temperatur kleiner als 20°C. 0,0xC A
// kleiner als Strom kleiner als 0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_2", "STAT_HV_BATT_HIST_SOC7_T3_I7_WERT", STAT_HV_BATT_HIST_SOC7_T3_I7_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T3_I8_WERT = (RXBUF_UINT32(108)/10.0f);
// Duration at 95% smaller than SoC. 10 ° C less than temperature less than 20 ° C. 0.5xC A less than current
// less than 1.0xC A / Dauer bei 95% kleiner als SoC. 10°C kleiner als Temperatur kleiner als 20°C. 0,5xC A
// kleiner als Strom kleiner als 1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_2", "STAT_HV_BATT_HIST_SOC7_T3_I8_WERT", STAT_HV_BATT_HIST_SOC7_T3_I8_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T3_I9_WERT = (RXBUF_UINT32(112)/10.0f);
// Duration at 95% smaller than SoC. 10 ° C less than temperature less than 20 ° C. 1.0xC A less than current
// less than 1.5xC A / Dauer bei 95% kleiner als SoC. 10°C kleiner als Temperatur kleiner als 20°C. 1,0xC A
// kleiner als Strom kleiner als 1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_2", "STAT_HV_BATT_HIST_SOC7_T3_I9_WERT", STAT_HV_BATT_HIST_SOC7_T3_I9_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T3_I10_WERT = (RXBUF_UINT32(116)/10.0f);
// Duration at 95% smaller than SoC. 10 ° C less than temperature less than 20 ° C. 1.5xC A less than current /
// Dauer bei 95% kleiner als SoC. 10°C kleiner als Temperatur kleiner als 20°C. 1,5xC A kleiner als Strom
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T3_2", "STAT_HV_BATT_HIST_SOC7_T3_I10_WERT", STAT_HV_BATT_HIST_SOC7_T3_I10_WERT, "\"s\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_HV_BATT_HIST_SOC_T5_2: { // 0xDF6B
if (datalen < 120) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_HV_BATT_HIST_SOC_T5_2", 120);
break;
}
float STAT_HV_BATT_HIST_SOC5_T5_I1_WERT = (RXBUF_UINT32(0)/10.0f);
// Duration at 70% less than SoC less than 90%. 27.5 ° C less than temperature less than 32.5 ° C. Current less
// than -2.5xC A / Dauer bei 70% kleiner als SoC kleiner als 90%. 27,5°C kleiner als Temperatur kleiner als
// 32,5°C. Strom kleiner als -2,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_2", "STAT_HV_BATT_HIST_SOC5_T5_I1_WERT", STAT_HV_BATT_HIST_SOC5_T5_I1_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T5_I2_WERT = (RXBUF_UINT32(4)/10.0f);
// Duration at 70% less than SoC less than 90%. 27.5 ° C less than temperature less than 32.5 ° C. -2.5xC A less
// than current less than -2.0xC A / Dauer bei 70% kleiner als SoC kleiner als 90%. 27,5°C kleiner als Temperatur
// kleiner als 32,5°C. -2,5xC A kleiner als Strom kleiner als -2,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_2", "STAT_HV_BATT_HIST_SOC5_T5_I2_WERT", STAT_HV_BATT_HIST_SOC5_T5_I2_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T5_I3_WERT = (RXBUF_UINT32(8)/10.0f);
// Duration at 70% less than SoC less than 90%. 27.5 ° C less than temperature less than 32.5 ° C. -2.0xC A less
// than current less than -1.5xC A / Dauer bei 70% kleiner als SoC kleiner als 90%. 27,5°C kleiner als Temperatur
// kleiner als 32,5°C. -2,0xC A kleiner als Strom kleiner als -1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_2", "STAT_HV_BATT_HIST_SOC5_T5_I3_WERT", STAT_HV_BATT_HIST_SOC5_T5_I3_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T5_I4_WERT = (RXBUF_UINT32(12)/10.0f);
// Duration at 70% less than SoC less than 90%. 27.5 ° C less than temperature less than 32.5 ° C. -1.5xC A less
// than current less than -1.0xC A / Dauer bei 70% kleiner als SoC kleiner als 90%. 27,5°C kleiner als Temperatur
// kleiner als 32,5°C. -1,5xC A kleiner als Strom kleiner als -1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_2", "STAT_HV_BATT_HIST_SOC5_T5_I4_WERT", STAT_HV_BATT_HIST_SOC5_T5_I4_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T5_I5_WERT = (RXBUF_UINT32(16)/10.0f);
// Duration at 70% less than SoC less than 90%. 27.5 ° C less than temperature less than 32.5 ° C. -1.0xC A less
// than current less than -0.5xC A / Dauer bei 70% kleiner als SoC kleiner als 90%. 27,5°C kleiner als Temperatur
// kleiner als 32,5°C. -1,0xC A kleiner als Strom kleiner als -0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_2", "STAT_HV_BATT_HIST_SOC5_T5_I5_WERT", STAT_HV_BATT_HIST_SOC5_T5_I5_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T5_I6_WERT = (RXBUF_UINT32(20)/10.0f);
// Duration at 70% less than SoC less than 90%. 27.5 ° C less than temperature less than 32.5 ° C. -0.5xC A less
// than current less than 0.0xC A / Dauer bei 70% kleiner als SoC kleiner als 90%. 27,5°C kleiner als Temperatur
// kleiner als 32,5°C. -0,5xC A kleiner als Strom kleiner als 0,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_2", "STAT_HV_BATT_HIST_SOC5_T5_I6_WERT", STAT_HV_BATT_HIST_SOC5_T5_I6_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T5_I7_WERT = (RXBUF_UINT32(24)/10.0f);
// Duration at 70% less than SoC less than 90%. 27.5 ° C less than temperature less than 32.5 ° C. 0.0xC A less
// than current less than 0.5xC A / Dauer bei 70% kleiner als SoC kleiner als 90%. 27,5°C kleiner als Temperatur
// kleiner als 32,5°C. 0,0xC A kleiner als Strom kleiner als 0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_2", "STAT_HV_BATT_HIST_SOC5_T5_I7_WERT", STAT_HV_BATT_HIST_SOC5_T5_I7_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T5_I8_WERT = (RXBUF_UINT32(28)/10.0f);
// Duration at 70% less than SoC less than 90%. 27.5 ° C less than temperature less than 32.5 ° C. 0.5xC A less
// than current less than 1.0xC A / Dauer bei 70% kleiner als SoC kleiner als 90%. 27,5°C kleiner als Temperatur
// kleiner als 32,5°C. 0,5xC A kleiner als Strom kleiner als 1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_2", "STAT_HV_BATT_HIST_SOC5_T5_I8_WERT", STAT_HV_BATT_HIST_SOC5_T5_I8_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T5_I9_WERT = (RXBUF_UINT32(32)/10.0f);
// Duration at 70% less than SoC less than 90%. 27.5 ° C less than temperature less than 32.5 ° C. 1.0xC A less
// than current less than 1.5xC A / Dauer bei 70% kleiner als SoC kleiner als 90%. 27,5°C kleiner als Temperatur
// kleiner als 32,5°C. 1,0xC A kleiner als Strom kleiner als 1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_2", "STAT_HV_BATT_HIST_SOC5_T5_I9_WERT", STAT_HV_BATT_HIST_SOC5_T5_I9_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T5_I10_WERT = (RXBUF_UINT32(36)/10.0f);
// Duration at 70% less than SoC less than 90%. 27.5 ° C less than temperature less than 32.5 ° C. 1.5xC A less
// than current / Dauer bei 70% kleiner als SoC kleiner als 90%. 27,5°C kleiner als Temperatur kleiner als
// 32,5°C. 1,5xC A kleiner als Strom
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_2", "STAT_HV_BATT_HIST_SOC5_T5_I10_WERT", STAT_HV_BATT_HIST_SOC5_T5_I10_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T5_I1_WERT = (RXBUF_UINT32(40)/10.0f);
// Duration at 90% less than SoC less than 95%. 27.5 ° C less than temperature less than 32.5 ° C. Current less
// than -2.5xC A / Dauer bei 90% kleiner als SoC kleiner als 95%. 27,5°C kleiner als Temperatur kleiner als
// 32,5°C. Strom kleiner als -2,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_2", "STAT_HV_BATT_HIST_SOC6_T5_I1_WERT", STAT_HV_BATT_HIST_SOC6_T5_I1_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T5_I2_WERT = (RXBUF_UINT32(44)/10.0f);
// Duration at 90% less than SoC less than 95%. 27.5 ° C less than temperature less than 32.5 ° C. -2.5xC A less
// than current less than -2.0xC A / Dauer bei 90% kleiner als SoC kleiner als 95%. 27,5°C kleiner als Temperatur
// kleiner als 32,5°C. -2,5xC A kleiner als Strom kleiner als -2,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_2", "STAT_HV_BATT_HIST_SOC6_T5_I2_WERT", STAT_HV_BATT_HIST_SOC6_T5_I2_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T5_I3_WERT = (RXBUF_UINT32(48)/10.0f);
// Duration at 90% less than SoC less than 95%. 27.5 ° C less than temperature less than 32.5 ° C. -2.0xC A less
// than current less than -1.5xC A / Dauer bei 90% kleiner als SoC kleiner als 95%. 27,5°C kleiner als Temperatur
// kleiner als 32,5°C. -2,0xC A kleiner als Strom kleiner als -1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_2", "STAT_HV_BATT_HIST_SOC6_T5_I3_WERT", STAT_HV_BATT_HIST_SOC6_T5_I3_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T5_I4_WERT = (RXBUF_UINT32(52)/10.0f);
// Duration at 90% less than SoC less than 95%. 27.5 ° C less than temperature less than 32.5 ° C. -1.5xC A less
// than current less than -1.0xC A / Dauer bei 90% kleiner als SoC kleiner als 95%. 27,5°C kleiner als Temperatur
// kleiner als 32,5°C. -1,5xC A kleiner als Strom kleiner als -1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_2", "STAT_HV_BATT_HIST_SOC6_T5_I4_WERT", STAT_HV_BATT_HIST_SOC6_T5_I4_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T5_I5_WERT = (RXBUF_UINT32(56)/10.0f);
// Duration at 90% less than SoC less than 95%. 27.5 ° C less than temperature less than 32.5 ° C. -1.0xC A less
// than current less than -0.5xC A / Dauer bei 90% kleiner als SoC kleiner als 95%. 27,5°C kleiner als Temperatur
// kleiner als 32,5°C. -1,0xC A kleiner als Strom kleiner als -0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_2", "STAT_HV_BATT_HIST_SOC6_T5_I5_WERT", STAT_HV_BATT_HIST_SOC6_T5_I5_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T5_I6_WERT = (RXBUF_UINT32(60)/10.0f);
// Duration at 90% less than SoC less than 95%. 27.5 ° C less than temperature less than 32.5 ° C. -0.5xC A less
// than current less than 0.0xC A / Dauer bei 90% kleiner als SoC kleiner als 95%. 27,5°C kleiner als Temperatur
// kleiner als 32,5°C. -0,5xC A kleiner als Strom kleiner als 0,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_2", "STAT_HV_BATT_HIST_SOC6_T5_I6_WERT", STAT_HV_BATT_HIST_SOC6_T5_I6_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T5_I7_WERT = (RXBUF_UINT32(64)/10.0f);
// Duration at 90% less than SoC less than 95%. 27.5 ° C less than temperature less than 32.5 ° C. 0.0xC A less
// than current less than 0.5xC A / Dauer bei 90% kleiner als SoC kleiner als 95%. 27,5°C kleiner als Temperatur
// kleiner als 32,5°C. 0,0xC A kleiner als Strom kleiner als 0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_2", "STAT_HV_BATT_HIST_SOC6_T5_I7_WERT", STAT_HV_BATT_HIST_SOC6_T5_I7_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T5_I8_WERT = (RXBUF_UINT32(68)/10.0f);
// Duration at 90% less than SoC less than 95%. 27.5 ° C less than temperature less than 32.5 ° C. 0.5xC A less
// than current less than 1.0xC A / Dauer bei 90% kleiner als SoC kleiner als 95%. 27,5°C kleiner als Temperatur
// kleiner als 32,5°C. 0,5xC A kleiner als Strom kleiner als 1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_2", "STAT_HV_BATT_HIST_SOC6_T5_I8_WERT", STAT_HV_BATT_HIST_SOC6_T5_I8_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T5_I9_WERT = (RXBUF_UINT32(72)/10.0f);
// Duration at 90% less than SoC less than 95%. 27.5 ° C less than temperature less than 32.5 ° C. 1.0xC A less
// than current less than 1.5xC A / Dauer bei 90% kleiner als SoC kleiner als 95%. 27,5°C kleiner als Temperatur
// kleiner als 32,5°C. 1,0xC A kleiner als Strom kleiner als 1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_2", "STAT_HV_BATT_HIST_SOC6_T5_I9_WERT", STAT_HV_BATT_HIST_SOC6_T5_I9_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T5_I10_WERT = (RXBUF_UINT32(76)/10.0f);
// Duration at 90% less than SoC less than 95%. 27.5 ° C less than temperature less than 32.5 ° C. 1.5xC A less
// than current / Dauer bei 90% kleiner als SoC kleiner als 95%. 27,5°C kleiner als Temperatur kleiner als
// 32,5°C. 1,5xC A kleiner als Strom
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_2", "STAT_HV_BATT_HIST_SOC6_T5_I10_WERT", STAT_HV_BATT_HIST_SOC6_T5_I10_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T5_I1_WERT = (RXBUF_UINT32(80)/10.0f);
// Duration at 95% smaller than SoC. 27.5 ° C less than temperature less than 32.5 ° C. Current less than -2.5xC
// A / Dauer bei 95% kleiner als SoC. 27,5°C kleiner als Temperatur kleiner als 32,5°C. Strom kleiner als -2,5xC
// A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_2", "STAT_HV_BATT_HIST_SOC7_T5_I1_WERT", STAT_HV_BATT_HIST_SOC7_T5_I1_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T5_I2_WERT = (RXBUF_UINT32(84)/10.0f);
// Duration at 95% smaller than SoC. 27.5 ° C less than temperature less than 32.5 ° C. -2.5xC A less than
// current less than -2.0xC A / Dauer bei 95% kleiner als SoC. 27,5°C kleiner als Temperatur kleiner als 32,5°C.
// -2,5xC A kleiner als Strom kleiner als -2,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_2", "STAT_HV_BATT_HIST_SOC7_T5_I2_WERT", STAT_HV_BATT_HIST_SOC7_T5_I2_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T5_I3_WERT = (RXBUF_UINT32(88)/10.0f);
// Duration at 95% smaller than SoC. 27.5 ° C less than temperature less than 32.5 ° C. -2.0xC A less than
// current less than -1.5xC A / Dauer bei 95% kleiner als SoC. 27,5°C kleiner als Temperatur kleiner als 32,5°C.
// -2,0xC A kleiner als Strom kleiner als -1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_2", "STAT_HV_BATT_HIST_SOC7_T5_I3_WERT", STAT_HV_BATT_HIST_SOC7_T5_I3_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T5_I4_WERT = (RXBUF_UINT32(92)/10.0f);
// Duration at 95% smaller than SoC. 27.5 ° C less than temperature less than 32.5 ° C. -1.5xC A less than
// current less than -1.0xC A / Dauer bei 95% kleiner als SoC. 27,5°C kleiner als Temperatur kleiner als 32,5°C.
// -1,5xC A kleiner als Strom kleiner als -1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_2", "STAT_HV_BATT_HIST_SOC7_T5_I4_WERT", STAT_HV_BATT_HIST_SOC7_T5_I4_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T5_I5_WERT = (RXBUF_UINT32(96)/10.0f);
// Duration at 95% smaller than SoC. 27.5 ° C less than temperature less than 32.5 ° C. -1.0xC A less than
// current less than -0.5xC A / Dauer bei 95% kleiner als SoC. 27,5°C kleiner als Temperatur kleiner als 32,5°C.
// -1,0xC A kleiner als Strom kleiner als -0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_2", "STAT_HV_BATT_HIST_SOC7_T5_I5_WERT", STAT_HV_BATT_HIST_SOC7_T5_I5_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T5_I6_WERT = (RXBUF_UINT32(100)/10.0f);
// Duration at 95% smaller than SoC. 27.5 ° C less than temperature less than 32.5 ° C. -0.5xC A less than
// current less than 0.0xC A / Dauer bei 95% kleiner als SoC. 27,5°C kleiner als Temperatur kleiner als 32,5°C.
// -0,5xC A kleiner als Strom kleiner als 0,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_2", "STAT_HV_BATT_HIST_SOC7_T5_I6_WERT", STAT_HV_BATT_HIST_SOC7_T5_I6_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T5_I7_WERT = (RXBUF_UINT32(104)/10.0f);
// Duration at 95% smaller than SoC. 27.5 ° C less than temperature less than 32.5 ° C. 0.0xC A less than current
// less than 0.5xC A / Dauer bei 95% kleiner als SoC. 27,5°C kleiner als Temperatur kleiner als 32,5°C. 0,0xC A
// kleiner als Strom kleiner als 0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_2", "STAT_HV_BATT_HIST_SOC7_T5_I7_WERT", STAT_HV_BATT_HIST_SOC7_T5_I7_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T5_I8_WERT = (RXBUF_UINT32(108)/10.0f);
// Duration at 95% smaller than SoC. 27.5 ° C less than temperature less than 32.5 ° C. 0.5xC A less than current
// less than 1.0xC A / Dauer bei 95% kleiner als SoC. 27,5°C kleiner als Temperatur kleiner als 32,5°C. 0,5xC A
// kleiner als Strom kleiner als 1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_2", "STAT_HV_BATT_HIST_SOC7_T5_I8_WERT", STAT_HV_BATT_HIST_SOC7_T5_I8_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T5_I9_WERT = (RXBUF_UINT32(112)/10.0f);
// Duration at 95% smaller than SoC. 27.5 ° C less than temperature less than 32.5 ° C. 1.0xC A less than current
// less than 1.5xC A / Dauer bei 95% kleiner als SoC. 27,5°C kleiner als Temperatur kleiner als 32,5°C. 1,0xC A
// kleiner als Strom kleiner als 1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_2", "STAT_HV_BATT_HIST_SOC7_T5_I9_WERT", STAT_HV_BATT_HIST_SOC7_T5_I9_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T5_I10_WERT = (RXBUF_UINT32(116)/10.0f);
// Duration at 95% smaller than SoC. 27.5 ° C less than temperature less than 32.5 ° C. 1.5xC A less than current
// / Dauer bei 95% kleiner als SoC. 27,5°C kleiner als Temperatur kleiner als 32,5°C. 1,5xC A kleiner als Strom
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T5_2", "STAT_HV_BATT_HIST_SOC7_T5_I10_WERT", STAT_HV_BATT_HIST_SOC7_T5_I10_WERT, "\"s\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_HV_BATT_HIST_SOC_T2_2: { // 0xDF6C
if (datalen < 120) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_HV_BATT_HIST_SOC_T2_2", 120);
break;
}
float STAT_HV_BATT_HIST_SOC5_T2_I1_WERT = (RXBUF_UINT32(0)/10.0f);
// Duration at 70% less than SoC less than 90%. 0 ° C less than temperature less than 10 ° C. Current less than
// -2.5xC A / Dauer bei 70 % kleiner als SoC kleiner als 90 %. 0°C kleiner als Temperatur kleiner als 10 °C.
// Strom kleiner als -2,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_2", "STAT_HV_BATT_HIST_SOC5_T2_I1_WERT", STAT_HV_BATT_HIST_SOC5_T2_I1_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T2_I2_WERT = (RXBUF_UINT32(4)/10.0f);
// Duration at 70% less than SoC less than 90%. 0 ° C less than temperature less than 10 ° C. -2.5xC A less than
// current less than -2.0xC A / Dauer bei 70 % kleiner als SoC kleiner als 90 %. 0°C kleiner als Temperatur
// kleiner als 10 °C. -2,5xC A kleiner als Strom kleiner als -2,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_2", "STAT_HV_BATT_HIST_SOC5_T2_I2_WERT", STAT_HV_BATT_HIST_SOC5_T2_I2_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T2_I3_WERT = (RXBUF_UINT32(8)/10.0f);
// Duration at 70% less than SoC less than 90%. 0 ° C less than temperature less than 10 ° C. -2.0xC A less than
// current less than -1.5xC A / Dauer bei 70 % kleiner als SoC kleiner als 90 %. 0°C kleiner als Temperatur
// kleiner als 10 °C. -2,0xC A kleiner als Strom kleiner als -1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_2", "STAT_HV_BATT_HIST_SOC5_T2_I3_WERT", STAT_HV_BATT_HIST_SOC5_T2_I3_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T2_I4_WERT = (RXBUF_UINT32(12)/10.0f);
// Duration at 70% less than SoC less than 90%. 0 ° C less than temperature less than 10 ° C. -1.5xC A less than
// current less than -1.0xC A / Dauer bei 70 % kleiner als SoC kleiner als 90 %. 0°C kleiner als Temperatur
// kleiner als 10 °C. -1,5xC A kleiner als Strom kleiner als -1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_2", "STAT_HV_BATT_HIST_SOC5_T2_I4_WERT", STAT_HV_BATT_HIST_SOC5_T2_I4_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T2_I5_WERT = (RXBUF_UINT32(16)/10.0f);
// Duration at 70% less than SoC less than 90%. 0 ° C less than temperature less than 10 ° C. -1.0xC A less than
// current less than -0.5xC A / Dauer bei 70 % kleiner als SoC kleiner als 90 %. 0°C kleiner als Temperatur
// kleiner als 10 °C. -1,0xC A kleiner als Strom kleiner als -0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_2", "STAT_HV_BATT_HIST_SOC5_T2_I5_WERT", STAT_HV_BATT_HIST_SOC5_T2_I5_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T2_I6_WERT = (RXBUF_UINT32(20)/10.0f);
// Duration at 70% less than SoC less than 90%. 0 ° C less than temperature less than 10 ° C. -0.5xC A less than
// current less than 0.0xC A / Dauer bei 70 % kleiner als SoC kleiner als 90 %. 0°C kleiner als Temperatur
// kleiner als 10 °C. -0,5xC A kleiner als Strom kleiner als 0,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_2", "STAT_HV_BATT_HIST_SOC5_T2_I6_WERT", STAT_HV_BATT_HIST_SOC5_T2_I6_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T2_I7_WERT = (RXBUF_UINT32(24)/10.0f);
// Duration at 70% less than SoC less than 90%. 0 ° C less than temperature less than 10 ° C. 0.0xC A less than
// current less than 0.5xC A / Dauer bei 70 % kleiner als SoC kleiner als 90 %. 0°C kleiner als Temperatur
// kleiner als 10 °C. 0,0xC A kleiner als Strom kleiner als 0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_2", "STAT_HV_BATT_HIST_SOC5_T2_I7_WERT", STAT_HV_BATT_HIST_SOC5_T2_I7_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T2_I8_WERT = (RXBUF_UINT32(28)/10.0f);
// Duration at 70% less than SoC less than 90%. 0 ° C less than temperature less than 10 ° C. 0.5xC A less than
// current less than 1.0xC A / Dauer bei 70 % kleiner als SoC kleiner als 90 %. 0°C kleiner als Temperatur
// kleiner als 10 °C. 0,5xC A kleiner als Strom kleiner als 1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_2", "STAT_HV_BATT_HIST_SOC5_T2_I8_WERT", STAT_HV_BATT_HIST_SOC5_T2_I8_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T2_I9_WERT = (RXBUF_UINT32(32)/10.0f);
// Duration at 70% less than SoC less than 90%. 0 ° C less than temperature less than 10 ° C. 1.0xC A less than
// current less than 1.5xC A / Dauer bei 70 % kleiner als SoC kleiner als 90 %. 0°C kleiner als Temperatur
// kleiner als 10 °C. 1,0xC A kleiner als Strom kleiner als 1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_2", "STAT_HV_BATT_HIST_SOC5_T2_I9_WERT", STAT_HV_BATT_HIST_SOC5_T2_I9_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T2_I10_WERT = (RXBUF_UINT32(36)/10.0f);
// Duration at 70% less than SoC less than 90%. 0 ° C less than temperature less than 10 ° C. 1.5xC A less than
// current / Dauer bei 70 % kleiner als SoC kleiner als 90 %. 0°C kleiner als Temperatur kleiner als 10 °C.
// 1,5xC A kleiner als Strom
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_2", "STAT_HV_BATT_HIST_SOC5_T2_I10_WERT", STAT_HV_BATT_HIST_SOC5_T2_I10_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T2_I1_WERT = (RXBUF_UINT32(40)/10.0f);
// Duration at 90% less than SoC less than 95%. 0 ° C less than temperature less than 10 ° C. Current less than
// -2.5xC A / Dauer bei 90 % kleiner als SoC kleiner als 95 %. 0°C kleiner als Temperatur kleiner als 10 °C.
// Strom kleiner als -2,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_2", "STAT_HV_BATT_HIST_SOC6_T2_I1_WERT", STAT_HV_BATT_HIST_SOC6_T2_I1_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T2_I2_WERT = (RXBUF_UINT32(44)/10.0f);
// Duration at 90% less than SoC less than 95%. 0 ° C less than temperature less than 10 ° C. -2.5xC A less than
// current less than -2.0xC A / Dauer bei 90 % kleiner als SoC kleiner als 95 %. 0°C kleiner als Temperatur
// kleiner als 10 °C. -2,5xC A kleiner als Strom kleiner als -2,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_2", "STAT_HV_BATT_HIST_SOC6_T2_I2_WERT", STAT_HV_BATT_HIST_SOC6_T2_I2_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T2_I3_WERT = (RXBUF_UINT32(48)/10.0f);
// Duration at 90% less than SoC less than 95%. 0 ° C less than temperature less than 10 ° C. -2.0xC A less than
// current less than -1.5xC A / Dauer bei 90 % kleiner als SoC kleiner als 95 %. 0°C kleiner als Temperatur
// kleiner als 10 °C. -2,0xC A kleiner als Strom kleiner als -1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_2", "STAT_HV_BATT_HIST_SOC6_T2_I3_WERT", STAT_HV_BATT_HIST_SOC6_T2_I3_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T2_I4_WERT = (RXBUF_UINT32(52)/10.0f);
// Duration at 90% less than SoC less than 95%. 0 ° C less than temperature less than 10 ° C. -1.5xC A less than
// current less than -1.0xC A / Dauer bei 90 % kleiner als SoC kleiner als 95 %. 0°C kleiner als Temperatur
// kleiner als 10 °C. -1,5xC A kleiner als Strom kleiner als -1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_2", "STAT_HV_BATT_HIST_SOC6_T2_I4_WERT", STAT_HV_BATT_HIST_SOC6_T2_I4_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T2_I5_WERT = (RXBUF_UINT32(56)/10.0f);
// Duration at 90% less than SoC less than 95%. 0 ° C less than temperature less than 10 ° C. -1.0xC A less than
// current less than -0.5xC A / Dauer bei 90 % kleiner als SoC kleiner als 95 %. 0°C kleiner als Temperatur
// kleiner als 10 °C. -1,0xC A kleiner als Strom kleiner als -0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_2", "STAT_HV_BATT_HIST_SOC6_T2_I5_WERT", STAT_HV_BATT_HIST_SOC6_T2_I5_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T2_I6_WERT = (RXBUF_UINT32(60)/10.0f);
// Duration at 90% less than SoC less than 95%. 0 ° C less than temperature less than 10 ° C. -0.5xC A less than
// current less than 0.0xC A / Dauer bei 90 % kleiner als SoC kleiner als 95 %. 0°C kleiner als Temperatur
// kleiner als 10 °C. -0,5xC A kleiner als Strom kleiner als 0,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_2", "STAT_HV_BATT_HIST_SOC6_T2_I6_WERT", STAT_HV_BATT_HIST_SOC6_T2_I6_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T2_I7_WERT = (RXBUF_UINT32(64)/10.0f);
// Duration at 90% less than SoC less than 95%. 0 ° C less than temperature less than 10 ° C. 0.0xC A less than
// current less than 0.5xC A / Dauer bei 90 % kleiner als SoC kleiner als 95 %. 0°C kleiner als Temperatur
// kleiner als 10 °C. 0,0xC A kleiner als Strom kleiner als 0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_2", "STAT_HV_BATT_HIST_SOC6_T2_I7_WERT", STAT_HV_BATT_HIST_SOC6_T2_I7_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T2_I8_WERT = (RXBUF_UINT32(68)/10.0f);
// Duration at 90% less than SoC less than 95%. 0 ° C less than temperature less than 10 ° C. 0.5xC A less than
// current less than 1.0xC A / Dauer bei 90 % kleiner als SoC kleiner als 95 %. 0°C kleiner als Temperatur
// kleiner als 10 °C. 0,5xC A kleiner als Strom kleiner als 1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_2", "STAT_HV_BATT_HIST_SOC6_T2_I8_WERT", STAT_HV_BATT_HIST_SOC6_T2_I8_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T2_I9_WERT = (RXBUF_UINT32(72)/10.0f);
// Duration at 90% less than SoC less than 95%. 0 ° C less than temperature less than 10 ° C. 1.0xC A less than
// current less than 1.5xC A / Dauer bei 90 % kleiner als SoC kleiner als 95 %. 0°C kleiner als Temperatur
// kleiner als 10 °C. 1,0xC A kleiner als Strom kleiner als 1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_2", "STAT_HV_BATT_HIST_SOC6_T2_I9_WERT", STAT_HV_BATT_HIST_SOC6_T2_I9_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T2_I10_WERT = (RXBUF_UINT32(76)/10.0f);
// Duration at 90% less than SoC less than 95%. 0 ° C less than temperature less than 10 ° C. 1.5xC A less than
// current / Dauer bei 90 % kleiner als SoC kleiner als 95 %. 0°C kleiner als Temperatur kleiner als 10 °C.
// 1,5xC A kleiner als Strom
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_2", "STAT_HV_BATT_HIST_SOC6_T2_I10_WERT", STAT_HV_BATT_HIST_SOC6_T2_I10_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T2_I1_WERT = (RXBUF_UINT32(80)/10.0f);
// Duration at 95% smaller than SoC. 0 ° C less than temperature less than 10 ° C. Current less than -2.5xC A /
// Dauer bei 95 % kleiner als SoC. 0°C kleiner als Temperatur kleiner als 10 °C. Strom kleiner als -2,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_2", "STAT_HV_BATT_HIST_SOC7_T2_I1_WERT", STAT_HV_BATT_HIST_SOC7_T2_I1_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T2_I2_WERT = (RXBUF_UINT32(84)/10.0f);
// Duration at 95% smaller than SoC. 0 ° C less than temperature less than 10 ° C. -2.5xC A less than current
// less than -2.0xC A / Dauer bei 95 % kleiner als SoC. 0°C kleiner als Temperatur kleiner als 10 °C. -2,5xC A
// kleiner als Strom kleiner als -2,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_2", "STAT_HV_BATT_HIST_SOC7_T2_I2_WERT", STAT_HV_BATT_HIST_SOC7_T2_I2_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T2_I3_WERT = (RXBUF_UINT32(88)/10.0f);
// Duration at 95% smaller than SoC. 0 ° C less than temperature less than 10 ° C. -2.0xC A less than current
// less than -1.5xC A / Dauer bei 95 % kleiner als SoC. 0°C kleiner als Temperatur kleiner als 10 °C. -2,0xC A
// kleiner als Strom kleiner als -1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_2", "STAT_HV_BATT_HIST_SOC7_T2_I3_WERT", STAT_HV_BATT_HIST_SOC7_T2_I3_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T2_I4_WERT = (RXBUF_UINT32(92)/10.0f);
// Duration at 95% smaller than SoC. 0 ° C less than temperature less than 10 ° C. -1.5xC A less than current
// less than -1.0xC A / Dauer bei 95 % kleiner als SoC. 0°C kleiner als Temperatur kleiner als 10 °C. -1,5xC A
// kleiner als Strom kleiner als -1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_2", "STAT_HV_BATT_HIST_SOC7_T2_I4_WERT", STAT_HV_BATT_HIST_SOC7_T2_I4_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T2_I5_WERT = (RXBUF_UINT32(96)/10.0f);
// Duration at 95% smaller than SoC. 0 ° C less than temperature less than 10 ° C. -1.0xC A less than current
// less than -0.5xC A / Dauer bei 95 % kleiner als SoC. 0°C kleiner als Temperatur kleiner als 10 °C. -1,0xC A
// kleiner als Strom kleiner als -0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_2", "STAT_HV_BATT_HIST_SOC7_T2_I5_WERT", STAT_HV_BATT_HIST_SOC7_T2_I5_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T2_I6_WERT = (RXBUF_UINT32(100)/10.0f);
// Duration at 95% smaller than SoC. 0 ° C less than temperature less than 10 ° C. -0.5xC A less than current
// less than 0.0xC A / Dauer bei 95 % kleiner als SoC. 0°C kleiner als Temperatur kleiner als 10 °C. -0,5xC A
// kleiner als Strom kleiner als 0,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_2", "STAT_HV_BATT_HIST_SOC7_T2_I6_WERT", STAT_HV_BATT_HIST_SOC7_T2_I6_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T2_I7_WERT = (RXBUF_UINT32(104)/10.0f);
// Duration at 95% smaller than SoC. 0 ° C less than temperature less than 10 ° C. 0.0xC A less than current less
// than 0.5xC A / Dauer bei 95 % kleiner als SoC. 0°C kleiner als Temperatur kleiner als 10 °C. 0,0xC A kleiner
// als Strom kleiner als 0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_2", "STAT_HV_BATT_HIST_SOC7_T2_I7_WERT", STAT_HV_BATT_HIST_SOC7_T2_I7_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T2_I8_WERT = (RXBUF_UINT32(108)/10.0f);
// Duration at 95% smaller than SoC. 0 ° C less than temperature less than 10 ° C. 0.5xC A less than current less
// than 1.0xC A / Dauer bei 95 % kleiner als SoC. 0°C kleiner als Temperatur kleiner als 10 °C. 0,5xC A kleiner
// als Strom kleiner als 1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_2", "STAT_HV_BATT_HIST_SOC7_T2_I8_WERT", STAT_HV_BATT_HIST_SOC7_T2_I8_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T2_I9_WERT = (RXBUF_UINT32(112)/10.0f);
// Duration at 95% smaller than SoC. 0 ° C less than temperature less than 10 ° C. 1.0xC A less than current less
// than 1.5xC A / Dauer bei 95 % kleiner als SoC. 0°C kleiner als Temperatur kleiner als 10 °C. 1,0xC A kleiner
// als Strom kleiner als 1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_2", "STAT_HV_BATT_HIST_SOC7_T2_I9_WERT", STAT_HV_BATT_HIST_SOC7_T2_I9_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T2_I10_WERT = (RXBUF_UINT32(116)/10.0f);
// Duration at 95% smaller than SoC. 0 ° C less than temperature less than 10 ° C. 1.5xC A less than current /
// Dauer bei 95 % kleiner als SoC. 0°C kleiner als Temperatur kleiner als 10 °C. 1,5xC A kleiner als Strom
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T2_2", "STAT_HV_BATT_HIST_SOC7_T2_I10_WERT", STAT_HV_BATT_HIST_SOC7_T2_I10_WERT, "\"s\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_HV_BATT_HIST_SOC_T7_2: { // 0xDF6D
if (datalen < 120) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_HV_BATT_HIST_SOC_T7_2", 120);
break;
}
float STAT_HV_BATT_HIST_SOC5_T7_I1_WERT = (RXBUF_UINT32(0)/10.0f);
// Duration at 70% less than SoC less than 90%. 40 ° C less than temperature. Current less than -2.5xC A / Dauer
// bei 70% kleiner als SoC kleiner als 90%. 40°C kleiner als Temperatur. Strom kleiner als -2,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_2", "STAT_HV_BATT_HIST_SOC5_T7_I1_WERT", STAT_HV_BATT_HIST_SOC5_T7_I1_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T7_I2_WERT = (RXBUF_UINT32(4)/10.0f);
// Duration at 70% less than SoC less than 90%. 40 ° C less than temperature. -2.5xC A less than current less
// than -2.0xC A / Dauer bei 70% kleiner als SoC kleiner als 90%. 40°C kleiner als Temperatur. -2,5xC A kleiner
// als Strom kleiner als -2,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_2", "STAT_HV_BATT_HIST_SOC5_T7_I2_WERT", STAT_HV_BATT_HIST_SOC5_T7_I2_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T7_I3_WERT = (RXBUF_UINT32(8)/10.0f);
// Duration at 70% less than SoC less than 90%. 40 ° C less than temperature. -2.0xC A less than current less
// than -1.5xC A / Dauer bei 70% kleiner als SoC kleiner als 90%. 40°C kleiner als Temperatur. -2,0xC A kleiner
// als Strom kleiner als -1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_2", "STAT_HV_BATT_HIST_SOC5_T7_I3_WERT", STAT_HV_BATT_HIST_SOC5_T7_I3_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T7_I4_WERT = (RXBUF_UINT32(12)/10.0f);
// Duration at 70% less than SoC less than 90%. 40 ° C less than temperature. -1.5xC A less than current less
// than -1.0xC A / Dauer bei 70% kleiner als SoC kleiner als 90%. 40°C kleiner als Temperatur. -1,5xC A kleiner
// als Strom kleiner als -1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_2", "STAT_HV_BATT_HIST_SOC5_T7_I4_WERT", STAT_HV_BATT_HIST_SOC5_T7_I4_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T7_I5_WERT = (RXBUF_UINT32(16)/10.0f);
// Duration at 70% less than SoC less than 90%. 40 ° C less than temperature. -1.0xC A less than current less
// than -0.5xC A / Dauer bei 70% kleiner als SoC kleiner als 90%. 40°C kleiner als Temperatur. -1,0xC A kleiner
// als Strom kleiner als -0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_2", "STAT_HV_BATT_HIST_SOC5_T7_I5_WERT", STAT_HV_BATT_HIST_SOC5_T7_I5_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T7_I6_WERT = (RXBUF_UINT32(20)/10.0f);
// Duration at 70% less than SoC less than 90%. 40 ° C less than temperature. -0.5xC A less than current less
// than 0.0xC A / Dauer bei 70% kleiner als SoC kleiner als 90%. 40°C kleiner als Temperatur. -0,5xC A kleiner
// als Strom kleiner als 0,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_2", "STAT_HV_BATT_HIST_SOC5_T7_I6_WERT", STAT_HV_BATT_HIST_SOC5_T7_I6_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T7_I7_WERT = (RXBUF_UINT32(24)/10.0f);
// Duration at 70% less than SoC less than 90%. 40 ° C less than temperature. 0.0xC A less than current less than
// 0.5xC A / Dauer bei 70% kleiner als SoC kleiner als 90%. 40°C kleiner als Temperatur. 0,0xC A kleiner als
// Strom kleiner als 0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_2", "STAT_HV_BATT_HIST_SOC5_T7_I7_WERT", STAT_HV_BATT_HIST_SOC5_T7_I7_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T7_I8_WERT = (RXBUF_UINT32(28)/10.0f);
// Duration at 70% less than SoC less than 90%. 40 ° C less than temperature. 0.5xC A less than current less than
// 1.0xC A / Dauer bei 70% kleiner als SoC kleiner als 90%. 40°C kleiner als Temperatur. 0,5xC A kleiner als
// Strom kleiner als 1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_2", "STAT_HV_BATT_HIST_SOC5_T7_I8_WERT", STAT_HV_BATT_HIST_SOC5_T7_I8_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T7_I9_WERT = (RXBUF_UINT32(32)/10.0f);
// Duration at 70% less than SoC less than 90%. 40 ° C less than temperature. 1.0xC A less than current less than
// 1.5xC A / Dauer bei 70% kleiner als SoC kleiner als 90%. 40°C kleiner als Temperatur. 1,0xC A kleiner als
// Strom kleiner als 1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_2", "STAT_HV_BATT_HIST_SOC5_T7_I9_WERT", STAT_HV_BATT_HIST_SOC5_T7_I9_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T7_I10_WERT = (RXBUF_UINT32(36)/10.0f);
// Duration at 70% less than SoC less than 90%. 40 ° C less than temperature. 1.5xC A less than current / Dauer
// bei 70% kleiner als SoC kleiner als 90%. 40°C kleiner als Temperatur. 1,5xC A kleiner als Strom
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_2", "STAT_HV_BATT_HIST_SOC5_T7_I10_WERT", STAT_HV_BATT_HIST_SOC5_T7_I10_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T7_I1_WERT = (RXBUF_UINT32(40)/10.0f);
// Duration at 90% less than SoC less than 95%. 40 ° C less than temperature. Current less than -2.5xC A / Dauer
// bei 90% kleiner als SoC kleiner als 95%. 40°C kleiner als Temperatur. Strom kleiner als -2,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_2", "STAT_HV_BATT_HIST_SOC6_T7_I1_WERT", STAT_HV_BATT_HIST_SOC6_T7_I1_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T7_I2_WERT = (RXBUF_UINT32(44)/10.0f);
// Duration at 90% less than SoC less than 95%. 40 ° C less than temperature. -2.5xC A less than current less
// than -2.0xC A / Dauer bei 90% kleiner als SoC kleiner als 95%. 40°C kleiner als Temperatur. -2,5xC A kleiner
// als Strom kleiner als -2,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_2", "STAT_HV_BATT_HIST_SOC6_T7_I2_WERT", STAT_HV_BATT_HIST_SOC6_T7_I2_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T7_I3_WERT = (RXBUF_UINT32(48)/10.0f);
// Duration at 90% less than SoC less than 95%. 40 ° C less than temperature. -2.0xC A less than current less
// than -1.5xC A / Dauer bei 90% kleiner als SoC kleiner als 95%. 40°C kleiner als Temperatur. -2,0xC A kleiner
// als Strom kleiner als -1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_2", "STAT_HV_BATT_HIST_SOC6_T7_I3_WERT", STAT_HV_BATT_HIST_SOC6_T7_I3_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T7_I4_WERT = (RXBUF_UINT32(52)/10.0f);
// Duration at 90% less than SoC less than 95%. 40 ° C less than temperature. -1.5xC A less than current less
// than -1.0xC A / Dauer bei 90% kleiner als SoC kleiner als 95%. 40°C kleiner als Temperatur. -1,5xC A kleiner
// als Strom kleiner als -1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_2", "STAT_HV_BATT_HIST_SOC6_T7_I4_WERT", STAT_HV_BATT_HIST_SOC6_T7_I4_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T7_I5_WERT = (RXBUF_UINT32(56)/10.0f);
// Duration at 90% less than SoC less than 95%. 40 ° C less than temperature. -1.0xC A less than current less
// than -0.5xC A / Dauer bei 90% kleiner als SoC kleiner als 95%. 40°C kleiner als Temperatur. -1,0xC A kleiner
// als Strom kleiner als -0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_2", "STAT_HV_BATT_HIST_SOC6_T7_I5_WERT", STAT_HV_BATT_HIST_SOC6_T7_I5_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T7_I6_WERT = (RXBUF_UINT32(60)/10.0f);
// Duration at 90% less than SoC less than 95%. 40 ° C less than temperature. -0.5xC A less than current less
// than 0.0xC A / Dauer bei 90% kleiner als SoC kleiner als 95%. 40°C kleiner als Temperatur. -0,5xC A kleiner
// als Strom kleiner als 0,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_2", "STAT_HV_BATT_HIST_SOC6_T7_I6_WERT", STAT_HV_BATT_HIST_SOC6_T7_I6_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T7_I7_WERT = (RXBUF_UINT32(64)/10.0f);
// Duration at 90% less than SoC less than 95%. 40 ° C less than temperature. 0.0xC A less than current less than
// 0.5xC A / Dauer bei 90% kleiner als SoC kleiner als 95%. 40°C kleiner als Temperatur. 0,0xC A kleiner als
// Strom kleiner als 0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_2", "STAT_HV_BATT_HIST_SOC6_T7_I7_WERT", STAT_HV_BATT_HIST_SOC6_T7_I7_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T7_I8_WERT = (RXBUF_UINT32(68)/10.0f);
// Duration at 90% less than SoC less than 95%. 40 ° C less than temperature. 0.5xC A less than current less than
// 1.0xC A / Dauer bei 90% kleiner als SoC kleiner als 95%. 40°C kleiner als Temperatur. 0,5xC A kleiner als
// Strom kleiner als 1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_2", "STAT_HV_BATT_HIST_SOC6_T7_I8_WERT", STAT_HV_BATT_HIST_SOC6_T7_I8_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T7_I9_WERT = (RXBUF_UINT32(72)/10.0f);
// Duration at 90% less than SoC less than 95%. 40 ° C less than temperature. 1.0xC A less than current less than
// 1.5xC A / Dauer bei 90% kleiner als SoC kleiner als 95%. 40°C kleiner als Temperatur. 1,0xC A kleiner als
// Strom kleiner als 1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_2", "STAT_HV_BATT_HIST_SOC6_T7_I9_WERT", STAT_HV_BATT_HIST_SOC6_T7_I9_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T7_I10_WERT = (RXBUF_UINT32(76)/10.0f);
// Duration at 90% less than SoC less than 95%. 40 ° C less than temperature. 1.5xC A less than current / Dauer
// bei 90% kleiner als SoC kleiner als 95%. 40°C kleiner als Temperatur. 1,5xC A kleiner als Strom
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_2", "STAT_HV_BATT_HIST_SOC6_T7_I10_WERT", STAT_HV_BATT_HIST_SOC6_T7_I10_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T7_I1_WERT = (RXBUF_UINT32(80)/10.0f);
// Duration at 95% smaller than SoC. 40 ° C less than temperature. Current less than -2.5xC A / Dauer bei 95%
// kleiner als SoC. 40°C kleiner als Temperatur. Strom kleiner als -2,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_2", "STAT_HV_BATT_HIST_SOC7_T7_I1_WERT", STAT_HV_BATT_HIST_SOC7_T7_I1_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T7_I2_WERT = (RXBUF_UINT32(84)/10.0f);
// Duration at 95% smaller than SoC. 40 ° C less than temperature. -2.5xC A less than current less than -2.0xC A
// / Dauer bei 95% kleiner als SoC. 40°C kleiner als Temperatur. -2,5xC A kleiner als Strom kleiner als -2,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_2", "STAT_HV_BATT_HIST_SOC7_T7_I2_WERT", STAT_HV_BATT_HIST_SOC7_T7_I2_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T7_I3_WERT = (RXBUF_UINT32(88)/10.0f);
// Duration at 95% smaller than SoC. 40 ° C less than temperature. -2.0xC A less than current less than -1.5xC A
// / Dauer bei 95% kleiner als SoC. 40°C kleiner als Temperatur. -2,0xC A kleiner als Strom kleiner als -1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_2", "STAT_HV_BATT_HIST_SOC7_T7_I3_WERT", STAT_HV_BATT_HIST_SOC7_T7_I3_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T7_I4_WERT = (RXBUF_UINT32(92)/10.0f);
// Duration at 95% smaller than SoC. 40 ° C less than temperature. -1.5xC A less than current less than -1.0xC A
// / Dauer bei 95% kleiner als SoC. 40°C kleiner als Temperatur. -1,5xC A kleiner als Strom kleiner als -1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_2", "STAT_HV_BATT_HIST_SOC7_T7_I4_WERT", STAT_HV_BATT_HIST_SOC7_T7_I4_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T7_I5_WERT = (RXBUF_UINT32(96)/10.0f);
// Duration at 95% smaller than SoC. 40 ° C less than temperature. -1.0xC A less than current less than -0.5xC A
// / Dauer bei 95% kleiner als SoC. 40°C kleiner als Temperatur. -1,0xC A kleiner als Strom kleiner als -0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_2", "STAT_HV_BATT_HIST_SOC7_T7_I5_WERT", STAT_HV_BATT_HIST_SOC7_T7_I5_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T7_I6_WERT = (RXBUF_UINT32(100)/10.0f);
// Duration at 95% smaller than SoC. 40 ° C less than temperature. -0.5xC A less than current less than 0.0xC A /
// Dauer bei 95% kleiner als SoC. 40°C kleiner als Temperatur. -0,5xC A kleiner als Strom kleiner als 0,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_2", "STAT_HV_BATT_HIST_SOC7_T7_I6_WERT", STAT_HV_BATT_HIST_SOC7_T7_I6_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T7_I7_WERT = (RXBUF_UINT32(104)/10.0f);
// Duration at 95% smaller than SoC. 40 ° C less than temperature. 0.0xC A less than current less than 0.5xC A /
// Dauer bei 95% kleiner als SoC. 40°C kleiner als Temperatur. 0,0xC A kleiner als Strom kleiner als 0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_2", "STAT_HV_BATT_HIST_SOC7_T7_I7_WERT", STAT_HV_BATT_HIST_SOC7_T7_I7_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T7_I8_WERT = (RXBUF_UINT32(108)/10.0f);
// Duration at 95% smaller than SoC. 40 ° C less than temperature. 0.5xC A less than current less than 1.0xC A /
// Dauer bei 95% kleiner als SoC. 40°C kleiner als Temperatur. 0,5xC A kleiner als Strom kleiner als 1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_2", "STAT_HV_BATT_HIST_SOC7_T7_I8_WERT", STAT_HV_BATT_HIST_SOC7_T7_I8_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T7_I9_WERT = (RXBUF_UINT32(112)/10.0f);
// Duration at 95% smaller than SoC. 40 ° C less than temperature. 1.0xC A less than current less than 1.5xC A /
// Dauer bei 95% kleiner als SoC. 40°C kleiner als Temperatur. 1,0xC A kleiner als Strom kleiner als 1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_2", "STAT_HV_BATT_HIST_SOC7_T7_I9_WERT", STAT_HV_BATT_HIST_SOC7_T7_I9_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T7_I10_WERT = (RXBUF_UINT32(116)/10.0f);
// Duration at 95% smaller than SoC. 40 ° C less than temperature. 1.5xC A less than current / Dauer bei 95%
// kleiner als SoC. 40°C kleiner als Temperatur. 1,5xC A kleiner als Strom
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T7_2", "STAT_HV_BATT_HIST_SOC7_T7_I10_WERT", STAT_HV_BATT_HIST_SOC7_T7_I10_WERT, "\"s\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_HV_BATT_HIST_SOC_T6_2: { // 0xDF6E
if (datalen < 120) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_HV_BATT_HIST_SOC_T6_2", 120);
break;
}
float STAT_HV_BATT_HIST_SOC5_T6_I1_WERT = (RXBUF_UINT32(0)/10.0f);
// Duration at 70% less than SoC less than 90%. 32.5 ° C less than temperature less than 40 ° C. Current less
// than -2.5xC A / Dauer bei 70% kleiner als SoC kleiner als 90%. 32,5°C kleiner als Temperatur kleiner als 40°C.
// Strom kleiner als -2,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_2", "STAT_HV_BATT_HIST_SOC5_T6_I1_WERT", STAT_HV_BATT_HIST_SOC5_T6_I1_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T6_I2_WERT = (RXBUF_UINT32(4)/10.0f);
// Duration at 70% less than SoC less than 90%. 32.5 ° C less than temperature less than 40 ° C. -2.5xC A less
// than current less than -2.0xC A / Dauer bei 70% kleiner als SoC kleiner als 90%. 32,5°C kleiner als Temperatur
// kleiner als 40°C. -2,5xC A kleiner als Strom kleiner als -2,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_2", "STAT_HV_BATT_HIST_SOC5_T6_I2_WERT", STAT_HV_BATT_HIST_SOC5_T6_I2_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T6_I3_WERT = (RXBUF_UINT32(8)/10.0f);
// Duration at 70% less than SoC less than 90%. 32.5 ° C less than temperature less than 40 ° C. -2.0xC A less
// than current less than -1.5xC A / Dauer bei 70% kleiner als SoC kleiner als 90%. 32,5°C kleiner als Temperatur
// kleiner als 40°C. -2,0xC A kleiner als Strom kleiner als -1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_2", "STAT_HV_BATT_HIST_SOC5_T6_I3_WERT", STAT_HV_BATT_HIST_SOC5_T6_I3_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T6_I4_WERT = (RXBUF_UINT32(12)/10.0f);
// Duration at 70% less than SoC less than 90%. 32.5 ° C less than temperature less than 40 ° C. -1.5xC A less
// than current less than -1.0xC A / Dauer bei 70% kleiner als SoC kleiner als 90%. 32,5°C kleiner als Temperatur
// kleiner als 40°C. -1,5xC A kleiner als Strom kleiner als -1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_2", "STAT_HV_BATT_HIST_SOC5_T6_I4_WERT", STAT_HV_BATT_HIST_SOC5_T6_I4_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T6_I5_WERT = (RXBUF_UINT32(16)/10.0f);
// Duration at 70% less than SoC less than 90%. 32.5 ° C less than temperature less than 40 ° C. -1.0xC A less
// than current less than -0.5xC A / Dauer bei 70% kleiner als SoC kleiner als 90%. 32,5°C kleiner als Temperatur
// kleiner als 40°C. -1,0xC A kleiner als Strom kleiner als -0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_2", "STAT_HV_BATT_HIST_SOC5_T6_I5_WERT", STAT_HV_BATT_HIST_SOC5_T6_I5_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T6_I6_WERT = (RXBUF_UINT32(20)/10.0f);
// Duration at 70% less than SoC less than 90%. 32.5 ° C less than temperature less than 40 ° C. -0.5xC A less
// than current less than 0.0xC A / Dauer bei 70% kleiner als SoC kleiner als 90%. 32,5°C kleiner als Temperatur
// kleiner als 40°C. -0,5xC A kleiner als Strom kleiner als 0,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_2", "STAT_HV_BATT_HIST_SOC5_T6_I6_WERT", STAT_HV_BATT_HIST_SOC5_T6_I6_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T6_I7_WERT = (RXBUF_UINT32(24)/10.0f);
// Duration at 70% less than SoC less than 90%. 32.5 ° C less than temperature less than 40 ° C. 0.0xC A less
// than current less than 0.5xC A / Dauer bei 70% kleiner als SoC kleiner als 90%. 32,5°C kleiner als Temperatur
// kleiner als 40°C. 0,0xC A kleiner als Strom kleiner als 0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_2", "STAT_HV_BATT_HIST_SOC5_T6_I7_WERT", STAT_HV_BATT_HIST_SOC5_T6_I7_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T6_I8_WERT = (RXBUF_UINT32(28)/10.0f);
// Duration at 70% less than SoC less than 90%. 32.5 ° C less than temperature less than 40 ° C. 0.5xC A less
// than current less than 1.0xC A / Dauer bei 70% kleiner als SoC kleiner als 90%. 32,5°C kleiner als Temperatur
// kleiner als 40°C. 0,5xC A kleiner als Strom kleiner als 1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_2", "STAT_HV_BATT_HIST_SOC5_T6_I8_WERT", STAT_HV_BATT_HIST_SOC5_T6_I8_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T6_I9_WERT = (RXBUF_UINT32(32)/10.0f);
// Duration at 70% less than SoC less than 90%. 32.5 ° C less than temperature less than 40 ° C. 1.0xC A less
// than current less than 1.5xC A / Dauer bei 70% kleiner als SoC kleiner als 90%. 32,5°C kleiner als Temperatur
// kleiner als 40°C. 1,0xC A kleiner als Strom kleiner als 1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_2", "STAT_HV_BATT_HIST_SOC5_T6_I9_WERT", STAT_HV_BATT_HIST_SOC5_T6_I9_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC5_T6_I10_WERT = (RXBUF_UINT32(36)/10.0f);
// Duration at 70% less than SoC less than 90%. 32.5 ° C less than temperature less than 40 ° C. 1.5xC A less
// than current / Dauer bei 70% kleiner als SoC kleiner als 90%. 32,5°C kleiner als Temperatur kleiner als 40°C.
// 1,5xC A kleiner als Strom
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_2", "STAT_HV_BATT_HIST_SOC5_T6_I10_WERT", STAT_HV_BATT_HIST_SOC5_T6_I10_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T6_I1_WERT = (RXBUF_UINT32(40)/10.0f);
// Duration at 90% less than SoC less than 95%. 32.5 ° C less than temperature less than 40 ° C. Current less
// than -2.5xC A / Dauer bei 90% kleiner als SoC kleiner als 95%. 32,5°C kleiner als Temperatur kleiner als 40°C.
// Strom kleiner als -2,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_2", "STAT_HV_BATT_HIST_SOC6_T6_I1_WERT", STAT_HV_BATT_HIST_SOC6_T6_I1_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T6_I2_WERT = (RXBUF_UINT32(44)/10.0f);
// Duration at 90% less than SoC less than 95%. 32.5 ° C less than temperature less than 40 ° C. -2.5xC A less
// than current less than -2.0xC A / Dauer bei 90% kleiner als SoC kleiner als 95%. 32,5°C kleiner als Temperatur
// kleiner als 40°C. -2,5xC A kleiner als Strom kleiner als -2,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_2", "STAT_HV_BATT_HIST_SOC6_T6_I2_WERT", STAT_HV_BATT_HIST_SOC6_T6_I2_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T6_I3_WERT = (RXBUF_UINT32(48)/10.0f);
// Duration at 90% less than SoC less than 95%. 32.5 ° C less than temperature less than 40 ° C. -2.0xC A less
// than current less than -1.5xC A / Dauer bei 90% kleiner als SoC kleiner als 95%. 32,5°C kleiner als Temperatur
// kleiner als 40°C. -2,0xC A kleiner als Strom kleiner als -1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_2", "STAT_HV_BATT_HIST_SOC6_T6_I3_WERT", STAT_HV_BATT_HIST_SOC6_T6_I3_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T6_I4_WERT = (RXBUF_UINT32(52)/10.0f);
// Duration at 90% less than SoC less than 95%. 32.5 ° C less than temperature less than 40 ° C. -1.5xC A less
// than current less than -1.0xC A / Dauer bei 90% kleiner als SoC kleiner als 95%. 32,5°C kleiner als Temperatur
// kleiner als 40°C. -1,5xC A kleiner als Strom kleiner als -1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_2", "STAT_HV_BATT_HIST_SOC6_T6_I4_WERT", STAT_HV_BATT_HIST_SOC6_T6_I4_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T6_I5_WERT = (RXBUF_UINT32(56)/10.0f);
// Duration at 90% less than SoC less than 95%. 32.5 ° C less than temperature less than 40 ° C. -1.0xC A less
// than current less than -0.5xC A / Dauer bei 90% kleiner als SoC kleiner als 95%. 32,5°C kleiner als Temperatur
// kleiner als 40°C. -1,0xC A kleiner als Strom kleiner als -0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_2", "STAT_HV_BATT_HIST_SOC6_T6_I5_WERT", STAT_HV_BATT_HIST_SOC6_T6_I5_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T6_I6_WERT = (RXBUF_UINT32(60)/10.0f);
// Duration at 90% less than SoC less than 95%. 32.5 ° C less than temperature less than 40 ° C. -0.5xC A less
// than current less than 0.0xC A / Dauer bei 90% kleiner als SoC kleiner als 95%. 32,5°C kleiner als Temperatur
// kleiner als 40°C. -0,5xC A kleiner als Strom kleiner als 0,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_2", "STAT_HV_BATT_HIST_SOC6_T6_I6_WERT", STAT_HV_BATT_HIST_SOC6_T6_I6_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T6_I7_WERT = (RXBUF_UINT32(64)/10.0f);
// Duration at 90% less than SoC less than 95%. 32.5 ° C less than temperature less than 40 ° C. 0.0xC A less
// than current less than 0.5xC A / Dauer bei 90% kleiner als SoC kleiner als 95%. 32,5°C kleiner als Temperatur
// kleiner als 40°C. 0,0xC A kleiner als Strom kleiner als 0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_2", "STAT_HV_BATT_HIST_SOC6_T6_I7_WERT", STAT_HV_BATT_HIST_SOC6_T6_I7_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T6_I8_WERT = (RXBUF_UINT32(68)/10.0f);
// Duration at 90% less than SoC less than 95%. 32.5 ° C less than temperature less than 40 ° C. 0.5xC A less
// than current less than 1.0xC A / Dauer bei 90% kleiner als SoC kleiner als 95%. 32,5°C kleiner als Temperatur
// kleiner als 40°C. 0,5xC A kleiner als Strom kleiner als 1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_2", "STAT_HV_BATT_HIST_SOC6_T6_I8_WERT", STAT_HV_BATT_HIST_SOC6_T6_I8_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T6_I9_WERT = (RXBUF_UINT32(72)/10.0f);
// Duration at 90% less than SoC less than 95%. 32.5 ° C less than temperature less than 40 ° C. 1.0xC A less
// than current less than 1.5xC A / Dauer bei 90% kleiner als SoC kleiner als 95%. 32,5°C kleiner als Temperatur
// kleiner als 40°C. 1,0xC A kleiner als Strom kleiner als 1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_2", "STAT_HV_BATT_HIST_SOC6_T6_I9_WERT", STAT_HV_BATT_HIST_SOC6_T6_I9_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC6_T6_I10_WERT = (RXBUF_UINT32(76)/10.0f);
// Duration at 90% less than SoC less than 95%. 32.5 ° C less than temperature less than 40 ° C. 1.5xC A less
// than current / Dauer bei 90% kleiner als SoC kleiner als 95%. 32,5°C kleiner als Temperatur kleiner als 40°C.
// 1,5xC A kleiner als Strom
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_2", "STAT_HV_BATT_HIST_SOC6_T6_I10_WERT", STAT_HV_BATT_HIST_SOC6_T6_I10_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T6_I1_WERT = (RXBUF_UINT32(80)/10.0f);
// Duration at 95% smaller than SoC. 32.5 ° C less than temperature less than 40 ° C. Current less than -2.5xC A
// / Dauer bei 95% kleiner als SoC. 32,5°C kleiner als Temperatur kleiner als 40°C. Strom kleiner als -2,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_2", "STAT_HV_BATT_HIST_SOC7_T6_I1_WERT", STAT_HV_BATT_HIST_SOC7_T6_I1_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T6_I2_WERT = (RXBUF_UINT32(84)/10.0f);
// Duration at 95% smaller than SoC. 32.5 ° C less than temperature less than 40 ° C. -2.5xC A less than current
// less than -2.0xC A / Dauer bei 95% kleiner als SoC. 32,5°C kleiner als Temperatur kleiner als 40°C. -2,5xC A
// kleiner als Strom kleiner als -2,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_2", "STAT_HV_BATT_HIST_SOC7_T6_I2_WERT", STAT_HV_BATT_HIST_SOC7_T6_I2_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T6_I3_WERT = (RXBUF_UINT32(88)/10.0f);
// Duration at 95% smaller than SoC. 32.5 ° C less than temperature less than 40 ° C. -2.0xC A less than current
// less than -1.5xC A / Dauer bei 95% kleiner als SoC. 32,5°C kleiner als Temperatur kleiner als 40°C. -2,0xC A
// kleiner als Strom kleiner als -1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_2", "STAT_HV_BATT_HIST_SOC7_T6_I3_WERT", STAT_HV_BATT_HIST_SOC7_T6_I3_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T6_I4_WERT = (RXBUF_UINT32(92)/10.0f);
// Duration at 95% smaller than SoC. 32.5 ° C less than temperature less than 40 ° C. -1.5xC A less than current
// less than -1.0xC A / Dauer bei 95% kleiner als SoC. 32,5°C kleiner als Temperatur kleiner als 40°C. -1,5xC A
// kleiner als Strom kleiner als -1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_2", "STAT_HV_BATT_HIST_SOC7_T6_I4_WERT", STAT_HV_BATT_HIST_SOC7_T6_I4_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T6_I5_WERT = (RXBUF_UINT32(96)/10.0f);
// Duration at 95% smaller than SoC. 32.5 ° C less than temperature less than 40 ° C. -1.0xC A less than current
// less than -0.5xC A / Dauer bei 95% kleiner als SoC. 32,5°C kleiner als Temperatur kleiner als 40°C. -1,0xC A
// kleiner als Strom kleiner als -0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_2", "STAT_HV_BATT_HIST_SOC7_T6_I5_WERT", STAT_HV_BATT_HIST_SOC7_T6_I5_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T6_I6_WERT = (RXBUF_UINT32(100)/10.0f);
// Duration at 95% smaller than SoC. 32.5 ° C less than temperature less than 40 ° C. -0.5xC A less than current
// less than 0.0xC A / Dauer bei 95% kleiner als SoC. 32,5°C kleiner als Temperatur kleiner als 40°C. -0,5xC A
// kleiner als Strom kleiner als 0,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_2", "STAT_HV_BATT_HIST_SOC7_T6_I6_WERT", STAT_HV_BATT_HIST_SOC7_T6_I6_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T6_I7_WERT = (RXBUF_UINT32(104)/10.0f);
// Duration at 95% smaller than SoC. 32.5 ° C less than temperature less than 40 ° C. 0.0xC A less than current
// less than 0.5xC A / Dauer bei 95% kleiner als SoC. 32,5°C kleiner als Temperatur kleiner als 40°C. 0,0xC A
// kleiner als Strom kleiner als 0,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_2", "STAT_HV_BATT_HIST_SOC7_T6_I7_WERT", STAT_HV_BATT_HIST_SOC7_T6_I7_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T6_I8_WERT = (RXBUF_UINT32(108)/10.0f);
// Duration at 95% smaller than SoC. 32.5 ° C less than temperature less than 40 ° C. 0.5xC A less than current
// less than 1.0xC A / Dauer bei 95% kleiner als SoC. 32,5°C kleiner als Temperatur kleiner als 40°C. 0,5xC A
// kleiner als Strom kleiner als 1,0xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_2", "STAT_HV_BATT_HIST_SOC7_T6_I8_WERT", STAT_HV_BATT_HIST_SOC7_T6_I8_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T6_I9_WERT = (RXBUF_UINT32(112)/10.0f);
// Duration at 95% smaller than SoC. 32.5 ° C less than temperature less than 40 ° C. 1.0xC A less than current
// less than 1.5xC A / Dauer bei 95% kleiner als SoC. 32,5°C kleiner als Temperatur kleiner als 40°C. 1,0xC A
// kleiner als Strom kleiner als 1,5xC A
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_2", "STAT_HV_BATT_HIST_SOC7_T6_I9_WERT", STAT_HV_BATT_HIST_SOC7_T6_I9_WERT, "\"s\"");
float STAT_HV_BATT_HIST_SOC7_T6_I10_WERT = (RXBUF_UINT32(116)/10.0f);
// Duration at 95% smaller than SoC. 32.5 ° C less than temperature less than 40 ° C. 1.5xC A less than current /
// Dauer bei 95% kleiner als SoC. 32,5°C kleiner als Temperatur kleiner als 40°C. 1,5xC A kleiner als Strom
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HV_BATT_HIST_SOC_T6_2", "STAT_HV_BATT_HIST_SOC7_T6_I10_WERT", STAT_HV_BATT_HIST_SOC7_T6_I10_WERT, "\"s\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_HIS_ERR_LIM_STROM: { // 0xDF6F
if (datalen < 24) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_HIS_ERR_LIM_STROM", 24);
break;
}
float STAT_CHA_CURR_ERR_INT_LIM_WERT = (RXBUF_UINT32(0)/100.0f);
// Threshold value of the error integral of the current when loading [IerrIntLim_cha] / Schwellwert des
// Fehlerintegrals des Stroms beim Laden [IerrIntLim_cha]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HIS_ERR_LIM_STROM", "STAT_CHA_CURR_ERR_INT_LIM_WERT", STAT_CHA_CURR_ERR_INT_LIM_WERT, "\"As\"");
float STAT_DCH_CURR_ERR_INT_LIM_WERT = (RXBUF_UINT32(4)/100.0f);
// Threshold of the error integral of the current when discharging [IerrIntLim_dch] / Schwellwert des
// Fehlerintegrals des Stroms beim Entladen [IerrIntLim_dch]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HIS_ERR_LIM_STROM", "STAT_DCH_CURR_ERR_INT_LIM_WERT", STAT_DCH_CURR_ERR_INT_LIM_WERT, "\"As\"");
unsigned long STAT_HIS_CHG_ERR_LIM_STROM_1_WERT = (RXBUF_UINT32(8));
// Duration in minutes when loading in the class: 0 <= IerrInt_cha <IerrIntLim_cha / Dauer in Minuten beim Laden
// in der Klasse: 0 <= IerrInt_cha < IerrIntLim_cha
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_ERR_LIM_STROM", "STAT_HIS_CHG_ERR_LIM_STROM_1_WERT", STAT_HIS_CHG_ERR_LIM_STROM_1_WERT, "\"min\"");
unsigned long STAT_HIS_CHG_ERR_LIM_STROM_2_WERT = (RXBUF_UINT32(12));
// Duration in minutes when loading in the class: IerrInt_cha> IerrIntLim_cha / Dauer in Minuten beim Laden in
// der Klasse: IerrInt_cha > IerrIntLim_cha
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_ERR_LIM_STROM", "STAT_HIS_CHG_ERR_LIM_STROM_2_WERT", STAT_HIS_CHG_ERR_LIM_STROM_2_WERT, "\"min\"");
unsigned long STAT_HIS_DCH_ERR_LIM_STROM_1_WERT = (RXBUF_UINT32(16));
// Duration in minutes when unloading in the class: 0 <= IerrInt_dch <IerrIntLim_dch / Dauer in Minuten beim
// Entladen in der Klasse: 0 <= IerrInt_dch < IerrIntLim_dch
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_ERR_LIM_STROM", "STAT_HIS_DCH_ERR_LIM_STROM_1_WERT", STAT_HIS_DCH_ERR_LIM_STROM_1_WERT, "\"min\"");
unsigned long STAT_HIS_DCH_ERR_LIM_STROM_2_WERT = (RXBUF_UINT32(20));
// Duration in minutes when unloading in the class: IerrInt_dch> IerrIntLim_dch / Dauer in Minuten beim Entladen
// in der Klasse: IerrInt_dch > IerrIntLim_dch
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_ERR_LIM_STROM", "STAT_HIS_DCH_ERR_LIM_STROM_2_WERT", STAT_HIS_DCH_ERR_LIM_STROM_2_WERT, "\"min\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_HIS_EFF_STROM: { // 0xDF70
if (datalen < 48) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_HIS_EFF_STROM", 48);
break;
}
float STAT_CHA_EFF_CURR_LIM_100_PERC_WERT = (RXBUF_UINT32(0)/100.0f);
// RMS value of the current limit when loading to 100% life [Irms_cha (% 100)] / Effektivwert der Stromgrenze
// beim Laden auf 100% Leben [Irms_cha(%100)]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HIS_EFF_STROM", "STAT_CHA_EFF_CURR_LIM_100_PERC_WERT", STAT_CHA_EFF_CURR_LIM_100_PERC_WERT, "\"A\"");
float STAT_CHA_EFF_CURR_LIM_3_PERC_WERT = (RXBUF_UINT32(4)/100.0f);
// Effective value of the current limit when loading to 3% life [Irms_cha (% 3)] / Effektivwert der Stromgrenze
// beim Laden auf 3% Leben [Irms_cha(%3)]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HIS_EFF_STROM", "STAT_CHA_EFF_CURR_LIM_3_PERC_WERT", STAT_CHA_EFF_CURR_LIM_3_PERC_WERT, "\"A\"");
float STAT_ABS_EFF_CURR_LIM_100_PERC_WERT = (RXBUF_UINT32(8)/100.0f);
// RMS value of the current limit when charging and discharging (absolute) to 100% life [Irms_abs (% 100)] /
// Effektivwert der Stromgrenze beim Laden und Entladen (Absolut) auf 100% Leben [Irms_abs(%100)]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HIS_EFF_STROM", "STAT_ABS_EFF_CURR_LIM_100_PERC_WERT", STAT_ABS_EFF_CURR_LIM_100_PERC_WERT, "\"A\"");
float STAT_ABS_EFF_CURR_LIM_3_PERC_WERT = (RXBUF_UINT32(12)/100.0f);
// Effective value of the current limit when charging and discharging (absolute) to 3% life [Irms_cha (% 3)] /
// Effektivwert der Stromgrenze beim Laden und Entladen (Absolut) auf 3% Leben [Irms_cha(%3)]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HIS_EFF_STROM", "STAT_ABS_EFF_CURR_LIM_3_PERC_WERT", STAT_ABS_EFF_CURR_LIM_3_PERC_WERT, "\"A\"");
unsigned long STAT_HIS_EFF_CURR_CHG_1_WERT = (RXBUF_UINT32(16));
// Duration in minutes of the effective value of the current when charging in the class: 0 <= Irms <0.7 *
// Irms_cha (% 100) / Dauer in Minuten des Effektivwerts des Stroms beim Laden in der Klasse: 0 <= Irms < 0,7 *
// Irms_cha(%100)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM", "STAT_HIS_EFF_CURR_CHG_1_WERT", STAT_HIS_EFF_CURR_CHG_1_WERT, "\"min\"");
unsigned long STAT_HIS_EFF_CURR_CHG_2_WERT = (RXBUF_UINT32(20));
// Duration in minutes of the effective value of the current when charging in the class: 0.7 * Irms_cha (% 100)
// <= Irms <Irms_cha (% 100) / Dauer in Minuten des Effektivwerts des Stroms beim Laden in der Klasse: 0,7 *
// Irms_cha(%100) <= Irms < Irms_cha(%100)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM", "STAT_HIS_EFF_CURR_CHG_2_WERT", STAT_HIS_EFF_CURR_CHG_2_WERT, "\"min\"");
unsigned long STAT_HIS_EFF_CURR_CHG_3_WERT = (RXBUF_UINT32(24));
// Duration in minutes of the effective value of the current when charging in the class: Irms_cha (% 100) <= Irms
// <Irms_cha (% 3) / Dauer in Minuten des Effektivwerts des Stroms beim Laden in der Klasse: Irms_cha(%100) <=
// Irms < Irms_cha(%3)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM", "STAT_HIS_EFF_CURR_CHG_3_WERT", STAT_HIS_EFF_CURR_CHG_3_WERT, "\"min\"");
unsigned long STAT_HIS_EFF_CURR_CHG_4_WERT = (RXBUF_UINT32(28));
// Duration in minutes of the rms value of the current when charging in the class: Irms_cha (% 3) <Irms / Dauer
// in Minuten des Effektivwerts des Stroms beim Laden in der Klasse: Irms_cha(%3) < Irms
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM", "STAT_HIS_EFF_CURR_CHG_4_WERT", STAT_HIS_EFF_CURR_CHG_4_WERT, "\"min\"");
unsigned long STAT_HIS_EFF_CURR_ABS_1_WERT = (RXBUF_UINT32(32));
// Duration in minutes of the effective value of the current when charging and discharging in the class: 0 <=
// Irms <0.7 * Irms_abs (% 100) / Dauer in Minuten des Effektivwerts des Stroms beim Laden und Entladen in der
// Klasse: 0 <= Irms < 0,7 * Irms_abs(%100)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM", "STAT_HIS_EFF_CURR_ABS_1_WERT", STAT_HIS_EFF_CURR_ABS_1_WERT, "\"min\"");
unsigned long STAT_HIS_EFF_CURR_ABS_2_WERT = (RXBUF_UINT32(36));
// Duration in minutes of the effective value of the current when charging and discharging in the class: 0.7 *
// Irms_abs (% 100) <= Irms <Irms_abs (% 100) / Dauer in Minuten des Effektivwerts des Stroms beim Laden und
// Entladen in der Klasse: 0,7 * Irms_abs(%100) <= Irms < Irms_abs(%100)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM", "STAT_HIS_EFF_CURR_ABS_2_WERT", STAT_HIS_EFF_CURR_ABS_2_WERT, "\"min\"");
unsigned long STAT_HIS_EFF_CURR_ABS_3_WERT = (RXBUF_UINT32(40));
// Duration in minutes of the effective value of the current when charging and discharging in the class: Irms_abs
// (% 100) <= Irms <Irms_abs (% 3) / Dauer in Minuten des Effektivwerts des Stroms beim Laden und Entladen in der
// Klasse: Irms_abs(%100) <= Irms < Irms_abs(%3)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM", "STAT_HIS_EFF_CURR_ABS_3_WERT", STAT_HIS_EFF_CURR_ABS_3_WERT, "\"min\"");
unsigned long STAT_HIS_EFF_CURR_ABS_4_WERT = (RXBUF_UINT32(44));
// Duration in minutes of the rms value of the current during charging and discharging in the class: Irms_abs (%
// 3) <Irms / Dauer in Minuten des Effektivwerts des Stroms beim Laden und Entladen in der Klasse: Irms_abs(%3) <
// Irms
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM", "STAT_HIS_EFF_CURR_ABS_4_WERT", STAT_HIS_EFF_CURR_ABS_4_WERT, "\"min\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_PROJEKT_PARAMETER: { // 0xDF71
if (datalen < 5) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_PROJEKT_PARAMETER", 5);
break;
}
unsigned short STAT_ANZAHL_ZELLEN_INSGESAMT_WERT = (RXBUF_UINT(0));
// Number of cells in the HV storage system / Anzahl der Zellen des HV-Speichers
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "PROJEKT_PARAMETER", "STAT_ANZAHL_ZELLEN_INSGESAMT_WERT", STAT_ANZAHL_ZELLEN_INSGESAMT_WERT, "");
unsigned char STAT_ANZAHL_ZELLEN_PRO_MODUL_WERT = (RXBUF_UCHAR(2));
// Number of cells per module / Anzahl der Zellen pro Modul
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "PROJEKT_PARAMETER", "STAT_ANZAHL_ZELLEN_PRO_MODUL_WERT", STAT_ANZAHL_ZELLEN_PRO_MODUL_WERT, "");
unsigned char STAT_ANZAHL_MODULE_WERT = (RXBUF_UCHAR(3));
// Number of modules in the HV storage system / Anzahl der Module des HV-Speichers
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "PROJEKT_PARAMETER", "STAT_ANZAHL_MODULE_WERT", STAT_ANZAHL_MODULE_WERT, "");
unsigned char STAT_ANZAHL_TEMPERATURSENSOREN_PRO_MODUL_WERT = (RXBUF_UCHAR(4));
// Number of temperature sensors per module / Anzahl der Temperatursensoren pro Modul
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "PROJEKT_PARAMETER", "STAT_ANZAHL_TEMPERATURSENSOREN_PRO_MODUL_WERT", STAT_ANZAHL_TEMPERATURSENSOREN_PRO_MODUL_WERT, "");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_KURZSCHLUESSE: { // 0xDF72
if (datalen < 1) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_KURZSCHLUESSE", 1);
break;
}
unsigned char STAT_ANZAHL_KURZSCHLUESSE_WERT = (RXBUF_UCHAR(0));
// Number of short circuits that occurred / Anzahl der vorgekommenen Kurschlüsse
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "KURZSCHLUESSE", "STAT_ANZAHL_KURZSCHLUESSE_WERT", STAT_ANZAHL_KURZSCHLUESSE_WERT, "");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_HEIZUNG_VERBAUT: { // 0xDF73
if (datalen < 1) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_HEIZUNG_VERBAUT", 1);
break;
}
unsigned char STAT_HEIZUNG_VERBAUT = (RXBUF_UCHAR(0));
// Status heating installed (0 = no / 1 = yes) / Status Heizung verbaut (0=nein/ 1=ja)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "HEIZUNG_VERBAUT", "STAT_HEIZUNG_VERBAUT", STAT_HEIZUNG_VERBAUT, "\"0/1\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_VOKO_HEIZ_DAUER: { // 0xDF74
if (datalen < 25) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_VOKO_HEIZ_DAUER", 25);
break;
}
unsigned char STAT_VOKO_HEIZ_DAUER_MAX_WERT = (RXBUF_UCHAR(0));
// Predefined maximum preconditioning heating time in minutes (project-specific) / Vordefinierte maximale
// Vorkonditionierungs-Heizdauer in Minuten (projektspezifisch)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "VOKO_HEIZ_DAUER", "STAT_VOKO_HEIZ_DAUER_MAX_WERT", STAT_VOKO_HEIZ_DAUER_MAX_WERT, "\"min\"");
unsigned long STAT_VOKO_HEIZ_DAUER_1_WERT = (RXBUF_UINT32(1));
// Number of duration classes: 0 <t <= tmax * 0.1 / Anzahl der Dauerklasse: 0 < t <= tmax*0.1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "VOKO_HEIZ_DAUER", "STAT_VOKO_HEIZ_DAUER_1_WERT", STAT_VOKO_HEIZ_DAUER_1_WERT, "");
unsigned long STAT_VOKO_HEIZ_DAUER_2_WERT = (RXBUF_UINT32(5));
// Number of duration classes: tmax * 0.1 <t <= tmax * 0.2 / Anzahl der Dauerklasse: tmax*0.1 < t <= tmax*0.2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "VOKO_HEIZ_DAUER", "STAT_VOKO_HEIZ_DAUER_2_WERT", STAT_VOKO_HEIZ_DAUER_2_WERT, "");
unsigned long STAT_VOKO_HEIZ_DAUER_3_WERT = (RXBUF_UINT32(9));
// Number of duration classes: tmax * 0.2 <t <= tmax * 0.3 / Anzahl der Dauerklasse: tmax*0.2 < t <= tmax*0.3
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "VOKO_HEIZ_DAUER", "STAT_VOKO_HEIZ_DAUER_3_WERT", STAT_VOKO_HEIZ_DAUER_3_WERT, "");
unsigned long STAT_VOKO_HEIZ_DAUER_4_WERT = (RXBUF_UINT32(13));
// Number of duration classes: tmax * 0.3 <t <= tmax * 0.4 / Anzahl der Dauerklasse: tmax*0.3 < t <= tmax*0.4
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "VOKO_HEIZ_DAUER", "STAT_VOKO_HEIZ_DAUER_4_WERT", STAT_VOKO_HEIZ_DAUER_4_WERT, "");
unsigned long STAT_VOKO_HEIZ_DAUER_5_WERT = (RXBUF_UINT32(17));
// Number of duration classes: tmax * 0.4 <t <= tmax * 0.6 / Anzahl der Dauerklasse: tmax*0.4 < t <= tmax*0.6
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "VOKO_HEIZ_DAUER", "STAT_VOKO_HEIZ_DAUER_5_WERT", STAT_VOKO_HEIZ_DAUER_5_WERT, "");
unsigned long STAT_VOKO_HEIZ_DAUER_6_WERT = (RXBUF_UINT32(21));
// Number of duration classes: t> tmax * 0.6 / Anzahl der Dauerklasse: t > tmax*0.6
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "VOKO_HEIZ_DAUER", "STAT_VOKO_HEIZ_DAUER_6_WERT", STAT_VOKO_HEIZ_DAUER_6_WERT, "");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_LADE_KOND_HEIZ_DAUER: { // 0xDF75
if (datalen < 16) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_LADE_KOND_HEIZ_DAUER", 16);
break;
}
unsigned long STAT_LADE_KOND_HEIZ_DAUER_MAX_WERT = (RXBUF_UINT32(0));
// Predefined maximum charge conditioning cooling time in minutes (project-specific) / Vordefinierte maximale
// Ladekonditionierungs-Kuehldauer in Minuten (projektspezifisch)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "LADE_KOND_HEIZ_DAUER", "STAT_LADE_KOND_HEIZ_DAUER_MAX_WERT", STAT_LADE_KOND_HEIZ_DAUER_MAX_WERT, "\"min\"");
unsigned short STAT_LADE_KOND_HEIZ_DAUER_1_WERT = (RXBUF_UINT(4));
// Number of duration classes: 0 <t <= tmax * 0.1 / Anzahl der Dauerklasse: 0 < t <= tmax*0.1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "LADE_KOND_HEIZ_DAUER", "STAT_LADE_KOND_HEIZ_DAUER_1_WERT", STAT_LADE_KOND_HEIZ_DAUER_1_WERT, "");
unsigned short STAT_LADE_KOND_HEIZ_DAUER_2_WERT = (RXBUF_UINT(6));
// Number of duration classes: tmax * 0.1 <t <= tmax * 0.2 / Anzahl der Dauerklasse: tmax*0.1 < t <= tmax*0.2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "LADE_KOND_HEIZ_DAUER", "STAT_LADE_KOND_HEIZ_DAUER_2_WERT", STAT_LADE_KOND_HEIZ_DAUER_2_WERT, "");
unsigned short STAT_LADE_KOND_HEIZ_DAUER_3_WERT = (RXBUF_UINT(8));
// Number of duration classes: tmax * 0.2 <t <= tmax * 0.3 / Anzahl der Dauerklasse: tmax*0.2 < t <= tmax*0.3
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "LADE_KOND_HEIZ_DAUER", "STAT_LADE_KOND_HEIZ_DAUER_3_WERT", STAT_LADE_KOND_HEIZ_DAUER_3_WERT, "");
unsigned short STAT_LADE_KOND_HEIZ_DAUER_4_WERT = (RXBUF_UINT(10));
// Number of duration classes: tmax * 0.3 <t <= tmax * 0.4 / Anzahl der Dauerklasse: tmax*0.3 < t <= tmax*0.4
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "LADE_KOND_HEIZ_DAUER", "STAT_LADE_KOND_HEIZ_DAUER_4_WERT", STAT_LADE_KOND_HEIZ_DAUER_4_WERT, "");
unsigned short STAT_LADE_KOND_HEIZ_DAUER_5_WERT = (RXBUF_UINT(12));
// Number of duration classes: tmax * 0.4 <t <= tmax * 0.6 / Anzahl der Dauerklasse: tmax*0.4 < t <= tmax*0.6
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "LADE_KOND_HEIZ_DAUER", "STAT_LADE_KOND_HEIZ_DAUER_5_WERT", STAT_LADE_KOND_HEIZ_DAUER_5_WERT, "");
unsigned short STAT_LADE_KOND_HEIZ_DAUER_6_WERT = (RXBUF_UINT(14));
// Number of duration classes: t> tmax * 0.6 / Anzahl der Dauerklasse: t > tmax*0.6
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "LADE_KOND_HEIZ_DAUER", "STAT_LADE_KOND_HEIZ_DAUER_6_WERT", STAT_LADE_KOND_HEIZ_DAUER_6_WERT, "");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_VOKO_KUEHL_DAUER: { // 0xDF76
if (datalen < 25) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_VOKO_KUEHL_DAUER", 25);
break;
}
unsigned char STAT_VOKO_KUEHL_DAUER_MAX_WERT = (RXBUF_UCHAR(0));
// Predefined maximum pre-conditioning cooling time in minutes (project-specific) / Vordefinierte maximale
// Vorkonditionierungs-Kuehldauer in Minuten (projektspezifisch)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "VOKO_KUEHL_DAUER", "STAT_VOKO_KUEHL_DAUER_MAX_WERT", STAT_VOKO_KUEHL_DAUER_MAX_WERT, "\"min\"");
unsigned long STAT_VOKO_KUEHL_DAUER_1_WERT = (RXBUF_UINT32(1));
// Number of duration classes: 0 <t <= tmax * 0.1 / Anzahl der Dauerklasse: 0 < t <= tmax*0.1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "VOKO_KUEHL_DAUER", "STAT_VOKO_KUEHL_DAUER_1_WERT", STAT_VOKO_KUEHL_DAUER_1_WERT, "");
unsigned long STAT_VOKO_KUEHL_DAUER_2_WERT = (RXBUF_UINT32(5));
// Number of duration classes: tmax * 0.1 <t <= tmax * 0.2 / Anzahl der Dauerklasse: tmax*0.1 < t <= tmax*0.2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "VOKO_KUEHL_DAUER", "STAT_VOKO_KUEHL_DAUER_2_WERT", STAT_VOKO_KUEHL_DAUER_2_WERT, "");
unsigned long STAT_VOKO_KUEHL_DAUER_3_WERT = (RXBUF_UINT32(9));
// Number of duration classes: tmax * 0.2 <t <= tmax * 0.3 / Anzahl der Dauerklasse: tmax*0.2 < t <= tmax*0.3
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "VOKO_KUEHL_DAUER", "STAT_VOKO_KUEHL_DAUER_3_WERT", STAT_VOKO_KUEHL_DAUER_3_WERT, "");
unsigned long STAT_VOKO_KUEHL_DAUER_4_WERT = (RXBUF_UINT32(13));
// Number of duration classes: tmax * 0.3 <t <= tmax * 0.4 / Anzahl der Dauerklasse: tmax*0.3 < t <= tmax*0.4
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "VOKO_KUEHL_DAUER", "STAT_VOKO_KUEHL_DAUER_4_WERT", STAT_VOKO_KUEHL_DAUER_4_WERT, "");
unsigned long STAT_VOKO_KUEHL_DAUER_5_WERT = (RXBUF_UINT32(17));
// Number of duration classes: tmax * 0.4 <t <= tmax * 0.6 / Anzahl der Dauerklasse: tmax*0.4 < t <= tmax*0.6
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "VOKO_KUEHL_DAUER", "STAT_VOKO_KUEHL_DAUER_5_WERT", STAT_VOKO_KUEHL_DAUER_5_WERT, "");
unsigned long STAT_VOKO_KUEHL_DAUER_6_WERT = (RXBUF_UINT32(21));
// Number of duration classes: t> tmax * 0.6 / Anzahl der Dauerklasse: t > tmax*0.6
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "VOKO_KUEHL_DAUER", "STAT_VOKO_KUEHL_DAUER_6_WERT", STAT_VOKO_KUEHL_DAUER_6_WERT, "");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_LADE_DAUER: { // 0xDF77
if (datalen < 13) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_LADE_DAUER", 13);
break;
}
unsigned char STAT_LADE_DAUER_MAX_WERT = (RXBUF_UCHAR(0));
// Predefined maximum charging time in hours (project-specific) / Vordefinierte maximale Ladezeit in Stunden
// (projektspezifisch)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADE_DAUER", "STAT_LADE_DAUER_MAX_WERT", STAT_LADE_DAUER_MAX_WERT, "\"h\"");
unsigned short STAT_LADEDAUER_1_WERT = (RXBUF_UINT(1));
// Number of charging duration classes: 0 <t <= tmax * 0.05 / Anzahl der Ladedauerklasse: 0 < t <= tmax*0.05
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "LADE_DAUER", "STAT_LADEDAUER_1_WERT", STAT_LADEDAUER_1_WERT, "");
unsigned short STAT_LADEDAUER_2_WERT = (RXBUF_UINT(3));
// Number of charging duration classes: tmax * 0.05 <t <= tmax * 0.1 / Anzahl der Ladedauerklasse: tmax*0.05 < t
// <= tmax*0.1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "LADE_DAUER", "STAT_LADEDAUER_2_WERT", STAT_LADEDAUER_2_WERT, "");
unsigned short STAT_LADEDAUER_3_WERT = (RXBUF_UINT(5));
// Number of charging duration classes: tmax * 0.1 <t <= tmax * 0.35 / Anzahl der Ladedauerklasse: tmax*0.1 < t
// <= tmax*0.35
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "LADE_DAUER", "STAT_LADEDAUER_3_WERT", STAT_LADEDAUER_3_WERT, "");
unsigned short STAT_LADEDAUER_4_WERT = (RXBUF_UINT(7));
// Number of charging duration classes: tmax * 0.35 <t <= tmax * 0.5 / Anzahl der Ladedauerklasse: tmax*0.35 < t
// <= tmax*0.5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "LADE_DAUER", "STAT_LADEDAUER_4_WERT", STAT_LADEDAUER_4_WERT, "");
unsigned short STAT_LADEDAUER_5_WERT = (RXBUF_UINT(9));
// Number of charging duration classes: tmax * 0.5 <t <= tmax / Anzahl der Ladedauerklasse: tmax*0.5 < t <= tmax
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "LADE_DAUER", "STAT_LADEDAUER_5_WERT", STAT_LADEDAUER_5_WERT, "");
unsigned short STAT_LADEDAUER_6_WERT = (RXBUF_UINT(11));
// Number of charging duration classes: t> tmax / Anzahl der Ladedauerklasse: t > tmax
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "LADE_DAUER", "STAT_LADEDAUER_6_WERT", STAT_LADEDAUER_6_WERT, "");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_HIS_SOC_WARN_GRENZEN: { // 0xDF81
if (datalen < 28) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_HIS_SOC_WARN_GRENZEN", 28);
break;
}
float STAT_SOC_LOW_I_ZERO_WERT = (RXBUF_SINT(0)/100.0f);
// Predefined lower SOC warning limit-1 (project-specific) / Vordefinierte untere SOC-Warngrenze-1
// (projektspezifisch)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HIS_SOC_WARN_GRENZEN", "STAT_SOC_LOW_I_ZERO_WERT", STAT_SOC_LOW_I_ZERO_WERT, "\"%\"");
float STAT_SOC_LOW_WARN_WERT = (RXBUF_SINT(2)/100.0f);
// Predefined lower SOC warning limit-2 (project-specific) / Vordefinierte untere SOC-Warngrenze-2
// (projektspezifisch)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HIS_SOC_WARN_GRENZEN", "STAT_SOC_LOW_WARN_WERT", STAT_SOC_LOW_WARN_WERT, "\"%\"");
float STAT_SOC_HIGH_I_ZERO_WERT = (RXBUF_SINT(4)/100.0f);
// Predefined upper SOC warning limit-1 (project-specific) / Vordefinierte obere SOC-Warngrenze-1
// (projektspezifisch)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HIS_SOC_WARN_GRENZEN", "STAT_SOC_HIGH_I_ZERO_WERT", STAT_SOC_HIGH_I_ZERO_WERT, "\"%\"");
float STAT_SOC_HIGH_WARN_WERT = (RXBUF_SINT(6)/100.0f);
// Predefined upper SOC warning limit-2 (project-specific) / Vordefinierte obere SOC-Warngrenze-2
// (projektspezifisch)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HIS_SOC_WARN_GRENZEN", "STAT_SOC_HIGH_WARN_WERT", STAT_SOC_HIGH_WARN_WERT, "\"%\"");
unsigned long STAT_HIS_SOC_WARN_GRENZEN_1_WERT = (RXBUF_UINT32(8));
// Duration in: SOC <= SOC_LOW_I_ZERO / Dauer in: SOC<=SOC_LOW_I_ZERO
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_SOC_WARN_GRENZEN", "STAT_HIS_SOC_WARN_GRENZEN_1_WERT", STAT_HIS_SOC_WARN_GRENZEN_1_WERT, "\"min\"");
unsigned long STAT_HIS_SOC_WARN_GRENZEN_2_WERT = (RXBUF_UINT32(12));
// Duration in: SOC_LOW_I_ZERO <SOC <= SOC_LOW_WARN / Dauer in: SOC_LOW_I_ZERO<SOC<=SOC_LOW_WARN
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_SOC_WARN_GRENZEN", "STAT_HIS_SOC_WARN_GRENZEN_2_WERT", STAT_HIS_SOC_WARN_GRENZEN_2_WERT, "\"min\"");
unsigned long STAT_HIS_SOC_WARN_GRENZEN_3_WERT = (RXBUF_UINT32(16));
// Duration in: SOC_LOW_WARN <SOC <= SOC_HIGH_WARN / Dauer in: SOC_LOW_WARN<SOC<=SOC_HIGH_WARN
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_SOC_WARN_GRENZEN", "STAT_HIS_SOC_WARN_GRENZEN_3_WERT", STAT_HIS_SOC_WARN_GRENZEN_3_WERT, "\"min\"");
unsigned long STAT_HIS_SOC_WARN_GRENZEN_4_WERT = (RXBUF_UINT32(20));
// Duration in: SOC_HIGH_WARN <SOC <= SOC_HIGH_I_ZERO / Dauer in: SOC_HIGH_WARN<SOC<=SOC_HIGH_I_ZERO
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_SOC_WARN_GRENZEN", "STAT_HIS_SOC_WARN_GRENZEN_4_WERT", STAT_HIS_SOC_WARN_GRENZEN_4_WERT, "\"min\"");
unsigned long STAT_HIS_SOC_WARN_GRENZEN_5_WERT = (RXBUF_UINT32(24));
// Duration in: SOC> SOC_HIGH_I_ZERO / Dauer in: SOC >SOC_HIGH_I_ZERO
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_SOC_WARN_GRENZEN", "STAT_HIS_SOC_WARN_GRENZEN_5_WERT", STAT_HIS_SOC_WARN_GRENZEN_5_WERT, "\"min\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_ID_SBOX: { // 0xDF83
if (datalen < 8) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_ID_SBOX", 8);
break;
}
unsigned long STAT_ID_SER_NR_WERT = (RXBUF_UINT32(0));
// Sequential number coded in hexadecimal / Laufende Nummer hexadezimal codiert
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "ID_SBOX", "STAT_ID_SER_NR_WERT", STAT_ID_SER_NR_WERT, "");
unsigned char STAT_ID_MV_HW_WERT = (RXBUF_UCHAR(4));
// HW version, consecutive number coded in hexadecimal / HW Version, laufende Nummer hexadezimal codiert
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "ID_SBOX", "STAT_ID_MV_HW_WERT", STAT_ID_MV_HW_WERT, "");
unsigned char STAT_ID_MV_SW_WERT = (RXBUF_UCHAR(5));
// SW major version, consecutive number coded in hexadecimal / SW Hauptversion, laufende Nummer hexadezimal
// codiert
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "ID_SBOX", "STAT_ID_MV_SW_WERT", STAT_ID_MV_SW_WERT, "");
unsigned char STAT_ID_SV_SW_WERT = (RXBUF_UCHAR(6));
// SW minor version, consecutive number coded in hexadecimal / SW Unterversion, laufende Nummer hexadezimal
// codiert
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "ID_SBOX", "STAT_ID_SV_SW_WERT", STAT_ID_SV_SW_WERT, "");
unsigned char STAT_ID_VAR_WERT = (RXBUF_UCHAR(7));
// Variant identifier SBOX 00000b: BK2.0 / Variantenkennung SBOX 00000b: BK2.0
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "ID_SBOX", "STAT_ID_VAR_WERT", STAT_ID_VAR_WERT, "");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_SOC_HISTORIE: { // 0xDF86
if (datalen < 15) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_SOC_HISTORIE", 15);
break;
}
unsigned char STAT_SOC_DAY_1_WERT = (RXBUF_UCHAR(0));
// SOC value at the end of the first day of the week / SOC Wert am Ende des ersten Tages der Woche
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "SOC_HISTORIE", "STAT_SOC_DAY_1_WERT", STAT_SOC_DAY_1_WERT, "\"%\"");
unsigned char STAT_SOC_DAY_2_WERT = (RXBUF_UCHAR(1));
// SOC value at the end of the second day of the week / SOC Wert am Ende des zweiten Tages der Woche
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "SOC_HISTORIE", "STAT_SOC_DAY_2_WERT", STAT_SOC_DAY_2_WERT, "\"%\"");
unsigned char STAT_SOC_DAY_3_WERT = (RXBUF_UCHAR(2));
// SOC value at the end of the third day of the week / SOC Wert am Ende des dritten Tages der Woche
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "SOC_HISTORIE", "STAT_SOC_DAY_3_WERT", STAT_SOC_DAY_3_WERT, "\"%\"");
unsigned char STAT_SOC_DAY_4_WERT = (RXBUF_UCHAR(3));
// SOC value at the end of the fourth day of the week / SOC Wert am Ende des vierten Tages der Woche
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "SOC_HISTORIE", "STAT_SOC_DAY_4_WERT", STAT_SOC_DAY_4_WERT, "\"%\"");
unsigned char STAT_SOC_DAY_5_WERT = (RXBUF_UCHAR(4));
// SOC value at the end of the fifth day of the week / SOC Wert am Ende des fünften Tages der Woche
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "SOC_HISTORIE", "STAT_SOC_DAY_5_WERT", STAT_SOC_DAY_5_WERT, "\"%\"");
unsigned char STAT_SOC_DAY_6_WERT = (RXBUF_UCHAR(5));
// SOC value at the end of the sixth day of the week / SOC Wert am Ende des sechsten Tages der Woche
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "SOC_HISTORIE", "STAT_SOC_DAY_6_WERT", STAT_SOC_DAY_6_WERT, "\"%\"");
unsigned char STAT_SOC_DAY_7_WERT = (RXBUF_UCHAR(6));
// SOC value at the end of the seventh day of the week / SOC Wert am Ende des siebten Tages der Woche
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "SOC_HISTORIE", "STAT_SOC_DAY_7_WERT", STAT_SOC_DAY_7_WERT, "\"%\"");
unsigned char STAT_SOC_WEEK_2_WERT = (RXBUF_UCHAR(7));
// SOC value two weeks ago / SOC Wert vor zwei Wochen
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "SOC_HISTORIE", "STAT_SOC_WEEK_2_WERT", STAT_SOC_WEEK_2_WERT, "\"%\"");
unsigned char STAT_SOC_WEEK_3_WERT = (RXBUF_UCHAR(8));
// SOC value three weeks ago / SOC Wert vor drei Wochen
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "SOC_HISTORIE", "STAT_SOC_WEEK_3_WERT", STAT_SOC_WEEK_3_WERT, "\"%\"");
unsigned char STAT_SOC_WEEK_4_WERT = (RXBUF_UCHAR(9));
// SOC value four weeks ago / SOC Wert vor vier Wochen
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "SOC_HISTORIE", "STAT_SOC_WEEK_4_WERT", STAT_SOC_WEEK_4_WERT, "\"%\"");
unsigned short STAT_LAST_HV_ON_WERT = (RXBUF_UINT(10));
// Time in hours since the last time HV was on HVofftime_last / Zeit in Stunden seit das letzte Mal HV on war
// HVofftime_last
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "SOC_HISTORIE", "STAT_LAST_HV_ON_WERT", STAT_LAST_HV_ON_WERT, "\"h\"");
unsigned char STAT_SOC_LAST_DRIVE_CYCLE_WERT = (RXBUF_UCHAR(12));
// SOC at the last end of the journey / SOC beim letzten Fahrtende
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "SOC_HISTORIE", "STAT_SOC_LAST_DRIVE_CYCLE_WERT", STAT_SOC_LAST_DRIVE_CYCLE_WERT, "\"%\"");
unsigned short STAT_TIME_STAMP_LAST_CHG_END_WERT = (RXBUF_UINT(13));
// Time in hours when the last time loading was finished / canceled / Zeit in Stunden wann das letzte Mal Laden
// beendet/abgebrochen wurde
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "SOC_HISTORIE", "STAT_TIME_STAMP_LAST_CHG_END_WERT", STAT_TIME_STAMP_LAST_CHG_END_WERT, "\"h\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_KL30C: { // 0xDF89
if (datalen < 1) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_KL30C", 1);
break;
}
unsigned char STAT_KL30C = (RXBUF_UCHAR(0));
// Reading out the logical status of the KL30C> not for I01 and I12, use STATUS_KL30C_SPANNUNG here / Auslesen
// des logischen Status der KL30C > nicht für I01 und I12, hier STATUS_KL30C_SPANNUNG verwenden
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "KL30C", "STAT_KL30C", STAT_KL30C, "\"0-n\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_HIS_EFF_STROM_TMIN: { // 0xDF8A
if (datalen < 48) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_HIS_EFF_STROM_TMIN", 48);
break;
}
unsigned long STAT_CHA_EFF_CURR_LIM_100_PERC_TMIN_WERT = (RXBUF_UINT32(0));
// At T <-10: rms value of the current limit when loading to 100% life [Irms_cha (% 100)] >> This status
// output is no longer required and is set to zero. / Bei T < -10: Effektivwert der Stromgrenze beim Laden auf
// 100% Leben [Irms_cha(%100)] >> Dieses Statusausgabe wird nicht mehr benötigt und ist mit Null bedatet.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_TMIN", "STAT_CHA_EFF_CURR_LIM_100_PERC_TMIN_WERT", STAT_CHA_EFF_CURR_LIM_100_PERC_TMIN_WERT, "\"A\"");
unsigned long STAT_CHA_EFF_CURR_LIM_3_PERC_TMIN_WERT = (RXBUF_UINT32(4));
// At T <-10: RMS value of the current limit when loading to 3% life [Irms_cha (% 3)] >> This status
// output is no longer required and is set to zero. / Bei T < -10: Effektivwert der Stromgrenze beim Laden auf 3%
// Leben [Irms_cha(%3)] >> Dieses Statusausgabe wird nicht mehr benötigt und ist mit Null bedatet.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_TMIN", "STAT_CHA_EFF_CURR_LIM_3_PERC_TMIN_WERT", STAT_CHA_EFF_CURR_LIM_3_PERC_TMIN_WERT, "\"A\"");
unsigned long STAT_ABS_EFF_CURR_LIM_100_PERC_TMIN_WERT = (RXBUF_UINT32(8));
// At T <-10: RMS value of the current limit during charging and discharging (absolute) to 100% life [Irms_abs
// (% 100)] >> This status output is no longer required and is set to zero. / Bei T < -10: Effektivwert der
// Stromgrenze beim Laden und Entladen (Absolut) auf 100% Leben [Irms_abs(%100)] >> Dieses Statusausgabe wird
// nicht mehr benötigt und ist mit Null bedatet.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_TMIN", "STAT_ABS_EFF_CURR_LIM_100_PERC_TMIN_WERT", STAT_ABS_EFF_CURR_LIM_100_PERC_TMIN_WERT, "\"A\"");
unsigned long STAT_ABS_EFF_CURR_LIM_3_PERC_TMIN_WERT = (RXBUF_UINT32(12));
// At T <-10: RMS value of the current limit during charging and discharging (absolute) to 3% life [Irms_abs
// (% 3)] >> This status output is no longer required and is set to zero. / Bei T < -10: Effektivwert der
// Stromgrenze beim Laden und Entladen (Absolut) auf 3% Leben [Irms_abs(%3)] >> Dieses Statusausgabe wird nicht
// mehr benötigt und ist mit Null bedatet.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_TMIN", "STAT_ABS_EFF_CURR_LIM_3_PERC_TMIN_WERT", STAT_ABS_EFF_CURR_LIM_3_PERC_TMIN_WERT, "\"A\"");
unsigned long STAT_HIS_EFF_CURR_CHG_1_TMIN_WERT = (RXBUF_UINT32(16));
// If T <-10: Duration in minutes of the relative value of Irms_cha / Irms_cha_lim when loading in the class: 0
// <= Irel_cha <= 70 / Bei T < -10: Dauer in Minuten des Relativwerts von Irms_cha/Irms_cha_lim beim Laden in der
// Klasse: 0 <= Irel_cha <= 70
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_TMIN", "STAT_HIS_EFF_CURR_CHG_1_TMIN_WERT", STAT_HIS_EFF_CURR_CHG_1_TMIN_WERT, "\"min\"");
unsigned long STAT_HIS_EFF_CURR_CHG_2_TMIN_WERT = (RXBUF_UINT32(20));
// If T <-10: Duration in minutes of the relative value of Irms_cha / Irms_cha_lim when loading in the class: 70
// <Irel_cha <= 100 / Bei T < -10: Dauer in Minuten des Relativwerts von Irms_cha/Irms_cha_lim beim Laden in der
// Klasse: 70 < Irel_cha <= 100
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_TMIN", "STAT_HIS_EFF_CURR_CHG_2_TMIN_WERT", STAT_HIS_EFF_CURR_CHG_2_TMIN_WERT, "\"min\"");
unsigned long STAT_HIS_EFF_CURR_CHG_3_TMIN_WERT = (RXBUF_UINT32(24));
// For T <-10: Duration in minutes of the relative value of Irms_cha / Irms_cha_lim when loading in the class:
// 100 <Irel_cha <= 140 / Bei T < -10: Dauer in Minuten des Relativwerts von Irms_cha/Irms_cha_lim beim Laden in
// der Klasse: 100 < Irel_cha <= 140
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_TMIN", "STAT_HIS_EFF_CURR_CHG_3_TMIN_WERT", STAT_HIS_EFF_CURR_CHG_3_TMIN_WERT, "\"min\"");
unsigned long STAT_HIS_EFF_CURR_CHG_4_TMIN_WERT = (RXBUF_UINT32(28));
// If T <-10: Duration in minutes of the relative value of Irms_cha / Irms_cha_lim when loading in the class: 140
// <Irel_cha / Bei T < -10: Dauer in Minuten des Relativwerts von Irms_cha/Irms_cha_lim beim Laden in der Klasse:
// 140 < Irel_cha
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_TMIN", "STAT_HIS_EFF_CURR_CHG_4_TMIN_WERT", STAT_HIS_EFF_CURR_CHG_4_TMIN_WERT, "\"min\"");
unsigned long STAT_HIS_EFF_CURR_ABS_1_TMIN_WERT = (RXBUF_UINT32(32));
// At T <-10: Duration in minutes of the relative value of Irms_abs / Irms_dch_lim when loading and unloading in
// the class: 0 <= Irel_abs <= 70 / Bei T < -10: Dauer in Minuten des Relativwerts von Irms_abs/Irms_dch_lim beim
// Laden und Entladen in der Klasse: 0 <= Irel_abs <= 70
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_TMIN", "STAT_HIS_EFF_CURR_ABS_1_TMIN_WERT", STAT_HIS_EFF_CURR_ABS_1_TMIN_WERT, "\"min\"");
unsigned long STAT_HIS_EFF_CURR_ABS_2_TMIN_WERT = (RXBUF_UINT32(36));
// At T <-10: Duration in minutes of the relative value of Irms_abs / Irms_dch_lim when loading and unloading in
// the class: 70 <Irel_abs <= 100 / Bei T < -10: Dauer in Minuten des Relativwerts von Irms_abs/Irms_dch_lim beim
// Laden und Entladen in der Klasse: 70 < Irel_abs <= 100
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_TMIN", "STAT_HIS_EFF_CURR_ABS_2_TMIN_WERT", STAT_HIS_EFF_CURR_ABS_2_TMIN_WERT, "\"min\"");
unsigned long STAT_HIS_EFF_CURR_ABS_3_TMIN_WERT = (RXBUF_UINT32(40));
// At T <-10: Duration in minutes of the relative value of Irms_abs / Irms_dch_lim when loading and unloading in
// the class: 100 <Irel_abs <= 140 / Bei T < -10: Dauer in Minuten des Relativwerts von Irms_abs/Irms_dch_lim
// beim Laden und Entladen in der Klasse: 100 < Irel_abs <= 140
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_TMIN", "STAT_HIS_EFF_CURR_ABS_3_TMIN_WERT", STAT_HIS_EFF_CURR_ABS_3_TMIN_WERT, "\"min\"");
unsigned long STAT_HIS_EFF_CURR_ABS_4_TMIN_WERT = (RXBUF_UINT32(44));
// If T <-10: Duration in minutes of the relative value of Irms_abs / Irms_dch_lim when loading and unloading in
// the class: 140 <Irel_abs / Bei T < -10: Dauer in Minuten des Relativwerts von Irms_abs/Irms_dch_lim beim Laden
// und Entladen in der Klasse: 140 < Irel_abs
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_TMIN", "STAT_HIS_EFF_CURR_ABS_4_TMIN_WERT", STAT_HIS_EFF_CURR_ABS_4_TMIN_WERT, "\"min\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_HIS_EFF_STROM_TLOW: { // 0xDF8B
if (datalen < 48) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_HIS_EFF_STROM_TLOW", 48);
break;
}
unsigned long STAT_CHA_EFF_CURR_LIM_100_PERC_TLOW_WERT = (RXBUF_UINT32(0));
// At -10 <= T <5: RMS value of the current limit when loading to 100% life [Irms_cha (% 100)] >>
// This status output is no longer required and is set to zero. / Bei -10 <= T< 5: Effektivwert der Stromgrenze
// beim Laden auf 100% Leben [Irms_cha(%100)] >> Dieses Statusausgabe wird nicht mehr benötigt und ist mit Null
// bedatet.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_TLOW", "STAT_CHA_EFF_CURR_LIM_100_PERC_TLOW_WERT", STAT_CHA_EFF_CURR_LIM_100_PERC_TLOW_WERT, "\"A\"");
unsigned long STAT_CHA_EFF_CURR_LIM_3_PERC_TLOW_WERT = (RXBUF_UINT32(4));
// At -10 <= T <5: effective value of the current limit when loading to 3% life [Irms_cha (% 3)] >>
// This status output is no longer required and is set to zero. / Bei -10 <= T< 5: Effektivwert der Stromgrenze
// beim Laden auf 3% Leben [Irms_cha(%3)] >> Dieses Statusausgabe wird nicht mehr benötigt und ist mit Null
// bedatet.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_TLOW", "STAT_CHA_EFF_CURR_LIM_3_PERC_TLOW_WERT", STAT_CHA_EFF_CURR_LIM_3_PERC_TLOW_WERT, "\"A\"");
unsigned long STAT_ABS_EFF_CURR_LIM_100_PERC_TLOW_WERT = (RXBUF_UINT32(8));
// At -10 <= T <5: RMS value of the current limit during charging and discharging (absolute) to 100% life
// [Irms_abs (% 100)] >> This status output is no longer required and is set to zero. / Bei -10 <= T< 5:
// Effektivwert der Stromgrenze beim Laden und Entladen (Absolut) auf 100% Leben [Irms_abs(%100)] >> Dieses
// Statusausgabe wird nicht mehr benötigt und ist mit Null bedatet.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_TLOW", "STAT_ABS_EFF_CURR_LIM_100_PERC_TLOW_WERT", STAT_ABS_EFF_CURR_LIM_100_PERC_TLOW_WERT, "\"A\"");
unsigned long STAT_ABS_EFF_CURR_LIM_3_PERC_TLOW_WERT = (RXBUF_UINT32(12));
// At -10 <= T <5: rms value of the current limit during charging and discharging (absolute) to 3% life
// [Irms_abs (% 3)] >> This status output is no longer required and is set to zero. / Bei -10 <= T< 5:
// Effektivwert der Stromgrenze beim Laden und Entladen (Absolut) auf 3% Leben [Irms_abs(%3)] >> Dieses
// Statusausgabe wird nicht mehr benötigt und ist mit Null bedatet.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_TLOW", "STAT_ABS_EFF_CURR_LIM_3_PERC_TLOW_WERT", STAT_ABS_EFF_CURR_LIM_3_PERC_TLOW_WERT, "\"A\"");
unsigned long STAT_HIS_EFF_CURR_CHG_1_TLOW_WERT = (RXBUF_UINT32(16));
// With -10 <= T <5: Duration in minutes of the relative value of Irms_cha / Irms_cha_lim when loading in the
// class: 0 <= Irel_cha <= 70 / Bei -10 <= T < 5: Dauer in Minuten des Relativwerts von Irms_cha/Irms_cha_lim
// beim Laden in der Klasse: 0 <= Irel_cha <= 70
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_TLOW", "STAT_HIS_EFF_CURR_CHG_1_TLOW_WERT", STAT_HIS_EFF_CURR_CHG_1_TLOW_WERT, "\"min\"");
unsigned long STAT_HIS_EFF_CURR_CHG_2_TLOW_WERT = (RXBUF_UINT32(20));
// With -10 <= T <5: Duration in minutes of the relative value of Irms_cha / Irms_cha_lim when loading in the
// class: 70 <Irel_cha <= 100 / Bei -10 <= T < 5: Dauer in Minuten des Relativwerts von Irms_cha/Irms_cha_lim
// beim Laden in der Klasse: 70 < Irel_cha <= 100
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_TLOW", "STAT_HIS_EFF_CURR_CHG_2_TLOW_WERT", STAT_HIS_EFF_CURR_CHG_2_TLOW_WERT, "\"min\"");
unsigned long STAT_HIS_EFF_CURR_CHG_3_TLOW_WERT = (RXBUF_UINT32(24));
// With -10 <= T <5: Duration in minutes of the relative value of Irms_cha / Irms_cha_lim when loading in the
// class: 100 <Irel_cha <= 140 / Bei -10 <= T < 5: Dauer in Minuten des Relativwerts von Irms_cha/Irms_cha_lim
// beim Laden in der Klasse: 100 < Irel_cha <= 140
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_TLOW", "STAT_HIS_EFF_CURR_CHG_3_TLOW_WERT", STAT_HIS_EFF_CURR_CHG_3_TLOW_WERT, "\"min\"");
unsigned long STAT_HIS_EFF_CURR_CHG_4_TLOW_WERT = (RXBUF_UINT32(28));
// With -10 <= T <5: Duration in minutes of the relative value of Irms_cha / Irms_cha_lim when loading in the
// class: 140 <Irel_cha / Bei -10 <= T < 5: Dauer in Minuten des Relativwerts von Irms_cha/Irms_cha_lim beim
// Laden in der Klasse: 140 < Irel_cha
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_TLOW", "STAT_HIS_EFF_CURR_CHG_4_TLOW_WERT", STAT_HIS_EFF_CURR_CHG_4_TLOW_WERT, "\"min\"");
unsigned long STAT_HIS_EFF_CURR_ABS_1_TLOW_WERT = (RXBUF_UINT32(32));
// With -10 <= T <5: Duration in minutes of the relative value of Irms_abs / Irms_dch_lim when loading and
// unloading in the class: 0 <= Irel_abs <= 70 / Bei -10 <= T < 5: Dauer in Minuten des Relativwerts von
// Irms_abs/Irms_dch_lim beim Laden und Entladen in der Klasse: 0 <= Irel_abs <= 70
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_TLOW", "STAT_HIS_EFF_CURR_ABS_1_TLOW_WERT", STAT_HIS_EFF_CURR_ABS_1_TLOW_WERT, "\"min\"");
unsigned long STAT_HIS_EFF_CURR_ABS_2_TLOW_WERT = (RXBUF_UINT32(36));
// With -10 <= T <5: Duration in minutes of the relative value of Irms_abs / Irms_dch_lim when loading and
// unloading in the class: 70 <Irel_abs <= 100 / Bei -10 <= T < 5: Dauer in Minuten des Relativwerts von
// Irms_abs/Irms_dch_lim beim Laden und Entladen in der Klasse: 70 < Irel_abs <= 100
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_TLOW", "STAT_HIS_EFF_CURR_ABS_2_TLOW_WERT", STAT_HIS_EFF_CURR_ABS_2_TLOW_WERT, "\"min\"");
unsigned long STAT_HIS_EFF_CURR_ABS_3_TLOW_WERT = (RXBUF_UINT32(40));
// With -10 <= T <5: Duration in minutes of the relative value of Irms_abs / Irms_dch_lim when loading and
// unloading in the class: 100 <Irel_abs <= 140 / Bei -10 <= T < 5: Dauer in Minuten des Relativwerts von
// Irms_abs/Irms_dch_lim beim Laden und Entladen in der Klasse: 100 < Irel_abs <= 140
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_TLOW", "STAT_HIS_EFF_CURR_ABS_3_TLOW_WERT", STAT_HIS_EFF_CURR_ABS_3_TLOW_WERT, "\"min\"");
unsigned long STAT_HIS_EFF_CURR_ABS_4_TLOW_WERT = (RXBUF_UINT32(44));
// With -10 <= T <5: Duration in minutes of the relative value of Irms_abs / Irms_dch_lim when loading and
// unloading in the class: 140 <Irel_abs / Bei -10 <= T < 5: Dauer in Minuten des Relativwerts von
// Irms_abs/Irms_dch_lim beim Laden und Entladen in der Klasse: 140 < Irel_abs
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_TLOW", "STAT_HIS_EFF_CURR_ABS_4_TLOW_WERT", STAT_HIS_EFF_CURR_ABS_4_TLOW_WERT, "\"min\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_HIS_EFF_STROM_TMID: { // 0xDF8C
if (datalen < 48) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_HIS_EFF_STROM_TMID", 48);
break;
}
unsigned long STAT_CHA_EFF_CURR_LIM_100_PERC_TMID_WERT = (RXBUF_UINT32(0));
// With 5 <= T <25 (40 SP01): RMS value of the current limit when loading to 100% life [Irms_cha (% 100)]
// >> This status output is no longer required and is set to zero. / Bei 5 <= T< 25 (40 SP01): Effektivwert
// der Stromgrenze beim Laden auf 100% Leben [Irms_cha(%100)] >> Dieses Statusausgabe wird nicht mehr benötigt
// und ist mit Null bedatet.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_TMID", "STAT_CHA_EFF_CURR_LIM_100_PERC_TMID_WERT", STAT_CHA_EFF_CURR_LIM_100_PERC_TMID_WERT, "\"A\"");
unsigned long STAT_CHA_EFF_CURR_LIM_3_PERC_TMID_WERT = (RXBUF_UINT32(4));
// With 5 <= T <25 (40 SP01): RMS value of the current limit when loading to 3% life [Irms_cha (% 3)]
// >> This status output is no longer required and is set to zero. / Bei 5 <= T< 25 (40 SP01): Effektivwert
// der Stromgrenze beim Laden auf 3% Leben [Irms_cha(%3)] >> Dieses Statusausgabe wird nicht mehr benötigt und
// ist mit Null bedatet.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_TMID", "STAT_CHA_EFF_CURR_LIM_3_PERC_TMID_WERT", STAT_CHA_EFF_CURR_LIM_3_PERC_TMID_WERT, "\"A\"");
unsigned long STAT_ABS_EFF_CURR_LIM_100_PERC_TMID_WERT = (RXBUF_UINT32(8));
// With 5 <= T <25 (40 SP01): RMS value of the current limit when charging and discharging (absolute) to
// 100% life [Irms_abs (% 100)] >> This status output is no longer required and is set to zero. / Bei 5 <=
// T< 25 (40 SP01): Effektivwert der Stromgrenze beim Laden und Entladen (Absolut) auf 100% Leben
// [Irms_abs(%100)] >> Dieses Statusausgabe wird nicht mehr benötigt und ist mit Null bedatet.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_TMID", "STAT_ABS_EFF_CURR_LIM_100_PERC_TMID_WERT", STAT_ABS_EFF_CURR_LIM_100_PERC_TMID_WERT, "\"A\"");
unsigned long STAT_ABS_EFF_CURR_LIM_3_PERC_TMID_WERT = (RXBUF_UINT32(12));
// With 5 <= T <25 (40 SP01): RMS value of the current limit during charging and discharging (absolute) to
// 3% life [Irms_abs (% 3)] >> This status output is no longer required and is set to zero. / Bei 5 <= T<
// 25 (40 SP01): Effektivwert der Stromgrenze beim Laden und Entladen (Absolut) auf 3% Leben [Irms_abs(%3)] >>
// Dieses Statusausgabe wird nicht mehr benötigt und ist mit Null bedatet.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_TMID", "STAT_ABS_EFF_CURR_LIM_3_PERC_TMID_WERT", STAT_ABS_EFF_CURR_LIM_3_PERC_TMID_WERT, "\"A\"");
unsigned long STAT_HIS_EFF_CURR_CHG_1_TMID_WERT = (RXBUF_UINT32(16));
// With 5 <= T <25 (40 SP01): Duration in minutes of the relative value of Irms_cha / Irms_cha_lim when loading
// in the class: 0 <= Irel_cha <= 70 / Bei 5 <= T < 25 (40 SP01): Dauer in Minuten des Relativwerts von
// Irms_cha/Irms_cha_lim beim Laden in der Klasse: 0 <= Irel_cha <= 70
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_TMID", "STAT_HIS_EFF_CURR_CHG_1_TMID_WERT", STAT_HIS_EFF_CURR_CHG_1_TMID_WERT, "\"min\"");
unsigned long STAT_HIS_EFF_CURR_CHG_2_TMID_WERT = (RXBUF_UINT32(20));
// With 5 <= T <25 (40 SP01): Duration in minutes of the relative value of Irms_cha / Irms_cha_lim when loading
// in the class: 70 <Irel_cha <= 100 / Bei 5 <= T < 25 (40 SP01): Dauer in Minuten des Relativwerts von
// Irms_cha/Irms_cha_lim beim Laden in der Klasse: 70 < Irel_cha <= 100
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_TMID", "STAT_HIS_EFF_CURR_CHG_2_TMID_WERT", STAT_HIS_EFF_CURR_CHG_2_TMID_WERT, "\"min\"");
unsigned long STAT_HIS_EFF_CURR_CHG_3_TMID_WERT = (RXBUF_UINT32(24));
// With 5 <= T <25 (40 SP01): Duration in minutes of the relative value of Irms_cha / Irms_cha_lim when loading
// in the class: 100 <Irel_cha <= 140 / Bei 5 <= T < 25 (40 SP01): Dauer in Minuten des Relativwerts von
// Irms_cha/Irms_cha_lim beim Laden in der Klasse: 100 < Irel_cha <= 140
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_TMID", "STAT_HIS_EFF_CURR_CHG_3_TMID_WERT", STAT_HIS_EFF_CURR_CHG_3_TMID_WERT, "\"min\"");
unsigned long STAT_HIS_EFF_CURR_CHG_4_TMID_WERT = (RXBUF_UINT32(28));
// If 5 <= T <25 (40 SP01): Duration in minutes of the relative value of Irms_cha / Irms_cha_lim when loading in
// the class: 140 <Irel_cha / Bei 5 <= T < 25 (40 SP01): Dauer in Minuten des Relativwerts von
// Irms_cha/Irms_cha_lim beim Laden in der Klasse: 140 < Irel_cha
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_TMID", "STAT_HIS_EFF_CURR_CHG_4_TMID_WERT", STAT_HIS_EFF_CURR_CHG_4_TMID_WERT, "\"min\"");
unsigned long STAT_HIS_EFF_CURR_ABS_1_TMID_WERT = (RXBUF_UINT32(32));
// With 5 <= T <25 (40 SP01): Duration in minutes of the relative value of Irms_abs / Irms_dch_lim when loading
// and unloading in the class: 0 <= Irel_abs <= 70 / Bei 5 <= T < 25 (40 SP01): Dauer in Minuten des Relativwerts
// von Irms_abs/Irms_dch_lim beim Laden und Entladen in der Klasse: 0 <= Irel_abs <= 70
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_TMID", "STAT_HIS_EFF_CURR_ABS_1_TMID_WERT", STAT_HIS_EFF_CURR_ABS_1_TMID_WERT, "\"min\"");
unsigned long STAT_HIS_EFF_CURR_ABS_2_TMID_WERT = (RXBUF_UINT32(36));
// With 5 <= T <25 (40 SP01): Duration in minutes of the relative value of Irms_abs / Irms_dch_lim when loading
// and unloading in the class: 70 <Irel_abs <= 100 / Bei 5 <= T < 25 (40 SP01): Dauer in Minuten des Relativwerts
// von Irms_abs/Irms_dch_lim beim Laden und Entladen in der Klasse: 70 < Irel_abs <= 100
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_TMID", "STAT_HIS_EFF_CURR_ABS_2_TMID_WERT", STAT_HIS_EFF_CURR_ABS_2_TMID_WERT, "\"min\"");
unsigned long STAT_HIS_EFF_CURR_ABS_3_TMID_WERT = (RXBUF_UINT32(40));
// If 5 <= T <25 (40 SP01): Duration in minutes of the relative value of Irms_abs / Irms_dch_lim when loading and
// unloading in the class: 100 <Irel_abs <= 140 / Bei 5 <= T < 25 (40 SP01): Dauer in Minuten des Relativwerts
// von Irms_abs/Irms_dch_lim beim Laden und Entladen in der Klasse: 100 < Irel_abs <= 140
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_TMID", "STAT_HIS_EFF_CURR_ABS_3_TMID_WERT", STAT_HIS_EFF_CURR_ABS_3_TMID_WERT, "\"min\"");
unsigned long STAT_HIS_EFF_CURR_ABS_4_TMID_WERT = (RXBUF_UINT32(44));
// If 5 <= T <25 (40 SP01): Duration in minutes of the relative value of Irms_abs / Irms_dch_lim when loading and
// unloading in the class: 140 <Irel_abs / Bei 5 <= T < 25 (40 SP01): Dauer in Minuten des Relativwerts von
// Irms_abs/Irms_dch_lim beim Laden und Entladen in der Klasse: 140 < Irel_abs
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_TMID", "STAT_HIS_EFF_CURR_ABS_4_TMID_WERT", STAT_HIS_EFF_CURR_ABS_4_TMID_WERT, "\"min\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_HIS_EFF_STROM_THIGH: { // 0xDF8D
if (datalen < 48) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_HIS_EFF_STROM_THIGH", 48);
break;
}
unsigned long STAT_CHA_EFF_CURR_LIM_100_PERC_THIGH_WERT = (RXBUF_UINT32(0));
// ONLY SE03 !!! At 25 <= T <40: effective value of the current limit when loading to 100% life [Irms_cha
// (% 100)] >> This status output is no longer required and is set to zero. / NUR SE03!!! Bei 25 <= T< 40:
// Effektivwert der Stromgrenze beim Laden auf 100% Leben [Irms_cha(%100)] >> Dieses Statusausgabe wird nicht
// mehr benötigt und ist mit Null bedatet.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_THIGH", "STAT_CHA_EFF_CURR_LIM_100_PERC_THIGH_WERT", STAT_CHA_EFF_CURR_LIM_100_PERC_THIGH_WERT, "\"A\"");
unsigned long STAT_CHA_EFF_CURR_LIM_3_PERC_THIGH_WERT = (RXBUF_UINT32(4));
// ONLY SE03 !!! At 25 <= T <40: effective value of the current limit when loading to 3% life [Irms_cha (%
// 3)] >> This status output is no longer required and is set to zero. / NUR SE03!!! Bei 25 <= T< 40:
// Effektivwert der Stromgrenze beim Laden auf 3% Leben [Irms_cha(%3)] >> Dieses Statusausgabe wird nicht mehr
// benötigt und ist mit Null bedatet.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_THIGH", "STAT_CHA_EFF_CURR_LIM_3_PERC_THIGH_WERT", STAT_CHA_EFF_CURR_LIM_3_PERC_THIGH_WERT, "\"A\"");
unsigned long STAT_ABS_EFF_CURR_LIM_100_PERC_THIGH_WERT = (RXBUF_UINT32(8));
// ONLY SE03 !!! At 25 <= T <40: RMS value of the current limit during charging and discharging (absolute)
// to 100% life [Irms_abs (% 100)] >> This status output is no longer required and is set to zero. / NUR
// SE03!!! Bei 25 <= T< 40: Effektivwert der Stromgrenze beim Laden und Entladen (Absolut) auf 100% Leben
// [Irms_abs(%100)] >> Dieses Statusausgabe wird nicht mehr benötigt und ist mit Null bedatet.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_THIGH", "STAT_ABS_EFF_CURR_LIM_100_PERC_THIGH_WERT", STAT_ABS_EFF_CURR_LIM_100_PERC_THIGH_WERT, "\"A\"");
unsigned long STAT_ABS_EFF_CURR_LIM_3_PERC_THIGH_WERT = (RXBUF_UINT32(12));
// ONLY SE03 !!! At 25 <= T <40: RMS value of the current limit when charging and discharging (absolute) to
// 3% life [Irms_abs (% 3)] >> This status output is no longer required and is set to zero. / NUR SE03!!!
// Bei 25 <= T< 40: Effektivwert der Stromgrenze beim Laden und Entladen (Absolut) auf 3% Leben [Irms_abs(%3)] >>
// Dieses Statusausgabe wird nicht mehr benötigt und ist mit Null bedatet.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_THIGH", "STAT_ABS_EFF_CURR_LIM_3_PERC_THIGH_WERT", STAT_ABS_EFF_CURR_LIM_3_PERC_THIGH_WERT, "\"A\"");
unsigned long STAT_HIS_EFF_CURR_CHG_1_THIGH_WERT = (RXBUF_UINT32(16));
// ONLY SE03 !!! With 25 <= T <40: Duration in minutes of the relative value of Irms_cha / Irms_cha_lim when
// loading in the class: 0 <= Irel_cha <= 70 / NUR SE03!!! Bei 25 <= T < 40: Dauer in Minuten des Relativwerts
// von Irms_cha/Irms_cha_lim beim Laden in der Klasse: 0 <= Irel_cha <= 70
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_THIGH", "STAT_HIS_EFF_CURR_CHG_1_THIGH_WERT", STAT_HIS_EFF_CURR_CHG_1_THIGH_WERT, "\"min\"");
unsigned long STAT_HIS_EFF_CURR_CHG_2_THIGH_WERT = (RXBUF_UINT32(20));
// ONLY SE03 !!! If 25 <= T <40: Duration in minutes of the relative value of Irms_cha / Irms_cha_lim when
// loading in the class: 70 <Irel_cha <= 100 / NUR SE03!!! Bei 25 <= T < 40: Dauer in Minuten des Relativwerts
// von Irms_cha/Irms_cha_lim beim Laden in der Klasse: 70 < Irel_cha <= 100
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_THIGH", "STAT_HIS_EFF_CURR_CHG_2_THIGH_WERT", STAT_HIS_EFF_CURR_CHG_2_THIGH_WERT, "\"min\"");
unsigned long STAT_HIS_EFF_CURR_CHG_3_THIGH_WERT = (RXBUF_UINT32(24));
// ONLY SE03 !!! With 25 <= T <40: Duration in minutes of the relative value of Irms_cha / Irms_cha_lim when
// loading in the class: 100 <Irel_cha <= 140 / NUR SE03!!! Bei 25 <= T < 40: Dauer in Minuten des Relativwerts
// von Irms_cha/Irms_cha_lim beim Laden in der Klasse: 100 < Irel_cha <= 140
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_THIGH", "STAT_HIS_EFF_CURR_CHG_3_THIGH_WERT", STAT_HIS_EFF_CURR_CHG_3_THIGH_WERT, "\"min\"");
unsigned long STAT_HIS_EFF_CURR_CHG_4_THIGH_WERT = (RXBUF_UINT32(28));
// ONLY SE03 !!! With 25 <= T <40: Duration in minutes of the relative value of Irms_cha / Irms_cha_lim when
// loading in the class: 140 <Irel_cha / NUR SE03!!! Bei 25 <= T < 40: Dauer in Minuten des Relativwerts von
// Irms_cha/Irms_cha_lim beim Laden in der Klasse: 140 < Irel_cha
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_THIGH", "STAT_HIS_EFF_CURR_CHG_4_THIGH_WERT", STAT_HIS_EFF_CURR_CHG_4_THIGH_WERT, "\"min\"");
unsigned long STAT_HIS_EFF_CURR_ABS_1_THIGH_WERT = (RXBUF_UINT32(32));
// ONLY SE03 !!! With 25 <= T <40: Duration in minutes of the relative value of Irms_abs / Irms_dch_lim when
// loading and unloading in the class: 0 <= Irel_abs <= 70 / NUR SE03!!! Bei 25 <= T < 40: Dauer in Minuten des
// Relativwerts von Irms_abs/Irms_dch_lim beim Laden und Entladen in der Klasse: 0 <= Irel_abs <= 70
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_THIGH", "STAT_HIS_EFF_CURR_ABS_1_THIGH_WERT", STAT_HIS_EFF_CURR_ABS_1_THIGH_WERT, "\"min\"");
unsigned long STAT_HIS_EFF_CURR_ABS_2_THIGH_WERT = (RXBUF_UINT32(36));
// ONLY SE03 !!! With 25 <= T <40: Duration in minutes of the relative value of Irms_abs / Irms_dch_lim when
// loading and unloading in the class: 70 <Irel_abs <= 100 / NUR SE03!!! Bei 25 <= T < 40: Dauer in Minuten des
// Relativwerts von Irms_abs/Irms_dch_lim beim Laden und Entladen in der Klasse: 70 < Irel_abs <= 100
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_THIGH", "STAT_HIS_EFF_CURR_ABS_2_THIGH_WERT", STAT_HIS_EFF_CURR_ABS_2_THIGH_WERT, "\"min\"");
unsigned long STAT_HIS_EFF_CURR_ABS_3_THIGH_WERT = (RXBUF_UINT32(40));
// ONLY SE03 !!! With 25 <= T <40: Duration in minutes of the relative value of Irms_abs / Irms_dch_lim when
// loading and unloading in the class: 100 <Irel_abs <= 140 / NUR SE03!!! Bei 25 <= T < 40: Dauer in Minuten des
// Relativwerts von Irms_abs/Irms_dch_lim beim Laden und Entladen in der Klasse: 100 < Irel_abs <= 140
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_THIGH", "STAT_HIS_EFF_CURR_ABS_3_THIGH_WERT", STAT_HIS_EFF_CURR_ABS_3_THIGH_WERT, "\"min\"");
unsigned long STAT_HIS_EFF_CURR_ABS_4_THIGH_WERT = (RXBUF_UINT32(44));
// ONLY SE03 !!! If 25 <= T <40: Duration in minutes of the relative value of Irms_abs / Irms_dch_lim when
// loading and unloading in the class: 140 <Irel_abs / NUR SE03!!! Bei 25 <= T < 40: Dauer in Minuten des
// Relativwerts von Irms_abs/Irms_dch_lim beim Laden und Entladen in der Klasse: 140 < Irel_abs
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_THIGH", "STAT_HIS_EFF_CURR_ABS_4_THIGH_WERT", STAT_HIS_EFF_CURR_ABS_4_THIGH_WERT, "\"min\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_HIS_EFF_STROM_TMAX: { // 0xDF8E
if (datalen < 48) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_HIS_EFF_STROM_TMAX", 48);
break;
}
unsigned long STAT_CHA_EFF_CURR_LIM_100_PERC_TMAX_WERT = (RXBUF_UINT32(0));
// At 40 <= T: RMS value of the current limit when loading to 100% life [Irms_cha (% 100)] >> This
// status output is no longer required and is set to zero. / Bei 40 <= T: Effektivwert der Stromgrenze beim Laden
// auf 100% Leben [Irms_cha(%100)] >> Dieses Statusausgabe wird nicht mehr benötigt und ist mit Null bedatet.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_TMAX", "STAT_CHA_EFF_CURR_LIM_100_PERC_TMAX_WERT", STAT_CHA_EFF_CURR_LIM_100_PERC_TMAX_WERT, "\"A\"");
unsigned long STAT_CHA_EFF_CURR_LIM_3_PERC_TMAX_WERT = (RXBUF_UINT32(4));
// At 40 <= T: effective value of the current limit when loading to 3% life [Irms_cha (% 3)] >> This
// status output is no longer required and is set to zero. / Bei 40 <= T: Effektivwert der Stromgrenze beim Laden
// auf 3% Leben [Irms_cha(%3)] >> Dieses Statusausgabe wird nicht mehr benötigt und ist mit Null bedatet.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_TMAX", "STAT_CHA_EFF_CURR_LIM_3_PERC_TMAX_WERT", STAT_CHA_EFF_CURR_LIM_3_PERC_TMAX_WERT, "\"A\"");
unsigned long STAT_ABS_EFF_CURR_LIM_100_PERC_TMAX_WERT = (RXBUF_UINT32(8));
// At 40 <= T: RMS value of the current limit when charging and discharging (absolute) to 100% life [Irms_abs
// (% 100)] >> This status output is no longer required and is set to zero. / Bei 40 <= T: Effektivwert der
// Stromgrenze beim Laden und Entladen (Absolut) auf 100% Leben [Irms_abs(%100)] >> Dieses Statusausgabe wird
// nicht mehr benötigt und ist mit Null bedatet.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_TMAX", "STAT_ABS_EFF_CURR_LIM_100_PERC_TMAX_WERT", STAT_ABS_EFF_CURR_LIM_100_PERC_TMAX_WERT, "\"A\"");
unsigned long STAT_ABS_EFF_CURR_LIM_3_PERC_TMAX_WERT = (RXBUF_UINT32(12));
// At 40 <= T: RMS value of the current limit when charging and discharging (absolute) to 3% life [Irms_abs (%
// 3)] >> This status output is no longer required and is set to zero. / Bei 40 <= T: Effektivwert der
// Stromgrenze beim Laden und Entladen (Absolut) auf 3% Leben [Irms_abs(%3)] >> Dieses Statusausgabe wird nicht
// mehr benötigt und ist mit Null bedatet.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_TMAX", "STAT_ABS_EFF_CURR_LIM_3_PERC_TMAX_WERT", STAT_ABS_EFF_CURR_LIM_3_PERC_TMAX_WERT, "\"A\"");
unsigned long STAT_HIS_EFF_CURR_CHG_1_TMAX_WERT = (RXBUF_UINT32(16));
// At 40 <= T: Duration in minutes of the relative value of Irms_cha / Irms_cha_lim when loading in the class: 0
// <= Irel_cha <= 70 / Bei 40 <= T: Dauer in Minuten des Relativwerts von Irms_cha/Irms_cha_lim beim Laden in der
// Klasse: 0 <= Irel_cha <= 70
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_TMAX", "STAT_HIS_EFF_CURR_CHG_1_TMAX_WERT", STAT_HIS_EFF_CURR_CHG_1_TMAX_WERT, "\"min\"");
unsigned long STAT_HIS_EFF_CURR_CHG_2_TMAX_WERT = (RXBUF_UINT32(20));
// At 40 <= T: Duration in minutes of the relative value of Irms_cha / Irms_cha_lim when loading in the class: 70
// <Irel_cha <= 100 / Bei 40 <= T: Dauer in Minuten des Relativwerts von Irms_cha/Irms_cha_lim beim Laden in der
// Klasse: 70 < Irel_cha <= 100
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_TMAX", "STAT_HIS_EFF_CURR_CHG_2_TMAX_WERT", STAT_HIS_EFF_CURR_CHG_2_TMAX_WERT, "\"min\"");
unsigned long STAT_HIS_EFF_CURR_CHG_3_TMAX_WERT = (RXBUF_UINT32(24));
// At 40 <= T: Duration in minutes of the relative value of Irms_cha / Irms_cha_lim when loading in the class:
// 100 <Irel_cha <= 140 / Bei 40 <= T: Dauer in Minuten des Relativwerts von Irms_cha/Irms_cha_lim beim Laden in
// der Klasse: 100 < Irel_cha <= 140
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_TMAX", "STAT_HIS_EFF_CURR_CHG_3_TMAX_WERT", STAT_HIS_EFF_CURR_CHG_3_TMAX_WERT, "\"min\"");
unsigned long STAT_HIS_EFF_CURR_CHG_4_TMAX_WERT = (RXBUF_UINT32(28));
// At 40 <= T: Duration in minutes of the relative value of Irms_cha / Irms_cha_lim when loading in the class:
// 140 <Irel_cha / Bei 40 <= T: Dauer in Minuten des Relativwerts von Irms_cha/Irms_cha_lim beim Laden in der
// Klasse: 140 < Irel_cha
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_TMAX", "STAT_HIS_EFF_CURR_CHG_4_TMAX_WERT", STAT_HIS_EFF_CURR_CHG_4_TMAX_WERT, "\"min\"");
unsigned long STAT_HIS_EFF_CURR_ABS_1_TMAX_WERT = (RXBUF_UINT32(32));
// At 40 <= T: Duration in minutes of the relative value of Irms_abs / Irms_dch_lim when loading and unloading in
// the class: 0 <= Irel_abs <= 70 / Bei 40 <= T: Dauer in Minuten des Relativwerts von Irms_abs/Irms_dch_lim beim
// Laden und Entladen in der Klasse: 0 <= Irel_abs <= 70
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_TMAX", "STAT_HIS_EFF_CURR_ABS_1_TMAX_WERT", STAT_HIS_EFF_CURR_ABS_1_TMAX_WERT, "\"min\"");
unsigned long STAT_HIS_EFF_CURR_ABS_2_TMAX_WERT = (RXBUF_UINT32(36));
// At 40 <= T: Duration in minutes of the relative value of Irms_abs / Irms_dch_lim when loading and unloading in
// the class: 70 <Irel_abs <= 100 / Bei 40 <= T: Dauer in Minuten des Relativwerts von Irms_abs/Irms_dch_lim beim
// Laden und Entladen in der Klasse: 70 < Irel_abs <= 100
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_TMAX", "STAT_HIS_EFF_CURR_ABS_2_TMAX_WERT", STAT_HIS_EFF_CURR_ABS_2_TMAX_WERT, "\"min\"");
unsigned long STAT_HIS_EFF_CURR_ABS_3_TMAX_WERT = (RXBUF_UINT32(40));
// At 40 <= T: Duration in minutes of the relative value of Irms_abs / Irms_dch_lim when loading and unloading in
// the class: 100 <Irel_abs <= 140 / Bei 40 <= T: Dauer in Minuten des Relativwerts von Irms_abs/Irms_dch_lim
// beim Laden und Entladen in der Klasse: 100 < Irel_abs <= 140
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_TMAX", "STAT_HIS_EFF_CURR_ABS_3_TMAX_WERT", STAT_HIS_EFF_CURR_ABS_3_TMAX_WERT, "\"min\"");
unsigned long STAT_HIS_EFF_CURR_ABS_4_TMAX_WERT = (RXBUF_UINT32(44));
// At 40 <= T: Duration in minutes of the relative value of Irms_abs / Irms_dch_lim when loading and unloading in
// the class: 140 <Irel_abs / Bei 40 <= T: Dauer in Minuten des Relativwerts von Irms_abs/Irms_dch_lim beim Laden
// und Entladen in der Klasse: 140 < Irel_abs
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_EFF_STROM_TMAX", "STAT_HIS_EFF_CURR_ABS_4_TMAX_WERT", STAT_HIS_EFF_CURR_ABS_4_TMAX_WERT, "\"min\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_HIS_ERR_LIM_STROM_TMIN: { // 0xDF8F
if (datalen < 24) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_HIS_ERR_LIM_STROM_TMIN", 24);
break;
}
float STAT_CHA_CURR_ERR_INT_LIM_TMIN_WERT = (RXBUF_UINT32(0)/100.0f);
// At T <= -10: threshold value of the error integral of the current when loading [IerrIntLim_cha] / Bei T <=
// -10: Schwellwert des Fehlerintegrals des Stroms beim Laden [IerrIntLim_cha]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HIS_ERR_LIM_STROM_TMIN", "STAT_CHA_CURR_ERR_INT_LIM_TMIN_WERT", STAT_CHA_CURR_ERR_INT_LIM_TMIN_WERT, "\"As\"");
float STAT_DCH_CURR_ERR_INT_LIM_TMIN_WERT = (RXBUF_UINT32(4)/100.0f);
// At T <= -10: threshold value of the error integral of the current when discharging [IerrIntLim_dch] / Bei T <=
// -10: Schwellwert des Fehlerintegrals des Stroms beim Entladen [IerrIntLim_dch]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HIS_ERR_LIM_STROM_TMIN", "STAT_DCH_CURR_ERR_INT_LIM_TMIN_WERT", STAT_DCH_CURR_ERR_INT_LIM_TMIN_WERT, "\"As\"");
unsigned long STAT_HIS_CHG_ERR_LIM_STROM_1_TMIN_WERT = (RXBUF_UINT32(8));
// If T <= -10: Duration in minutes when loading in the class: 0 <= IerrInt_cha <IerrIntLim_cha / Bei T <= -10:
// Dauer in Minuten beim Laden in der Klasse: 0 <= IerrInt_cha < IerrIntLim_cha
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_ERR_LIM_STROM_TMIN", "STAT_HIS_CHG_ERR_LIM_STROM_1_TMIN_WERT", STAT_HIS_CHG_ERR_LIM_STROM_1_TMIN_WERT, "\"min\"");
unsigned long STAT_HIS_CHG_ERR_LIM_STROM_2_TMIN_WERT = (RXBUF_UINT32(12));
// If T <= -10: Duration in minutes when loading in the class: IerrInt_cha> IerrIntLim_cha / Bei T <= -10:
// Dauer in Minuten beim Laden in der Klasse: IerrInt_cha > IerrIntLim_cha
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_ERR_LIM_STROM_TMIN", "STAT_HIS_CHG_ERR_LIM_STROM_2_TMIN_WERT", STAT_HIS_CHG_ERR_LIM_STROM_2_TMIN_WERT, "\"min\"");
unsigned long STAT_HIS_DCH_ERR_LIM_STROM_1_TMIN_WERT = (RXBUF_UINT32(16));
// If T <= -10: Duration in minutes when loading in the class: 0 <= IerrInt_dch <IerrIntLim_dch / Bei T <= -10:
// Dauer in Minuten beim Laden in der Klasse: 0 <= IerrInt_dch < IerrIntLim_dch
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_ERR_LIM_STROM_TMIN", "STAT_HIS_DCH_ERR_LIM_STROM_1_TMIN_WERT", STAT_HIS_DCH_ERR_LIM_STROM_1_TMIN_WERT, "\"min\"");
unsigned long STAT_HIS_DCH_ERR_LIM_STROM_2_TMIN_WERT = (RXBUF_UINT32(20));
// If T <= -10: Duration in minutes when loading in the class: IerrInt_dch> IerrIntLim_dch / Bei T <= -10:
// Dauer in Minuten beim Laden in der Klasse: IerrInt_dch > IerrIntLim_dch
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_ERR_LIM_STROM_TMIN", "STAT_HIS_DCH_ERR_LIM_STROM_2_TMIN_WERT", STAT_HIS_DCH_ERR_LIM_STROM_2_TMIN_WERT, "\"min\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_HIS_ERR_LIM_STROM_TLOW: { // 0xDF90
if (datalen < 24) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_HIS_ERR_LIM_STROM_TLOW", 24);
break;
}
float STAT_CHA_CURR_ERR_INT_LIM_TLOW_WERT = (RXBUF_UINT32(0)/100.0f);
// At -10 <T <= 5: threshold value of the error integral of the current during loading [IerrIntLim_cha] / Bei -10
// < T <= 5: Schwellwert des Fehlerintegrals des Stroms beim Laden [IerrIntLim_cha]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HIS_ERR_LIM_STROM_TLOW", "STAT_CHA_CURR_ERR_INT_LIM_TLOW_WERT", STAT_CHA_CURR_ERR_INT_LIM_TLOW_WERT, "\"As\"");
float STAT_DCH_CURR_ERR_INT_LIM_TLOW_WERT = (RXBUF_UINT32(4)/100.0f);
// At -10 <T <= 5: threshold value of the error integral of the current during discharging [IerrIntLim_dch] / Bei
// -10 < T <= 5: Schwellwert des Fehlerintegrals des Stroms beim Entladen [IerrIntLim_dch]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HIS_ERR_LIM_STROM_TLOW", "STAT_DCH_CURR_ERR_INT_LIM_TLOW_WERT", STAT_DCH_CURR_ERR_INT_LIM_TLOW_WERT, "\"As\"");
unsigned long STAT_HIS_CHG_ERR_LIM_STROM_1_TLOW_WERT = (RXBUF_UINT32(8));
// With -10 <T <= 5: Duration in minutes when loading in the class: 0 <= IerrInt_cha <IerrIntLim_cha / Bei -10 <
// T <= 5: Dauer in Minuten beim Laden in der Klasse: 0 <= IerrInt_cha < IerrIntLim_cha
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_ERR_LIM_STROM_TLOW", "STAT_HIS_CHG_ERR_LIM_STROM_1_TLOW_WERT", STAT_HIS_CHG_ERR_LIM_STROM_1_TLOW_WERT, "\"min\"");
unsigned long STAT_HIS_CHG_ERR_LIM_STROM_2_TLOW_WERT = (RXBUF_UINT32(12));
// With -10 <T <= 5: Duration in minutes when loading in the class: IerrInt_cha> IerrIntLim_cha / Bei
// -10 < T <= 5: Dauer in Minuten beim Laden in der Klasse: IerrInt_cha > IerrIntLim_cha
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_ERR_LIM_STROM_TLOW", "STAT_HIS_CHG_ERR_LIM_STROM_2_TLOW_WERT", STAT_HIS_CHG_ERR_LIM_STROM_2_TLOW_WERT, "\"min\"");
unsigned long STAT_HIS_DCH_ERR_LIM_STROM_1_TLOW_WERT = (RXBUF_UINT32(16));
// With -10 <T <= 5: Duration in minutes when loading in the class: 0 <= IerrInt_dch <IerrIntLim_dch / Bei -10 <
// T <= 5: Dauer in Minuten beim Laden in der Klasse: 0 <= IerrInt_dch < IerrIntLim_dch
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_ERR_LIM_STROM_TLOW", "STAT_HIS_DCH_ERR_LIM_STROM_1_TLOW_WERT", STAT_HIS_DCH_ERR_LIM_STROM_1_TLOW_WERT, "\"min\"");
unsigned long STAT_HIS_DCH_ERR_LIM_STROM_2_TLOW_WERT = (RXBUF_UINT32(20));
// With -10 <T <= 5: Duration in minutes when loading in the class: IerrInt_dch> IerrIntLim_dch / Bei
// -10 < T <= 5: Dauer in Minuten beim Laden in der Klasse: IerrInt_dch > IerrIntLim_dch
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_ERR_LIM_STROM_TLOW", "STAT_HIS_DCH_ERR_LIM_STROM_2_TLOW_WERT", STAT_HIS_DCH_ERR_LIM_STROM_2_TLOW_WERT, "\"min\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_HIS_ERR_LIM_STROM_THIGH: { // 0xDF91
if (datalen < 24) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_HIS_ERR_LIM_STROM_THIGH", 24);
break;
}
float STAT_CHA_CURR_ERR_INT_LIM_THIGH_WERT = (RXBUF_UINT32(0)/100.0f);
// If 5 <T <= 25: Threshold value of the error integral of the current when loading [IerrIntLim_cha] / Bei 5 < T
// <= 25: Schwellwert des Fehlerintegrals des Stroms beim Laden [IerrIntLim_cha]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HIS_ERR_LIM_STROM_THIGH", "STAT_CHA_CURR_ERR_INT_LIM_THIGH_WERT", STAT_CHA_CURR_ERR_INT_LIM_THIGH_WERT, "\"As\"");
float STAT_DCH_CURR_ERR_INT_LIM_THIGH_WERT = (RXBUF_UINT32(4)/100.0f);
// If 5 <T <= 25: threshold value of the error integral of the current during discharge [IerrIntLim_dch] / Bei 5
// < T <= 25: Schwellwert des Fehlerintegrals des Stroms beim Entladen [IerrIntLim_dch]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HIS_ERR_LIM_STROM_THIGH", "STAT_DCH_CURR_ERR_INT_LIM_THIGH_WERT", STAT_DCH_CURR_ERR_INT_LIM_THIGH_WERT, "\"As\"");
unsigned long STAT_HIS_CHG_ERR_LIM_STROM_1_THIGH_WERT = (RXBUF_UINT32(8));
// With 5 <T <= 25: Duration in minutes when loading in the class: 0 <= IerrInt_cha <IerrIntLim_cha / Bei 5 < T
// <= 25: Dauer in Minuten beim Laden in der Klasse: 0 <= IerrInt_cha < IerrIntLim_cha
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_ERR_LIM_STROM_THIGH", "STAT_HIS_CHG_ERR_LIM_STROM_1_THIGH_WERT", STAT_HIS_CHG_ERR_LIM_STROM_1_THIGH_WERT, "\"min\"");
unsigned long STAT_HIS_CHG_ERR_LIM_STROM_2_THIGH_WERT = (RXBUF_UINT32(12));
// With 5 <T <= 25: Duration in minutes when loading in the class: IerrInt_cha> IerrIntLim_cha / Bei 5 <
// T <= 25: Dauer in Minuten beim Laden in der Klasse: IerrInt_cha > IerrIntLim_cha
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_ERR_LIM_STROM_THIGH", "STAT_HIS_CHG_ERR_LIM_STROM_2_THIGH_WERT", STAT_HIS_CHG_ERR_LIM_STROM_2_THIGH_WERT, "\"min\"");
unsigned long STAT_HIS_DCH_ERR_LIM_STROM_1_THIGH_WERT = (RXBUF_UINT32(16));
// With 5 <T <= 25: Duration in minutes when loading in the class: 0 <= IerrInt_dch <IerrIntLim_dch / Bei 5 < T
// <= 25: Dauer in Minuten beim Laden in der Klasse: 0 <= IerrInt_dch < IerrIntLim_dch
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_ERR_LIM_STROM_THIGH", "STAT_HIS_DCH_ERR_LIM_STROM_1_THIGH_WERT", STAT_HIS_DCH_ERR_LIM_STROM_1_THIGH_WERT, "\"min\"");
unsigned long STAT_HIS_DCH_ERR_LIM_STROM_2_THIGH_WERT = (RXBUF_UINT32(20));
// With 5 <T <= 25: Duration in minutes when loading in the class: IerrInt_dch> IerrIntLim_dch / Bei 5 <
// T <= 25: Dauer in Minuten beim Laden in der Klasse: IerrInt_dch > IerrIntLim_dch
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_ERR_LIM_STROM_THIGH", "STAT_HIS_DCH_ERR_LIM_STROM_2_THIGH_WERT", STAT_HIS_DCH_ERR_LIM_STROM_2_THIGH_WERT, "\"min\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_HIS_ERR_LIM_STROM_TMAX: { // 0xDF92
if (datalen < 24) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_HIS_ERR_LIM_STROM_TMAX", 24);
break;
}
float STAT_CHA_CURR_ERR_INT_LIM_TMAX_WERT = (RXBUF_UINT32(0)/100.0f);
// If 25 <T: threshold value of the error integral of the current during loading [IerrIntLim_cha] / Bei 25 < T:
// Schwellwert des Fehlerintegrals des Stroms beim Laden [IerrIntLim_cha]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HIS_ERR_LIM_STROM_TMAX", "STAT_CHA_CURR_ERR_INT_LIM_TMAX_WERT", STAT_CHA_CURR_ERR_INT_LIM_TMAX_WERT, "\"As\"");
float STAT_DCH_CURR_ERR_INT_LIM_TMAX_WERT = (RXBUF_UINT32(4)/100.0f);
// If 25 <T: threshold value of the error integral of the current during discharging [IerrIntLim_dch] / Bei 25 <
// T: Schwellwert des Fehlerintegrals des Stroms beim Entladen [IerrIntLim_dch]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HIS_ERR_LIM_STROM_TMAX", "STAT_DCH_CURR_ERR_INT_LIM_TMAX_WERT", STAT_DCH_CURR_ERR_INT_LIM_TMAX_WERT, "\"As\"");
unsigned long STAT_HIS_CHG_ERR_LIM_STROM_1_TMAX_WERT = (RXBUF_UINT32(8));
// At 25 <T: Duration in minutes when loading in the class: 0 <= IerrInt_cha <IerrIntLim_cha / Bei 25 < T: Dauer
// in Minuten beim Laden in der Klasse: 0 <= IerrInt_cha < IerrIntLim_cha
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_ERR_LIM_STROM_TMAX", "STAT_HIS_CHG_ERR_LIM_STROM_1_TMAX_WERT", STAT_HIS_CHG_ERR_LIM_STROM_1_TMAX_WERT, "\"min\"");
unsigned long STAT_HIS_CHG_ERR_LIM_STROM_2_TMAX_WERT = (RXBUF_UINT32(12));
// At 25 <T: Duration in minutes when loading in the class: IerrInt_cha> IerrIntLim_cha / Bei 25 < T: Dauer
// in Minuten beim Laden in der Klasse: IerrInt_cha > IerrIntLim_cha
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_ERR_LIM_STROM_TMAX", "STAT_HIS_CHG_ERR_LIM_STROM_2_TMAX_WERT", STAT_HIS_CHG_ERR_LIM_STROM_2_TMAX_WERT, "\"min\"");
unsigned long STAT_HIS_DCH_ERR_LIM_STROM_1_TMAX_WERT = (RXBUF_UINT32(16));
// At 25 <T: Duration in minutes when loading in the class: 0 <= IerrInt_dch <IerrIntLim_dch / Bei 25 < T: Dauer
// in Minuten beim Laden in der Klasse: 0 <= IerrInt_dch < IerrIntLim_dch
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_ERR_LIM_STROM_TMAX", "STAT_HIS_DCH_ERR_LIM_STROM_1_TMAX_WERT", STAT_HIS_DCH_ERR_LIM_STROM_1_TMAX_WERT, "\"min\"");
unsigned long STAT_HIS_DCH_ERR_LIM_STROM_2_TMAX_WERT = (RXBUF_UINT32(20));
// At 25 <T: Duration in minutes when loading in the class: IerrInt_dch> IerrIntLim_dch / Bei 25 < T: Dauer
// in Minuten beim Laden in der Klasse: IerrInt_dch > IerrIntLim_dch
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HIS_ERR_LIM_STROM_TMAX", "STAT_HIS_DCH_ERR_LIM_STROM_2_TMAX_WERT", STAT_HIS_DCH_ERR_LIM_STROM_2_TMAX_WERT, "\"min\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_LADEZEIT_ADAPT_KENNFELD_LESEN: { // 0xDF9C
if (datalen < 51) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_LADEZEIT_ADAPT_KENNFELD_LESEN", 51);
break;
}
float STAT_PWR_STUETZP_P1_WERT = (RXBUF_UCHAR(0)*200.0f);
// Available charging power, base P1 / Zur Verfügung stehende Ladeleistung, Stützpunkt P1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "LADEZEIT_ADAPT_KENNFELD_LESEN", "STAT_PWR_STUETZP_P1_WERT", STAT_PWR_STUETZP_P1_WERT, "\"W\"");
float STAT_PWR_STUETZP_P2_WERT = (RXBUF_UCHAR(1)*200.0f);
// Available charging power, base P2 / Zur Verfügung stehende Ladeleistung, Stützpunkt P2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "LADEZEIT_ADAPT_KENNFELD_LESEN", "STAT_PWR_STUETZP_P2_WERT", STAT_PWR_STUETZP_P2_WERT, "\"W\"");
char STAT_TEMP_STUETZP_T1_WERT = (RXBUF_SCHAR(2));
// Storage tank temperature, support point T1 / Speichertemperatur, Stützpunkt T1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADEZEIT_ADAPT_KENNFELD_LESEN", "STAT_TEMP_STUETZP_T1_WERT", STAT_TEMP_STUETZP_T1_WERT, "\"°C\"");
char STAT_TEMP_STUETZP_T2_WERT = (RXBUF_SCHAR(3));
// Storage tank temperature, support point T2 / Speichertemperatur, Stützpunkt T2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADEZEIT_ADAPT_KENNFELD_LESEN", "STAT_TEMP_STUETZP_T2_WERT", STAT_TEMP_STUETZP_T2_WERT, "\"°C\"");
char STAT_TEMP_STUETZP_T3_WERT = (RXBUF_SCHAR(4));
// Storage tank temperature, support point T3 / Speichertemperatur, Stützpunkt T3
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADEZEIT_ADAPT_KENNFELD_LESEN", "STAT_TEMP_STUETZP_T3_WERT", STAT_TEMP_STUETZP_T3_WERT, "\"°C\"");
char STAT_TEMP_STUETZP_T4_WERT = (RXBUF_SCHAR(5));
// Storage tank temperature, support point T4 / Speichertemperatur, Stützpunkt T4
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADEZEIT_ADAPT_KENNFELD_LESEN", "STAT_TEMP_STUETZP_T4_WERT", STAT_TEMP_STUETZP_T4_WERT, "\"°C\"");
unsigned char STAT_SOC_STUETZP_SOC1_WERT = (RXBUF_UCHAR(6));
// SOC (SOC_akt_max), base point SOC1 / SOC (SOC_akt_max), Stützpunkt SOC1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADEZEIT_ADAPT_KENNFELD_LESEN", "STAT_SOC_STUETZP_SOC1_WERT", STAT_SOC_STUETZP_SOC1_WERT, "\"%\"");
unsigned char STAT_SOC_STUETZP_SOC2_WERT = (RXBUF_UCHAR(7));
// SOC (SOC_akt_max), base point SOC2 / SOC (SOC_akt_max), Stützpunkt SOC2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADEZEIT_ADAPT_KENNFELD_LESEN", "STAT_SOC_STUETZP_SOC2_WERT", STAT_SOC_STUETZP_SOC2_WERT, "\"%\"");
unsigned char STAT_SOC_STUETZP_SOC3_WERT = (RXBUF_UCHAR(8));
// SOC (SOC_akt_max), base point SOC3 / SOC (SOC_akt_max), Stützpunkt SOC3
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADEZEIT_ADAPT_KENNFELD_LESEN", "STAT_SOC_STUETZP_SOC3_WERT", STAT_SOC_STUETZP_SOC3_WERT, "\"%\"");
unsigned char STAT_SOC_STUETZP_SOC4_WERT = (RXBUF_UCHAR(9));
// SOC (SOC_akt_max), base point SOC4 / SOC (SOC_akt_max), Stützpunkt SOC4
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADEZEIT_ADAPT_KENNFELD_LESEN", "STAT_SOC_STUETZP_SOC4_WERT", STAT_SOC_STUETZP_SOC4_WERT, "\"%\"");
unsigned char STAT_SOC_STUETZP_SOC5_WERT = (RXBUF_UCHAR(10));
// SOC (SOC_akt_max), base point SOC5 / SOC (SOC_akt_max), Stützpunkt SOC5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADEZEIT_ADAPT_KENNFELD_LESEN", "STAT_SOC_STUETZP_SOC5_WERT", STAT_SOC_STUETZP_SOC5_WERT, "\"%\"");
unsigned char STAT_FAKT_P1_T1_SOC1_WERT = (RXBUF_UCHAR(11));
// Learning factor, characteristic value P1_T1_SOC1 / Lernfaktor, Kennwert P1_T1_SOC1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADEZEIT_ADAPT_KENNFELD_LESEN", "STAT_FAKT_P1_T1_SOC1_WERT", STAT_FAKT_P1_T1_SOC1_WERT, "\"%\"");
unsigned char STAT_FAKT_P1_T1_SOC2_WERT = (RXBUF_UCHAR(12));
// Learning factor, characteristic value P1_T1_SOC2 / Lernfaktor, Kennwert P1_T1_SOC2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADEZEIT_ADAPT_KENNFELD_LESEN", "STAT_FAKT_P1_T1_SOC2_WERT", STAT_FAKT_P1_T1_SOC2_WERT, "\"%\"");
unsigned char STAT_FAKT_P1_T1_SOC3_WERT = (RXBUF_UCHAR(13));
// Learning factor, characteristic value P1_T1_SOC3 / Lernfaktor, Kennwert P1_T1_SOC3
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADEZEIT_ADAPT_KENNFELD_LESEN", "STAT_FAKT_P1_T1_SOC3_WERT", STAT_FAKT_P1_T1_SOC3_WERT, "\"%\"");
unsigned char STAT_FAKT_P1_T1_SOC4_WERT = (RXBUF_UCHAR(14));
// Learning factor, characteristic value P1_T1_SOC4 / Lernfaktor, Kennwert P1_T1_SOC4
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADEZEIT_ADAPT_KENNFELD_LESEN", "STAT_FAKT_P1_T1_SOC4_WERT", STAT_FAKT_P1_T1_SOC4_WERT, "\"%\"");
unsigned char STAT_FAKT_P1_T1_SOC5_WERT = (RXBUF_UCHAR(15));
// Learning factor, characteristic value P1_T1_SOC5 / Lernfaktor, Kennwert P1_T1_SOC5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADEZEIT_ADAPT_KENNFELD_LESEN", "STAT_FAKT_P1_T1_SOC5_WERT", STAT_FAKT_P1_T1_SOC5_WERT, "\"%\"");
unsigned char STAT_FAKT_P1_T2_SOC1_WERT = (RXBUF_UCHAR(16));
// Learning factor, characteristic value P1_T2_SOC1 / Lernfaktor, Kennwert P1_T2_SOC1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADEZEIT_ADAPT_KENNFELD_LESEN", "STAT_FAKT_P1_T2_SOC1_WERT", STAT_FAKT_P1_T2_SOC1_WERT, "\"%\"");
unsigned char STAT_FAKT_P1_T2_SOC2_WERT = (RXBUF_UCHAR(17));
// Learning factor, characteristic value P1_T2_SOC2 / Lernfaktor, Kennwert P1_T2_SOC2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADEZEIT_ADAPT_KENNFELD_LESEN", "STAT_FAKT_P1_T2_SOC2_WERT", STAT_FAKT_P1_T2_SOC2_WERT, "\"%\"");
unsigned char STAT_FAKT_P1_T2_SOC3_WERT = (RXBUF_UCHAR(18));
// Learning factor, characteristic value P1_T2_SOC3 / Lernfaktor, Kennwert P1_T2_SOC3
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADEZEIT_ADAPT_KENNFELD_LESEN", "STAT_FAKT_P1_T2_SOC3_WERT", STAT_FAKT_P1_T2_SOC3_WERT, "\"%\"");
unsigned char STAT_FAKT_P1_T2_SOC4_WERT = (RXBUF_UCHAR(19));
// Learning factor, characteristic value P1_T2_SOC4 / Lernfaktor, Kennwert P1_T2_SOC4
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADEZEIT_ADAPT_KENNFELD_LESEN", "STAT_FAKT_P1_T2_SOC4_WERT", STAT_FAKT_P1_T2_SOC4_WERT, "\"%\"");
unsigned char STAT_FAKT_P1_T2_SOC5_WERT = (RXBUF_UCHAR(20));
// Learning factor, characteristic value P1_T2_SOC5 / Lernfaktor, Kennwert P1_T2_SOC5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADEZEIT_ADAPT_KENNFELD_LESEN", "STAT_FAKT_P1_T2_SOC5_WERT", STAT_FAKT_P1_T2_SOC5_WERT, "\"%\"");
unsigned char STAT_FAKT_P1_T3_SOC1_WERT = (RXBUF_UCHAR(21));
// Learning factor, characteristic value P1_T3_SOC1 / Lernfaktor, Kennwert P1_T3_SOC1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADEZEIT_ADAPT_KENNFELD_LESEN", "STAT_FAKT_P1_T3_SOC1_WERT", STAT_FAKT_P1_T3_SOC1_WERT, "\"%\"");
unsigned char STAT_FAKT_P1_T3_SOC2_WERT = (RXBUF_UCHAR(22));
// Learning factor, characteristic value P1_T3_SOC2 / Lernfaktor, Kennwert P1_T3_SOC2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADEZEIT_ADAPT_KENNFELD_LESEN", "STAT_FAKT_P1_T3_SOC2_WERT", STAT_FAKT_P1_T3_SOC2_WERT, "\"%\"");
unsigned char STAT_FAKT_P1_T3_SOC3_WERT = (RXBUF_UCHAR(23));
// Learning factor, characteristic value P1_T3_SOC3 / Lernfaktor, Kennwert P1_T3_SOC3
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADEZEIT_ADAPT_KENNFELD_LESEN", "STAT_FAKT_P1_T3_SOC3_WERT", STAT_FAKT_P1_T3_SOC3_WERT, "\"%\"");
unsigned char STAT_FAKT_P1_T3_SOC4_WERT = (RXBUF_UCHAR(24));
// Learning factor, characteristic value P1_T3_SOC4 / Lernfaktor, Kennwert P1_T3_SOC4
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADEZEIT_ADAPT_KENNFELD_LESEN", "STAT_FAKT_P1_T3_SOC4_WERT", STAT_FAKT_P1_T3_SOC4_WERT, "\"%\"");
unsigned char STAT_FAKT_P1_T3_SOC5_WERT = (RXBUF_UCHAR(25));
// Learning factor, characteristic value P1_T3_SOC5 / Lernfaktor, Kennwert P1_T3_SOC5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADEZEIT_ADAPT_KENNFELD_LESEN", "STAT_FAKT_P1_T3_SOC5_WERT", STAT_FAKT_P1_T3_SOC5_WERT, "\"%\"");
unsigned char STAT_FAKT_P1_T4_SOC1_WERT = (RXBUF_UCHAR(26));
// Learning factor, characteristic value P1_T4_SOC1 / Lernfaktor, Kennwert P1_T4_SOC1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADEZEIT_ADAPT_KENNFELD_LESEN", "STAT_FAKT_P1_T4_SOC1_WERT", STAT_FAKT_P1_T4_SOC1_WERT, "\"%\"");
unsigned char STAT_FAKT_P1_T4_SOC2_WERT = (RXBUF_UCHAR(27));
// Learning factor, characteristic value P1_T4_SOC2 / Lernfaktor, Kennwert P1_T4_SOC2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADEZEIT_ADAPT_KENNFELD_LESEN", "STAT_FAKT_P1_T4_SOC2_WERT", STAT_FAKT_P1_T4_SOC2_WERT, "\"%\"");
unsigned char STAT_FAKT_P1_T4_SOC3_WERT = (RXBUF_UCHAR(28));
// Learning factor, characteristic value P1_T4_SOC3 / Lernfaktor, Kennwert P1_T4_SOC3
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADEZEIT_ADAPT_KENNFELD_LESEN", "STAT_FAKT_P1_T4_SOC3_WERT", STAT_FAKT_P1_T4_SOC3_WERT, "\"%\"");
unsigned char STAT_FAKT_P1_T4_SOC4_WERT = (RXBUF_UCHAR(29));
// Learning factor, characteristic value P1_T4_SOC4 / Lernfaktor, Kennwert P1_T4_SOC4
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADEZEIT_ADAPT_KENNFELD_LESEN", "STAT_FAKT_P1_T4_SOC4_WERT", STAT_FAKT_P1_T4_SOC4_WERT, "\"%\"");
unsigned char STAT_FAKT_P1_T4_SOC5_WERT = (RXBUF_UCHAR(30));
// Learning factor, characteristic value P1_T4_SOC5 / Lernfaktor, Kennwert P1_T4_SOC5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADEZEIT_ADAPT_KENNFELD_LESEN", "STAT_FAKT_P1_T4_SOC5_WERT", STAT_FAKT_P1_T4_SOC5_WERT, "\"%\"");
unsigned char STAT_FAKT_P2_T1_SOC1_WERT = (RXBUF_UCHAR(31));
// Learning factor, characteristic value P2_T1_SOC1 / Lernfaktor, Kennwert P2_T1_SOC1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADEZEIT_ADAPT_KENNFELD_LESEN", "STAT_FAKT_P2_T1_SOC1_WERT", STAT_FAKT_P2_T1_SOC1_WERT, "\"%\"");
unsigned char STAT_FAKT_P2_T1_SOC2_WERT = (RXBUF_UCHAR(32));
// Learning factor, characteristic value P2_T1_SOC2 / Lernfaktor, Kennwert P2_T1_SOC2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADEZEIT_ADAPT_KENNFELD_LESEN", "STAT_FAKT_P2_T1_SOC2_WERT", STAT_FAKT_P2_T1_SOC2_WERT, "\"%\"");
unsigned char STAT_FAKT_P2_T1_SOC3_WERT = (RXBUF_UCHAR(33));
// Learning factor, characteristic value P2_T1_SOC3 / Lernfaktor, Kennwert P2_T1_SOC3
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADEZEIT_ADAPT_KENNFELD_LESEN", "STAT_FAKT_P2_T1_SOC3_WERT", STAT_FAKT_P2_T1_SOC3_WERT, "\"%\"");
unsigned char STAT_FAKT_P2_T1_SOC4_WERT = (RXBUF_UCHAR(34));
// Learning factor, characteristic value P2_T1_SOC4 / Lernfaktor, Kennwert P2_T1_SOC4
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADEZEIT_ADAPT_KENNFELD_LESEN", "STAT_FAKT_P2_T1_SOC4_WERT", STAT_FAKT_P2_T1_SOC4_WERT, "\"%\"");
unsigned char STAT_FAKT_P2_T1_SOC5_WERT = (RXBUF_UCHAR(35));
// Learning factor, characteristic value P2_T1_SOC5 / Lernfaktor, Kennwert P2_T1_SOC5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADEZEIT_ADAPT_KENNFELD_LESEN", "STAT_FAKT_P2_T1_SOC5_WERT", STAT_FAKT_P2_T1_SOC5_WERT, "\"%\"");
unsigned char STAT_FAKT_P2_T2_SOC1_WERT = (RXBUF_UCHAR(36));
// Learning factor, characteristic value P2_T2_SOC1 / Lernfaktor, Kennwert P2_T2_SOC1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADEZEIT_ADAPT_KENNFELD_LESEN", "STAT_FAKT_P2_T2_SOC1_WERT", STAT_FAKT_P2_T2_SOC1_WERT, "\"%\"");
unsigned char STAT_FAKT_P2_T2_SOC2_WERT = (RXBUF_UCHAR(37));
// Learning factor, characteristic value P2_T2_SOC2 / Lernfaktor, Kennwert P2_T2_SOC2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADEZEIT_ADAPT_KENNFELD_LESEN", "STAT_FAKT_P2_T2_SOC2_WERT", STAT_FAKT_P2_T2_SOC2_WERT, "\"%\"");
unsigned char STAT_FAKT_P2_T2_SOC3_WERT = (RXBUF_UCHAR(38));
// Learning factor, characteristic value P2_T2_SOC3 / Lernfaktor, Kennwert P2_T2_SOC3
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADEZEIT_ADAPT_KENNFELD_LESEN", "STAT_FAKT_P2_T2_SOC3_WERT", STAT_FAKT_P2_T2_SOC3_WERT, "\"%\"");
unsigned char STAT_FAKT_P2_T2_SOC4_WERT = (RXBUF_UCHAR(39));
// Learning factor, characteristic value P2_T2_SOC4 / Lernfaktor, Kennwert P2_T2_SOC4
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADEZEIT_ADAPT_KENNFELD_LESEN", "STAT_FAKT_P2_T2_SOC4_WERT", STAT_FAKT_P2_T2_SOC4_WERT, "\"%\"");
unsigned char STAT_FAKT_P2_T2_SOC5_WERT = (RXBUF_UCHAR(40));
// Learning factor, characteristic value P2_T2_SOC5 / Lernfaktor, Kennwert P2_T2_SOC5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADEZEIT_ADAPT_KENNFELD_LESEN", "STAT_FAKT_P2_T2_SOC5_WERT", STAT_FAKT_P2_T2_SOC5_WERT, "\"%\"");
unsigned char STAT_FAKT_P2_T3_SOC1_WERT = (RXBUF_UCHAR(41));
// Learning factor, characteristic value P2_T3_SOC1 / Lernfaktor, Kennwert P2_T3_SOC1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADEZEIT_ADAPT_KENNFELD_LESEN", "STAT_FAKT_P2_T3_SOC1_WERT", STAT_FAKT_P2_T3_SOC1_WERT, "\"%\"");
unsigned char STAT_FAKT_P2_T3_SOC2_WERT = (RXBUF_UCHAR(42));
// Learning factor, characteristic value P2_T3_SOC2 / Lernfaktor, Kennwert P2_T3_SOC2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADEZEIT_ADAPT_KENNFELD_LESEN", "STAT_FAKT_P2_T3_SOC2_WERT", STAT_FAKT_P2_T3_SOC2_WERT, "\"%\"");
unsigned char STAT_FAKT_P2_T3_SOC3_WERT = (RXBUF_UCHAR(43));
// Learning factor, characteristic value P2_T3_SOC3 / Lernfaktor, Kennwert P2_T3_SOC3
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADEZEIT_ADAPT_KENNFELD_LESEN", "STAT_FAKT_P2_T3_SOC3_WERT", STAT_FAKT_P2_T3_SOC3_WERT, "\"%\"");
unsigned char STAT_FAKT_P2_T3_SOC4_WERT = (RXBUF_UCHAR(44));
// Learning factor, characteristic value P2_T3_SOC4 / Lernfaktor, Kennwert P2_T3_SOC4
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADEZEIT_ADAPT_KENNFELD_LESEN", "STAT_FAKT_P2_T3_SOC4_WERT", STAT_FAKT_P2_T3_SOC4_WERT, "\"%\"");
unsigned char STAT_FAKT_P2_T3_SOC5_WERT = (RXBUF_UCHAR(45));
// Learning factor, characteristic value P2_T3_SOC5 / Lernfaktor, Kennwert P2_T3_SOC5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADEZEIT_ADAPT_KENNFELD_LESEN", "STAT_FAKT_P2_T3_SOC5_WERT", STAT_FAKT_P2_T3_SOC5_WERT, "\"%\"");
unsigned char STAT_FAKT_P2_T4_SOC1_WERT = (RXBUF_UCHAR(46));
// Learning factor, characteristic value P2_T4_SOC1 / Lernfaktor, Kennwert P2_T4_SOC1
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADEZEIT_ADAPT_KENNFELD_LESEN", "STAT_FAKT_P2_T4_SOC1_WERT", STAT_FAKT_P2_T4_SOC1_WERT, "\"%\"");
unsigned char STAT_FAKT_P2_T4_SOC2_WERT = (RXBUF_UCHAR(47));
// Learning factor, characteristic value P2_T4_SOC2 / Lernfaktor, Kennwert P2_T4_SOC2
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADEZEIT_ADAPT_KENNFELD_LESEN", "STAT_FAKT_P2_T4_SOC2_WERT", STAT_FAKT_P2_T4_SOC2_WERT, "\"%\"");
unsigned char STAT_FAKT_P2_T4_SOC3_WERT = (RXBUF_UCHAR(48));
// Learning factor, characteristic value P2_T4_SOC3 / Lernfaktor, Kennwert P2_T4_SOC3
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADEZEIT_ADAPT_KENNFELD_LESEN", "STAT_FAKT_P2_T4_SOC3_WERT", STAT_FAKT_P2_T4_SOC3_WERT, "\"%\"");
unsigned char STAT_FAKT_P2_T4_SOC4_WERT = (RXBUF_UCHAR(49));
// Learning factor, characteristic value P2_T4_SOC4 / Lernfaktor, Kennwert P2_T4_SOC4
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADEZEIT_ADAPT_KENNFELD_LESEN", "STAT_FAKT_P2_T4_SOC4_WERT", STAT_FAKT_P2_T4_SOC4_WERT, "\"%\"");
unsigned char STAT_FAKT_P2_T4_SOC5_WERT = (RXBUF_UCHAR(50));
// Learning factor, characteristic value P2_T4_SOC5 / Lernfaktor, Kennwert P2_T4_SOC5
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "LADEZEIT_ADAPT_KENNFELD_LESEN", "STAT_FAKT_P2_T4_SOC5_WERT", STAT_FAKT_P2_T4_SOC5_WERT, "\"%\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_VERH_VOLLADE_LADEVORG_LESEN: { // 0xDF9E
if (datalen < 1) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_VERH_VOLLADE_LADEVORG_LESEN", 1);
break;
}
unsigned char STAT_VERH_VOLLADE_LADEVORG_WERT = (RXBUF_UCHAR(0));
// Percentage of the ratio of full charges to total charges / Prozentualer Wert vom Verhältnis der
// Volladevorgänge zu den gesamten Ladevorgängen
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "VERH_VOLLADE_LADEVORG_LESEN", "STAT_VERH_VOLLADE_LADEVORG_WERT", STAT_VERH_VOLLADE_LADEVORG_WERT, "\"%\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_ZUSTAND_SPEICHER: { // 0xDFA0
if (datalen < 38) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_ZUSTAND_SPEICHER", 38);
break;
}
float STAT_ZELLKAPAZITAET_MIN_WERT = (RXBUF_UINT(0)/100.0f);
// Output of the current minimum measured cell capacity of all cells in Ah / Ausgabe der aktuellen minimalen
// gemessenen Zellkapazität aller Zellen in Ah
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ZUSTAND_SPEICHER", "STAT_ZELLKAPAZITAET_MIN_WERT", STAT_ZELLKAPAZITAET_MIN_WERT, "\"Ah\"");
float STAT_ZELLKAPAZITAET_MAX_WERT = (RXBUF_UINT(2)/100.0f);
// Output of the current maximum measured cell capacity of all cells in Ah / Ausgabe der aktuellen maximalen
// gemessenen Zellkapazität aller Zellen in Ah
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ZUSTAND_SPEICHER", "STAT_ZELLKAPAZITAET_MAX_WERT", STAT_ZELLKAPAZITAET_MAX_WERT, "\"Ah\"");
float STAT_ZELLKAPAZITAET_MEAN_WERT = (RXBUF_UINT(4)/100.0f);
// Output of the current mean measured cell capacity averaged over all cells in Ah / Ausgabe der aktuellen
// mittleren gemessenen Zellkapazität gemittelt über alle Zellen in Ah
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ZUSTAND_SPEICHER", "STAT_ZELLKAPAZITAET_MEAN_WERT", STAT_ZELLKAPAZITAET_MEAN_WERT, "\"Ah\"");
float STAT_ZELLSPANNUNG_MIN_WERT = (RXBUF_UINT(6)/10000.0f);
// Output of the current minimum measured cell voltage of all cells in V. / Ausgabe der aktuellen minimalen
// gemessenen Zellspannung aller Zellen in V
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ZUSTAND_SPEICHER", "STAT_ZELLSPANNUNG_MIN_WERT", STAT_ZELLSPANNUNG_MIN_WERT, "\"V\"");
float STAT_ZELLSPANNUNG_MAX_WERT = (RXBUF_UINT(8)/10000.0f);
// Output of the current maximum measured cell voltage of all cells in V / Ausgabe der aktuellen maximalen
// gemessenen Zellspannung aller Zellen in V
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ZUSTAND_SPEICHER", "STAT_ZELLSPANNUNG_MAX_WERT", STAT_ZELLSPANNUNG_MAX_WERT, "\"V\"");
float STAT_ZELLSPANNUNG_MEAN_WERT = (RXBUF_UINT(10)/10000.0f);
// Output of the current mean measured cell voltage of all cells in V / Ausgabe der aktuellen mittleren
// gemessenen Zellspannung aller Zellen in V
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ZUSTAND_SPEICHER", "STAT_ZELLSPANNUNG_MEAN_WERT", STAT_ZELLSPANNUNG_MEAN_WERT, "\"V\"");
float STAT_ZELLTEMPERATUR_MIN_WERT = (RXBUF_SINT(12)/100.0f);
// Output of the current minimum measured cell temperature of all cells in ° C / Ausgabe der aktuellen minimalen
// gemessenen Zelltemperatur aller Zellen in °C
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ZUSTAND_SPEICHER", "STAT_ZELLTEMPERATUR_MIN_WERT", STAT_ZELLTEMPERATUR_MIN_WERT, "\"°C\"");
float STAT_ZELLTEMPERATUR_MAX_WERT = (RXBUF_SINT(14)/100.0f);
// Output of the current maximum measured cell temperature of all cells in ° C / Ausgabe der aktuellen maximalen
// gemessenen Zelltemperatur aller Zellen in °C
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ZUSTAND_SPEICHER", "STAT_ZELLTEMPERATUR_MAX_WERT", STAT_ZELLTEMPERATUR_MAX_WERT, "\"°C\"");
float STAT_ZELLTEMPERATUR_MEAN_WERT = (RXBUF_SINT(16)/100.0f);
// Output of the current mean measured cell temperature of all cells in ° C / Ausgabe der aktuellen mittleren
// gemessenen Zelltemperatur aller Zellen in °C
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ZUSTAND_SPEICHER", "STAT_ZELLTEMPERATUR_MEAN_WERT", STAT_ZELLTEMPERATUR_MEAN_WERT, "\"°C\"");
float STAT_ZELLWIDERSTANDSFAKTOR_MIN_WERT = (RXBUF_UINT(18)/10000.0f);
// Output of the current minimum measured resistance factor of all cells / Ausgabe des aktuellen minimalen
// gemessenen Widerstandsfaktors aller Zellen
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ZUSTAND_SPEICHER", "STAT_ZELLWIDERSTANDSFAKTOR_MIN_WERT", STAT_ZELLWIDERSTANDSFAKTOR_MIN_WERT, "");
float STAT_ZELLWIDERSTANDSFAKTOR_MAX_WERT = (RXBUF_UINT(20)/10000.0f);
// Output of the current maximum measured resistance factor of all cells / Ausgabe des aktuellen maximalen
// gemessenen Widerstandsfaktors aller Zellen
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ZUSTAND_SPEICHER", "STAT_ZELLWIDERSTANDSFAKTOR_MAX_WERT", STAT_ZELLWIDERSTANDSFAKTOR_MAX_WERT, "");
float STAT_ZELLWIDERSTANDSFAKTOR_MEAN_WERT = (RXBUF_UINT(22)/10000.0f);
// Output of the current mean measured resistance factor of all cells / Ausgabe des aktuellen mittleren
// gemessenen Widerstandsfaktors aller Zellen
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ZUSTAND_SPEICHER", "STAT_ZELLWIDERSTANDSFAKTOR_MEAN_WERT", STAT_ZELLWIDERSTANDSFAKTOR_MEAN_WERT, "");
float STAT_ZELLSOC_MIN_WERT = (RXBUF_UINT(24)/100.0f);
// Output of the current minimum measured SoC of all cells in% / Ausgabe des aktuellen minimalen gemessenen SoC
// aller Zellen in %
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ZUSTAND_SPEICHER", "STAT_ZELLSOC_MIN_WERT", STAT_ZELLSOC_MIN_WERT, "\"%\"");
float STAT_ZELLSOC_MAX_WERT = (RXBUF_UINT(26)/100.0f);
// Output of the current maximum measured SoC of all cells in% / Ausgabe des aktuellen maximalen gemessenen SoC
// aller Zellen in %
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ZUSTAND_SPEICHER", "STAT_ZELLSOC_MAX_WERT", STAT_ZELLSOC_MAX_WERT, "\"%\"");
float STAT_ZELLSOC_MEAN_WERT = (RXBUF_UINT(28)/100.0f);
// Output of the current mean measured SoC of all cells in% / Ausgabe des aktuellen mittleren gemessenen SoC
// aller Zellen in %
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ZUSTAND_SPEICHER", "STAT_ZELLSOC_MEAN_WERT", STAT_ZELLSOC_MEAN_WERT, "\"%\"");
float STAT_ZELLOCV_MIN_WERT = (RXBUF_UINT(30)/10000.0f);
// Output of the current minimum OCV of all cells measured in the last resting state in V. / Ausgabe der
// aktuellen minimalen im letzten Ruhezustand gemessenen OCV aller Zellen in V
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ZUSTAND_SPEICHER", "STAT_ZELLOCV_MIN_WERT", STAT_ZELLOCV_MIN_WERT, "\"V\"");
float STAT_ZELLOCV_MAX_WERT = (RXBUF_UINT(32)/10000.0f);
// Output of the current maximum OCV of all cells measured in the last resting state in V. / Ausgabe der
// aktuellen maximalen im letzten Ruhezustand gemessenen OCV aller Zellen in V
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ZUSTAND_SPEICHER", "STAT_ZELLOCV_MAX_WERT", STAT_ZELLOCV_MAX_WERT, "\"V\"");
float STAT_ZELLOCV_MEAN_WERT = (RXBUF_UINT(34)/10000.0f);
// Output of the current mean OCV of all cells measured in the last resting state in V / Ausgabe der aktuellen
// mittleren im letzten Ruhezustand gemessenen OCV aller Zellen in V
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ZUSTAND_SPEICHER", "STAT_ZELLOCV_MEAN_WERT", STAT_ZELLOCV_MEAN_WERT, "\"V\"");
float STAT_IMPEDANCE_ESTIMATION_ALPHA_WERT = (RXBUF_UINT(36)/10000.0f);
// Current aging factor of the serial and parallel ohmic resistance as well as the parallel capacitance (1.5 =
// increase of the current resistance by 50%) / Aktueller Alterungsfaktor des seriellen und parallelen ohmschen
// Wider aktuellenstands sowie der parallelen Kapazität (1,5 = Eröhung des aktuellen Wider aktuellenstands um
// 50%)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "ZUSTAND_SPEICHER", "STAT_IMPEDANCE_ESTIMATION_ALPHA_WERT", STAT_IMPEDANCE_ESTIMATION_ALPHA_WERT, "");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_HIS_ERR_LIM_SPANNUNG: { // 0xDFA1
if (datalen < 12) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_HIS_ERR_LIM_SPANNUNG", 12);
break;
}
float STAT_OVER_VOLT_INT_LIM_WERT = (RXBUF_UINT(0)/1000.0f);
// [UerrIntLim_over] Error threshold of the OVERVOLTAGE integral (at temperatures <-10 ° C the error threshold
// changes depending on the temperature.) / [UerrIntLim_over] Fehlerschwellwert des ÜBERspannungsintegrals (Bei
// Temperaturen < -10°C verändert sich der Fehlerschellwert temperaturabhängig.)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HIS_ERR_LIM_SPANNUNG", "STAT_OVER_VOLT_INT_LIM_WERT", STAT_OVER_VOLT_INT_LIM_WERT, "");
float STAT_UNDER_VOLT_INT_LIM_WERT = (RXBUF_UINT(2)/1000.0f);
// [UerrIntLim_under] Error threshold value of the UNDERVOLTAGE integral (at temperatures <-10 ° C the error
// threshold value changes depending on the temperature.) / [UerrIntLim_under] Fehlerschwellwert des
// UNTERspannungsintegrals (Bei Temperaturen < -10°C verändert sich der Fehlerschellwert temperaturabhängig.)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HIS_ERR_LIM_SPANNUNG", "STAT_UNDER_VOLT_INT_LIM_WERT", STAT_UNDER_VOLT_INT_LIM_WERT, "");
unsigned short STAT_HIS_ERR_LIM_SPANNUNG_MODSMAX_UNDER_1_WERT = (RXBUF_UINT(4));
// Maximum duration in minutes across all modules when loading in the class: 0 <UerrInt_under <= UerrIntLim_under
// / Maximum der Dauer in Minuten über alle Module beim Laden in der Klasse: 0 <UerrInt_under <=
// UerrIntLim_under
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "HIS_ERR_LIM_SPANNUNG", "STAT_HIS_ERR_LIM_SPANNUNG_MODSMAX_UNDER_1_WERT", STAT_HIS_ERR_LIM_SPANNUNG_MODSMAX_UNDER_1_WERT, "\"min\"");
unsigned short STAT_HIS_ERR_LIM_SPANNUNG_MODSMAX_UNDER_2_WERT = (RXBUF_UINT(6));
// Maximum of the duration in minutes over all modules when loading in the class: UerrInt_under> UerrIntLim_under
// / Maximum der Dauer in Minuten über alle Module beim Laden in der Klasse: UerrInt_under > UerrIntLim_under
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "HIS_ERR_LIM_SPANNUNG", "STAT_HIS_ERR_LIM_SPANNUNG_MODSMAX_UNDER_2_WERT", STAT_HIS_ERR_LIM_SPANNUNG_MODSMAX_UNDER_2_WERT, "\"min\"");
unsigned short STAT_HIS_ERR_LIM_SPANNUNG_MODSMAX_OVER_1_WERT = (RXBUF_UINT(8));
// Maximum duration in minutes across all modules when loading in the class: 0 <UerrInt_over <= UerrIntLim_over /
// Maximum der Dauer in Minuten über alle Module beim Laden in der Klasse: 0 <UerrInt_over <= UerrIntLim_over
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "HIS_ERR_LIM_SPANNUNG", "STAT_HIS_ERR_LIM_SPANNUNG_MODSMAX_OVER_1_WERT", STAT_HIS_ERR_LIM_SPANNUNG_MODSMAX_OVER_1_WERT, "\"min\"");
unsigned short STAT_HIS_ERR_LIM_SPANNUNG_MODSMAX_OVER_2_WERT = (RXBUF_UINT(10));
// Maximum duration in minutes across all modules when loading in the class: UerrInt_over> UerrIntLim_over /
// Maximum der Dauer in Minuten über alle Module beim Laden in der Klasse: UerrInt_over > UerrIntLim_over
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "HIS_ERR_LIM_SPANNUNG", "STAT_HIS_ERR_LIM_SPANNUNG_MODSMAX_OVER_2_WERT", STAT_HIS_ERR_LIM_SPANNUNG_MODSMAX_OVER_2_WERT, "\"min\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_HIS_SOC_MAX_MIN: { // 0xDFAE
if (datalen < 2) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_HIS_SOC_MAX_MIN", 2);
break;
}
unsigned char STAT_SOC_MIN_NENN_MAX_WERT = (RXBUF_UCHAR(0));
// Output of the maximum nominal MIN SoC that occurs over the life of the vehicle. / Ausgabe des maximalen
// MIN-Nenn-SoC, der über Fahrzeuglebensdauer auftritt.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "HIS_SOC_MAX_MIN", "STAT_SOC_MIN_NENN_MAX_WERT", STAT_SOC_MIN_NENN_MAX_WERT, "\"%\"");
unsigned char STAT_SOC_MIN_NENN_MIN_WERT = (RXBUF_UCHAR(1));
// Output of the minimum nominal MIN SoC that occurs over the life of the vehicle. / Ausgabe des minimalen
// MIN-Nenn-SoC, der über Fahrzeuglebensdauer auftritt.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "HIS_SOC_MAX_MIN", "STAT_SOC_MIN_NENN_MIN_WERT", STAT_SOC_MIN_NENN_MIN_WERT, "\"%\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_STATUS_HV_SPEICHER_ID: { // 0xDFE1
if (datalen < 4) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_STATUS_HV_SPEICHER_ID", 4);
break;
}
unsigned short STAT_SP_ID_00 = (RXBUF_UINT(0));
// ID_00 memory type [invalid value = FFFF] / ID_00 Speicher-Typ [Ungültigkeitswert = FFFF]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "STATUS_HV_SPEICHER_ID", "STAT_SP_ID_00", STAT_SP_ID_00, "\"0-n\"");
unsigned short STAT_SP_ID_01_WERT = (RXBUF_UINT(2));
// ID_01 memory number [invalid value = FFFF] / ID_01 Speicher-Nummer [Ungültigkeitswert = FFFF]
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "STATUS_HV_SPEICHER_ID", "STAT_SP_ID_01_WERT", STAT_SP_ID_01_WERT, "\"HEX\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_SYMMETRIERBAND: { // 0xDFE2
if (datalen < 11) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_SYMMETRIERBAND", 11);
break;
}
float STAT_SOC_LAST_BALANCING_WERT = (RXBUF_UCHAR(0)/2.0f);
// SoC that was last successfully balanced / SoC bei dem zuletzt erfolgreich Symmetriert wurde
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "SYMMETRIERBAND", "STAT_SOC_LAST_BALANCING_WERT", STAT_SOC_LAST_BALANCING_WERT, "\"%\"");
unsigned long STAT_TIME_LAST_BALANCING_WERT = (RXBUF_UINT32(1));
// Absolute time at which the last successful symmetry / Absolute Zeit bei der zuletzt erfolgreich symmetriert
// wurde
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "SYMMETRIERBAND", "STAT_TIME_LAST_BALANCING_WERT", STAT_TIME_LAST_BALANCING_WERT, "\"s\"");
unsigned char STAT_DIFFERENCE_VOLTAGE_LAST_BALANCING_WERT = (RXBUF_UCHAR(5));
// Voltage difference in the last successful balancing process / Spannungsdifferenz beim letzten erfolgreichen
// Symmetriervorgang
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "SYMMETRIERBAND", "STAT_DIFFERENCE_VOLTAGE_LAST_BALANCING_WERT", STAT_DIFFERENCE_VOLTAGE_LAST_BALANCING_WERT, "\"mV\"");
float STAT_LAST_PARKING_SOC_1_WERT = (RXBUF_UCHAR(6)/2.0f);
// Last SoC at which the vehicle reached idle voltage / Letzter SoC bei dem das Fahrzeug Ruhespannung erreicht
// hat
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "SYMMETRIERBAND", "STAT_LAST_PARKING_SOC_1_WERT", STAT_LAST_PARKING_SOC_1_WERT, "\"%\"");
float STAT_LAST_PARKING_SOC_2_WERT = (RXBUF_UCHAR(7)/2.0f);
// Second to last SoC in which the vehicle has reached idle voltage / Zweitletzter SoC bei dem das Fahrzeug
// Ruhespannung erreicht hat
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "SYMMETRIERBAND", "STAT_LAST_PARKING_SOC_2_WERT", STAT_LAST_PARKING_SOC_2_WERT, "\"%\"");
float STAT_LAST_PARKING_SOC_3_WERT = (RXBUF_UCHAR(8)/2.0f);
// Third to last SoC at which the vehicle reached idle voltage / Drittletzter SoC bei dem das Fahrzeug
// Ruhespannung erreicht hat
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "SYMMETRIERBAND", "STAT_LAST_PARKING_SOC_3_WERT", STAT_LAST_PARKING_SOC_3_WERT, "\"%\"");
float STAT_LAST_PARKING_SOC_4_WERT = (RXBUF_UCHAR(9)/2.0f);
// Fourth to last SoC in which the vehicle has reached idle voltage / Viertletzter SoC bei dem das Fahrzeug
// Ruhespannung erreicht hat
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "SYMMETRIERBAND", "STAT_LAST_PARKING_SOC_4_WERT", STAT_LAST_PARKING_SOC_4_WERT, "\"%\"");
float STAT_LAST_PARKING_SOC_5_WERT = (RXBUF_UCHAR(10)/2.0f);
// Fifth to last SoC in which the vehicle has reached idle voltage / Fünftletzter SoC bei dem das Fahrzeug
// Ruhespannung erreicht hat
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "SYMMETRIERBAND", "STAT_LAST_PARKING_SOC_5_WERT", STAT_LAST_PARKING_SOC_5_WERT, "\"%\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_GW_INFO_SCHNELLLADEN: { // 0xE50D
if (datalen < 16) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_GW_INFO_SCHNELLLADEN", 16);
break;
}
float STAT_ENERGIEANTEIL_SCHNELLLADEN_TEMP_HIGH_WERT = (RXBUF_UINT(0)/100.0f);
// Share of the total energy throughput from fast charging at higher temperatures / Anteil des
// Gesamt-Energiedurchsatzes durch Schnellladen bei höheren Temperaturen
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "GW_INFO_SCHNELLLADEN", "STAT_ENERGIEANTEIL_SCHNELLLADEN_TEMP_HIGH_WERT", STAT_ENERGIEANTEIL_SCHNELLLADEN_TEMP_HIGH_WERT, "\"%\"");
float STAT_ENERGIEANTEIL_SCHNELLLADEN_TEMP_LOW_WERT = (RXBUF_UINT(2)/100.0f);
// Share of the total energy throughput from fast charging at lower temperatures / Anteil des
// Gesamt-Energiedurchsatzes durch Schnellladen bei niedrigeren Temperaturen
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "GW_INFO_SCHNELLLADEN", "STAT_ENERGIEANTEIL_SCHNELLLADEN_TEMP_LOW_WERT", STAT_ENERGIEANTEIL_SCHNELLLADEN_TEMP_LOW_WERT, "\"%\"");
float STAT_ENERGIEDURCHSATZ_SCHNELLLADEN_TEMP_HIGH_WERT = (RXBUF_UINT32(4)/10.0f);
// Energy throughput through fast charging at higher temperatures / Energiedurchsatz durch Schnellladen bei
// höheren Temperaturen
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "GW_INFO_SCHNELLLADEN", "STAT_ENERGIEDURCHSATZ_SCHNELLLADEN_TEMP_HIGH_WERT", STAT_ENERGIEDURCHSATZ_SCHNELLLADEN_TEMP_HIGH_WERT, "\"kWh\"");
float STAT_ENERGIEDURCHSATZ_SCHNELLLADEN_TEMP_LOW_WERT = (RXBUF_UINT32(8)/10.0f);
// Energy throughput through fast charging at lower temperatures / Energiedurchsatz durch Schnellladen bei
// niedrigeren Temperaturen
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "GW_INFO_SCHNELLLADEN", "STAT_ENERGIEDURCHSATZ_SCHNELLLADEN_TEMP_LOW_WERT", STAT_ENERGIEDURCHSATZ_SCHNELLLADEN_TEMP_LOW_WERT, "\"kWh\"");
float STAT_ENERGIEDURCHSATZ_GESAMT_WERT = (RXBUF_UINT32(12)/10.0f);
// Total energy throughput of the storage / Gesamter Energiedurchsatz des Speichers
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "GW_INFO_SCHNELLLADEN", "STAT_ENERGIEDURCHSATZ_GESAMT_WERT", STAT_ENERGIEDURCHSATZ_GESAMT_WERT, "\"kWh\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_CODIERVARIABLEN_HV_SPEICHER: { // 0xE540
if (datalen < 4) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_CODIERVARIABLEN_HV_SPEICHER", 4);
break;
}
unsigned char STAT_COOL_VALVE_PRESENT_WERT = (RXBUF_UCHAR(0));
// Coding parameters: cooling valve active / Codierparameter: Kühlventil aktiv
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "CODIERVARIABLEN_HV_SPEICHER", "STAT_COOL_VALVE_PRESENT_WERT", STAT_COOL_VALVE_PRESENT_WERT, "\"HEX\"");
unsigned char STAT_COUNTRY_CODE_WERT = (RXBUF_UCHAR(1));
// Coding parameters: country code / Codierparameter: Ländercode
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "CODIERVARIABLEN_HV_SPEICHER", "STAT_COUNTRY_CODE_WERT", STAT_COUNTRY_CODE_WERT, "\"HEX\"");
unsigned char STAT_COD_FUNKTION_SWITCH_WERT = (RXBUF_UCHAR(2));
// Coding parameters: Switch function / Codierparameter: Funktion Switch
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "CODIERVARIABLEN_HV_SPEICHER", "STAT_COD_FUNKTION_SWITCH_WERT", STAT_COD_FUNKTION_SWITCH_WERT, "\"HEX\"");
unsigned char STAT_COD_STATSP_WERT = (RXBUF_UCHAR(3));
// Coding parameters: stationary memory / Codierparameter: Stationärspeicher
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "CODIERVARIABLEN_HV_SPEICHER", "STAT_COD_STATSP_WERT", STAT_COD_STATSP_WERT, "\"HEX\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_ANZAHL_DEFEKTE_SICHERUNG: { // 0xE5F1
if (datalen < 1) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_ANZAHL_DEFEKTE_SICHERUNG", 1);
break;
}
unsigned char STAT_ANZAHL_DEFEKTE_SICHERUNG_WERT = (RXBUF_UCHAR(0));
// Number of defective fuses since all modules were last replaced / Anzahl der defekten Sicherungen seit dem
// letzten Tausch aller Module
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "ANZAHL_DEFEKTE_SICHERUNG", "STAT_ANZAHL_DEFEKTE_SICHERUNG_WERT", STAT_ANZAHL_DEFEKTE_SICHERUNG_WERT, "");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_HVOFF_VOLTAGES: { // 0xE5F2
if (datalen < 139) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_HVOFF_VOLTAGES", 139);
break;
}
unsigned char STAT_HVOFF_VOLTAGES_COUNTER_RB1_WERT = (RXBUF_UCHAR(0));
// Counter of written data records / Zähler der geschriebenen Datensätze
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_COUNTER_RB1_WERT", STAT_HVOFF_VOLTAGES_COUNTER_RB1_WERT, "");
float STAT_HVOFF_VOLTAGES_UCEL_MIN_RB1_1_WERT = (RXBUF_UINT(1)/10000.0f);
// Minimum cell voltage / Minimale Zellspannung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_UCEL_MIN_RB1_1_WERT", STAT_HVOFF_VOLTAGES_UCEL_MIN_RB1_1_WERT, "\"V\"");
float STAT_HVOFF_VOLTAGES_UCEL_MIN_RB1_2_WERT = (RXBUF_UINT(3)/10000.0f);
// Minimum cell voltage / Minimale Zellspannung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_UCEL_MIN_RB1_2_WERT", STAT_HVOFF_VOLTAGES_UCEL_MIN_RB1_2_WERT, "\"V\"");
float STAT_HVOFF_VOLTAGES_UCEL_MIN_RB1_3_WERT = (RXBUF_UINT(5)/10000.0f);
// Minimum cell voltage / Minimale Zellspannung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_UCEL_MIN_RB1_3_WERT", STAT_HVOFF_VOLTAGES_UCEL_MIN_RB1_3_WERT, "\"V\"");
float STAT_HVOFF_VOLTAGES_UCEL_MIN_RB1_4_WERT = (RXBUF_UINT(7)/10000.0f);
// Minimum cell voltage / Minimale Zellspannung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_UCEL_MIN_RB1_4_WERT", STAT_HVOFF_VOLTAGES_UCEL_MIN_RB1_4_WERT, "\"V\"");
unsigned char STAT_HVOFF_VOLTAGES_IDX_UCEL_MIN_RB1_1_WERT = (RXBUF_UCHAR(9));
// Index of the cell with the minimum cell voltage / Index der Zelle mit der minimalen Zellspannung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_IDX_UCEL_MIN_RB1_1_WERT", STAT_HVOFF_VOLTAGES_IDX_UCEL_MIN_RB1_1_WERT, "");
unsigned char STAT_HVOFF_VOLTAGES_IDX_UCEL_MIN_RB1_2_WERT = (RXBUF_UCHAR(10));
// Index of the cell with the minimum cell voltage / Index der Zelle mit der minimalen Zellspannung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_IDX_UCEL_MIN_RB1_2_WERT", STAT_HVOFF_VOLTAGES_IDX_UCEL_MIN_RB1_2_WERT, "");
unsigned char STAT_HVOFF_VOLTAGES_IDX_UCEL_MIN_RB1_3_WERT = (RXBUF_UCHAR(11));
// Index of the cell with the minimum cell voltage / Index der Zelle mit der minimalen Zellspannung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_IDX_UCEL_MIN_RB1_3_WERT", STAT_HVOFF_VOLTAGES_IDX_UCEL_MIN_RB1_3_WERT, "");
unsigned char STAT_HVOFF_VOLTAGES_IDX_UCEL_MIN_RB1_4_WERT = (RXBUF_UCHAR(12));
// Index of the cell with the minimum cell voltage / Index der Zelle mit der minimalen Zellspannung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_IDX_UCEL_MIN_RB1_4_WERT", STAT_HVOFF_VOLTAGES_IDX_UCEL_MIN_RB1_4_WERT, "");
float STAT_HVOFF_VOLTAGES_UCEL_MEAN_RB1_1_WERT = (RXBUF_UINT(13)/10000.0f);
// Average cell voltage / Durchschnittliche Zellspannung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_UCEL_MEAN_RB1_1_WERT", STAT_HVOFF_VOLTAGES_UCEL_MEAN_RB1_1_WERT, "\"V\"");
float STAT_HVOFF_VOLTAGES_UCEL_MEAN_RB1_2_WERT = (RXBUF_UINT(15)/10000.0f);
// Average cell voltage / Durchschnittliche Zellspannung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_UCEL_MEAN_RB1_2_WERT", STAT_HVOFF_VOLTAGES_UCEL_MEAN_RB1_2_WERT, "\"V\"");
float STAT_HVOFF_VOLTAGES_UCEL_MEAN_RB1_3_WERT = (RXBUF_UINT(17)/10000.0f);
// Average cell voltage / Durchschnittliche Zellspannung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_UCEL_MEAN_RB1_3_WERT", STAT_HVOFF_VOLTAGES_UCEL_MEAN_RB1_3_WERT, "\"V\"");
float STAT_HVOFF_VOLTAGES_UCEL_MEAN_RB1_4_WERT = (RXBUF_UINT(19)/10000.0f);
// Average cell voltage / Durchschnittliche Zellspannung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_UCEL_MEAN_RB1_4_WERT", STAT_HVOFF_VOLTAGES_UCEL_MEAN_RB1_4_WERT, "\"V\"");
float STAT_HVOFF_VOLTAGES_UCEL_MAX_RB1_1_WERT = (RXBUF_UINT(21)/10000.0f);
// Maximum cell voltage / Maximale Zellspannung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_UCEL_MAX_RB1_1_WERT", STAT_HVOFF_VOLTAGES_UCEL_MAX_RB1_1_WERT, "\"V\"");
float STAT_HVOFF_VOLTAGES_UCEL_MAX_RB1_2_WERT = (RXBUF_UINT(23)/10000.0f);
// Maximum cell voltage / Maximale Zellspannung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_UCEL_MAX_RB1_2_WERT", STAT_HVOFF_VOLTAGES_UCEL_MAX_RB1_2_WERT, "\"V\"");
float STAT_HVOFF_VOLTAGES_UCEL_MAX_RB1_3_WERT = (RXBUF_UINT(25)/10000.0f);
// Maximum cell voltage / Maximale Zellspannung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_UCEL_MAX_RB1_3_WERT", STAT_HVOFF_VOLTAGES_UCEL_MAX_RB1_3_WERT, "\"V\"");
float STAT_HVOFF_VOLTAGES_UCEL_MAX_RB1_4_WERT = (RXBUF_UINT(27)/10000.0f);
// Maximum cell voltage / Maximale Zellspannung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_UCEL_MAX_RB1_4_WERT", STAT_HVOFF_VOLTAGES_UCEL_MAX_RB1_4_WERT, "\"V\"");
unsigned char STAT_HVOFF_VOLTAGES_IDX_UCEL_MAX_RB1_1_WERT = (RXBUF_UCHAR(29));
// Index of the cell with the maximum cell voltage / Index der Zelle mit der maximalen Zellspannung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_IDX_UCEL_MAX_RB1_1_WERT", STAT_HVOFF_VOLTAGES_IDX_UCEL_MAX_RB1_1_WERT, "");
unsigned char STAT_HVOFF_VOLTAGES_IDX_UCEL_MAX_RB1_2_WERT = (RXBUF_UCHAR(30));
// Index of the cell with the maximum cell voltage / Index der Zelle mit der maximalen Zellspannung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_IDX_UCEL_MAX_RB1_2_WERT", STAT_HVOFF_VOLTAGES_IDX_UCEL_MAX_RB1_2_WERT, "");
unsigned char STAT_HVOFF_VOLTAGES_IDX_UCEL_MAX_RB1_3_WERT = (RXBUF_UCHAR(31));
// Index of the cell with the maximum cell voltage / Index der Zelle mit der maximalen Zellspannung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_IDX_UCEL_MAX_RB1_3_WERT", STAT_HVOFF_VOLTAGES_IDX_UCEL_MAX_RB1_3_WERT, "");
unsigned char STAT_HVOFF_VOLTAGES_IDX_UCEL_MAX_RB1_4_WERT = (RXBUF_UCHAR(32));
// Index of the cell with the maximum cell voltage / Index der Zelle mit der maximalen Zellspannung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_IDX_UCEL_MAX_RB1_4_WERT", STAT_HVOFF_VOLTAGES_IDX_UCEL_MAX_RB1_4_WERT, "");
float STAT_HVOFF_VOLTAGES_UCEL_1_RB1_1_WERT = (RXBUF_UINT(33)/10000.0f);
// Voltage of the cell with the lowest index (first cell) / Spannung der Zelle mit dem niedrigsten Index (erste
// Zelle)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_UCEL_1_RB1_1_WERT", STAT_HVOFF_VOLTAGES_UCEL_1_RB1_1_WERT, "\"V\"");
float STAT_HVOFF_VOLTAGES_UCEL_1_RB1_2_WERT = (RXBUF_UINT(35)/10000.0f);
// Voltage of the cell with the lowest index (first cell) / Spannung der Zelle mit dem niedrigsten Index (erste
// Zelle)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_UCEL_1_RB1_2_WERT", STAT_HVOFF_VOLTAGES_UCEL_1_RB1_2_WERT, "\"V\"");
float STAT_HVOFF_VOLTAGES_UCEL_1_RB1_3_WERT = (RXBUF_UINT(37)/10000.0f);
// Voltage of the cell with the lowest index (first cell) / Spannung der Zelle mit dem niedrigsten Index (erste
// Zelle)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_UCEL_1_RB1_3_WERT", STAT_HVOFF_VOLTAGES_UCEL_1_RB1_3_WERT, "\"V\"");
float STAT_HVOFF_VOLTAGES_UCEL_1_RB1_4_WERT = (RXBUF_UINT(39)/10000.0f);
// Voltage of the cell with the lowest index (first cell) / Spannung der Zelle mit dem niedrigsten Index (erste
// Zelle)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_UCEL_1_RB1_4_WERT", STAT_HVOFF_VOLTAGES_UCEL_1_RB1_4_WERT, "\"V\"");
unsigned long STAT_HVOFF_VOLTAGES_SME_LIFETIME_RB1_1_WERT = (RXBUF_UINT32(41));
// SME lifetime at the time of voltage measurement / SME Lebensdauer zum Zeitpunkt der Spannungsmessung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_SME_LIFETIME_RB1_1_WERT", STAT_HVOFF_VOLTAGES_SME_LIFETIME_RB1_1_WERT, "\"s\"");
unsigned long STAT_HVOFF_VOLTAGES_SME_LIFETIME_RB1_2_WERT = (RXBUF_UINT32(45));
// SME lifetime at the time of voltage measurement / SME Lebensdauer zum Zeitpunkt der Spannungsmessung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_SME_LIFETIME_RB1_2_WERT", STAT_HVOFF_VOLTAGES_SME_LIFETIME_RB1_2_WERT, "\"s\"");
unsigned long STAT_HVOFF_VOLTAGES_SME_LIFETIME_RB1_3_WERT = (RXBUF_UINT32(49));
// SME lifetime at the time of voltage measurement / SME Lebensdauer zum Zeitpunkt der Spannungsmessung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_SME_LIFETIME_RB1_3_WERT", STAT_HVOFF_VOLTAGES_SME_LIFETIME_RB1_3_WERT, "\"s\"");
unsigned long STAT_HVOFF_VOLTAGES_SME_LIFETIME_RB1_4_WERT = (RXBUF_UINT32(53));
// SME lifetime at the time of voltage measurement / SME Lebensdauer zum Zeitpunkt der Spannungsmessung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_SME_LIFETIME_RB1_4_WERT", STAT_HVOFF_VOLTAGES_SME_LIFETIME_RB1_4_WERT, "\"s\"");
unsigned char STAT_HVOFF_VOLTAGES_STAT_SYM_RB1_1 = (RXBUF_UCHAR(57));
// Cell symmetry status: 0 = inactive; 1 = active / Status der Zellsymmetrierung: 0 = inaktiv; 1 = aktiv
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_STAT_SYM_RB1_1", STAT_HVOFF_VOLTAGES_STAT_SYM_RB1_1, "\"0/1\"");
unsigned char STAT_HVOFF_VOLTAGES_STAT_SYM_RB1_2 = (RXBUF_UCHAR(58));
// Cell symmetry status: 0 = inactive; 1 = active / Status der Zellsymmetrierung: 0 = inaktiv; 1 = aktiv
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_STAT_SYM_RB1_2", STAT_HVOFF_VOLTAGES_STAT_SYM_RB1_2, "\"0/1\"");
unsigned char STAT_HVOFF_VOLTAGES_STAT_SYM_RB1_3 = (RXBUF_UCHAR(59));
// Cell symmetry status: 0 = inactive; 1 = active / Status der Zellsymmetrierung: 0 = inaktiv; 1 = aktiv
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_STAT_SYM_RB1_3", STAT_HVOFF_VOLTAGES_STAT_SYM_RB1_3, "\"0/1\"");
unsigned char STAT_HVOFF_VOLTAGES_STAT_SYM_RB1_4 = (RXBUF_UCHAR(60));
// Cell symmetry status: 0 = inactive; 1 = active / Status der Zellsymmetrierung: 0 = inaktiv; 1 = aktiv
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_STAT_SYM_RB1_4", STAT_HVOFF_VOLTAGES_STAT_SYM_RB1_4, "\"0/1\"");
unsigned char STAT_HVOFF_VOLTAGES_INFO_SYM_RB1_1 = (RXBUF_UCHAR(61));
// Info about the number of cells in symmetry (n) / Info über die Anzahl in Symmetrierung befindlicher Zellen (n)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_INFO_SYM_RB1_1", STAT_HVOFF_VOLTAGES_INFO_SYM_RB1_1, "\"0-n\"");
unsigned char STAT_HVOFF_VOLTAGES_INFO_SYM_RB1_2 = (RXBUF_UCHAR(62));
// Info about the number of cells in symmetry (n) / Info über die Anzahl in Symmetrierung befindlicher Zellen (n)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_INFO_SYM_RB1_2", STAT_HVOFF_VOLTAGES_INFO_SYM_RB1_2, "\"0-n\"");
unsigned char STAT_HVOFF_VOLTAGES_INFO_SYM_RB1_3 = (RXBUF_UCHAR(63));
// Info about the number of cells in symmetry (n) / Info über die Anzahl in Symmetrierung befindlicher Zellen (n)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_INFO_SYM_RB1_3", STAT_HVOFF_VOLTAGES_INFO_SYM_RB1_3, "\"0-n\"");
unsigned char STAT_HVOFF_VOLTAGES_INFO_SYM_RB1_4 = (RXBUF_UCHAR(64));
// Info about the number of cells in symmetry (n) / Info über die Anzahl in Symmetrierung befindlicher Zellen (n)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_INFO_SYM_RB1_4", STAT_HVOFF_VOLTAGES_INFO_SYM_RB1_4, "\"0-n\"");
char STAT_HVOFF_VOLTAGES_T_CORE_AVG_RB1_1_WERT = (RXBUF_SCHAR(65));
// Average storage temperature / Durchschnittliche Speichertemperatur
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_T_CORE_AVG_RB1_1_WERT", STAT_HVOFF_VOLTAGES_T_CORE_AVG_RB1_1_WERT, "\"°C\"");
char STAT_HVOFF_VOLTAGES_T_CORE_AVG_RB1_2_WERT = (RXBUF_SCHAR(66));
// Average storage temperature / Durchschnittliche Speichertemperatur
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_T_CORE_AVG_RB1_2_WERT", STAT_HVOFF_VOLTAGES_T_CORE_AVG_RB1_2_WERT, "\"°C\"");
char STAT_HVOFF_VOLTAGES_T_CORE_AVG_RB1_3_WERT = (RXBUF_SCHAR(67));
// Average storage temperature / Durchschnittliche Speichertemperatur
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_T_CORE_AVG_RB1_3_WERT", STAT_HVOFF_VOLTAGES_T_CORE_AVG_RB1_3_WERT, "\"°C\"");
char STAT_HVOFF_VOLTAGES_T_CORE_AVG_RB1_4_WERT = (RXBUF_SCHAR(68));
// Average storage temperature / Durchschnittliche Speichertemperatur
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_T_CORE_AVG_RB1_4_WERT", STAT_HVOFF_VOLTAGES_T_CORE_AVG_RB1_4_WERT, "\"°C\"");
unsigned char STAT_HVOFF_VOLTAGES_COUNTER_RB2_WERT = (RXBUF_UCHAR(69));
// Counter of written data records / Zähler der geschriebenen Datensätze
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_COUNTER_RB2_WERT", STAT_HVOFF_VOLTAGES_COUNTER_RB2_WERT, "");
float STAT_HVOFF_VOLTAGES_UCEL_MIN_RB2_1_WERT = (RXBUF_UINT(70)/10000.0f);
// Minimum cell voltage / Minimale Zellspannung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_UCEL_MIN_RB2_1_WERT", STAT_HVOFF_VOLTAGES_UCEL_MIN_RB2_1_WERT, "\"V\"");
float STAT_HVOFF_VOLTAGES_UCEL_MIN_RB2_2_WERT = (RXBUF_UINT(72)/10000.0f);
// Minimum cell voltage / Minimale Zellspannung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_UCEL_MIN_RB2_2_WERT", STAT_HVOFF_VOLTAGES_UCEL_MIN_RB2_2_WERT, "\"V\"");
float STAT_HVOFF_VOLTAGES_UCEL_MIN_RB2_3_WERT = (RXBUF_UINT(74)/10000.0f);
// Minimum cell voltage / Minimale Zellspannung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_UCEL_MIN_RB2_3_WERT", STAT_HVOFF_VOLTAGES_UCEL_MIN_RB2_3_WERT, "\"V\"");
float STAT_HVOFF_VOLTAGES_UCEL_MIN_RB2_4_WERT = (RXBUF_UINT(76)/10000.0f);
// Minimum cell voltage / Minimale Zellspannung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_UCEL_MIN_RB2_4_WERT", STAT_HVOFF_VOLTAGES_UCEL_MIN_RB2_4_WERT, "\"V\"");
unsigned char STAT_HVOFF_VOLTAGES_IDX_UCEL_MIN_RB2_1_WERT = (RXBUF_UCHAR(78));
// Index of the cell with the minimum cell voltage / Index der Zelle mit der minimalen Zellspannung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_IDX_UCEL_MIN_RB2_1_WERT", STAT_HVOFF_VOLTAGES_IDX_UCEL_MIN_RB2_1_WERT, "");
unsigned char STAT_HVOFF_VOLTAGES_IDX_UCEL_MIN_RB2_2_WERT = (RXBUF_UCHAR(79));
// Index of the cell with the minimum cell voltage / Index der Zelle mit der minimalen Zellspannung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_IDX_UCEL_MIN_RB2_2_WERT", STAT_HVOFF_VOLTAGES_IDX_UCEL_MIN_RB2_2_WERT, "");
unsigned char STAT_HVOFF_VOLTAGES_IDX_UCEL_MIN_RB2_3_WERT = (RXBUF_UCHAR(80));
// Index of the cell with the minimum cell voltage / Index der Zelle mit der minimalen Zellspannung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_IDX_UCEL_MIN_RB2_3_WERT", STAT_HVOFF_VOLTAGES_IDX_UCEL_MIN_RB2_3_WERT, "");
unsigned char STAT_HVOFF_VOLTAGES_IDX_UCEL_MIN_RB2_4_WERT = (RXBUF_UCHAR(81));
// Index of the cell with the minimum cell voltage / Index der Zelle mit der minimalen Zellspannung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_IDX_UCEL_MIN_RB2_4_WERT", STAT_HVOFF_VOLTAGES_IDX_UCEL_MIN_RB2_4_WERT, "");
float STAT_HVOFF_VOLTAGES_UCEL_MEAN_RB2_1_WERT = (RXBUF_UINT(82)/10000.0f);
// Average cell voltage / Durchschnittliche Zellspannung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_UCEL_MEAN_RB2_1_WERT", STAT_HVOFF_VOLTAGES_UCEL_MEAN_RB2_1_WERT, "\"V\"");
float STAT_HVOFF_VOLTAGES_UCEL_MEAN_RB2_2_WERT = (RXBUF_UINT(84)/10000.0f);
// Average cell voltage / Durchschnittliche Zellspannung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_UCEL_MEAN_RB2_2_WERT", STAT_HVOFF_VOLTAGES_UCEL_MEAN_RB2_2_WERT, "\"V\"");
float STAT_HVOFF_VOLTAGES_UCEL_MEAN_RB2_3_WERT = (RXBUF_UINT(86)/10000.0f);
// Average cell voltage / Durchschnittliche Zellspannung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_UCEL_MEAN_RB2_3_WERT", STAT_HVOFF_VOLTAGES_UCEL_MEAN_RB2_3_WERT, "\"V\"");
float STAT_HVOFF_VOLTAGES_UCEL_MEAN_RB2_4_WERT = (RXBUF_UINT(88)/10000.0f);
// Average cell voltage / Durchschnittliche Zellspannung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_UCEL_MEAN_RB2_4_WERT", STAT_HVOFF_VOLTAGES_UCEL_MEAN_RB2_4_WERT, "\"V\"");
float STAT_HVOFF_VOLTAGES_UCEL_MAX_RB2_1_WERT = (RXBUF_UINT(90)/10000.0f);
// Maximum cell voltage / Maximale Zellspannung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_UCEL_MAX_RB2_1_WERT", STAT_HVOFF_VOLTAGES_UCEL_MAX_RB2_1_WERT, "\"V\"");
float STAT_HVOFF_VOLTAGES_UCEL_MAX_RB2_2_WERT = (RXBUF_UINT(92)/10000.0f);
// Maximum cell voltage / Maximale Zellspannung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_UCEL_MAX_RB2_2_WERT", STAT_HVOFF_VOLTAGES_UCEL_MAX_RB2_2_WERT, "\"V\"");
float STAT_HVOFF_VOLTAGES_UCEL_MAX_RB2_3_WERT = (RXBUF_UINT(94)/10000.0f);
// Maximum cell voltage / Maximale Zellspannung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_UCEL_MAX_RB2_3_WERT", STAT_HVOFF_VOLTAGES_UCEL_MAX_RB2_3_WERT, "\"V\"");
float STAT_HVOFF_VOLTAGES_UCEL_MAX_RB2_4_WERT = (RXBUF_UINT(96)/10000.0f);
// Maximum cell voltage / Maximale Zellspannung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_UCEL_MAX_RB2_4_WERT", STAT_HVOFF_VOLTAGES_UCEL_MAX_RB2_4_WERT, "\"V\"");
unsigned char STAT_HVOFF_VOLTAGES_IDX_UCEL_MAX_RB2_1_WERT = (RXBUF_UCHAR(98));
// Index of the cell with the maximum cell voltage / Index der Zelle mit der maximalen Zellspannung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_IDX_UCEL_MAX_RB2_1_WERT", STAT_HVOFF_VOLTAGES_IDX_UCEL_MAX_RB2_1_WERT, "");
unsigned char STAT_HVOFF_VOLTAGES_IDX_UCEL_MAX_RB2_2_WERT = (RXBUF_UCHAR(99));
// Index of the cell with the maximum cell voltage / Index der Zelle mit der maximalen Zellspannung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_IDX_UCEL_MAX_RB2_2_WERT", STAT_HVOFF_VOLTAGES_IDX_UCEL_MAX_RB2_2_WERT, "");
unsigned char STAT_HVOFF_VOLTAGES_IDX_UCEL_MAX_RB2_3_WERT = (RXBUF_UCHAR(100));
// Index of the cell with the maximum cell voltage / Index der Zelle mit der maximalen Zellspannung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_IDX_UCEL_MAX_RB2_3_WERT", STAT_HVOFF_VOLTAGES_IDX_UCEL_MAX_RB2_3_WERT, "");
unsigned char STAT_HVOFF_VOLTAGES_IDX_UCEL_MAX_RB2_4_WERT = (RXBUF_UCHAR(101));
// Index of the cell with the maximum cell voltage / Index der Zelle mit der maximalen Zellspannung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_IDX_UCEL_MAX_RB2_4_WERT", STAT_HVOFF_VOLTAGES_IDX_UCEL_MAX_RB2_4_WERT, "");
float STAT_HVOFF_VOLTAGES_UCEL_1_RB2_1_WERT = (RXBUF_UINT(102)/10000.0f);
// Voltage of the cell with the lowest index (first cell) / Spannung der Zelle mit dem niedrigsten Index (erste
// Zelle)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_UCEL_1_RB2_1_WERT", STAT_HVOFF_VOLTAGES_UCEL_1_RB2_1_WERT, "\"V\"");
float STAT_HVOFF_VOLTAGES_UCEL_1_RB2_2_WERT = (RXBUF_UINT(104)/10000.0f);
// Voltage of the cell with the lowest index (first cell) / Spannung der Zelle mit dem niedrigsten Index (erste
// Zelle)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_UCEL_1_RB2_2_WERT", STAT_HVOFF_VOLTAGES_UCEL_1_RB2_2_WERT, "\"V\"");
float STAT_HVOFF_VOLTAGES_UCEL_1_RB2_3_WERT = (RXBUF_UINT(106)/10000.0f);
// Voltage of the cell with the lowest index (first cell) / Spannung der Zelle mit dem niedrigsten Index (erste
// Zelle)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_UCEL_1_RB2_3_WERT", STAT_HVOFF_VOLTAGES_UCEL_1_RB2_3_WERT, "\"V\"");
float STAT_HVOFF_VOLTAGES_UCEL_1_RB2_4_WERT = (RXBUF_UINT(108)/10000.0f);
// Voltage of the cell with the lowest index (first cell) / Spannung der Zelle mit dem niedrigsten Index (erste
// Zelle)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_UCEL_1_RB2_4_WERT", STAT_HVOFF_VOLTAGES_UCEL_1_RB2_4_WERT, "\"V\"");
unsigned long STAT_HVOFF_VOLTAGES_SME_LIFETIME_RB2_1_WERT = (RXBUF_UINT32(110));
// SME lifetime at the time of voltage measurement / SME Lebensdauer zum Zeitpunkt der Spannungsmessung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_SME_LIFETIME_RB2_1_WERT", STAT_HVOFF_VOLTAGES_SME_LIFETIME_RB2_1_WERT, "\"s\"");
unsigned long STAT_HVOFF_VOLTAGES_SME_LIFETIME_RB2_2_WERT = (RXBUF_UINT32(114));
// SME lifetime at the time of voltage measurement / SME Lebensdauer zum Zeitpunkt der Spannungsmessung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_SME_LIFETIME_RB2_2_WERT", STAT_HVOFF_VOLTAGES_SME_LIFETIME_RB2_2_WERT, "\"s\"");
unsigned long STAT_HVOFF_VOLTAGES_SME_LIFETIME_RB2_3_WERT = (RXBUF_UINT32(118));
// SME lifetime at the time of voltage measurement / SME Lebensdauer zum Zeitpunkt der Spannungsmessung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_SME_LIFETIME_RB2_3_WERT", STAT_HVOFF_VOLTAGES_SME_LIFETIME_RB2_3_WERT, "\"s\"");
unsigned long STAT_HVOFF_VOLTAGES_SME_LIFETIME_RB2_4_WERT = (RXBUF_UINT32(122));
// SME lifetime at the time of voltage measurement / SME Lebensdauer zum Zeitpunkt der Spannungsmessung
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_SME_LIFETIME_RB2_4_WERT", STAT_HVOFF_VOLTAGES_SME_LIFETIME_RB2_4_WERT, "\"s\"");
unsigned char STAT_HVOFF_VOLTAGES_STAT_SYM_RB2_1 = (RXBUF_UCHAR(126));
// Cell symmetry status: 0 = inactive; 1 = active / Status der Zellsymmetrierung: 0 = inaktiv; 1 = aktiv
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_STAT_SYM_RB2_1", STAT_HVOFF_VOLTAGES_STAT_SYM_RB2_1, "\"0/1\"");
unsigned char STAT_HVOFF_VOLTAGES_STAT_SYM_RB2_2 = (RXBUF_UCHAR(127));
// Cell symmetry status: 0 = inactive; 1 = active / Status der Zellsymmetrierung: 0 = inaktiv; 1 = aktiv
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_STAT_SYM_RB2_2", STAT_HVOFF_VOLTAGES_STAT_SYM_RB2_2, "\"0/1\"");
unsigned char STAT_HVOFF_VOLTAGES_STAT_SYM_RB2_3 = (RXBUF_UCHAR(128));
// Cell symmetry status: 0 = inactive; 1 = active / Status der Zellsymmetrierung: 0 = inaktiv; 1 = aktiv
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_STAT_SYM_RB2_3", STAT_HVOFF_VOLTAGES_STAT_SYM_RB2_3, "\"0/1\"");
unsigned char STAT_HVOFF_VOLTAGES_STAT_SYM_RB2_4 = (RXBUF_UCHAR(129));
// Cell symmetry status: 0 = inactive; 1 = active / Status der Zellsymmetrierung: 0 = inaktiv; 1 = aktiv
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_STAT_SYM_RB2_4", STAT_HVOFF_VOLTAGES_STAT_SYM_RB2_4, "\"0/1\"");
unsigned char STAT_HVOFF_VOLTAGES_INFO_SYM_RB2_1 = (RXBUF_UCHAR(130));
// Info about the number of cells in symmetry / Info über die Anzahl in Symmetrierung befindlicher Zellen
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_INFO_SYM_RB2_1", STAT_HVOFF_VOLTAGES_INFO_SYM_RB2_1, "\"0-n\"");
unsigned char STAT_HVOFF_VOLTAGES_INFO_SYM_RB2_2 = (RXBUF_UCHAR(131));
// Info about the number of cells in symmetry / Info über die Anzahl in Symmetrierung befindlicher Zellen
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_INFO_SYM_RB2_2", STAT_HVOFF_VOLTAGES_INFO_SYM_RB2_2, "\"0-n\"");
unsigned char STAT_HVOFF_VOLTAGES_INFO_SYM_RB2_3 = (RXBUF_UCHAR(132));
// Info about the number of cells in symmetry / Info über die Anzahl in Symmetrierung befindlicher Zellen
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_INFO_SYM_RB2_3", STAT_HVOFF_VOLTAGES_INFO_SYM_RB2_3, "\"0-n\"");
unsigned char STAT_HVOFF_VOLTAGES_INFO_SYM_RB2_4 = (RXBUF_UCHAR(133));
// Info about the number of cells in symmetry / Info über die Anzahl in Symmetrierung befindlicher Zellen
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_INFO_SYM_RB2_4", STAT_HVOFF_VOLTAGES_INFO_SYM_RB2_4, "\"0-n\"");
char STAT_HVOFF_VOLTAGES_T_CORE_AVG_RB2_1_WERT = (RXBUF_SCHAR(134));
// Average storage temperature / Durchschnittliche Speichertemperatur
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_T_CORE_AVG_RB2_1_WERT", STAT_HVOFF_VOLTAGES_T_CORE_AVG_RB2_1_WERT, "\"°C\"");
char STAT_HVOFF_VOLTAGES_T_CORE_AVG_RB2_2_WERT = (RXBUF_SCHAR(135));
// Average storage temperature / Durchschnittliche Speichertemperatur
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_T_CORE_AVG_RB2_2_WERT", STAT_HVOFF_VOLTAGES_T_CORE_AVG_RB2_2_WERT, "\"°C\"");
char STAT_HVOFF_VOLTAGES_T_CORE_AVG_RB2_3_WERT = (RXBUF_SCHAR(136));
// Average storage temperature / Durchschnittliche Speichertemperatur
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_T_CORE_AVG_RB2_3_WERT", STAT_HVOFF_VOLTAGES_T_CORE_AVG_RB2_3_WERT, "\"°C\"");
char STAT_HVOFF_VOLTAGES_T_CORE_AVG_RB2_4_WERT = (RXBUF_SCHAR(137));
// Average storage temperature / Durchschnittliche Speichertemperatur
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_T_CORE_AVG_RB2_4_WERT", STAT_HVOFF_VOLTAGES_T_CORE_AVG_RB2_4_WERT, "\"°C\"");
unsigned char STAT_HVOFF_VOLTAGES_COUNTER_SCORE_WERT = (RXBUF_UCHAR(138));
// Counter for evaluating the voltage drop over the lifetime / Zähler zur Bewertung des Spannungsabfalls über die
// Lebenszeit
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "HVOFF_VOLTAGES", "STAT_HVOFF_VOLTAGES_COUNTER_SCORE_WERT", STAT_HVOFF_VOLTAGES_COUNTER_SCORE_WERT, "");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_RB_SOH_KAPATEST_ERW: { // 0xE5F3
if (datalen < 27) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_RB_SOH_KAPATEST_ERW", 27);
break;
}
unsigned char STAT_TEMP_MEAN_DCH_END_TEST_1_WERT = (RXBUF_UCHAR(0));
// Mean simulated temperature at HVS level at the end of discharge of the first capacity test / Mittlere
// simulierte Temperatur auf HVS-Ebene bei Entladeende des ersten Kapazitätstests
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_SOH_KAPATEST_ERW", "STAT_TEMP_MEAN_DCH_END_TEST_1_WERT", STAT_TEMP_MEAN_DCH_END_TEST_1_WERT, "\"°C\"");
unsigned char STAT_TEMP_MIN_DCH_END_TEST_1_WERT = (RXBUF_UCHAR(1));
// Minimum simulated temperature at HVS level at the end of discharge of the first capacity test / Minimale
// simulierte Temperatur auf HVS-Ebene bei Entladeende des ersten Kapazitätstests
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_SOH_KAPATEST_ERW", "STAT_TEMP_MIN_DCH_END_TEST_1_WERT", STAT_TEMP_MIN_DCH_END_TEST_1_WERT, "\"°C\"");
unsigned char STAT_TEMP_MAX_DCH_END_TEST_1_WERT = (RXBUF_UCHAR(2));
// Maximum simulated temperature at HVS level at the end of discharge of the first capacity test / Maximale
// simulierte Temperatur auf HVS-Ebene bei Entladeende des ersten Kapazitätstests
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_SOH_KAPATEST_ERW", "STAT_TEMP_MAX_DCH_END_TEST_1_WERT", STAT_TEMP_MAX_DCH_END_TEST_1_WERT, "\"°C\"");
unsigned char STAT_TEMP_MEAN_CHA_END_TEST_1_WERT = (RXBUF_UCHAR(3));
// Mean simulated temperature at HVS level at the end of charging of the first capacity test / Mittlere
// simulierte Temperatur auf HVS-Ebene bei Ladeende des ersten Kapazitätstests
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_SOH_KAPATEST_ERW", "STAT_TEMP_MEAN_CHA_END_TEST_1_WERT", STAT_TEMP_MEAN_CHA_END_TEST_1_WERT, "\"°C\"");
unsigned char STAT_TEMP_MIN_CHA_END_TEST_1_WERT = (RXBUF_UCHAR(4));
// Minimum simulated temperature at HVS level at the end of charging of the first capacity test / Minimale
// simulierte Temperatur auf HVS-Ebene bei Ladeende des ersten Kapazitätstests
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_SOH_KAPATEST_ERW", "STAT_TEMP_MIN_CHA_END_TEST_1_WERT", STAT_TEMP_MIN_CHA_END_TEST_1_WERT, "\"°C\"");
unsigned char STAT_TEMP_MAX_CHA_END_TEST_1_WERT = (RXBUF_UCHAR(5));
// Maximum simulated temperature at HVS level at the end of charging of the first capacity test / Maximale
// simulierte Temperatur auf HVS-Ebene bei Ladeende des ersten Kapazitätstests
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_SOH_KAPATEST_ERW", "STAT_TEMP_MAX_CHA_END_TEST_1_WERT", STAT_TEMP_MAX_CHA_END_TEST_1_WERT, "\"°C\"");
float STAT_FRC_PWR_CHG_TEST_1_WERT = (RXBUF_UCHAR(6)/10.0f);
// Charging power (from forecast) during the first capacity test / Ladeleistung (aus Prognose) bei erstem
// Kapazitätstest
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOH_KAPATEST_ERW", "STAT_FRC_PWR_CHG_TEST_1_WERT", STAT_FRC_PWR_CHG_TEST_1_WERT, "\"kW\"");
float STAT_I_DCH_END_FILT_TEST_1_WERT = (RXBUF_UCHAR(7)/10.0f);
// Aborted discharge current (filtered) during the first capacity test / Entladeabbruch-Strom (gefiltert) bei
// erstem Kapazitätstest
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOH_KAPATEST_ERW", "STAT_I_DCH_END_FILT_TEST_1_WERT", STAT_I_DCH_END_FILT_TEST_1_WERT, "\"A\"");
unsigned char STAT_U_CELL_MIN_IDX_DCH_END_TEST_1_WERT = (RXBUF_UCHAR(8));
// Index of the cell with the minimum cell voltage at the end of the discharge of the first capacity test / Index
// der Zelle mit der minimalen Zellspannung bei Entladeende des ersen Kapazitätstests
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_SOH_KAPATEST_ERW", "STAT_U_CELL_MIN_IDX_DCH_END_TEST_1_WERT", STAT_U_CELL_MIN_IDX_DCH_END_TEST_1_WERT, "");
unsigned char STAT_TEMP_MEAN_DCH_END_TEST_2_WERT = (RXBUF_UCHAR(9));
// Mean simulated temperature at HVS level at the end of discharge of the second capacity test / Mittlere
// simulierte Temperatur auf HVS-Ebene bei Entladeende des zweiten Kapazitätstests
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_SOH_KAPATEST_ERW", "STAT_TEMP_MEAN_DCH_END_TEST_2_WERT", STAT_TEMP_MEAN_DCH_END_TEST_2_WERT, "\"°C\"");
unsigned char STAT_TEMP_MIN_DCH_END_TEST_2_WERT = (RXBUF_UCHAR(10));
// Minimum simulated temperature at HVS level at the end of the discharge of the second capacity test / Minimale
// simulierte Temperatur auf HVS-Ebene bei Entladeende des zweiten Kapazitätstests
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_SOH_KAPATEST_ERW", "STAT_TEMP_MIN_DCH_END_TEST_2_WERT", STAT_TEMP_MIN_DCH_END_TEST_2_WERT, "\"°C\"");
unsigned char STAT_TEMP_MAX_DCH_END_TEST_2_WERT = (RXBUF_UCHAR(11));
// Maximum simulated temperature at HVS level at the end of the discharge of the second capacity test / Maximale
// simulierte Temperatur auf HVS-Ebene bei Entladeende des zweiten Kapazitätstests
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_SOH_KAPATEST_ERW", "STAT_TEMP_MAX_DCH_END_TEST_2_WERT", STAT_TEMP_MAX_DCH_END_TEST_2_WERT, "\"°C\"");
unsigned char STAT_TEMP_MEAN_CHA_END_TEST_2_WERT = (RXBUF_UCHAR(12));
// Mean simulated temperature at HVS level at the end of charging of the second capacity test / Mittlere
// simulierte Temperatur auf HVS-Ebene bei Ladeende des zweiten Kapazitätstests
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_SOH_KAPATEST_ERW", "STAT_TEMP_MEAN_CHA_END_TEST_2_WERT", STAT_TEMP_MEAN_CHA_END_TEST_2_WERT, "\"°C\"");
unsigned char STAT_TEMP_MIN_CHA_END_TEST_2_WERT = (RXBUF_UCHAR(13));
// Minimum simulated temperature at HVS level at the end of charging of the second capacity test / Minimale
// simulierte Temperatur auf HVS-Ebene bei Ladeende des zweiten Kapazitätstests
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_SOH_KAPATEST_ERW", "STAT_TEMP_MIN_CHA_END_TEST_2_WERT", STAT_TEMP_MIN_CHA_END_TEST_2_WERT, "\"°C\"");
unsigned char STAT_TEMP_MAX_CHA_END_TEST_2_WERT = (RXBUF_UCHAR(14));
// Maximum simulated temperature at HVS level at the end of charging of the second capacity test / Maximale
// simulierte Temperatur auf HVS-Ebene bei Ladeende des zweiten Kapazitätstests
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_SOH_KAPATEST_ERW", "STAT_TEMP_MAX_CHA_END_TEST_2_WERT", STAT_TEMP_MAX_CHA_END_TEST_2_WERT, "\"°C\"");
float STAT_FRC_PWR_CHG_TEST_2_WERT = (RXBUF_UCHAR(15)/10.0f);
// Charging power (from forecast) in the second capacity test / Ladeleistung (aus Prognose) bei zweitem
// Kapazitätstest
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOH_KAPATEST_ERW", "STAT_FRC_PWR_CHG_TEST_2_WERT", STAT_FRC_PWR_CHG_TEST_2_WERT, "\"kW\"");
float STAT_I_DCH_END_FILT_TEST_2_WERT = (RXBUF_UCHAR(16)/10.0f);
// Aborted discharge current (filtered) during the second capacity test / Entladeabbruch-Strom (gefiltert) bei
// zweitem Kapazitätstest
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOH_KAPATEST_ERW", "STAT_I_DCH_END_FILT_TEST_2_WERT", STAT_I_DCH_END_FILT_TEST_2_WERT, "\"A\"");
unsigned char STAT_U_CELL_MIN_IDX_DCH_END_TEST_2_WERT = (RXBUF_UCHAR(17));
// Index of the cell with the minimum cell voltage at the end of the discharge of the second capacity test /
// Index der Zelle mit der minimalen Zellspannung bei Entladeende des zweiten Kapazitätstests
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_SOH_KAPATEST_ERW", "STAT_U_CELL_MIN_IDX_DCH_END_TEST_2_WERT", STAT_U_CELL_MIN_IDX_DCH_END_TEST_2_WERT, "");
unsigned char STAT_TEMP_MEAN_DCH_END_TEST_3_WERT = (RXBUF_UCHAR(18));
// Mean simulated temperature at HVS level at the end of discharge of the third capacity test / Mittlere
// simulierte Temperatur auf HVS-Ebene bei Entladeende des dritten Kapazitätstests
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_SOH_KAPATEST_ERW", "STAT_TEMP_MEAN_DCH_END_TEST_3_WERT", STAT_TEMP_MEAN_DCH_END_TEST_3_WERT, "\"°C\"");
unsigned char STAT_TEMP_MIN_DCH_END_TEST_3_WERT = (RXBUF_UCHAR(19));
// Minimum simulated temperature at HVS level at the end of the discharge of the third capacity test / Minimale
// simulierte Temperatur auf HVS-Ebene bei Entladeende des dritten Kapazitätstests
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_SOH_KAPATEST_ERW", "STAT_TEMP_MIN_DCH_END_TEST_3_WERT", STAT_TEMP_MIN_DCH_END_TEST_3_WERT, "\"°C\"");
unsigned char STAT_TEMP_MAX_DCH_END_TEST_3_WERT = (RXBUF_UCHAR(20));
// Maximum simulated temperature at HVS level at the end of the discharge of the third capacity test / Maximale
// simulierte Temperatur auf HVS-Ebene bei Entladeende des dritten Kapazitätstests
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_SOH_KAPATEST_ERW", "STAT_TEMP_MAX_DCH_END_TEST_3_WERT", STAT_TEMP_MAX_DCH_END_TEST_3_WERT, "\"°C\"");
unsigned char STAT_TEMP_MEAN_CHA_END_TEST_3_WERT = (RXBUF_UCHAR(21));
// Mean simulated temperature at HVS level at the end of charging of the third capacity test / Mittlere
// simulierte Temperatur auf HVS-Ebene bei Ladeende des dritten Kapazitätstests
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_SOH_KAPATEST_ERW", "STAT_TEMP_MEAN_CHA_END_TEST_3_WERT", STAT_TEMP_MEAN_CHA_END_TEST_3_WERT, "\"°C\"");
unsigned char STAT_TEMP_MIN_CHA_END_TEST_3_WERT = (RXBUF_UCHAR(22));
// Minimum simulated temperature at HVS level at the end of charging of the third capacity test / Minimale
// simulierte Temperatur auf HVS-Ebene bei Ladeende des dritten Kapazitätstests
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_SOH_KAPATEST_ERW", "STAT_TEMP_MIN_CHA_END_TEST_3_WERT", STAT_TEMP_MIN_CHA_END_TEST_3_WERT, "\"°C\"");
unsigned char STAT_TEMP_MAX_CHA_END_TEST_3_WERT = (RXBUF_UCHAR(23));
// Maximum simulated temperature at HVS level at the end of charging of the third capacity test / Maximale
// simulierte Temperatur auf HVS-Ebene bei Ladeende des dritten Kapazitätstests
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_SOH_KAPATEST_ERW", "STAT_TEMP_MAX_CHA_END_TEST_3_WERT", STAT_TEMP_MAX_CHA_END_TEST_3_WERT, "\"°C\"");
float STAT_FRC_PWR_CHG_TEST_3_WERT = (RXBUF_UCHAR(24)/10.0f);
// Charging power (from forecast) in the third capacity test / Ladeleistung (aus Prognose) bei drittem
// Kapazitätstest
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOH_KAPATEST_ERW", "STAT_FRC_PWR_CHG_TEST_3_WERT", STAT_FRC_PWR_CHG_TEST_3_WERT, "\"kW\"");
float STAT_I_DCH_END_FILT_TEST_3_WERT = (RXBUF_UCHAR(25)/10.0f);
// Aborted discharge current (filtered) during the third capacity test / Entladeabbruch-Strom (gefiltert) bei
// drittem Kapazitätstest
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "RB_SOH_KAPATEST_ERW", "STAT_I_DCH_END_FILT_TEST_3_WERT", STAT_I_DCH_END_FILT_TEST_3_WERT, "\"A\"");
unsigned char STAT_U_CELL_MIN_IDX_DCH_END_TEST_3_WERT = (RXBUF_UCHAR(26));
// Index of the cell with the minimum cell voltage at the end of the discharge of the third capacity test / Index
// der Zelle mit der minimalen Zellspannung bei Entladeende des dritten Kapazitätstests
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "RB_SOH_KAPATEST_ERW", "STAT_U_CELL_MIN_IDX_DCH_END_TEST_3_WERT", STAT_U_CELL_MIN_IDX_DCH_END_TEST_3_WERT, "");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_CPI_ANALYSE: { // 0xE5F4
if (datalen < 23) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_CPI_ANALYSE", 23);
break;
}
float STAT_CPI_REL_TEMP_WERT = (RXBUF_SINT(0)/10.0f);
// Relative deviation of the calculated temperature gradient from the threshold value / Relative Abweichung des
// berechneten Temperaturgradienten vom Schwellenwert
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "CPI_ANALYSE", "STAT_CPI_REL_TEMP_WERT", STAT_CPI_REL_TEMP_WERT, "\"%\"");
float STAT_CPI_TEMP_GRAD_WERT = (RXBUF_SINT32(2)/1000.0f);
// Calculated temperature gradient of the CPI diagnosis (unit K / min) / Berechneter Temperaturgradient der
// CPI-Diagnose (Einheit K/min)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "CPI_ANALYSE", "STAT_CPI_TEMP_GRAD_WERT", STAT_CPI_TEMP_GRAD_WERT, "");
unsigned long STAT_CPI_E_LOSS_WERT = (RXBUF_UINT32(6));
// Calculated energy loss of the CPI diagnosis (unit: Ws / min) / Berechnete Verlustenergie der CPI-Diagnose
// (Einheit: Ws/min)
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "CPI_ANALYSE", "STAT_CPI_E_LOSS_WERT", STAT_CPI_E_LOSS_WERT, "");
unsigned char STAT_CPI_DIAGNOSE = (RXBUF_UCHAR(10));
// Result of CPI diagnosis / Ergebnis CPI Diagnose
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "CPI_ANALYSE", "STAT_CPI_DIAGNOSE", STAT_CPI_DIAGNOSE, "\"0-n\"");
char STAT_CPI_TEMP_UMGEBUNG_WERT = (RXBUF_SCHAR(11));
// Ambient temperature during the CPI diagnosis / Umgebungstemperatatur während der CPI-Diagnose
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "CPI_ANALYSE", "STAT_CPI_TEMP_UMGEBUNG_WERT", STAT_CPI_TEMP_UMGEBUNG_WERT, "\"°C\"");
unsigned char STAT_CPI_FRT_AC = (RXBUF_UCHAR(12));
// Status of the interior air conditioning during the CPI diagnosis / Status der Innenraum-Klimatisierung während
// der CPI-Diagnose
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "CPI_ANALYSE", "STAT_CPI_FRT_AC", STAT_CPI_FRT_AC, "\"0-n\"");
unsigned long STAT_CPI_LIFE_TIME_WERT = (RXBUF_UINT32(13));
// Time stamp at the end of the CPI diagnosis / Zeitstempel am Ende der CPI-Diagnose
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "SME", "CPI_ANALYSE", "STAT_CPI_LIFE_TIME_WERT", STAT_CPI_LIFE_TIME_WERT, "\"s\"");
unsigned short STAT_ANZAHL_CPI_OK_WERT = (RXBUF_UINT(17));
// Number of CPI diagnoses since the last reset with the result Diag OK / Anzahl der CPI-Diagnosen seit dem
// letzten Reset mit Ergebnis Diag OK
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "CPI_ANALYSE", "STAT_ANZAHL_CPI_OK_WERT", STAT_ANZAHL_CPI_OK_WERT, "");
unsigned short STAT_ANZAHL_CPI_FAILED_WERT = (RXBUF_UINT(19));
// Number of CPI diagnoses since the last reset with the result Diag Failed / Anzahl der CPI-Diagnosen seit dem
// letzten Reset mit Ergebnis Diag Failed
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "CPI_ANALYSE", "STAT_ANZAHL_CPI_FAILED_WERT", STAT_ANZAHL_CPI_FAILED_WERT, "");
unsigned short STAT_ANZAHL_CPI_ABGEBROCHEN_WERT = (RXBUF_UINT(21));
// Number of prematurely aborted CPI diagnoses since the last reset / Anzahl der vorzeitig abgebrochenen
// CPI-Diagnosen seit dem letzten Reset
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "SME", "CPI_ANALYSE", "STAT_ANZAHL_CPI_ABGEBROCHEN_WERT", STAT_ANZAHL_CPI_ABGEBROCHEN_WERT, "");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
case I3_PID_SME_KAPAZITAETSTEST_ASYMMETRIE_POTENTIAL: { // 0xE5FA
if (datalen < 4) {
ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_SME_KAPAZITAETSTEST_ASYMMETRIE_POTENTIAL", 4);
break;
}
unsigned char STAT_KAPATEST_ASYM_ZELLE_ID_WERT = (RXBUF_UCHAR(0));
// Cell index of the cell that was most deeply discharged during the capacity test. / Zell-Index der Zelle, die
// während des Kapazitäts-Test am tiefsten entladen wurde.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "KAPAZITAETSTEST_ASYMMETRIE_POTENTIAL", "STAT_KAPATEST_ASYM_ZELLE_ID_WERT", STAT_KAPATEST_ASYM_ZELLE_ID_WERT, "");
unsigned char STAT_KAPATEST_ASYM_MOD_ID_WERT = (RXBUF_UCHAR(1));
// Module index of the cell that was deeply discharged during the capacity test. / Modul-Index der Zelle, die
// während Kapazitätstest am tiefsten entladen wurde.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "SME", "KAPAZITAETSTEST_ASYMMETRIE_POTENTIAL", "STAT_KAPATEST_ASYM_MOD_ID_WERT", STAT_KAPATEST_ASYM_MOD_ID_WERT, "");
float STAT_KAPATEST_ASYM_POT_WERT = (RXBUF_UINT(2)/10.0f);
// Capacity area that can potentially be made usable by balancing. / Kapazitätsbereich, der potenziell durch eine
// Symmetrierung nutzbar gemacht werden kann.
ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "SME", "KAPAZITAETSTEST_ASYMMETRIE_POTENTIAL", "STAT_KAPATEST_ASYM_POT_WERT", STAT_KAPATEST_ASYM_POT_WERT, "\"%\"");
// ========== Add your processing here ==========
hexdump(rxbuf, type, pid);
break;
}
| 386,753 |
678 | <reponame>bzxy/cydia<filename>iOSOpenDev/frameworks/iTunesStoreUI.framework/Headers/SUScriptNumberFormatter.h
/**
* This header is generated by class-dump-z 0.2b.
*
* Source: /System/Library/PrivateFrameworks/iTunesStoreUI.framework/iTunesStoreUI
*/
#import <iTunesStoreUI/SUScriptObject.h>
@class NSString, NSNumberFormatter;
@interface SUScriptNumberFormatter : SUScriptObject {
NSNumberFormatter *_numberFormatter; // 36 = 0x24
}
@property(retain) NSString *style; // G=0x64275; S=0x6410d;
@property(retain) NSString *localeIdentifier; // G=0x63f95; S=0x63ff5;
+ (void)initialize; // 0x64471
+ (id)webScriptNameForSelector:(SEL)selector; // 0x643b9
+ (id)webScriptNameForKey:(const char *)key; // 0x64315
- (id)scriptAttributeKeys; // 0x64411
- (id)attributeKeys; // 0x64401
// declared property getter: - (id)style; // 0x64275
// declared property setter: - (void)setStyle:(id)style; // 0x6410d
// declared property setter: - (void)setLocaleIdentifier:(id)identifier; // 0x63ff5
// declared property getter: - (id)localeIdentifier; // 0x63f95
- (id)stringFromNumber:(id)number; // 0x63ec5
- (id)numberFromString:(id)string; // 0x63df5
- (void)dealloc; // 0x63da9
- (id)init; // 0x63d31
@end
| 479 |
441 | # -*- coding: utf-8 -*-
"""
Created on Wed Dec 28 23:20:29 2016
@author: tomhope
"""
import numpy as np
import tensorflow as tf
elems = np.array(["T", "e", "n", "s", "o", "r", " ", "F", "l", "o", "w"])
scan_sum = tf.scan(lambda a, x: a + x, elems)
sess = tf.InteractiveSession()
sess.run(scan_sum)
| 138 |
45,293 | // Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
package org.jetbrains.kotlin.js.backend.ast;
import org.jetbrains.annotations.Nullable;
import java.util.List;
/**
* The context in which a JsNode visitation occurs. This represents the set of
* possible operations a JsVisitor subclass can perform on the currently visited
* node.
*/
public abstract class JsContext<T extends JsNode> {
public <R extends T> void addPrevious(R node) {
throw new UnsupportedOperationException();
}
public <R extends T> void addPrevious(List<R> nodes) {
for (R node : nodes) {
addPrevious(node);
}
}
public <R extends T> void addNext(R node) {
throw new UnsupportedOperationException();
}
public abstract void removeMe();
public abstract <R extends T> void replaceMe(R node);
@Nullable
public abstract T getCurrentNode();
}
| 307 |
563 | package com.gentics.mesh.test.context.helper;
import static org.assertj.core.api.Assertions.fail;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import io.vertx.core.Vertx;
import io.vertx.core.eventbus.MessageConsumer;
/**
* AutoClosable implementation, which will register an event handler upon
* creation and will wait (up to the given timeout) in
* {@link UnexpectedEvent#close()} for the event to be fired. If the event was fired, an exception is thrown.
* See {@link EventHelper#notExpectEvent(com.gentics.mesh.core.rest.MeshEvent, int)} for usage.
*/
public class UnexpectedEvent implements AutoCloseable {
protected CountDownLatch latch = new CountDownLatch(1);
protected String address;
protected int timeoutMs;
protected MessageConsumer<Object> consumer;
/**
* Create an instance and register the event handler
* @param vertx vertx instance
* @param address event address
* @param timeoutMs timeout in milliseconds
*/
public UnexpectedEvent(Vertx vertx, String address, int timeoutMs) {
this.address = address;
this.timeoutMs = timeoutMs;
consumer = vertx.eventBus().consumer(address);
consumer.handler(msg -> latch.countDown());
}
@Override
public void close() {
try {
if (latch.await(timeoutMs, TimeUnit.MILLISECONDS)) {
fail("Event " + address + " was handled at least once within timeout");
}
} catch (InterruptedException e) {
throw new RuntimeException(e);
} finally {
consumer.unregister();
}
}
}
| 473 |
746 | // Copyright (c) OpenMMLab. All rights reserved.
#include "detector.h"
#include <numeric>
#include "apis/c/common_internal.h"
#include "apis/c/executor_internal.h"
#include "apis/c/model.h"
#include "apis/c/pipeline.h"
#include "archive/value_archive.h"
#include "codebase/mmdet/mmdet.h"
#include "core/device.h"
#include "core/model.h"
#include "core/utils/formatter.h"
#include "core/value.h"
using namespace std;
using namespace mmdeploy;
namespace {
Value& config_template() {
// clang-format off
static Value v{
{
"pipeline", {
{"input", {"image"}},
{"output", {"det"}},
{
"tasks",{
{
{"name", "mmdetection"},
{"type", "Inference"},
{"params", {{"model", "TBD"}}},
{"input", {"image"}},
{"output", {"det"}}
}
}
}
}
}
};
// clang-format on
return v;
}
int mmdeploy_detector_create_impl(mm_model_t model, const char* device_name, int device_id,
mmdeploy_exec_info_t exec_info, mm_handle_t* handle) {
auto config = config_template();
config["pipeline"]["tasks"][0]["params"]["model"] = *static_cast<Model*>(model);
return mmdeploy_pipeline_create(Cast(&config), device_name, device_id, exec_info, handle);
}
} // namespace
int mmdeploy_detector_create(mm_model_t model, const char* device_name, int device_id,
mm_handle_t* handle) {
return mmdeploy_detector_create_impl(model, device_name, device_id, nullptr, handle);
}
int mmdeploy_detector_create_v2(mm_model_t model, const char* device_name, int device_id,
mmdeploy_exec_info_t exec_info, mm_handle_t* handle) {
return mmdeploy_detector_create_impl(model, device_name, device_id, exec_info, handle);
}
int mmdeploy_detector_create_by_path(const char* model_path, const char* device_name, int device_id,
mm_handle_t* handle) {
mm_model_t model{};
if (auto ec = mmdeploy_model_create_by_path(model_path, &model)) {
return ec;
}
auto ec = mmdeploy_detector_create_impl(model, device_name, device_id, nullptr, handle);
mmdeploy_model_destroy(model);
return ec;
}
int mmdeploy_detector_create_input(const mm_mat_t* mats, int mat_count, mmdeploy_value_t* input) {
return mmdeploy_common_create_input(mats, mat_count, input);
}
int mmdeploy_detector_apply(mm_handle_t handle, const mm_mat_t* mats, int mat_count,
mm_detect_t** results, int** result_count) {
wrapped<mmdeploy_value_t> input;
if (auto ec = mmdeploy_detector_create_input(mats, mat_count, input.ptr())) {
return ec;
}
wrapped<mmdeploy_value_t> output;
if (auto ec = mmdeploy_detector_apply_v2(handle, input, output.ptr())) {
return ec;
}
if (auto ec = mmdeploy_detector_get_result(output, results, result_count)) {
return ec;
}
return MM_SUCCESS;
}
int mmdeploy_detector_apply_v2(mm_handle_t handle, mmdeploy_value_t input,
mmdeploy_value_t* output) {
return mmdeploy_pipeline_apply(handle, input, output);
}
int mmdeploy_detector_apply_async(mm_handle_t handle, mmdeploy_sender_t input,
mmdeploy_sender_t* output) {
return mmdeploy_pipeline_apply_async(handle, input, output);
}
int mmdeploy_detector_get_result(mmdeploy_value_t output, mm_detect_t** results,
int** result_count) {
if (!output || !results || !result_count) {
return MM_E_INVALID_ARG;
}
try {
Value& value = Cast(output)->front();
auto detector_outputs = from_value<vector<mmdet::DetectorOutput>>(value);
vector<int> _result_count;
_result_count.reserve(detector_outputs.size());
for (const auto& det_output : detector_outputs) {
_result_count.push_back((int)det_output.detections.size());
}
auto total = std::accumulate(_result_count.begin(), _result_count.end(), 0);
std::unique_ptr<int[]> result_count_data(new int[_result_count.size()]{});
auto result_count_ptr = result_count_data.get();
std::copy(_result_count.begin(), _result_count.end(), result_count_data.get());
auto deleter = [&](mm_detect_t* p) {
mmdeploy_detector_release_result(p, result_count_ptr, (int)detector_outputs.size());
};
std::unique_ptr<mm_detect_t[], decltype(deleter)> result_data(new mm_detect_t[total]{},
deleter);
// ownership transferred to result_data
result_count_data.release();
auto result_ptr = result_data.get();
for (const auto& det_output : detector_outputs) {
for (const auto& detection : det_output.detections) {
result_ptr->label_id = detection.label_id;
result_ptr->score = detection.score;
const auto& bbox = detection.bbox;
result_ptr->bbox = {bbox[0], bbox[1], bbox[2], bbox[3]};
auto mask_byte_size = detection.mask.byte_size();
if (mask_byte_size) {
auto& mask = detection.mask;
result_ptr->mask = new mm_instance_mask_t{};
result_ptr->mask->data = new char[mask_byte_size];
result_ptr->mask->width = mask.width();
result_ptr->mask->height = mask.height();
std::copy(mask.data<char>(), mask.data<char>() + mask_byte_size, result_ptr->mask->data);
}
++result_ptr;
}
}
*result_count = result_count_ptr;
*results = result_data.release();
return MM_SUCCESS;
} catch (const std::exception& e) {
MMDEPLOY_ERROR("unhandled exception: {}", e.what());
} catch (...) {
MMDEPLOY_ERROR("unknown exception caught");
}
return MM_E_FAIL;
}
void mmdeploy_detector_release_result(mm_detect_t* results, const int* result_count, int count) {
auto result_ptr = results;
for (int i = 0; i < count; ++i) {
for (int j = 0; j < result_count[i]; ++j, ++result_ptr) {
if (result_ptr->mask) {
delete[] result_ptr->mask->data;
delete result_ptr->mask;
}
}
}
delete[] results;
delete[] result_count;
}
void mmdeploy_detector_destroy(mm_handle_t handle) { mmdeploy_pipeline_destroy(handle); }
| 2,756 |
310 | /*
This file is part of ``kdtree'', a library for working with kd-trees.
Copyright (C) 2007-2011 <NAME> <<EMAIL>>
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
3. The name of the author may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
OF SUCH DAMAGE.
*/
/* single nearest neighbor search written by <NAME> <<EMAIL>>
*/
#include "kdtree.h"
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
enum { DIM = 3 };
struct kdhyperrect {
float min[DIM], max[DIM]; /* minimum/maximum coords */
};
struct kdnode {
float pos[DIM];
int dir;
void *data;
struct kdnode *left, *right; /* negative/positive side */
};
struct kdtree {
struct kdnode *root;
struct kdhyperrect *rect;
void (*destr)(void *);
};
#define SQ(x) ((x) * (x))
static void clear_rec(struct kdnode *node, void (*destr)(void *));
static int insert_rec(struct kdnode **node, const float *pos, void *data,
int dir);
static struct kdhyperrect *hyperrect_create(const float *min, const float *max);
static void hyperrect_extend(struct kdhyperrect *rect, const float *pos);
static float hyperrect_dist_sq(struct kdhyperrect *rect, const float *pos);
struct kdtree *kd_create() {
struct kdtree *tree;
if (!(tree = malloc(sizeof *tree))) {
return 0;
}
tree->root = 0;
tree->destr = 0;
tree->rect = 0;
return tree;
}
static void clear_rec(struct kdnode *node, void (*destr)(void *)) {
if (!node)
return;
clear_rec(node->left, destr);
clear_rec(node->right, destr);
if (destr) {
destr(node->data);
}
free(node);
}
static void kd_clear(struct kdtree *tree) {
clear_rec(tree->root, tree->destr);
tree->root = 0;
if (tree->rect) {
free(tree->rect);
tree->rect = 0;
}
}
void kd_free(struct kdtree *tree) {
if (tree) {
kd_clear(tree);
free(tree);
}
}
static int insert_rec(struct kdnode **nptr, const float *pos, void *data,
int dir) {
int new_dir;
struct kdnode *node;
if (!*nptr) {
if (!(node = malloc(sizeof *node))) {
return -1;
}
memcpy(node->pos, pos, DIM * sizeof *node->pos);
node->data = data;
node->dir = dir;
node->left = node->right = 0;
*nptr = node;
return 0;
}
node = *nptr;
new_dir = (node->dir + 1) % DIM;
if (pos[node->dir] < node->pos[node->dir]) {
return insert_rec(&(*nptr)->left, pos, data, new_dir);
}
return insert_rec(&(*nptr)->right, pos, data, new_dir);
}
int kd_insert(struct kdtree *tree, const float *pos, void *data) {
if (insert_rec(&tree->root, pos, data, 0)) {
return -1;
}
if (tree->rect == 0) {
tree->rect = hyperrect_create(pos, pos);
} else {
hyperrect_extend(tree->rect, pos);
}
return 0;
}
static void kd_nearest_i(struct kdnode *node, const float *pos,
struct kdnode **result, float *result_dist_sq,
struct kdhyperrect *rect) {
int dir = node->dir;
int i;
float dummy, dist_sq;
struct kdnode *nearer_subtree, *farther_subtree;
float *nearer_hyperrect_coord, *farther_hyperrect_coord;
/* Decide whether to go left or right in the tree */
dummy = pos[dir] - node->pos[dir];
if (dummy <= 0) {
nearer_subtree = node->left;
farther_subtree = node->right;
nearer_hyperrect_coord = rect->max + dir;
farther_hyperrect_coord = rect->min + dir;
} else {
nearer_subtree = node->right;
farther_subtree = node->left;
nearer_hyperrect_coord = rect->min + dir;
farther_hyperrect_coord = rect->max + dir;
}
if (nearer_subtree) {
/* Slice the hyperrect to get the hyperrect of the nearer subtree */
dummy = *nearer_hyperrect_coord;
*nearer_hyperrect_coord = node->pos[dir];
/* Recurse down into nearer subtree */
kd_nearest_i(nearer_subtree, pos, result, result_dist_sq, rect);
/* Undo the slice */
*nearer_hyperrect_coord = dummy;
}
/* Check the distance of the point at the current node, compare it
* with our best so far */
dist_sq = 0;
for (i = 0; i < DIM; i++) {
dist_sq += SQ(node->pos[i] - pos[i]);
}
if (dist_sq < *result_dist_sq) {
*result = node;
*result_dist_sq = dist_sq;
}
if (farther_subtree) {
/* Get the hyperrect of the farther subtree */
dummy = *farther_hyperrect_coord;
*farther_hyperrect_coord = node->pos[dir];
/* Check if we have to recurse down by calculating the closest
* point of the hyperrect and see if it's closer than our
* minimum distance in result_dist_sq. */
if (hyperrect_dist_sq(rect, pos) < *result_dist_sq) {
/* Recurse down into farther subtree */
kd_nearest_i(farther_subtree, pos, result, result_dist_sq, rect);
}
/* Undo the slice on the hyperrect */
*farther_hyperrect_coord = dummy;
}
}
int kd_nearest(struct kdtree *kd, const float *pos, void **res) {
struct kdhyperrect rect;
struct kdnode *result;
float dist_sq;
int i;
if (!kd)
return -1;
if (!kd->rect)
return -1;
/* Duplicate the bounding hyperrectangle, we will work on the copy */
memcpy(&rect, kd->rect, sizeof(struct kdhyperrect));
/* Our first guesstimate is the root node */
result = kd->root;
dist_sq = 0;
for (i = 0; i < DIM; i++)
dist_sq += SQ(result->pos[i] - pos[i]);
/* Search for the nearest neighbour recursively */
kd_nearest_i(kd->root, pos, &result, &dist_sq, &rect);
if (result) {
*res = result->data;
return 0;
} else {
return -1;
}
}
/* ---- hyperrectangle helpers ---- */
static struct kdhyperrect *hyperrect_create(const float *min,
const float *max) {
size_t size = DIM * sizeof(float);
struct kdhyperrect *rect = 0;
if (!(rect = malloc(sizeof(struct kdhyperrect)))) {
return 0;
}
memcpy(rect->min, min, size);
memcpy(rect->max, max, size);
return rect;
}
static void hyperrect_extend(struct kdhyperrect *rect, const float *pos) {
int i;
for (i = 0; i < DIM; i++) {
if (pos[i] < rect->min[i]) {
rect->min[i] = pos[i];
}
if (pos[i] > rect->max[i]) {
rect->max[i] = pos[i];
}
}
}
static float hyperrect_dist_sq(struct kdhyperrect *rect, const float *pos) {
int i;
float result = 0;
for (i = 0; i < DIM; i++) {
if (pos[i] < rect->min[i]) {
result += SQ(rect->min[i] - pos[i]);
} else if (pos[i] > rect->max[i]) {
result += SQ(rect->max[i] - pos[i]);
}
}
return result;
}
| 2,956 |
1,405 | package com.lenovo.safecenter.broadcast;
import android.app.Service;
import android.content.Intent;
import android.media.AudioManager;
import android.media.MediaPlayer;
import android.os.IBinder;
import com.lenovo.safecenter.R;
import java.io.IOException;
public class AlarmService extends Service {
private MediaPlayer a;
private AudioManager b;
private boolean c = false;
public IBinder onBind(Intent intent) {
return null;
}
public void onCreate() {
super.onCreate();
this.a = MediaPlayer.create(this, (int) R.raw.alarm);
this.b = (AudioManager) getSystemService("audio");
}
public void onStart(Intent intent, int startId) {
super.onStart(intent, startId);
this.c = true;
new Thread() {
/* class com.lenovo.safecenter.broadcast.AlarmService.AnonymousClass1 */
public final void run() {
while (AlarmService.this.c) {
AlarmService.this.b.setStreamVolume(3, AlarmService.this.b.getStreamMaxVolume(3), 0);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}.start();
if (this.a != null) {
this.a.stop();
try {
this.a.prepare();
} catch (IOException | IllegalStateException e) {
}
this.a.setLooping(true);
this.a.start();
}
}
public void onDestroy() {
super.onDestroy();
if (this.a != null) {
this.a.stop();
this.a.release();
}
this.c = false;
}
}
| 865 |
2,023 | <gh_stars>1000+
import os
import urllib2
import urllib
from urlparse import urlparse
from bs4 import BeautifulSoup
import easygui as eg
eg.msgbox("Search/Enter proper url"+'\n'+"Ex:naruto 100 or bleach 400"+'\n'+" www.mangareader.net/naruto/100",title="Manga Downloader", ok_button="ok")
q=eg.enterbox(msg='Search or Enter the Link.',title='Manga Downloader')
print q
def user_input(q):
if 'www' in q:
site1(q)
else:
search(q)
def search(query):
"""Name episod
Ex: 1.Bleach 544
2.Naruto 100"""
s=query.lower().strip(' ').split(' ')
link='http://www.mangareader.net/'+s[0]+'/'+s[1]
if len(s) > 2:
link='http://www.mangareader.net/'+'-'.join(s[0:-1])+'/'+s[-1]
site1(link)
def site1(link):
link=link.strip('http://')
link=link.strip('.html')
if (link.count('/')>2):
print 'link.count:',link.count('/')
two=link.find('/',20)
three=link.find('/',two+1)
#link=http://www.mangareader.net/440-45521-1/watashi-ni-xx-shinasai/chapter-8.html
link='http://www.mangareader.net/'+link[two+1:three]+'/'+link[three+9:]
print link
if 'http://' not in link:
link1="http://"+link
else:
link1=link
try:
html=urllib2.urlopen(link1).read()
except urllib2.HTTPError:
print('Enter proper url')
soup = BeautifulSoup(html)
link_image=soup.img['src']
link_next=soup.img.parent['href']
""" Creates folder at specified location"""
link_properties = urlparse(link)
start=link_properties.path.find('/')
end=link_properties.path.find('/',start+1)
folder_name=link_properties.path[start+1:end]+'_'+link_properties.path[end+1:]
if not os.path.exists(folder_name):
os.makedirs(folder_name)
"""Completed creating Directory"""
if 'www.' in link_next:
pass
link_next='http://www.mangareader.net'+link_next
i=0
while ('/'+link_properties.path[end+1:]+'/')in link_image:
f = open(folder_name+'/'+str(i+1)+'.jpg','wb')
f.write(urllib.urlopen(link_image).read())
f.close()
html=urllib2.urlopen(link_next).read()
soup = BeautifulSoup(html)
link_image=soup.img['src']
link_next=soup.img.parent['href']
link_next='http://www.mangareader.net'+link_next
print link_next,link_image
i=i+1
#search("one piece 100")
user_input(q)
| 1,221 |
2,094 | ////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Project: Embedded Learning Library (ELL)
// File: LinearPredictor.h (predictors)
// Authors: <NAME>
//
////////////////////////////////////////////////////////////////////////////////////////////////////
#pragma once
#include "IPredictor.h"
#include <math/include/Vector.h>
#include <data/include/AutoDataVector.h>
#include <utilities/include/IArchivable.h>
#include <cstddef>
#include <memory>
namespace ell
{
namespace predictors
{
/// <summary> A linear binary predictor. </summary>
///
/// <typeparam name="ElementType"> The fundamental type used by this predictor. </typeparam>
template <typename ElementType>
class LinearPredictor : public IPredictor<ElementType>
, public utilities::IArchivable
{
public:
/// <summary> Type of the data vector expected by this predictor type. </summary>
using DataVectorType = data::AutoDataVector;
/// <summary> Default Constructor. </summary>
LinearPredictor() = default;
/// <summary> Constructs an instance of LinearPredictor. </summary>
///
/// <param name="dim"> The dimension. </param>
LinearPredictor(size_t dim);
/// <summary> Constructs an instance of LinearPredictor. </summary>
///
/// <param name="weights"> The weights. </param>
/// <param name="bias"> The bias. </param>
LinearPredictor(const math::ColumnVector<ElementType>& weights, ElementType bias);
/// <summary> Constructs an instance of a LinearPredictor from an existing one. </summary>
///
/// <param name="dim"> The dimension. </param>
/// <typeparam name="OtherElementType"> The fundamental type used by the other predictor.
/// This allows a linear predictor to be initialized from another whose fundamental type is different,
/// but compatible. Since trainers always output a linear predictor of type double, this can be used
/// to create the same predictor using float.
/// </typeparam>
template <typename OtherElementType>
LinearPredictor(const LinearPredictor<OtherElementType>& other);
/// <summary> Returns the underlying DoubleVector. </summary>
///
/// <returns> The underlying vector. </returns>
math::ColumnVector<ElementType>& GetWeights() { return _w; }
/// <summary> Returns the underlying DoubleVector. </summary>
///
/// <returns> The underlying vector. </returns>
const math::ConstColumnVectorReference<ElementType>& GetWeights() const { return _w; }
/// <summary> Returns the underlying bias. </summary>
///
/// <returns> The bias. </returns>
ElementType& GetBias() { return _b; }
/// <summary> Returns the underlying bias. </summary>
///
/// <returns> The bias. </returns>
ElementType GetBias() const { return _b; }
/// <summary> Gets the dimension of the linear predictor. </summary>
///
/// <returns> The dimension. </returns>
size_t Size() const { return _w.Size(); }
/// <summary> Resizes the weight vector to a given size. </summary>
///
/// <param name="size"> The new size. </param>
void Resize(size_t size);
/// <summary> Returns the output of the predictor for a given example. </summary>
///
/// <param name="example"> The data vector. </param>
///
/// <returns> The prediction. </returns>
ElementType Predict(const DataVectorType& dataVector) const;
/// <summary> Returns a vector of dataVector elements weighted by the predictor weights. </summary>
///
/// <param name="example"> The data vector. </param>
///
/// <returns> The weighted elements vector. </returns>
DataVectorType GetWeightedElements(const DataVectorType& dataVector) const;
/// <summary> Scales the linear predictor by a scalar </summary>
///
/// <param name="scalar"> The scalar. </param>
void Scale(ElementType scalar);
/// <summary> Resets the linear predictor to the zero vector with zero bias. </summary>
void Reset();
/// <summary> Gets the name of this type (for serialization). </summary>
///
/// <returns> The name of this type. </returns>
static std::string GetTypeName() { return utilities::GetCompositeTypeName<ElementType>("LinearPredictor"); }
/// <summary> Gets the name of this type (for serialization). </summary>
///
/// <returns> The name of this type. </returns>
std::string GetRuntimeTypeName() const override { return GetTypeName(); }
protected:
void WriteToArchive(utilities::Archiver& archiver) const override;
void ReadFromArchive(utilities::Unarchiver& archiver) override;
private:
math::ColumnVector<ElementType> _w;
ElementType _b = 0;
};
} // namespace predictors
} // namespace ell
#pragma region implementation
#include <data/include/DataVectorOperations.h>
#include <math/include/VectorOperations.h>
#include <memory>
namespace ell
{
namespace predictors
{
template <typename ElementType>
LinearPredictor<ElementType>::LinearPredictor(size_t dim) :
_w(dim),
_b(0)
{
}
template <typename ElementType>
LinearPredictor<ElementType>::LinearPredictor(const math::ColumnVector<ElementType>& weights, ElementType bias) :
_w(weights),
_b(bias)
{
}
template <typename ElementType>
template <typename OtherElementType>
LinearPredictor<ElementType>::LinearPredictor(const LinearPredictor<OtherElementType>& other) :
_b(other.GetBias())
{
auto weights = other.GetWeights();
_w.Resize(weights.Size());
for (size_t i = 0; i < weights.Size(); ++i)
{
_w[i] = static_cast<ElementType>(weights[i]);
}
}
template <typename ElementType>
void LinearPredictor<ElementType>::Reset()
{
_w.Reset();
_b = 0;
}
template <typename ElementType>
void LinearPredictor<ElementType>::Resize(size_t size)
{
_w.Resize(size);
}
template <typename ElementType>
ElementType LinearPredictor<ElementType>::Predict(const DataVectorType& dataVector) const
{
return _w * dataVector + _b;
}
template <typename ElementType>
auto LinearPredictor<ElementType>::GetWeightedElements(const DataVectorType& dataVector) const -> DataVectorType
{
auto transformation = [&](data::IndexValue indexValue) -> ElementType { return indexValue.value * _w[indexValue.index]; };
return dataVector.TransformAs<data::IterationPolicy::skipZeros, DataVectorType>(transformation);
}
template <typename ElementType>
void LinearPredictor<ElementType>::Scale(ElementType scalar)
{
_w *= scalar;
_b *= scalar;
}
template <typename ElementType>
void LinearPredictor<ElementType>::WriteToArchive(utilities::Archiver& archiver) const
{
auto w = _w.ToArray();
archiver["w"] << w;
archiver["b"] << _b;
}
template <typename ElementType>
void LinearPredictor<ElementType>::ReadFromArchive(utilities::Unarchiver& archiver)
{
std::vector<ElementType> w;
archiver["w"] >> w;
_w = math::ColumnVector<ElementType>(std::move(w));
archiver["b"] >> _b;
}
} // namespace predictors
} // namespace ell
#pragma endregion implementation
| 2,848 |
435 | <filename>pycon-au-2018/videos/data-is-the-new-shiny-thing.json<gh_stars>100-1000
{
"copyright_text": "CC BY 3.0 AU",
"description": "Data Science is the tag of choice for grant applications, project proposals,\nand media opportunities. It\u2019s the latest shiny buzz word toy. But it turns\nout that data science is crucial to our lives and the future of the planet.\nIt\u2019s also a fun, easy, and motivating way to teach kids programming and give\nthem the chance to make a real difference in the world. So let\u2019s talk about\nusing Python and real datasets to take over the world, and, incidentally,\nteach STEM.",
"language": "eng",
"recorded": "2018-08-24",
"related_urls": [
{
"label": "Talk schedule",
"url": "https://2018.pycon-au.org/talks/41003-education-invited-speaker/"
}
],
"speakers": [
"<NAME>"
],
"thumbnail_url": "https://i.ytimg.com/vi/Crq5zI_LsKQ/hqdefault.jpg",
"title": "Data is the new shiny thing",
"videos": [
{
"type": "youtube",
"url": "https://www.youtube.com/watch?v=Crq5zI_LsKQ"
}
]
}
| 402 |
4,879 | #include "testing/testing.hpp"
#include "platform/country_file.hpp"
#include "platform/local_country_file.hpp"
#include "platform/local_country_file_utils.hpp"
#include "platform/mwm_version.hpp"
#include "platform/platform.hpp"
#include "platform/platform_tests_support/scoped_dir.hpp"
#include "platform/platform_tests_support/scoped_file.hpp"
#include "platform/settings.hpp"
#include "coding/file_writer.hpp"
#include "coding/internal/file_data.hpp"
#include "base/file_name_utils.hpp"
#include "base/logging.hpp"
#include "base/scope_guard.hpp"
#include "defines.hpp"
#include <algorithm>
#include <functional>
#include <set>
#include <string>
using namespace platform::tests_support;
using namespace std;
namespace platform
{
namespace
{
template <typename T>
bool Contains(vector<T> const & v, T const & t)
{
return find(v.begin(), v.end(), t) != v.end();
}
} // namespace
// Checks that all unsigned numbers less than 10 ^ 18 can be parsed as
// a timestamp.
UNIT_TEST(LocalCountryFile_ParseVersion)
{
int64_t version = 0;
TEST(ParseVersion("1", version), ());
TEST_EQUAL(version, 1, ());
TEST(ParseVersion("141010", version), ());
TEST_EQUAL(version, 141010, ());
TEST(ParseVersion("150309", version), ());
TEST_EQUAL(version, 150309, ());
TEST(ParseVersion("999999999999999999", version), ());
TEST_EQUAL(version, 999999999999999999, ());
TEST(!ParseVersion("1000000000000000000", version), ());
TEST(!ParseVersion("00000000000000000000000000000000123", version), ());
TEST(!ParseVersion("", version), ());
TEST(!ParseVersion("150309 ", version), ());
TEST(!ParseVersion(" 150309", version), ());
TEST(!ParseVersion("-150309", version), ());
TEST(!ParseVersion("just string", version), ());
}
// Checks basic functionality of LocalCountryFile.
UNIT_TEST(LocalCountryFile_Smoke)
{
CountryFile countryFile("TestCountry");
countryFile.SetRemoteSize(1 /* mapSize */);
LocalCountryFile localFile("/test-dir", countryFile, 150309);
TEST_EQUAL("/test-dir/TestCountry" DATA_FILE_EXTENSION, localFile.GetPath(MapFileType::Map), ());
// Not synced with disk yet.
TEST(!localFile.HasFiles(), ());
TEST(!localFile.OnDisk(MapFileType::Map), ());
TEST(!localFile.OnDisk(MapFileType::Diff), ());
TEST_EQUAL("/test-dir", localFile.GetDirectory(), ());
TEST_EQUAL(0, localFile.GetSize(MapFileType::Map), ());
TEST_EQUAL(0, localFile.GetSize(MapFileType::Diff), ());
TEST_EQUAL(150309, localFile.GetVersion(), ());
}
// Creates test country map file and checks sync-with-disk functionality.
UNIT_TEST(LocalCountryFile_DiskFiles)
{
Platform & platform = GetPlatform();
CountryFile countryFile("TestCountry");
countryFile.SetRemoteSize(1 /* mapSize */);
for (int64_t version : {1, 150312})
{
LocalCountryFile localFile(platform.WritableDir(), countryFile, version);
TEST(!localFile.OnDisk(MapFileType::Map), ());
TEST(!localFile.OnDisk(MapFileType::Diff), ());
string const mapFileName = GetFileName(countryFile.GetName(), MapFileType::Map);
string const mapFileContents("map");
ScopedFile testMapFile(mapFileName, mapFileContents);
localFile.SyncWithDisk();
TEST(localFile.OnDisk(MapFileType::Map), ());
TEST(!localFile.OnDisk(MapFileType::Diff), ());
TEST_EQUAL(mapFileContents.size(), localFile.GetSize(MapFileType::Map), ());
localFile.SyncWithDisk();
TEST(localFile.OnDisk(MapFileType::Map), ());
TEST_EQUAL(mapFileContents.size(), localFile.GetSize(MapFileType::Map), ());
localFile.DeleteFromDisk(MapFileType::Map);
TEST(!testMapFile.Exists(), (testMapFile, "wasn't deleted by LocalCountryFile."));
testMapFile.Reset();
}
}
UNIT_TEST(LocalCountryFile_CleanupMapFiles)
{
Platform & platform = GetPlatform();
string const mapsDir = platform.WritableDir();
// Two fake directories for test country files and indexes.
ScopedDir dir3("3");
ScopedDir dir4("4");
ScopedDir absentCountryIndexesDir(dir4, "Absent");
ScopedDir irelandIndexesDir(dir4, "Ireland");
CountryFile irelandFile("Ireland");
LocalCountryFile irelandLocalFile(dir4.GetFullPath(), irelandFile, 4 /* version */);
ScopedFile irelandMapFile(dir4, irelandFile, MapFileType::Map);
// Check FindAllLocalMaps()
vector<LocalCountryFile> localFiles;
FindAllLocalMapsAndCleanup(4 /* latestVersion */, localFiles);
TEST(Contains(localFiles, irelandLocalFile), (irelandLocalFile, localFiles));
irelandLocalFile.SyncWithDisk();
TEST(irelandLocalFile.OnDisk(MapFileType::Map), ());
irelandLocalFile.DeleteFromDisk(MapFileType::Map);
TEST(!irelandMapFile.Exists(), (irelandMapFile));
irelandMapFile.Reset();
TEST(!dir3.Exists(), ("Empty directory", dir3, "wasn't removed."));
dir3.Reset();
TEST(dir4.Exists(), ());
TEST(!absentCountryIndexesDir.Exists(), ("Indexes for absent country weren't deleted."));
absentCountryIndexesDir.Reset();
TEST(irelandIndexesDir.Exists(), ());
}
UNIT_TEST(LocalCountryFile_CleanupPartiallyDownloadedFiles)
{
ScopedDir oldDir("101009");
ScopedDir latestDir("101010");
ScopedFile toBeDeleted[] = {
{"Ireland.mwm.ready", ScopedFile::Mode::Create},
{"Netherlands.mwm.routing.downloading2", ScopedFile::Mode::Create},
{"Germany.mwm.ready3", ScopedFile::Mode::Create},
{"UK_England.mwm.resume4", ScopedFile::Mode::Create},
{base::JoinPath(oldDir.GetRelativePath(), "Russia_Central.mwm.downloading"),
ScopedFile::Mode::Create}};
ScopedFile toBeKept[] = {
{"Italy.mwm", ScopedFile::Mode::Create},
{"Spain.mwm", ScopedFile::Mode::Create},
{"Spain.mwm.routing", ScopedFile::Mode::Create},
{base::JoinPath(latestDir.GetRelativePath(), "Russia_Southern.mwm.downloading"),
ScopedFile::Mode::Create}};
CleanupMapsDirectory(101010 /* latestVersion */);
for (ScopedFile & file : toBeDeleted)
{
TEST(!file.Exists(), (file));
file.Reset();
}
TEST(!oldDir.Exists(), (oldDir));
oldDir.Reset();
for (ScopedFile & file : toBeKept)
TEST(file.Exists(), (file));
TEST(latestDir.Exists(), (latestDir));
}
// Creates test-dir and following files:
// * test-dir/Ireland.mwm
// * test-dir/Netherlands.mwm
// * test-dir/Netherlands.mwm.routing
// After that, checks that FindAllLocalMapsInDirectory() correctly finds all created files.
UNIT_TEST(LocalCountryFile_DirectoryLookup)
{
// This tests creates a map file for Ireland and map + routing files
// for Netherlands in a test directory.
CountryFile const irelandFile("Ireland");
CountryFile const netherlandsFile("Netherlands");
ScopedDir testDir("test-dir");
ScopedFile testIrelandMapFile(testDir, irelandFile, MapFileType::Map);
ScopedFile testNetherlandsMapFile(testDir, netherlandsFile, MapFileType::Map);
vector<LocalCountryFile> localFiles;
FindAllLocalMapsInDirectoryAndCleanup(testDir.GetFullPath(), 150309 /* version */,
-1 /* latestVersion */, localFiles);
sort(localFiles.begin(), localFiles.end());
for (LocalCountryFile & localFile : localFiles)
localFile.SyncWithDisk();
LocalCountryFile expectedIrelandFile(testDir.GetFullPath(), irelandFile, 150309);
expectedIrelandFile.SyncWithDisk();
LocalCountryFile expectedNetherlandsFile(testDir.GetFullPath(), netherlandsFile, 150309);
expectedNetherlandsFile.SyncWithDisk();
vector<LocalCountryFile> expectedLocalFiles = {expectedIrelandFile, expectedNetherlandsFile};
sort(expectedLocalFiles.begin(), expectedLocalFiles.end());
TEST_EQUAL(expectedLocalFiles, localFiles, ());
}
// Creates directory 010101 and 010101/Italy.mwm file. After that,
// checks that this file will be recognized as a map file for Italy
// with version 010101. Also, checks that World.mwm and
// WorldCoasts.mwm exist in writable dir.
UNIT_TEST(LocalCountryFile_AllLocalFilesLookup)
{
CountryFile const italyFile("Italy");
ScopedDir testDir("10101");
settings::Delete("LastMigration");
ScopedFile testItalyMapFile(testDir, italyFile, MapFileType::Map);
vector<LocalCountryFile> localFiles;
FindAllLocalMapsAndCleanup(10101 /* latestVersion */, localFiles);
multiset<LocalCountryFile> localFilesSet(localFiles.begin(), localFiles.end());
bool worldFound = false;
bool worldCoastsFound = false;
for (auto const & file : localFiles)
{
// With the new concepts, World mwm files have valid version.
if (file.GetCountryName() == WORLD_FILE_NAME)
{
worldFound = true;
TEST_NOT_EQUAL(0, file.GetVersion(), (file));
}
if (file.GetCountryName() == WORLD_COASTS_FILE_NAME)
{
worldCoastsFound = true;
TEST_NOT_EQUAL(0, file.GetVersion(), (file));
}
}
TEST(worldFound, ());
TEST(worldCoastsFound, ());
LocalCountryFile expectedItalyFile(testDir.GetFullPath(), italyFile, 10101);
TEST_EQUAL(1, localFilesSet.count(expectedItalyFile), (localFiles));
}
UNIT_TEST(LocalCountryFile_PreparePlaceForCountryFiles)
{
Platform & platform = GetPlatform();
CountryFile italyFile("Italy");
LocalCountryFile expectedItalyFile(platform.WritableDir(), italyFile, 0 /* version */);
shared_ptr<LocalCountryFile> italyLocalFile =
PreparePlaceForCountryFiles(0 /* version */, italyFile);
TEST(italyLocalFile.get(), ());
TEST_EQUAL(expectedItalyFile, *italyLocalFile, ());
ScopedDir directoryForV1("1");
CountryFile germanyFile("Germany");
LocalCountryFile expectedGermanyFile(directoryForV1.GetFullPath(), germanyFile, 1 /* version */);
shared_ptr<LocalCountryFile> germanyLocalFile =
PreparePlaceForCountryFiles(1 /* version */, germanyFile);
TEST(germanyLocalFile.get(), ());
TEST_EQUAL(expectedGermanyFile, *germanyLocalFile, ());
CountryFile franceFile("France");
LocalCountryFile expectedFranceFile(directoryForV1.GetFullPath(), franceFile, 1 /* version */);
shared_ptr<LocalCountryFile> franceLocalFile =
PreparePlaceForCountryFiles(1 /* version */, franceFile);
TEST(franceLocalFile.get(), ());
TEST_EQUAL(expectedFranceFile, *franceLocalFile, ());
}
UNIT_TEST(LocalCountryFile_CountryIndexes)
{
ScopedDir testDir("101010");
CountryFile germanyFile("Germany");
LocalCountryFile germanyLocalFile(testDir.GetFullPath(), germanyFile, 101010 /* version */);
TEST_EQUAL(base::JoinPath(germanyLocalFile.GetDirectory(), germanyFile.GetName()),
CountryIndexes::IndexesDir(germanyLocalFile), ());
CountryIndexes::PreparePlaceOnDisk(germanyLocalFile);
string const bitsPath = CountryIndexes::GetPath(germanyLocalFile, CountryIndexes::Index::Bits);
TEST(!Platform::IsFileExistsByFullPath(bitsPath), (bitsPath));
{
FileWriter writer(bitsPath);
string const contents = "bits index";
writer.Write(contents.data(), contents.size());
}
TEST(Platform::IsFileExistsByFullPath(bitsPath), (bitsPath));
TEST(CountryIndexes::DeleteFromDisk(germanyLocalFile),
("Can't delete indexes for:", germanyLocalFile));
TEST(!Platform::IsFileExistsByFullPath(bitsPath), (bitsPath));
}
UNIT_TEST(LocalCountryFile_DoNotDeleteUserFiles)
{
base::ScopedLogLevelChanger const criticalLogLevel(LCRITICAL);
ScopedDir testDir("101010");
CountryFile germanyFile("Germany");
LocalCountryFile germanyLocalFile(testDir.GetFullPath(), germanyFile, 101010 /* version */);
CountryIndexes::PreparePlaceOnDisk(germanyLocalFile);
string const userFilePath =
base::JoinPath(CountryIndexes::IndexesDir(germanyLocalFile), "user-data.txt");
{
FileWriter writer(userFilePath);
string const data = "user data";
writer.Write(data.data(), data.size());
}
TEST(!CountryIndexes::DeleteFromDisk(germanyLocalFile),
("Indexes dir should not be deleted for:", germanyLocalFile));
TEST(base::DeleteFileX(userFilePath), ("Can't delete test file:", userFilePath));
TEST(CountryIndexes::DeleteFromDisk(germanyLocalFile),
("Can't delete indexes for:", germanyLocalFile));
}
UNIT_TEST(LocalCountryFile_MakeTemporary)
{
string const path = GetPlatform().WritablePathForFile("minsk-pass" DATA_FILE_EXTENSION);
LocalCountryFile file = LocalCountryFile::MakeTemporary(path);
TEST_EQUAL(file.GetPath(MapFileType::Map), path, ());
}
} // namespace platform
| 4,095 |
16,500 | <reponame>cmejj/How-to-Make-a-Computer-Operating-System
#include <time.h>
#include "time_int.h"
tm_t* gmtime_r( const time_t* timep, tm_t* result ) {
if ( _gmtime( *timep, result ) < 0 ) {
return NULL;
}
return result;
}
| 119 |
886 | <filename>core/src/main/java/com/flowci/core/agent/service/AgentService.java
/*
* Copyright 2018 flow.ci
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.flowci.core.agent.service;
import com.flowci.core.agent.domain.Agent;
import com.flowci.core.agent.domain.AgentProfile;
import com.flowci.core.agent.domain.CmdIn;
import com.flowci.core.agent.domain.AgentOption;
import com.flowci.tree.Selector;
import java.util.Collection;
import java.util.List;
import java.util.Optional;
/**
* @author yang
*/
public interface AgentService {
/**
* Get agent by id
*/
Agent get(String id);
/**
* Get agent profile by token
*/
AgentProfile getProfile(String token);
/**
* Get agent by name
*/
Agent getByName(String name);
/**
* Get agent by token
*/
Agent getByToken(String token);
/**
* Check agent token is existed
*/
boolean isExisted(String token);
/**
* List agents
*/
List<Agent> list();
/**
* List agent by given ids
*/
Iterable<Agent> list(Collection<String> ids);
/**
* Delete agent by token
*/
Agent delete(String token);
/**
* Delete agent by object
*/
void delete(Agent agent);
/**
* Find available agent and set to busy, atomic
*/
Optional<Agent> acquire(String jobId, Selector selector);
/**
* Acquire job id to specific agent and set to busy, atomic
*/
Optional<Agent> acquire(String jobId, Selector selector, String agentId, boolean shouldIdle);
/**
* Release agent, set to IDLE, atomic
*/
void release(Collection<String> ids);
/**
* Create agent by name and tags
*/
Agent create(AgentOption option);
/**
* Update agent name or and tags
*/
Agent update(AgentOption option);
/**
* Update agent status
*/
Agent update(Agent agent, Agent.Status status);
/**
* Dispatch cmd to agent
*/
void dispatch(CmdIn cmd, Agent agent);
}
| 890 |
912 | '''
------------------------------------------------------------------------------
Copyright (c) 2015 Microsoft Corporation
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
------------------------------------------------------------------------------
'''
from __future__ import generators, unicode_literals
import json
from .error import OneDriveError
class HttpResponse(object):
def __init__(self, status, headers, content):
"""Initialize the HttpResponse class returned after
an HTTP request is made
Args:
status (int): HTTP status (ex. 200, 201, etc.)
headers (dict of (str, str)): The headers in the
response
content (str): The body of the response
"""
self._status = status
self._headers = headers
self._content = content
if self.content and (self.status < 200 or self.status >= 300):
try:
message = json.loads(self.content)
except ValueError: # Invalid or empty response message
from .error import ErrorCode
message = {
"error": {
"code": ErrorCode.Malformed,
"message": "The following invalid JSON was returned:\n%s" % self.content
}
}
if "error" in message:
if type(message["error"]) == dict:
raise OneDriveError(message["error"], self.status)
else:
raise Exception(str(message["error"]))
def __str__(self):
properties = {
'Status': self.status,
'Headers': self.headers,
'Content': self.content
}
ret = ""
for k, v in properties.items():
ret += "{}: {}\n".format(k, v)
return ret
@property
def status(self):
"""The HTTP status of the response
Returns:
int: HTTP status
"""
return self._status
@property
def headers(self):
"""The headers of the response
Returns:
dict of (str, str):
The headers used by the response
"""
return self._headers
@property
def content(self):
"""The content of the response
Returns:
str: The body of the response
"""
return self._content
| 1,318 |
482 | package io.cattle.platform.lock.definition;
// Quite purposefully not public, create your own lock
class DefaultBlockingLockDefinition extends AbstractLockDefinition implements BlockingLockDefinition {
long wait;
public DefaultBlockingLockDefinition(String lockId, long wait) {
super(lockId);
this.wait = wait;
}
@Override
public long getWait() {
return wait;
}
}
| 134 |
72,551 | //===--- AccessSummaryDumper.cpp - Dump access summaries for functions -----===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
#define DEBUG_TYPE "sil-access-summary-dumper"
#include "swift/SIL/SILArgument.h"
#include "swift/SIL/SILFunction.h"
#include "swift/SIL/SILInstruction.h"
#include "swift/SIL/SILValue.h"
#include "swift/SILOptimizer/Analysis/AccessSummaryAnalysis.h"
#include "swift/SILOptimizer/PassManager/Passes.h"
#include "swift/SILOptimizer/PassManager/Transforms.h"
#include "llvm/Support/Debug.h"
using namespace swift;
namespace {
/// Dumps summaries of kinds of accesses a function performs on its
/// @inout_aliasiable arguments.
class AccessSummaryDumper : public SILModuleTransform {
void run() override {
auto *analysis = PM->getAnalysis<AccessSummaryAnalysis>();
for (auto &fn : *getModule()) {
llvm::outs() << "@" << fn.getName() << "\n";
if (fn.empty()) {
llvm::outs() << "<unknown>\n";
continue;
}
const AccessSummaryAnalysis::FunctionSummary &summary =
analysis->getOrCreateSummary(&fn);
summary.print(llvm::outs(), &fn);
llvm::outs() << "\n";
}
}
};
} // end anonymous namespace
SILTransform *swift::createAccessSummaryDumper() {
return new AccessSummaryDumper();
}
| 559 |
348 | <filename>docs/data/leg-t1/085/08503018.json<gh_stars>100-1000
{"nom":"Beauvoir-sur-Mer","circ":"3ème circonscription","dpt":"Vendée","inscrits":3208,"abs":1578,"votants":1630,"blancs":25,"nuls":22,"exp":1583,"res":[{"nuance":"REM","nom":"<NAME>","voix":554},{"nuance":"DVD","nom":"M. <NAME>","voix":314},{"nuance":"FN","nom":"Mme <NAME>","voix":240},{"nuance":"LR","nom":"Mme <NAME>","voix":156},{"nuance":"FI","nom":"M. <NAME>","voix":134},{"nuance":"DLF","nom":"Mme <NAME>","voix":49},{"nuance":"SOC","nom":"M. <NAME>","voix":44},{"nuance":"ECO","nom":"<NAME>","voix":41},{"nuance":"COM","nom":"Mme <NAME>","voix":32},{"nuance":"EXG","nom":"M. <NAME>","voix":12},{"nuance":"DIV","nom":"M. <NAME>","voix":4},{"nuance":"DIV","nom":"M. <NAME>","voix":3}]} | 312 |
648 | {"resourceType":"DataElement","id":"Immunization.wasNotGiven","meta":{"lastUpdated":"2015-10-24T07:41:03.495+11:00"},"url":"http://hl7.org/fhir/DataElement/Immunization.wasNotGiven","status":"draft","experimental":true,"stringency":"fully-specified","element":[{"path":"Immunization.wasNotGiven","short":"Flag for whether immunization was given","definition":"Indicates if the vaccination was or was not given.","min":1,"max":"1","type":[{"code":"boolean"}],"isModifier":true,"mapping":[{"identity":"rim","map":"[actionNegationInd=true].reasonCode"},{"identity":"w5","map":"status"}]}]} | 169 |
346 | from __future__ import unicode_literals
import textx
from os.path import join, dirname
import textx.scoping.providers as scoping_providers
def test_issue108_obj_proc_multifile():
"""
see issue 108 for a detailed error report
"""
mm = textx.metamodel_from_str('''
Model:
imports*=Import
classes*=Class;
Import: 'import' importURI=STRING ';';
Class: 'class' name=ID '{' '}';
''')
lst_class_names = []
lst_models = []
def print_obj(x):
lst_class_names.append(x.name)
def print_model(m, mm):
lst_models.append(m)
mm.register_scope_providers(
{'*.*': scoping_providers.PlainNameImportURI()})
mm.register_obj_processors({'Class': print_obj})
mm.register_model_processor(print_model)
current_dir = dirname(__file__)
mm.model_from_file(join(current_dir, 'issue108', 'a.dsl'))
assert 2 == len(lst_models)
assert 2 == len(lst_class_names)
| 421 |
573 | <gh_stars>100-1000
// Copyright 2015, VIXL authors
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// * Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
// * Neither the name of ARM Limited nor the names of its contributors may be
// used to endorse or promote products derived from this software without
// specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// ---------------------------------------------------------------------
// This file is auto generated using tools/generate_simulator_traces.py.
//
// PLEASE DO NOT EDIT.
// ---------------------------------------------------------------------
#ifndef VIXL_ASSEMBLER_COND_RD_RN_RM_SHADD16_A32_H_
#define VIXL_ASSEMBLER_COND_RD_RN_RM_SHADD16_A32_H_
const byte kInstruction_shadd16_hi_r1_r9_r5[] = {
0x15, 0x1f, 0x39, 0x86 // shadd16 hi r1 r9 r5
};
const byte kInstruction_shadd16_pl_r8_r6_r2[] = {
0x12, 0x8f, 0x36, 0x56 // shadd16 pl r8 r6 r2
};
const byte kInstruction_shadd16_hi_r5_r8_r2[] = {
0x12, 0x5f, 0x38, 0x86 // shadd16 hi r5 r8 r2
};
const byte kInstruction_shadd16_vc_r9_r2_r7[] = {
0x17, 0x9f, 0x32, 0x76 // shadd16 vc r9 r2 r7
};
const byte kInstruction_shadd16_lt_r4_r6_r3[] = {
0x13, 0x4f, 0x36, 0xb6 // shadd16 lt r4 r6 r3
};
const byte kInstruction_shadd16_le_r11_r6_r2[] = {
0x12, 0xbf, 0x36, 0xd6 // shadd16 le r11 r6 r2
};
const byte kInstruction_shadd16_cc_r8_r14_r4[] = {
0x14, 0x8f, 0x3e, 0x36 // shadd16 cc r8 r14 r4
};
const byte kInstruction_shadd16_le_r5_r14_r6[] = {
0x16, 0x5f, 0x3e, 0xd6 // shadd16 le r5 r14 r6
};
const byte kInstruction_shadd16_lt_r6_r1_r0[] = {
0x10, 0x6f, 0x31, 0xb6 // shadd16 lt r6 r1 r0
};
const byte kInstruction_shadd16_lt_r5_r0_r9[] = {
0x19, 0x5f, 0x30, 0xb6 // shadd16 lt r5 r0 r9
};
const byte kInstruction_shadd16_le_r8_r12_r7[] = {
0x17, 0x8f, 0x3c, 0xd6 // shadd16 le r8 r12 r7
};
const byte kInstruction_shadd16_eq_r7_r14_r6[] = {
0x16, 0x7f, 0x3e, 0x06 // shadd16 eq r7 r14 r6
};
const byte kInstruction_shadd16_cs_r7_r4_r6[] = {
0x16, 0x7f, 0x34, 0x26 // shadd16 cs r7 r4 r6
};
const byte kInstruction_shadd16_gt_r9_r6_r9[] = {
0x19, 0x9f, 0x36, 0xc6 // shadd16 gt r9 r6 r9
};
const byte kInstruction_shadd16_ne_r13_r9_r1[] = {
0x11, 0xdf, 0x39, 0x16 // shadd16 ne r13 r9 r1
};
const byte kInstruction_shadd16_ge_r13_r1_r13[] = {
0x1d, 0xdf, 0x31, 0xa6 // shadd16 ge r13 r1 r13
};
const byte kInstruction_shadd16_ls_r8_r10_r2[] = {
0x12, 0x8f, 0x3a, 0x96 // shadd16 ls r8 r10 r2
};
const byte kInstruction_shadd16_hi_r0_r13_r5[] = {
0x15, 0x0f, 0x3d, 0x86 // shadd16 hi r0 r13 r5
};
const byte kInstruction_shadd16_pl_r13_r7_r8[] = {
0x18, 0xdf, 0x37, 0x56 // shadd16 pl r13 r7 r8
};
const byte kInstruction_shadd16_ge_r4_r13_r11[] = {
0x1b, 0x4f, 0x3d, 0xa6 // shadd16 ge r4 r13 r11
};
const byte kInstruction_shadd16_cs_r5_r10_r5[] = {
0x15, 0x5f, 0x3a, 0x26 // shadd16 cs r5 r10 r5
};
const byte kInstruction_shadd16_cs_r5_r4_r3[] = {
0x13, 0x5f, 0x34, 0x26 // shadd16 cs r5 r4 r3
};
const byte kInstruction_shadd16_ls_r6_r14_r8[] = {
0x18, 0x6f, 0x3e, 0x96 // shadd16 ls r6 r14 r8
};
const byte kInstruction_shadd16_vs_r3_r8_r6[] = {
0x16, 0x3f, 0x38, 0x66 // shadd16 vs r3 r8 r6
};
const byte kInstruction_shadd16_vc_r7_r12_r3[] = {
0x13, 0x7f, 0x3c, 0x76 // shadd16 vc r7 r12 r3
};
const byte kInstruction_shadd16_ge_r1_r4_r1[] = {
0x11, 0x1f, 0x34, 0xa6 // shadd16 ge r1 r4 r1
};
const byte kInstruction_shadd16_cc_r4_r7_r10[] = {
0x1a, 0x4f, 0x37, 0x36 // shadd16 cc r4 r7 r10
};
const byte kInstruction_shadd16_cc_r2_r0_r13[] = {
0x1d, 0x2f, 0x30, 0x36 // shadd16 cc r2 r0 r13
};
const byte kInstruction_shadd16_vs_r9_r6_r8[] = {
0x18, 0x9f, 0x36, 0x66 // shadd16 vs r9 r6 r8
};
const byte kInstruction_shadd16_cs_r14_r11_r13[] = {
0x1d, 0xef, 0x3b, 0x26 // shadd16 cs r14 r11 r13
};
const byte kInstruction_shadd16_pl_r5_r8_r4[] = {
0x14, 0x5f, 0x38, 0x56 // shadd16 pl r5 r8 r4
};
const byte kInstruction_shadd16_pl_r2_r3_r7[] = {
0x17, 0x2f, 0x33, 0x56 // shadd16 pl r2 r3 r7
};
const byte kInstruction_shadd16_cs_r7_r12_r14[] = {
0x1e, 0x7f, 0x3c, 0x26 // shadd16 cs r7 r12 r14
};
const byte kInstruction_shadd16_hi_r6_r6_r1[] = {
0x11, 0x6f, 0x36, 0x86 // shadd16 hi r6 r6 r1
};
const byte kInstruction_shadd16_cc_r6_r9_r6[] = {
0x16, 0x6f, 0x39, 0x36 // shadd16 cc r6 r9 r6
};
const byte kInstruction_shadd16_ne_r12_r12_r0[] = {
0x10, 0xcf, 0x3c, 0x16 // shadd16 ne r12 r12 r0
};
const byte kInstruction_shadd16_cc_r9_r3_r8[] = {
0x18, 0x9f, 0x33, 0x36 // shadd16 cc r9 r3 r8
};
const byte kInstruction_shadd16_mi_r13_r6_r1[] = {
0x11, 0xdf, 0x36, 0x46 // shadd16 mi r13 r6 r1
};
const byte kInstruction_shadd16_lt_r4_r8_r6[] = {
0x16, 0x4f, 0x38, 0xb6 // shadd16 lt r4 r8 r6
};
const byte kInstruction_shadd16_hi_r11_r5_r9[] = {
0x19, 0xbf, 0x35, 0x86 // shadd16 hi r11 r5 r9
};
const byte kInstruction_shadd16_cc_r6_r10_r6[] = {
0x16, 0x6f, 0x3a, 0x36 // shadd16 cc r6 r10 r6
};
const byte kInstruction_shadd16_eq_r10_r10_r5[] = {
0x15, 0xaf, 0x3a, 0x06 // shadd16 eq r10 r10 r5
};
const byte kInstruction_shadd16_al_r5_r4_r11[] = {
0x1b, 0x5f, 0x34, 0xe6 // shadd16 al r5 r4 r11
};
const byte kInstruction_shadd16_pl_r11_r11_r2[] = {
0x12, 0xbf, 0x3b, 0x56 // shadd16 pl r11 r11 r2
};
const byte kInstruction_shadd16_ls_r6_r14_r12[] = {
0x1c, 0x6f, 0x3e, 0x96 // shadd16 ls r6 r14 r12
};
const byte kInstruction_shadd16_vc_r7_r7_r2[] = {
0x12, 0x7f, 0x37, 0x76 // shadd16 vc r7 r7 r2
};
const byte kInstruction_shadd16_eq_r10_r8_r4[] = {
0x14, 0xaf, 0x38, 0x06 // shadd16 eq r10 r8 r4
};
const byte kInstruction_shadd16_al_r14_r7_r2[] = {
0x12, 0xef, 0x37, 0xe6 // shadd16 al r14 r7 r2
};
const byte kInstruction_shadd16_cs_r3_r11_r10[] = {
0x1a, 0x3f, 0x3b, 0x26 // shadd16 cs r3 r11 r10
};
const byte kInstruction_shadd16_ls_r11_r4_r0[] = {
0x10, 0xbf, 0x34, 0x96 // shadd16 ls r11 r4 r0
};
const byte kInstruction_shadd16_hi_r11_r8_r9[] = {
0x19, 0xbf, 0x38, 0x86 // shadd16 hi r11 r8 r9
};
const byte kInstruction_shadd16_vs_r2_r14_r13[] = {
0x1d, 0x2f, 0x3e, 0x66 // shadd16 vs r2 r14 r13
};
const byte kInstruction_shadd16_al_r1_r13_r9[] = {
0x19, 0x1f, 0x3d, 0xe6 // shadd16 al r1 r13 r9
};
const byte kInstruction_shadd16_eq_r3_r9_r13[] = {
0x1d, 0x3f, 0x39, 0x06 // shadd16 eq r3 r9 r13
};
const byte kInstruction_shadd16_ge_r10_r3_r13[] = {
0x1d, 0xaf, 0x33, 0xa6 // shadd16 ge r10 r3 r13
};
const byte kInstruction_shadd16_pl_r8_r5_r10[] = {
0x1a, 0x8f, 0x35, 0x56 // shadd16 pl r8 r5 r10
};
const byte kInstruction_shadd16_vc_r8_r11_r6[] = {
0x16, 0x8f, 0x3b, 0x76 // shadd16 vc r8 r11 r6
};
const byte kInstruction_shadd16_eq_r0_r0_r5[] = {
0x15, 0x0f, 0x30, 0x06 // shadd16 eq r0 r0 r5
};
const byte kInstruction_shadd16_ne_r6_r5_r8[] = {
0x18, 0x6f, 0x35, 0x16 // shadd16 ne r6 r5 r8
};
const byte kInstruction_shadd16_hi_r5_r13_r3[] = {
0x13, 0x5f, 0x3d, 0x86 // shadd16 hi r5 r13 r3
};
const byte kInstruction_shadd16_ne_r11_r14_r14[] = {
0x1e, 0xbf, 0x3e, 0x16 // shadd16 ne r11 r14 r14
};
const byte kInstruction_shadd16_mi_r1_r0_r6[] = {
0x16, 0x1f, 0x30, 0x46 // shadd16 mi r1 r0 r6
};
const byte kInstruction_shadd16_le_r14_r8_r2[] = {
0x12, 0xef, 0x38, 0xd6 // shadd16 le r14 r8 r2
};
const byte kInstruction_shadd16_eq_r9_r6_r5[] = {
0x15, 0x9f, 0x36, 0x06 // shadd16 eq r9 r6 r5
};
const byte kInstruction_shadd16_eq_r11_r0_r13[] = {
0x1d, 0xbf, 0x30, 0x06 // shadd16 eq r11 r0 r13
};
const byte kInstruction_shadd16_pl_r4_r5_r14[] = {
0x1e, 0x4f, 0x35, 0x56 // shadd16 pl r4 r5 r14
};
const byte kInstruction_shadd16_cs_r13_r5_r13[] = {
0x1d, 0xdf, 0x35, 0x26 // shadd16 cs r13 r5 r13
};
const byte kInstruction_shadd16_mi_r0_r13_r8[] = {
0x18, 0x0f, 0x3d, 0x46 // shadd16 mi r0 r13 r8
};
const byte kInstruction_shadd16_lt_r2_r13_r3[] = {
0x13, 0x2f, 0x3d, 0xb6 // shadd16 lt r2 r13 r3
};
const byte kInstruction_shadd16_ls_r8_r1_r11[] = {
0x1b, 0x8f, 0x31, 0x96 // shadd16 ls r8 r1 r11
};
const byte kInstruction_shadd16_vc_r14_r11_r8[] = {
0x18, 0xef, 0x3b, 0x76 // shadd16 vc r14 r11 r8
};
const byte kInstruction_shadd16_lt_r4_r13_r12[] = {
0x1c, 0x4f, 0x3d, 0xb6 // shadd16 lt r4 r13 r12
};
const byte kInstruction_shadd16_eq_r2_r1_r14[] = {
0x1e, 0x2f, 0x31, 0x06 // shadd16 eq r2 r1 r14
};
const byte kInstruction_shadd16_eq_r9_r4_r14[] = {
0x1e, 0x9f, 0x34, 0x06 // shadd16 eq r9 r4 r14
};
const byte kInstruction_shadd16_hi_r10_r6_r13[] = {
0x1d, 0xaf, 0x36, 0x86 // shadd16 hi r10 r6 r13
};
const byte kInstruction_shadd16_ge_r12_r9_r4[] = {
0x14, 0xcf, 0x39, 0xa6 // shadd16 ge r12 r9 r4
};
const byte kInstruction_shadd16_le_r9_r11_r14[] = {
0x1e, 0x9f, 0x3b, 0xd6 // shadd16 le r9 r11 r14
};
const byte kInstruction_shadd16_ls_r0_r9_r5[] = {
0x15, 0x0f, 0x39, 0x96 // shadd16 ls r0 r9 r5
};
const byte kInstruction_shadd16_mi_r2_r3_r8[] = {
0x18, 0x2f, 0x33, 0x46 // shadd16 mi r2 r3 r8
};
const byte kInstruction_shadd16_ne_r14_r10_r14[] = {
0x1e, 0xef, 0x3a, 0x16 // shadd16 ne r14 r10 r14
};
const byte kInstruction_shadd16_eq_r6_r2_r10[] = {
0x1a, 0x6f, 0x32, 0x06 // shadd16 eq r6 r2 r10
};
const byte kInstruction_shadd16_lt_r11_r0_r12[] = {
0x1c, 0xbf, 0x30, 0xb6 // shadd16 lt r11 r0 r12
};
const byte kInstruction_shadd16_ne_r1_r12_r10[] = {
0x1a, 0x1f, 0x3c, 0x16 // shadd16 ne r1 r12 r10
};
const byte kInstruction_shadd16_cc_r1_r0_r2[] = {
0x12, 0x1f, 0x30, 0x36 // shadd16 cc r1 r0 r2
};
const byte kInstruction_shadd16_al_r5_r5_r7[] = {
0x17, 0x5f, 0x35, 0xe6 // shadd16 al r5 r5 r7
};
const byte kInstruction_shadd16_hi_r7_r13_r1[] = {
0x11, 0x7f, 0x3d, 0x86 // shadd16 hi r7 r13 r1
};
const byte kInstruction_shadd16_cs_r4_r4_r9[] = {
0x19, 0x4f, 0x34, 0x26 // shadd16 cs r4 r4 r9
};
const byte kInstruction_shadd16_eq_r14_r4_r14[] = {
0x1e, 0xef, 0x34, 0x06 // shadd16 eq r14 r4 r14
};
const byte kInstruction_shadd16_vs_r10_r5_r14[] = {
0x1e, 0xaf, 0x35, 0x66 // shadd16 vs r10 r5 r14
};
const byte kInstruction_shadd16_gt_r4_r3_r11[] = {
0x1b, 0x4f, 0x33, 0xc6 // shadd16 gt r4 r3 r11
};
const byte kInstruction_shadd16_ne_r14_r10_r12[] = {
0x1c, 0xef, 0x3a, 0x16 // shadd16 ne r14 r10 r12
};
const byte kInstruction_shadd16_vs_r2_r11_r0[] = {
0x10, 0x2f, 0x3b, 0x66 // shadd16 vs r2 r11 r0
};
const byte kInstruction_shadd16_ge_r5_r12_r7[] = {
0x17, 0x5f, 0x3c, 0xa6 // shadd16 ge r5 r12 r7
};
const byte kInstruction_shadd16_mi_r7_r14_r6[] = {
0x16, 0x7f, 0x3e, 0x46 // shadd16 mi r7 r14 r6
};
const byte kInstruction_shadd16_gt_r8_r3_r8[] = {
0x18, 0x8f, 0x33, 0xc6 // shadd16 gt r8 r3 r8
};
const byte kInstruction_shadd16_hi_r9_r14_r3[] = {
0x13, 0x9f, 0x3e, 0x86 // shadd16 hi r9 r14 r3
};
const byte kInstruction_shadd16_vc_r2_r11_r2[] = {
0x12, 0x2f, 0x3b, 0x76 // shadd16 vc r2 r11 r2
};
const byte kInstruction_shadd16_hi_r11_r7_r12[] = {
0x1c, 0xbf, 0x37, 0x86 // shadd16 hi r11 r7 r12
};
const byte kInstruction_shadd16_cs_r6_r4_r11[] = {
0x1b, 0x6f, 0x34, 0x26 // shadd16 cs r6 r4 r11
};
const byte kInstruction_shadd16_cs_r12_r5_r9[] = {
0x19, 0xcf, 0x35, 0x26 // shadd16 cs r12 r5 r9
};
const byte kInstruction_shadd16_ls_r5_r10_r5[] = {
0x15, 0x5f, 0x3a, 0x96 // shadd16 ls r5 r10 r5
};
const byte kInstruction_shadd16_ls_r0_r9_r13[] = {
0x1d, 0x0f, 0x39, 0x96 // shadd16 ls r0 r9 r13
};
const byte kInstruction_shadd16_lt_r3_r3_r5[] = {
0x15, 0x3f, 0x33, 0xb6 // shadd16 lt r3 r3 r5
};
const byte kInstruction_shadd16_mi_r0_r12_r8[] = {
0x18, 0x0f, 0x3c, 0x46 // shadd16 mi r0 r12 r8
};
const byte kInstruction_shadd16_pl_r3_r12_r12[] = {
0x1c, 0x3f, 0x3c, 0x56 // shadd16 pl r3 r12 r12
};
const byte kInstruction_shadd16_eq_r8_r12_r5[] = {
0x15, 0x8f, 0x3c, 0x06 // shadd16 eq r8 r12 r5
};
const byte kInstruction_shadd16_cc_r7_r8_r1[] = {
0x11, 0x7f, 0x38, 0x36 // shadd16 cc r7 r8 r1
};
const byte kInstruction_shadd16_hi_r2_r13_r10[] = {
0x1a, 0x2f, 0x3d, 0x86 // shadd16 hi r2 r13 r10
};
const byte kInstruction_shadd16_al_r7_r10_r10[] = {
0x1a, 0x7f, 0x3a, 0xe6 // shadd16 al r7 r10 r10
};
const byte kInstruction_shadd16_vc_r1_r12_r2[] = {
0x12, 0x1f, 0x3c, 0x76 // shadd16 vc r1 r12 r2
};
const byte kInstruction_shadd16_cc_r8_r5_r8[] = {
0x18, 0x8f, 0x35, 0x36 // shadd16 cc r8 r5 r8
};
const byte kInstruction_shadd16_ls_r3_r7_r9[] = {
0x19, 0x3f, 0x37, 0x96 // shadd16 ls r3 r7 r9
};
const byte kInstruction_shadd16_al_r8_r10_r8[] = {
0x18, 0x8f, 0x3a, 0xe6 // shadd16 al r8 r10 r8
};
const byte kInstruction_shadd16_lt_r4_r12_r10[] = {
0x1a, 0x4f, 0x3c, 0xb6 // shadd16 lt r4 r12 r10
};
const byte kInstruction_shadd16_ge_r10_r5_r11[] = {
0x1b, 0xaf, 0x35, 0xa6 // shadd16 ge r10 r5 r11
};
const byte kInstruction_shadd16_ls_r3_r14_r4[] = {
0x14, 0x3f, 0x3e, 0x96 // shadd16 ls r3 r14 r4
};
const byte kInstruction_shadd16_hi_r3_r6_r12[] = {
0x1c, 0x3f, 0x36, 0x86 // shadd16 hi r3 r6 r12
};
const byte kInstruction_shadd16_hi_r6_r0_r4[] = {
0x14, 0x6f, 0x30, 0x86 // shadd16 hi r6 r0 r4
};
const byte kInstruction_shadd16_al_r11_r6_r0[] = {
0x10, 0xbf, 0x36, 0xe6 // shadd16 al r11 r6 r0
};
const byte kInstruction_shadd16_mi_r3_r1_r9[] = {
0x19, 0x3f, 0x31, 0x46 // shadd16 mi r3 r1 r9
};
const byte kInstruction_shadd16_mi_r12_r13_r0[] = {
0x10, 0xcf, 0x3d, 0x46 // shadd16 mi r12 r13 r0
};
const byte kInstruction_shadd16_le_r1_r2_r5[] = {
0x15, 0x1f, 0x32, 0xd6 // shadd16 le r1 r2 r5
};
const byte kInstruction_shadd16_hi_r4_r3_r14[] = {
0x1e, 0x4f, 0x33, 0x86 // shadd16 hi r4 r3 r14
};
const byte kInstruction_shadd16_eq_r6_r11_r11[] = {
0x1b, 0x6f, 0x3b, 0x06 // shadd16 eq r6 r11 r11
};
const byte kInstruction_shadd16_cc_r14_r11_r14[] = {
0x1e, 0xef, 0x3b, 0x36 // shadd16 cc r14 r11 r14
};
const byte kInstruction_shadd16_hi_r4_r10_r0[] = {
0x10, 0x4f, 0x3a, 0x86 // shadd16 hi r4 r10 r0
};
const byte kInstruction_shadd16_cc_r7_r11_r1[] = {
0x11, 0x7f, 0x3b, 0x36 // shadd16 cc r7 r11 r1
};
const byte kInstruction_shadd16_mi_r14_r6_r10[] = {
0x1a, 0xef, 0x36, 0x46 // shadd16 mi r14 r6 r10
};
const byte kInstruction_shadd16_eq_r2_r0_r11[] = {
0x1b, 0x2f, 0x30, 0x06 // shadd16 eq r2 r0 r11
};
const byte kInstruction_shadd16_mi_r13_r5_r12[] = {
0x1c, 0xdf, 0x35, 0x46 // shadd16 mi r13 r5 r12
};
const byte kInstruction_shadd16_eq_r2_r12_r5[] = {
0x15, 0x2f, 0x3c, 0x06 // shadd16 eq r2 r12 r5
};
const byte kInstruction_shadd16_le_r12_r0_r2[] = {
0x12, 0xcf, 0x30, 0xd6 // shadd16 le r12 r0 r2
};
const byte kInstruction_shadd16_vc_r10_r10_r9[] = {
0x19, 0xaf, 0x3a, 0x76 // shadd16 vc r10 r10 r9
};
const byte kInstruction_shadd16_ls_r11_r11_r8[] = {
0x18, 0xbf, 0x3b, 0x96 // shadd16 ls r11 r11 r8
};
const byte kInstruction_shadd16_hi_r10_r11_r9[] = {
0x19, 0xaf, 0x3b, 0x86 // shadd16 hi r10 r11 r9
};
const byte kInstruction_shadd16_vs_r7_r12_r14[] = {
0x1e, 0x7f, 0x3c, 0x66 // shadd16 vs r7 r12 r14
};
const byte kInstruction_shadd16_gt_r11_r14_r12[] = {
0x1c, 0xbf, 0x3e, 0xc6 // shadd16 gt r11 r14 r12
};
const byte kInstruction_shadd16_vs_r0_r12_r8[] = {
0x18, 0x0f, 0x3c, 0x66 // shadd16 vs r0 r12 r8
};
const byte kInstruction_shadd16_al_r0_r5_r7[] = {
0x17, 0x0f, 0x35, 0xe6 // shadd16 al r0 r5 r7
};
const byte kInstruction_shadd16_hi_r5_r13_r8[] = {
0x18, 0x5f, 0x3d, 0x86 // shadd16 hi r5 r13 r8
};
const byte kInstruction_shadd16_le_r9_r9_r7[] = {
0x17, 0x9f, 0x39, 0xd6 // shadd16 le r9 r9 r7
};
const byte kInstruction_shadd16_cc_r4_r9_r5[] = {
0x15, 0x4f, 0x39, 0x36 // shadd16 cc r4 r9 r5
};
const byte kInstruction_shadd16_vs_r8_r1_r3[] = {
0x13, 0x8f, 0x31, 0x66 // shadd16 vs r8 r1 r3
};
const byte kInstruction_shadd16_cc_r0_r10_r12[] = {
0x1c, 0x0f, 0x3a, 0x36 // shadd16 cc r0 r10 r12
};
const byte kInstruction_shadd16_eq_r7_r14_r0[] = {
0x10, 0x7f, 0x3e, 0x06 // shadd16 eq r7 r14 r0
};
const byte kInstruction_shadd16_vs_r12_r9_r11[] = {
0x1b, 0xcf, 0x39, 0x66 // shadd16 vs r12 r9 r11
};
const byte kInstruction_shadd16_gt_r5_r9_r11[] = {
0x1b, 0x5f, 0x39, 0xc6 // shadd16 gt r5 r9 r11
};
const byte kInstruction_shadd16_cs_r14_r13_r7[] = {
0x17, 0xef, 0x3d, 0x26 // shadd16 cs r14 r13 r7
};
const byte kInstruction_shadd16_mi_r11_r3_r10[] = {
0x1a, 0xbf, 0x33, 0x46 // shadd16 mi r11 r3 r10
};
const byte kInstruction_shadd16_hi_r11_r8_r12[] = {
0x1c, 0xbf, 0x38, 0x86 // shadd16 hi r11 r8 r12
};
const byte kInstruction_shadd16_cs_r3_r8_r13[] = {
0x1d, 0x3f, 0x38, 0x26 // shadd16 cs r3 r8 r13
};
const byte kInstruction_shadd16_pl_r10_r12_r6[] = {
0x16, 0xaf, 0x3c, 0x56 // shadd16 pl r10 r12 r6
};
const byte kInstruction_shadd16_vc_r7_r3_r2[] = {
0x12, 0x7f, 0x33, 0x76 // shadd16 vc r7 r3 r2
};
const byte kInstruction_shadd16_mi_r9_r0_r8[] = {
0x18, 0x9f, 0x30, 0x46 // shadd16 mi r9 r0 r8
};
const byte kInstruction_shadd16_eq_r2_r13_r7[] = {
0x17, 0x2f, 0x3d, 0x06 // shadd16 eq r2 r13 r7
};
const byte kInstruction_shadd16_ne_r2_r14_r0[] = {
0x10, 0x2f, 0x3e, 0x16 // shadd16 ne r2 r14 r0
};
const byte kInstruction_shadd16_vs_r4_r10_r0[] = {
0x10, 0x4f, 0x3a, 0x66 // shadd16 vs r4 r10 r0
};
const byte kInstruction_shadd16_ls_r0_r2_r2[] = {
0x12, 0x0f, 0x32, 0x96 // shadd16 ls r0 r2 r2
};
const byte kInstruction_shadd16_cc_r1_r6_r0[] = {
0x10, 0x1f, 0x36, 0x36 // shadd16 cc r1 r6 r0
};
const byte kInstruction_shadd16_lt_r12_r0_r8[] = {
0x18, 0xcf, 0x30, 0xb6 // shadd16 lt r12 r0 r8
};
const byte kInstruction_shadd16_cc_r9_r3_r14[] = {
0x1e, 0x9f, 0x33, 0x36 // shadd16 cc r9 r3 r14
};
const byte kInstruction_shadd16_vs_r7_r9_r1[] = {
0x11, 0x7f, 0x39, 0x66 // shadd16 vs r7 r9 r1
};
const byte kInstruction_shadd16_eq_r11_r9_r14[] = {
0x1e, 0xbf, 0x39, 0x06 // shadd16 eq r11 r9 r14
};
const byte kInstruction_shadd16_pl_r6_r10_r4[] = {
0x14, 0x6f, 0x3a, 0x56 // shadd16 pl r6 r10 r4
};
const byte kInstruction_shadd16_ne_r8_r5_r6[] = {
0x16, 0x8f, 0x35, 0x16 // shadd16 ne r8 r5 r6
};
const byte kInstruction_shadd16_cs_r0_r6_r2[] = {
0x12, 0x0f, 0x36, 0x26 // shadd16 cs r0 r6 r2
};
const byte kInstruction_shadd16_eq_r11_r12_r4[] = {
0x14, 0xbf, 0x3c, 0x06 // shadd16 eq r11 r12 r4
};
const byte kInstruction_shadd16_lt_r14_r3_r14[] = {
0x1e, 0xef, 0x33, 0xb6 // shadd16 lt r14 r3 r14
};
const byte kInstruction_shadd16_le_r7_r12_r14[] = {
0x1e, 0x7f, 0x3c, 0xd6 // shadd16 le r7 r12 r14
};
const byte kInstruction_shadd16_hi_r2_r9_r9[] = {
0x19, 0x2f, 0x39, 0x86 // shadd16 hi r2 r9 r9
};
const byte kInstruction_shadd16_ne_r8_r1_r0[] = {
0x10, 0x8f, 0x31, 0x16 // shadd16 ne r8 r1 r0
};
const byte kInstruction_shadd16_cc_r5_r11_r2[] = {
0x12, 0x5f, 0x3b, 0x36 // shadd16 cc r5 r11 r2
};
const byte kInstruction_shadd16_hi_r0_r1_r2[] = {
0x12, 0x0f, 0x31, 0x86 // shadd16 hi r0 r1 r2
};
const byte kInstruction_shadd16_al_r4_r9_r4[] = {
0x14, 0x4f, 0x39, 0xe6 // shadd16 al r4 r9 r4
};
const byte kInstruction_shadd16_cs_r12_r7_r14[] = {
0x1e, 0xcf, 0x37, 0x26 // shadd16 cs r12 r7 r14
};
const byte kInstruction_shadd16_cc_r4_r12_r10[] = {
0x1a, 0x4f, 0x3c, 0x36 // shadd16 cc r4 r12 r10
};
const byte kInstruction_shadd16_al_r3_r5_r10[] = {
0x1a, 0x3f, 0x35, 0xe6 // shadd16 al r3 r5 r10
};
const byte kInstruction_shadd16_mi_r5_r3_r7[] = {
0x17, 0x5f, 0x33, 0x46 // shadd16 mi r5 r3 r7
};
const byte kInstruction_shadd16_ls_r10_r6_r2[] = {
0x12, 0xaf, 0x36, 0x96 // shadd16 ls r10 r6 r2
};
const byte kInstruction_shadd16_mi_r0_r12_r11[] = {
0x1b, 0x0f, 0x3c, 0x46 // shadd16 mi r0 r12 r11
};
const byte kInstruction_shadd16_vc_r12_r5_r6[] = {
0x16, 0xcf, 0x35, 0x76 // shadd16 vc r12 r5 r6
};
const byte kInstruction_shadd16_cs_r3_r9_r4[] = {
0x14, 0x3f, 0x39, 0x26 // shadd16 cs r3 r9 r4
};
const byte kInstruction_shadd16_ls_r4_r9_r11[] = {
0x1b, 0x4f, 0x39, 0x96 // shadd16 ls r4 r9 r11
};
const byte kInstruction_shadd16_le_r14_r8_r13[] = {
0x1d, 0xef, 0x38, 0xd6 // shadd16 le r14 r8 r13
};
const byte kInstruction_shadd16_gt_r4_r10_r8[] = {
0x18, 0x4f, 0x3a, 0xc6 // shadd16 gt r4 r10 r8
};
const byte kInstruction_shadd16_al_r6_r9_r9[] = {
0x19, 0x6f, 0x39, 0xe6 // shadd16 al r6 r9 r9
};
const byte kInstruction_shadd16_ne_r8_r5_r12[] = {
0x1c, 0x8f, 0x35, 0x16 // shadd16 ne r8 r5 r12
};
const byte kInstruction_shadd16_ne_r0_r4_r8[] = {
0x18, 0x0f, 0x34, 0x16 // shadd16 ne r0 r4 r8
};
const byte kInstruction_shadd16_mi_r7_r13_r3[] = {
0x13, 0x7f, 0x3d, 0x46 // shadd16 mi r7 r13 r3
};
const byte kInstruction_shadd16_cc_r11_r7_r0[] = {
0x10, 0xbf, 0x37, 0x36 // shadd16 cc r11 r7 r0
};
const byte kInstruction_shadd16_hi_r1_r0_r12[] = {
0x1c, 0x1f, 0x30, 0x86 // shadd16 hi r1 r0 r12
};
const byte kInstruction_shadd16_lt_r8_r9_r3[] = {
0x13, 0x8f, 0x39, 0xb6 // shadd16 lt r8 r9 r3
};
const byte kInstruction_shadd16_al_r0_r2_r1[] = {
0x11, 0x0f, 0x32, 0xe6 // shadd16 al r0 r2 r1
};
const byte kInstruction_shadd16_vs_r4_r3_r14[] = {
0x1e, 0x4f, 0x33, 0x66 // shadd16 vs r4 r3 r14
};
const byte kInstruction_shadd16_ge_r2_r11_r1[] = {
0x11, 0x2f, 0x3b, 0xa6 // shadd16 ge r2 r11 r1
};
const byte kInstruction_shadd16_lt_r12_r9_r6[] = {
0x16, 0xcf, 0x39, 0xb6 // shadd16 lt r12 r9 r6
};
const byte kInstruction_shadd16_ls_r8_r2_r7[] = {
0x17, 0x8f, 0x32, 0x96 // shadd16 ls r8 r2 r7
};
const byte kInstruction_shadd16_le_r8_r13_r3[] = {
0x13, 0x8f, 0x3d, 0xd6 // shadd16 le r8 r13 r3
};
const byte kInstruction_shadd16_eq_r11_r13_r14[] = {
0x1e, 0xbf, 0x3d, 0x06 // shadd16 eq r11 r13 r14
};
const byte kInstruction_shadd16_lt_r1_r6_r13[] = {
0x1d, 0x1f, 0x36, 0xb6 // shadd16 lt r1 r6 r13
};
const byte kInstruction_shadd16_cs_r3_r8_r11[] = {
0x1b, 0x3f, 0x38, 0x26 // shadd16 cs r3 r8 r11
};
const byte kInstruction_shadd16_pl_r12_r5_r4[] = {
0x14, 0xcf, 0x35, 0x56 // shadd16 pl r12 r5 r4
};
const byte kInstruction_shadd16_eq_r8_r7_r2[] = {
0x12, 0x8f, 0x37, 0x06 // shadd16 eq r8 r7 r2
};
const byte kInstruction_shadd16_ls_r2_r12_r2[] = {
0x12, 0x2f, 0x3c, 0x96 // shadd16 ls r2 r12 r2
};
const byte kInstruction_shadd16_le_r14_r2_r3[] = {
0x13, 0xef, 0x32, 0xd6 // shadd16 le r14 r2 r3
};
const byte kInstruction_shadd16_ge_r10_r11_r6[] = {
0x16, 0xaf, 0x3b, 0xa6 // shadd16 ge r10 r11 r6
};
const byte kInstruction_shadd16_hi_r0_r2_r2[] = {
0x12, 0x0f, 0x32, 0x86 // shadd16 hi r0 r2 r2
};
const byte kInstruction_shadd16_ge_r2_r0_r2[] = {
0x12, 0x2f, 0x30, 0xa6 // shadd16 ge r2 r0 r2
};
const byte kInstruction_shadd16_vs_r11_r14_r0[] = {
0x10, 0xbf, 0x3e, 0x66 // shadd16 vs r11 r14 r0
};
const byte kInstruction_shadd16_lt_r2_r0_r1[] = {
0x11, 0x2f, 0x30, 0xb6 // shadd16 lt r2 r0 r1
};
const byte kInstruction_shadd16_cs_r2_r5_r11[] = {
0x1b, 0x2f, 0x35, 0x26 // shadd16 cs r2 r5 r11
};
const byte kInstruction_shadd16_ls_r7_r14_r5[] = {
0x15, 0x7f, 0x3e, 0x96 // shadd16 ls r7 r14 r5
};
const byte kInstruction_shadd16_pl_r0_r0_r3[] = {
0x13, 0x0f, 0x30, 0x56 // shadd16 pl r0 r0 r3
};
const byte kInstruction_shadd16_ge_r6_r8_r8[] = {
0x18, 0x6f, 0x38, 0xa6 // shadd16 ge r6 r8 r8
};
const byte kInstruction_shadd16_le_r11_r1_r10[] = {
0x1a, 0xbf, 0x31, 0xd6 // shadd16 le r11 r1 r10
};
const byte kInstruction_shadd16_vs_r5_r2_r7[] = {
0x17, 0x5f, 0x32, 0x66 // shadd16 vs r5 r2 r7
};
const byte kInstruction_shadd16_ne_r4_r4_r8[] = {
0x18, 0x4f, 0x34, 0x16 // shadd16 ne r4 r4 r8
};
const byte kInstruction_shadd16_cc_r9_r14_r13[] = {
0x1d, 0x9f, 0x3e, 0x36 // shadd16 cc r9 r14 r13
};
const byte kInstruction_shadd16_hi_r14_r6_r3[] = {
0x13, 0xef, 0x36, 0x86 // shadd16 hi r14 r6 r3
};
const byte kInstruction_shadd16_al_r0_r8_r0[] = {
0x10, 0x0f, 0x38, 0xe6 // shadd16 al r0 r8 r0
};
const byte kInstruction_shadd16_lt_r6_r11_r1[] = {
0x11, 0x6f, 0x3b, 0xb6 // shadd16 lt r6 r11 r1
};
const byte kInstruction_shadd16_ge_r7_r6_r12[] = {
0x1c, 0x7f, 0x36, 0xa6 // shadd16 ge r7 r6 r12
};
const byte kInstruction_shadd16_cs_r4_r6_r14[] = {
0x1e, 0x4f, 0x36, 0x26 // shadd16 cs r4 r6 r14
};
const byte kInstruction_shadd16_cs_r7_r6_r7[] = {
0x17, 0x7f, 0x36, 0x26 // shadd16 cs r7 r6 r7
};
const byte kInstruction_shadd16_cs_r3_r7_r10[] = {
0x1a, 0x3f, 0x37, 0x26 // shadd16 cs r3 r7 r10
};
const byte kInstruction_shadd16_ne_r0_r2_r1[] = {
0x11, 0x0f, 0x32, 0x16 // shadd16 ne r0 r2 r1
};
const byte kInstruction_shadd16_vs_r9_r10_r13[] = {
0x1d, 0x9f, 0x3a, 0x66 // shadd16 vs r9 r10 r13
};
const byte kInstruction_shadd16_vc_r11_r14_r12[] = {
0x1c, 0xbf, 0x3e, 0x76 // shadd16 vc r11 r14 r12
};
const byte kInstruction_shadd16_ge_r14_r8_r7[] = {
0x17, 0xef, 0x38, 0xa6 // shadd16 ge r14 r8 r7
};
const byte kInstruction_shadd16_lt_r13_r0_r11[] = {
0x1b, 0xdf, 0x30, 0xb6 // shadd16 lt r13 r0 r11
};
const byte kInstruction_shadd16_lt_r14_r13_r4[] = {
0x14, 0xef, 0x3d, 0xb6 // shadd16 lt r14 r13 r4
};
const byte kInstruction_shadd16_al_r1_r10_r9[] = {
0x19, 0x1f, 0x3a, 0xe6 // shadd16 al r1 r10 r9
};
const byte kInstruction_shadd16_ge_r11_r14_r11[] = {
0x1b, 0xbf, 0x3e, 0xa6 // shadd16 ge r11 r14 r11
};
const byte kInstruction_shadd16_cs_r11_r4_r11[] = {
0x1b, 0xbf, 0x34, 0x26 // shadd16 cs r11 r4 r11
};
const byte kInstruction_shadd16_ge_r0_r14_r7[] = {
0x17, 0x0f, 0x3e, 0xa6 // shadd16 ge r0 r14 r7
};
const byte kInstruction_shadd16_mi_r1_r2_r9[] = {
0x19, 0x1f, 0x32, 0x46 // shadd16 mi r1 r2 r9
};
const byte kInstruction_shadd16_eq_r5_r12_r3[] = {
0x13, 0x5f, 0x3c, 0x06 // shadd16 eq r5 r12 r3
};
const byte kInstruction_shadd16_ge_r1_r5_r12[] = {
0x1c, 0x1f, 0x35, 0xa6 // shadd16 ge r1 r5 r12
};
const byte kInstruction_shadd16_lt_r10_r11_r4[] = {
0x14, 0xaf, 0x3b, 0xb6 // shadd16 lt r10 r11 r4
};
const byte kInstruction_shadd16_le_r1_r1_r5[] = {
0x15, 0x1f, 0x31, 0xd6 // shadd16 le r1 r1 r5
};
const byte kInstruction_shadd16_al_r9_r1_r8[] = {
0x18, 0x9f, 0x31, 0xe6 // shadd16 al r9 r1 r8
};
const byte kInstruction_shadd16_ne_r6_r8_r4[] = {
0x14, 0x6f, 0x38, 0x16 // shadd16 ne r6 r8 r4
};
const byte kInstruction_shadd16_ge_r12_r2_r9[] = {
0x19, 0xcf, 0x32, 0xa6 // shadd16 ge r12 r2 r9
};
const byte kInstruction_shadd16_pl_r4_r3_r10[] = {
0x1a, 0x4f, 0x33, 0x56 // shadd16 pl r4 r3 r10
};
const byte kInstruction_shadd16_eq_r14_r4_r11[] = {
0x1b, 0xef, 0x34, 0x06 // shadd16 eq r14 r4 r11
};
const byte kInstruction_shadd16_cc_r9_r7_r6[] = {
0x16, 0x9f, 0x37, 0x36 // shadd16 cc r9 r7 r6
};
const byte kInstruction_shadd16_ge_r12_r4_r5[] = {
0x15, 0xcf, 0x34, 0xa6 // shadd16 ge r12 r4 r5
};
const byte kInstruction_shadd16_hi_r2_r3_r4[] = {
0x14, 0x2f, 0x33, 0x86 // shadd16 hi r2 r3 r4
};
const byte kInstruction_shadd16_cs_r0_r3_r1[] = {
0x11, 0x0f, 0x33, 0x26 // shadd16 cs r0 r3 r1
};
const byte kInstruction_shadd16_hi_r6_r2_r8[] = {
0x18, 0x6f, 0x32, 0x86 // shadd16 hi r6 r2 r8
};
const byte kInstruction_shadd16_cc_r3_r14_r13[] = {
0x1d, 0x3f, 0x3e, 0x36 // shadd16 cc r3 r14 r13
};
const byte kInstruction_shadd16_gt_r11_r4_r7[] = {
0x17, 0xbf, 0x34, 0xc6 // shadd16 gt r11 r4 r7
};
const byte kInstruction_shadd16_hi_r5_r0_r12[] = {
0x1c, 0x5f, 0x30, 0x86 // shadd16 hi r5 r0 r12
};
const byte kInstruction_shadd16_gt_r0_r14_r14[] = {
0x1e, 0x0f, 0x3e, 0xc6 // shadd16 gt r0 r14 r14
};
const byte kInstruction_shadd16_hi_r9_r0_r10[] = {
0x1a, 0x9f, 0x30, 0x86 // shadd16 hi r9 r0 r10
};
const byte kInstruction_shadd16_vc_r7_r11_r8[] = {
0x18, 0x7f, 0x3b, 0x76 // shadd16 vc r7 r11 r8
};
const byte kInstruction_shadd16_pl_r11_r9_r6[] = {
0x16, 0xbf, 0x39, 0x56 // shadd16 pl r11 r9 r6
};
const byte kInstruction_shadd16_al_r3_r3_r7[] = {
0x17, 0x3f, 0x33, 0xe6 // shadd16 al r3 r3 r7
};
const byte kInstruction_shadd16_mi_r5_r7_r9[] = {
0x19, 0x5f, 0x37, 0x46 // shadd16 mi r5 r7 r9
};
const byte kInstruction_shadd16_cc_r11_r2_r4[] = {
0x14, 0xbf, 0x32, 0x36 // shadd16 cc r11 r2 r4
};
const byte kInstruction_shadd16_cc_r9_r13_r10[] = {
0x1a, 0x9f, 0x3d, 0x36 // shadd16 cc r9 r13 r10
};
const byte kInstruction_shadd16_al_r5_r2_r6[] = {
0x16, 0x5f, 0x32, 0xe6 // shadd16 al r5 r2 r6
};
const byte kInstruction_shadd16_ge_r9_r4_r6[] = {
0x16, 0x9f, 0x34, 0xa6 // shadd16 ge r9 r4 r6
};
const byte kInstruction_shadd16_ls_r3_r3_r4[] = {
0x14, 0x3f, 0x33, 0x96 // shadd16 ls r3 r3 r4
};
const byte kInstruction_shadd16_ge_r14_r1_r8[] = {
0x18, 0xef, 0x31, 0xa6 // shadd16 ge r14 r1 r8
};
const byte kInstruction_shadd16_ls_r7_r12_r7[] = {
0x17, 0x7f, 0x3c, 0x96 // shadd16 ls r7 r12 r7
};
const byte kInstruction_shadd16_al_r11_r10_r5[] = {
0x15, 0xbf, 0x3a, 0xe6 // shadd16 al r11 r10 r5
};
const byte kInstruction_shadd16_al_r7_r4_r6[] = {
0x16, 0x7f, 0x34, 0xe6 // shadd16 al r7 r4 r6
};
const byte kInstruction_shadd16_vs_r12_r4_r10[] = {
0x1a, 0xcf, 0x34, 0x66 // shadd16 vs r12 r4 r10
};
const byte kInstruction_shadd16_eq_r4_r4_r4[] = {
0x14, 0x4f, 0x34, 0x06 // shadd16 eq r4 r4 r4
};
const byte kInstruction_shadd16_vs_r6_r6_r12[] = {
0x1c, 0x6f, 0x36, 0x66 // shadd16 vs r6 r6 r12
};
const byte kInstruction_shadd16_pl_r9_r3_r5[] = {
0x15, 0x9f, 0x33, 0x56 // shadd16 pl r9 r3 r5
};
const byte kInstruction_shadd16_eq_r6_r5_r13[] = {
0x1d, 0x6f, 0x35, 0x06 // shadd16 eq r6 r5 r13
};
const byte kInstruction_shadd16_cc_r8_r2_r12[] = {
0x1c, 0x8f, 0x32, 0x36 // shadd16 cc r8 r2 r12
};
const byte kInstruction_shadd16_le_r4_r2_r0[] = {
0x10, 0x4f, 0x32, 0xd6 // shadd16 le r4 r2 r0
};
const byte kInstruction_shadd16_lt_r7_r9_r8[] = {
0x18, 0x7f, 0x39, 0xb6 // shadd16 lt r7 r9 r8
};
const byte kInstruction_shadd16_le_r4_r7_r11[] = {
0x1b, 0x4f, 0x37, 0xd6 // shadd16 le r4 r7 r11
};
const byte kInstruction_shadd16_eq_r5_r7_r5[] = {
0x15, 0x5f, 0x37, 0x06 // shadd16 eq r5 r7 r5
};
const byte kInstruction_shadd16_vc_r10_r7_r12[] = {
0x1c, 0xaf, 0x37, 0x76 // shadd16 vc r10 r7 r12
};
const byte kInstruction_shadd16_eq_r7_r10_r6[] = {
0x16, 0x7f, 0x3a, 0x06 // shadd16 eq r7 r10 r6
};
const byte kInstruction_shadd16_pl_r1_r12_r2[] = {
0x12, 0x1f, 0x3c, 0x56 // shadd16 pl r1 r12 r2
};
const byte kInstruction_shadd16_le_r14_r6_r6[] = {
0x16, 0xef, 0x36, 0xd6 // shadd16 le r14 r6 r6
};
const byte kInstruction_shadd16_ne_r3_r8_r8[] = {
0x18, 0x3f, 0x38, 0x16 // shadd16 ne r3 r8 r8
};
const byte kInstruction_shadd16_eq_r4_r12_r8[] = {
0x18, 0x4f, 0x3c, 0x06 // shadd16 eq r4 r12 r8
};
const byte kInstruction_shadd16_ge_r11_r2_r3[] = {
0x13, 0xbf, 0x32, 0xa6 // shadd16 ge r11 r2 r3
};
const byte kInstruction_shadd16_hi_r12_r6_r11[] = {
0x1b, 0xcf, 0x36, 0x86 // shadd16 hi r12 r6 r11
};
const byte kInstruction_shadd16_cs_r4_r5_r10[] = {
0x1a, 0x4f, 0x35, 0x26 // shadd16 cs r4 r5 r10
};
const byte kInstruction_shadd16_ge_r10_r2_r10[] = {
0x1a, 0xaf, 0x32, 0xa6 // shadd16 ge r10 r2 r10
};
const byte kInstruction_shadd16_ge_r5_r14_r6[] = {
0x16, 0x5f, 0x3e, 0xa6 // shadd16 ge r5 r14 r6
};
const byte kInstruction_shadd16_gt_r13_r7_r5[] = {
0x15, 0xdf, 0x37, 0xc6 // shadd16 gt r13 r7 r5
};
const byte kInstruction_shadd16_ge_r13_r4_r12[] = {
0x1c, 0xdf, 0x34, 0xa6 // shadd16 ge r13 r4 r12
};
const byte kInstruction_shadd16_lt_r8_r10_r14[] = {
0x1e, 0x8f, 0x3a, 0xb6 // shadd16 lt r8 r10 r14
};
const byte kInstruction_shadd16_le_r4_r3_r13[] = {
0x1d, 0x4f, 0x33, 0xd6 // shadd16 le r4 r3 r13
};
const byte kInstruction_shadd16_pl_r0_r9_r0[] = {
0x10, 0x0f, 0x39, 0x56 // shadd16 pl r0 r9 r0
};
const byte kInstruction_shadd16_eq_r2_r3_r1[] = {
0x11, 0x2f, 0x33, 0x06 // shadd16 eq r2 r3 r1
};
const byte kInstruction_shadd16_vc_r0_r0_r3[] = {
0x13, 0x0f, 0x30, 0x76 // shadd16 vc r0 r0 r3
};
const byte kInstruction_shadd16_mi_r10_r8_r11[] = {
0x1b, 0xaf, 0x38, 0x46 // shadd16 mi r10 r8 r11
};
const byte kInstruction_shadd16_mi_r5_r14_r14[] = {
0x1e, 0x5f, 0x3e, 0x46 // shadd16 mi r5 r14 r14
};
const byte kInstruction_shadd16_gt_r5_r11_r2[] = {
0x12, 0x5f, 0x3b, 0xc6 // shadd16 gt r5 r11 r2
};
const byte kInstruction_shadd16_al_r4_r7_r11[] = {
0x1b, 0x4f, 0x37, 0xe6 // shadd16 al r4 r7 r11
};
const TestResult kReferenceshadd16[] = {
{
ARRAY_SIZE(kInstruction_shadd16_hi_r1_r9_r5),
kInstruction_shadd16_hi_r1_r9_r5,
},
{
ARRAY_SIZE(kInstruction_shadd16_pl_r8_r6_r2),
kInstruction_shadd16_pl_r8_r6_r2,
},
{
ARRAY_SIZE(kInstruction_shadd16_hi_r5_r8_r2),
kInstruction_shadd16_hi_r5_r8_r2,
},
{
ARRAY_SIZE(kInstruction_shadd16_vc_r9_r2_r7),
kInstruction_shadd16_vc_r9_r2_r7,
},
{
ARRAY_SIZE(kInstruction_shadd16_lt_r4_r6_r3),
kInstruction_shadd16_lt_r4_r6_r3,
},
{
ARRAY_SIZE(kInstruction_shadd16_le_r11_r6_r2),
kInstruction_shadd16_le_r11_r6_r2,
},
{
ARRAY_SIZE(kInstruction_shadd16_cc_r8_r14_r4),
kInstruction_shadd16_cc_r8_r14_r4,
},
{
ARRAY_SIZE(kInstruction_shadd16_le_r5_r14_r6),
kInstruction_shadd16_le_r5_r14_r6,
},
{
ARRAY_SIZE(kInstruction_shadd16_lt_r6_r1_r0),
kInstruction_shadd16_lt_r6_r1_r0,
},
{
ARRAY_SIZE(kInstruction_shadd16_lt_r5_r0_r9),
kInstruction_shadd16_lt_r5_r0_r9,
},
{
ARRAY_SIZE(kInstruction_shadd16_le_r8_r12_r7),
kInstruction_shadd16_le_r8_r12_r7,
},
{
ARRAY_SIZE(kInstruction_shadd16_eq_r7_r14_r6),
kInstruction_shadd16_eq_r7_r14_r6,
},
{
ARRAY_SIZE(kInstruction_shadd16_cs_r7_r4_r6),
kInstruction_shadd16_cs_r7_r4_r6,
},
{
ARRAY_SIZE(kInstruction_shadd16_gt_r9_r6_r9),
kInstruction_shadd16_gt_r9_r6_r9,
},
{
ARRAY_SIZE(kInstruction_shadd16_ne_r13_r9_r1),
kInstruction_shadd16_ne_r13_r9_r1,
},
{
ARRAY_SIZE(kInstruction_shadd16_ge_r13_r1_r13),
kInstruction_shadd16_ge_r13_r1_r13,
},
{
ARRAY_SIZE(kInstruction_shadd16_ls_r8_r10_r2),
kInstruction_shadd16_ls_r8_r10_r2,
},
{
ARRAY_SIZE(kInstruction_shadd16_hi_r0_r13_r5),
kInstruction_shadd16_hi_r0_r13_r5,
},
{
ARRAY_SIZE(kInstruction_shadd16_pl_r13_r7_r8),
kInstruction_shadd16_pl_r13_r7_r8,
},
{
ARRAY_SIZE(kInstruction_shadd16_ge_r4_r13_r11),
kInstruction_shadd16_ge_r4_r13_r11,
},
{
ARRAY_SIZE(kInstruction_shadd16_cs_r5_r10_r5),
kInstruction_shadd16_cs_r5_r10_r5,
},
{
ARRAY_SIZE(kInstruction_shadd16_cs_r5_r4_r3),
kInstruction_shadd16_cs_r5_r4_r3,
},
{
ARRAY_SIZE(kInstruction_shadd16_ls_r6_r14_r8),
kInstruction_shadd16_ls_r6_r14_r8,
},
{
ARRAY_SIZE(kInstruction_shadd16_vs_r3_r8_r6),
kInstruction_shadd16_vs_r3_r8_r6,
},
{
ARRAY_SIZE(kInstruction_shadd16_vc_r7_r12_r3),
kInstruction_shadd16_vc_r7_r12_r3,
},
{
ARRAY_SIZE(kInstruction_shadd16_ge_r1_r4_r1),
kInstruction_shadd16_ge_r1_r4_r1,
},
{
ARRAY_SIZE(kInstruction_shadd16_cc_r4_r7_r10),
kInstruction_shadd16_cc_r4_r7_r10,
},
{
ARRAY_SIZE(kInstruction_shadd16_cc_r2_r0_r13),
kInstruction_shadd16_cc_r2_r0_r13,
},
{
ARRAY_SIZE(kInstruction_shadd16_vs_r9_r6_r8),
kInstruction_shadd16_vs_r9_r6_r8,
},
{
ARRAY_SIZE(kInstruction_shadd16_cs_r14_r11_r13),
kInstruction_shadd16_cs_r14_r11_r13,
},
{
ARRAY_SIZE(kInstruction_shadd16_pl_r5_r8_r4),
kInstruction_shadd16_pl_r5_r8_r4,
},
{
ARRAY_SIZE(kInstruction_shadd16_pl_r2_r3_r7),
kInstruction_shadd16_pl_r2_r3_r7,
},
{
ARRAY_SIZE(kInstruction_shadd16_cs_r7_r12_r14),
kInstruction_shadd16_cs_r7_r12_r14,
},
{
ARRAY_SIZE(kInstruction_shadd16_hi_r6_r6_r1),
kInstruction_shadd16_hi_r6_r6_r1,
},
{
ARRAY_SIZE(kInstruction_shadd16_cc_r6_r9_r6),
kInstruction_shadd16_cc_r6_r9_r6,
},
{
ARRAY_SIZE(kInstruction_shadd16_ne_r12_r12_r0),
kInstruction_shadd16_ne_r12_r12_r0,
},
{
ARRAY_SIZE(kInstruction_shadd16_cc_r9_r3_r8),
kInstruction_shadd16_cc_r9_r3_r8,
},
{
ARRAY_SIZE(kInstruction_shadd16_mi_r13_r6_r1),
kInstruction_shadd16_mi_r13_r6_r1,
},
{
ARRAY_SIZE(kInstruction_shadd16_lt_r4_r8_r6),
kInstruction_shadd16_lt_r4_r8_r6,
},
{
ARRAY_SIZE(kInstruction_shadd16_hi_r11_r5_r9),
kInstruction_shadd16_hi_r11_r5_r9,
},
{
ARRAY_SIZE(kInstruction_shadd16_cc_r6_r10_r6),
kInstruction_shadd16_cc_r6_r10_r6,
},
{
ARRAY_SIZE(kInstruction_shadd16_eq_r10_r10_r5),
kInstruction_shadd16_eq_r10_r10_r5,
},
{
ARRAY_SIZE(kInstruction_shadd16_al_r5_r4_r11),
kInstruction_shadd16_al_r5_r4_r11,
},
{
ARRAY_SIZE(kInstruction_shadd16_pl_r11_r11_r2),
kInstruction_shadd16_pl_r11_r11_r2,
},
{
ARRAY_SIZE(kInstruction_shadd16_ls_r6_r14_r12),
kInstruction_shadd16_ls_r6_r14_r12,
},
{
ARRAY_SIZE(kInstruction_shadd16_vc_r7_r7_r2),
kInstruction_shadd16_vc_r7_r7_r2,
},
{
ARRAY_SIZE(kInstruction_shadd16_eq_r10_r8_r4),
kInstruction_shadd16_eq_r10_r8_r4,
},
{
ARRAY_SIZE(kInstruction_shadd16_al_r14_r7_r2),
kInstruction_shadd16_al_r14_r7_r2,
},
{
ARRAY_SIZE(kInstruction_shadd16_cs_r3_r11_r10),
kInstruction_shadd16_cs_r3_r11_r10,
},
{
ARRAY_SIZE(kInstruction_shadd16_ls_r11_r4_r0),
kInstruction_shadd16_ls_r11_r4_r0,
},
{
ARRAY_SIZE(kInstruction_shadd16_hi_r11_r8_r9),
kInstruction_shadd16_hi_r11_r8_r9,
},
{
ARRAY_SIZE(kInstruction_shadd16_vs_r2_r14_r13),
kInstruction_shadd16_vs_r2_r14_r13,
},
{
ARRAY_SIZE(kInstruction_shadd16_al_r1_r13_r9),
kInstruction_shadd16_al_r1_r13_r9,
},
{
ARRAY_SIZE(kInstruction_shadd16_eq_r3_r9_r13),
kInstruction_shadd16_eq_r3_r9_r13,
},
{
ARRAY_SIZE(kInstruction_shadd16_ge_r10_r3_r13),
kInstruction_shadd16_ge_r10_r3_r13,
},
{
ARRAY_SIZE(kInstruction_shadd16_pl_r8_r5_r10),
kInstruction_shadd16_pl_r8_r5_r10,
},
{
ARRAY_SIZE(kInstruction_shadd16_vc_r8_r11_r6),
kInstruction_shadd16_vc_r8_r11_r6,
},
{
ARRAY_SIZE(kInstruction_shadd16_eq_r0_r0_r5),
kInstruction_shadd16_eq_r0_r0_r5,
},
{
ARRAY_SIZE(kInstruction_shadd16_ne_r6_r5_r8),
kInstruction_shadd16_ne_r6_r5_r8,
},
{
ARRAY_SIZE(kInstruction_shadd16_hi_r5_r13_r3),
kInstruction_shadd16_hi_r5_r13_r3,
},
{
ARRAY_SIZE(kInstruction_shadd16_ne_r11_r14_r14),
kInstruction_shadd16_ne_r11_r14_r14,
},
{
ARRAY_SIZE(kInstruction_shadd16_mi_r1_r0_r6),
kInstruction_shadd16_mi_r1_r0_r6,
},
{
ARRAY_SIZE(kInstruction_shadd16_le_r14_r8_r2),
kInstruction_shadd16_le_r14_r8_r2,
},
{
ARRAY_SIZE(kInstruction_shadd16_eq_r9_r6_r5),
kInstruction_shadd16_eq_r9_r6_r5,
},
{
ARRAY_SIZE(kInstruction_shadd16_eq_r11_r0_r13),
kInstruction_shadd16_eq_r11_r0_r13,
},
{
ARRAY_SIZE(kInstruction_shadd16_pl_r4_r5_r14),
kInstruction_shadd16_pl_r4_r5_r14,
},
{
ARRAY_SIZE(kInstruction_shadd16_cs_r13_r5_r13),
kInstruction_shadd16_cs_r13_r5_r13,
},
{
ARRAY_SIZE(kInstruction_shadd16_mi_r0_r13_r8),
kInstruction_shadd16_mi_r0_r13_r8,
},
{
ARRAY_SIZE(kInstruction_shadd16_lt_r2_r13_r3),
kInstruction_shadd16_lt_r2_r13_r3,
},
{
ARRAY_SIZE(kInstruction_shadd16_ls_r8_r1_r11),
kInstruction_shadd16_ls_r8_r1_r11,
},
{
ARRAY_SIZE(kInstruction_shadd16_vc_r14_r11_r8),
kInstruction_shadd16_vc_r14_r11_r8,
},
{
ARRAY_SIZE(kInstruction_shadd16_lt_r4_r13_r12),
kInstruction_shadd16_lt_r4_r13_r12,
},
{
ARRAY_SIZE(kInstruction_shadd16_eq_r2_r1_r14),
kInstruction_shadd16_eq_r2_r1_r14,
},
{
ARRAY_SIZE(kInstruction_shadd16_eq_r9_r4_r14),
kInstruction_shadd16_eq_r9_r4_r14,
},
{
ARRAY_SIZE(kInstruction_shadd16_hi_r10_r6_r13),
kInstruction_shadd16_hi_r10_r6_r13,
},
{
ARRAY_SIZE(kInstruction_shadd16_ge_r12_r9_r4),
kInstruction_shadd16_ge_r12_r9_r4,
},
{
ARRAY_SIZE(kInstruction_shadd16_le_r9_r11_r14),
kInstruction_shadd16_le_r9_r11_r14,
},
{
ARRAY_SIZE(kInstruction_shadd16_ls_r0_r9_r5),
kInstruction_shadd16_ls_r0_r9_r5,
},
{
ARRAY_SIZE(kInstruction_shadd16_mi_r2_r3_r8),
kInstruction_shadd16_mi_r2_r3_r8,
},
{
ARRAY_SIZE(kInstruction_shadd16_ne_r14_r10_r14),
kInstruction_shadd16_ne_r14_r10_r14,
},
{
ARRAY_SIZE(kInstruction_shadd16_eq_r6_r2_r10),
kInstruction_shadd16_eq_r6_r2_r10,
},
{
ARRAY_SIZE(kInstruction_shadd16_lt_r11_r0_r12),
kInstruction_shadd16_lt_r11_r0_r12,
},
{
ARRAY_SIZE(kInstruction_shadd16_ne_r1_r12_r10),
kInstruction_shadd16_ne_r1_r12_r10,
},
{
ARRAY_SIZE(kInstruction_shadd16_cc_r1_r0_r2),
kInstruction_shadd16_cc_r1_r0_r2,
},
{
ARRAY_SIZE(kInstruction_shadd16_al_r5_r5_r7),
kInstruction_shadd16_al_r5_r5_r7,
},
{
ARRAY_SIZE(kInstruction_shadd16_hi_r7_r13_r1),
kInstruction_shadd16_hi_r7_r13_r1,
},
{
ARRAY_SIZE(kInstruction_shadd16_cs_r4_r4_r9),
kInstruction_shadd16_cs_r4_r4_r9,
},
{
ARRAY_SIZE(kInstruction_shadd16_eq_r14_r4_r14),
kInstruction_shadd16_eq_r14_r4_r14,
},
{
ARRAY_SIZE(kInstruction_shadd16_vs_r10_r5_r14),
kInstruction_shadd16_vs_r10_r5_r14,
},
{
ARRAY_SIZE(kInstruction_shadd16_gt_r4_r3_r11),
kInstruction_shadd16_gt_r4_r3_r11,
},
{
ARRAY_SIZE(kInstruction_shadd16_ne_r14_r10_r12),
kInstruction_shadd16_ne_r14_r10_r12,
},
{
ARRAY_SIZE(kInstruction_shadd16_vs_r2_r11_r0),
kInstruction_shadd16_vs_r2_r11_r0,
},
{
ARRAY_SIZE(kInstruction_shadd16_ge_r5_r12_r7),
kInstruction_shadd16_ge_r5_r12_r7,
},
{
ARRAY_SIZE(kInstruction_shadd16_mi_r7_r14_r6),
kInstruction_shadd16_mi_r7_r14_r6,
},
{
ARRAY_SIZE(kInstruction_shadd16_gt_r8_r3_r8),
kInstruction_shadd16_gt_r8_r3_r8,
},
{
ARRAY_SIZE(kInstruction_shadd16_hi_r9_r14_r3),
kInstruction_shadd16_hi_r9_r14_r3,
},
{
ARRAY_SIZE(kInstruction_shadd16_vc_r2_r11_r2),
kInstruction_shadd16_vc_r2_r11_r2,
},
{
ARRAY_SIZE(kInstruction_shadd16_hi_r11_r7_r12),
kInstruction_shadd16_hi_r11_r7_r12,
},
{
ARRAY_SIZE(kInstruction_shadd16_cs_r6_r4_r11),
kInstruction_shadd16_cs_r6_r4_r11,
},
{
ARRAY_SIZE(kInstruction_shadd16_cs_r12_r5_r9),
kInstruction_shadd16_cs_r12_r5_r9,
},
{
ARRAY_SIZE(kInstruction_shadd16_ls_r5_r10_r5),
kInstruction_shadd16_ls_r5_r10_r5,
},
{
ARRAY_SIZE(kInstruction_shadd16_ls_r0_r9_r13),
kInstruction_shadd16_ls_r0_r9_r13,
},
{
ARRAY_SIZE(kInstruction_shadd16_lt_r3_r3_r5),
kInstruction_shadd16_lt_r3_r3_r5,
},
{
ARRAY_SIZE(kInstruction_shadd16_mi_r0_r12_r8),
kInstruction_shadd16_mi_r0_r12_r8,
},
{
ARRAY_SIZE(kInstruction_shadd16_pl_r3_r12_r12),
kInstruction_shadd16_pl_r3_r12_r12,
},
{
ARRAY_SIZE(kInstruction_shadd16_eq_r8_r12_r5),
kInstruction_shadd16_eq_r8_r12_r5,
},
{
ARRAY_SIZE(kInstruction_shadd16_cc_r7_r8_r1),
kInstruction_shadd16_cc_r7_r8_r1,
},
{
ARRAY_SIZE(kInstruction_shadd16_hi_r2_r13_r10),
kInstruction_shadd16_hi_r2_r13_r10,
},
{
ARRAY_SIZE(kInstruction_shadd16_al_r7_r10_r10),
kInstruction_shadd16_al_r7_r10_r10,
},
{
ARRAY_SIZE(kInstruction_shadd16_vc_r1_r12_r2),
kInstruction_shadd16_vc_r1_r12_r2,
},
{
ARRAY_SIZE(kInstruction_shadd16_cc_r8_r5_r8),
kInstruction_shadd16_cc_r8_r5_r8,
},
{
ARRAY_SIZE(kInstruction_shadd16_ls_r3_r7_r9),
kInstruction_shadd16_ls_r3_r7_r9,
},
{
ARRAY_SIZE(kInstruction_shadd16_al_r8_r10_r8),
kInstruction_shadd16_al_r8_r10_r8,
},
{
ARRAY_SIZE(kInstruction_shadd16_lt_r4_r12_r10),
kInstruction_shadd16_lt_r4_r12_r10,
},
{
ARRAY_SIZE(kInstruction_shadd16_ge_r10_r5_r11),
kInstruction_shadd16_ge_r10_r5_r11,
},
{
ARRAY_SIZE(kInstruction_shadd16_ls_r3_r14_r4),
kInstruction_shadd16_ls_r3_r14_r4,
},
{
ARRAY_SIZE(kInstruction_shadd16_hi_r3_r6_r12),
kInstruction_shadd16_hi_r3_r6_r12,
},
{
ARRAY_SIZE(kInstruction_shadd16_hi_r6_r0_r4),
kInstruction_shadd16_hi_r6_r0_r4,
},
{
ARRAY_SIZE(kInstruction_shadd16_al_r11_r6_r0),
kInstruction_shadd16_al_r11_r6_r0,
},
{
ARRAY_SIZE(kInstruction_shadd16_mi_r3_r1_r9),
kInstruction_shadd16_mi_r3_r1_r9,
},
{
ARRAY_SIZE(kInstruction_shadd16_mi_r12_r13_r0),
kInstruction_shadd16_mi_r12_r13_r0,
},
{
ARRAY_SIZE(kInstruction_shadd16_le_r1_r2_r5),
kInstruction_shadd16_le_r1_r2_r5,
},
{
ARRAY_SIZE(kInstruction_shadd16_hi_r4_r3_r14),
kInstruction_shadd16_hi_r4_r3_r14,
},
{
ARRAY_SIZE(kInstruction_shadd16_eq_r6_r11_r11),
kInstruction_shadd16_eq_r6_r11_r11,
},
{
ARRAY_SIZE(kInstruction_shadd16_cc_r14_r11_r14),
kInstruction_shadd16_cc_r14_r11_r14,
},
{
ARRAY_SIZE(kInstruction_shadd16_hi_r4_r10_r0),
kInstruction_shadd16_hi_r4_r10_r0,
},
{
ARRAY_SIZE(kInstruction_shadd16_cc_r7_r11_r1),
kInstruction_shadd16_cc_r7_r11_r1,
},
{
ARRAY_SIZE(kInstruction_shadd16_mi_r14_r6_r10),
kInstruction_shadd16_mi_r14_r6_r10,
},
{
ARRAY_SIZE(kInstruction_shadd16_eq_r2_r0_r11),
kInstruction_shadd16_eq_r2_r0_r11,
},
{
ARRAY_SIZE(kInstruction_shadd16_mi_r13_r5_r12),
kInstruction_shadd16_mi_r13_r5_r12,
},
{
ARRAY_SIZE(kInstruction_shadd16_eq_r2_r12_r5),
kInstruction_shadd16_eq_r2_r12_r5,
},
{
ARRAY_SIZE(kInstruction_shadd16_le_r12_r0_r2),
kInstruction_shadd16_le_r12_r0_r2,
},
{
ARRAY_SIZE(kInstruction_shadd16_vc_r10_r10_r9),
kInstruction_shadd16_vc_r10_r10_r9,
},
{
ARRAY_SIZE(kInstruction_shadd16_ls_r11_r11_r8),
kInstruction_shadd16_ls_r11_r11_r8,
},
{
ARRAY_SIZE(kInstruction_shadd16_hi_r10_r11_r9),
kInstruction_shadd16_hi_r10_r11_r9,
},
{
ARRAY_SIZE(kInstruction_shadd16_vs_r7_r12_r14),
kInstruction_shadd16_vs_r7_r12_r14,
},
{
ARRAY_SIZE(kInstruction_shadd16_gt_r11_r14_r12),
kInstruction_shadd16_gt_r11_r14_r12,
},
{
ARRAY_SIZE(kInstruction_shadd16_vs_r0_r12_r8),
kInstruction_shadd16_vs_r0_r12_r8,
},
{
ARRAY_SIZE(kInstruction_shadd16_al_r0_r5_r7),
kInstruction_shadd16_al_r0_r5_r7,
},
{
ARRAY_SIZE(kInstruction_shadd16_hi_r5_r13_r8),
kInstruction_shadd16_hi_r5_r13_r8,
},
{
ARRAY_SIZE(kInstruction_shadd16_le_r9_r9_r7),
kInstruction_shadd16_le_r9_r9_r7,
},
{
ARRAY_SIZE(kInstruction_shadd16_cc_r4_r9_r5),
kInstruction_shadd16_cc_r4_r9_r5,
},
{
ARRAY_SIZE(kInstruction_shadd16_vs_r8_r1_r3),
kInstruction_shadd16_vs_r8_r1_r3,
},
{
ARRAY_SIZE(kInstruction_shadd16_cc_r0_r10_r12),
kInstruction_shadd16_cc_r0_r10_r12,
},
{
ARRAY_SIZE(kInstruction_shadd16_eq_r7_r14_r0),
kInstruction_shadd16_eq_r7_r14_r0,
},
{
ARRAY_SIZE(kInstruction_shadd16_vs_r12_r9_r11),
kInstruction_shadd16_vs_r12_r9_r11,
},
{
ARRAY_SIZE(kInstruction_shadd16_gt_r5_r9_r11),
kInstruction_shadd16_gt_r5_r9_r11,
},
{
ARRAY_SIZE(kInstruction_shadd16_cs_r14_r13_r7),
kInstruction_shadd16_cs_r14_r13_r7,
},
{
ARRAY_SIZE(kInstruction_shadd16_mi_r11_r3_r10),
kInstruction_shadd16_mi_r11_r3_r10,
},
{
ARRAY_SIZE(kInstruction_shadd16_hi_r11_r8_r12),
kInstruction_shadd16_hi_r11_r8_r12,
},
{
ARRAY_SIZE(kInstruction_shadd16_cs_r3_r8_r13),
kInstruction_shadd16_cs_r3_r8_r13,
},
{
ARRAY_SIZE(kInstruction_shadd16_pl_r10_r12_r6),
kInstruction_shadd16_pl_r10_r12_r6,
},
{
ARRAY_SIZE(kInstruction_shadd16_vc_r7_r3_r2),
kInstruction_shadd16_vc_r7_r3_r2,
},
{
ARRAY_SIZE(kInstruction_shadd16_mi_r9_r0_r8),
kInstruction_shadd16_mi_r9_r0_r8,
},
{
ARRAY_SIZE(kInstruction_shadd16_eq_r2_r13_r7),
kInstruction_shadd16_eq_r2_r13_r7,
},
{
ARRAY_SIZE(kInstruction_shadd16_ne_r2_r14_r0),
kInstruction_shadd16_ne_r2_r14_r0,
},
{
ARRAY_SIZE(kInstruction_shadd16_vs_r4_r10_r0),
kInstruction_shadd16_vs_r4_r10_r0,
},
{
ARRAY_SIZE(kInstruction_shadd16_ls_r0_r2_r2),
kInstruction_shadd16_ls_r0_r2_r2,
},
{
ARRAY_SIZE(kInstruction_shadd16_cc_r1_r6_r0),
kInstruction_shadd16_cc_r1_r6_r0,
},
{
ARRAY_SIZE(kInstruction_shadd16_lt_r12_r0_r8),
kInstruction_shadd16_lt_r12_r0_r8,
},
{
ARRAY_SIZE(kInstruction_shadd16_cc_r9_r3_r14),
kInstruction_shadd16_cc_r9_r3_r14,
},
{
ARRAY_SIZE(kInstruction_shadd16_vs_r7_r9_r1),
kInstruction_shadd16_vs_r7_r9_r1,
},
{
ARRAY_SIZE(kInstruction_shadd16_eq_r11_r9_r14),
kInstruction_shadd16_eq_r11_r9_r14,
},
{
ARRAY_SIZE(kInstruction_shadd16_pl_r6_r10_r4),
kInstruction_shadd16_pl_r6_r10_r4,
},
{
ARRAY_SIZE(kInstruction_shadd16_ne_r8_r5_r6),
kInstruction_shadd16_ne_r8_r5_r6,
},
{
ARRAY_SIZE(kInstruction_shadd16_cs_r0_r6_r2),
kInstruction_shadd16_cs_r0_r6_r2,
},
{
ARRAY_SIZE(kInstruction_shadd16_eq_r11_r12_r4),
kInstruction_shadd16_eq_r11_r12_r4,
},
{
ARRAY_SIZE(kInstruction_shadd16_lt_r14_r3_r14),
kInstruction_shadd16_lt_r14_r3_r14,
},
{
ARRAY_SIZE(kInstruction_shadd16_le_r7_r12_r14),
kInstruction_shadd16_le_r7_r12_r14,
},
{
ARRAY_SIZE(kInstruction_shadd16_hi_r2_r9_r9),
kInstruction_shadd16_hi_r2_r9_r9,
},
{
ARRAY_SIZE(kInstruction_shadd16_ne_r8_r1_r0),
kInstruction_shadd16_ne_r8_r1_r0,
},
{
ARRAY_SIZE(kInstruction_shadd16_cc_r5_r11_r2),
kInstruction_shadd16_cc_r5_r11_r2,
},
{
ARRAY_SIZE(kInstruction_shadd16_hi_r0_r1_r2),
kInstruction_shadd16_hi_r0_r1_r2,
},
{
ARRAY_SIZE(kInstruction_shadd16_al_r4_r9_r4),
kInstruction_shadd16_al_r4_r9_r4,
},
{
ARRAY_SIZE(kInstruction_shadd16_cs_r12_r7_r14),
kInstruction_shadd16_cs_r12_r7_r14,
},
{
ARRAY_SIZE(kInstruction_shadd16_cc_r4_r12_r10),
kInstruction_shadd16_cc_r4_r12_r10,
},
{
ARRAY_SIZE(kInstruction_shadd16_al_r3_r5_r10),
kInstruction_shadd16_al_r3_r5_r10,
},
{
ARRAY_SIZE(kInstruction_shadd16_mi_r5_r3_r7),
kInstruction_shadd16_mi_r5_r3_r7,
},
{
ARRAY_SIZE(kInstruction_shadd16_ls_r10_r6_r2),
kInstruction_shadd16_ls_r10_r6_r2,
},
{
ARRAY_SIZE(kInstruction_shadd16_mi_r0_r12_r11),
kInstruction_shadd16_mi_r0_r12_r11,
},
{
ARRAY_SIZE(kInstruction_shadd16_vc_r12_r5_r6),
kInstruction_shadd16_vc_r12_r5_r6,
},
{
ARRAY_SIZE(kInstruction_shadd16_cs_r3_r9_r4),
kInstruction_shadd16_cs_r3_r9_r4,
},
{
ARRAY_SIZE(kInstruction_shadd16_ls_r4_r9_r11),
kInstruction_shadd16_ls_r4_r9_r11,
},
{
ARRAY_SIZE(kInstruction_shadd16_le_r14_r8_r13),
kInstruction_shadd16_le_r14_r8_r13,
},
{
ARRAY_SIZE(kInstruction_shadd16_gt_r4_r10_r8),
kInstruction_shadd16_gt_r4_r10_r8,
},
{
ARRAY_SIZE(kInstruction_shadd16_al_r6_r9_r9),
kInstruction_shadd16_al_r6_r9_r9,
},
{
ARRAY_SIZE(kInstruction_shadd16_ne_r8_r5_r12),
kInstruction_shadd16_ne_r8_r5_r12,
},
{
ARRAY_SIZE(kInstruction_shadd16_ne_r0_r4_r8),
kInstruction_shadd16_ne_r0_r4_r8,
},
{
ARRAY_SIZE(kInstruction_shadd16_mi_r7_r13_r3),
kInstruction_shadd16_mi_r7_r13_r3,
},
{
ARRAY_SIZE(kInstruction_shadd16_cc_r11_r7_r0),
kInstruction_shadd16_cc_r11_r7_r0,
},
{
ARRAY_SIZE(kInstruction_shadd16_hi_r1_r0_r12),
kInstruction_shadd16_hi_r1_r0_r12,
},
{
ARRAY_SIZE(kInstruction_shadd16_lt_r8_r9_r3),
kInstruction_shadd16_lt_r8_r9_r3,
},
{
ARRAY_SIZE(kInstruction_shadd16_al_r0_r2_r1),
kInstruction_shadd16_al_r0_r2_r1,
},
{
ARRAY_SIZE(kInstruction_shadd16_vs_r4_r3_r14),
kInstruction_shadd16_vs_r4_r3_r14,
},
{
ARRAY_SIZE(kInstruction_shadd16_ge_r2_r11_r1),
kInstruction_shadd16_ge_r2_r11_r1,
},
{
ARRAY_SIZE(kInstruction_shadd16_lt_r12_r9_r6),
kInstruction_shadd16_lt_r12_r9_r6,
},
{
ARRAY_SIZE(kInstruction_shadd16_ls_r8_r2_r7),
kInstruction_shadd16_ls_r8_r2_r7,
},
{
ARRAY_SIZE(kInstruction_shadd16_le_r8_r13_r3),
kInstruction_shadd16_le_r8_r13_r3,
},
{
ARRAY_SIZE(kInstruction_shadd16_eq_r11_r13_r14),
kInstruction_shadd16_eq_r11_r13_r14,
},
{
ARRAY_SIZE(kInstruction_shadd16_lt_r1_r6_r13),
kInstruction_shadd16_lt_r1_r6_r13,
},
{
ARRAY_SIZE(kInstruction_shadd16_cs_r3_r8_r11),
kInstruction_shadd16_cs_r3_r8_r11,
},
{
ARRAY_SIZE(kInstruction_shadd16_pl_r12_r5_r4),
kInstruction_shadd16_pl_r12_r5_r4,
},
{
ARRAY_SIZE(kInstruction_shadd16_eq_r8_r7_r2),
kInstruction_shadd16_eq_r8_r7_r2,
},
{
ARRAY_SIZE(kInstruction_shadd16_ls_r2_r12_r2),
kInstruction_shadd16_ls_r2_r12_r2,
},
{
ARRAY_SIZE(kInstruction_shadd16_le_r14_r2_r3),
kInstruction_shadd16_le_r14_r2_r3,
},
{
ARRAY_SIZE(kInstruction_shadd16_ge_r10_r11_r6),
kInstruction_shadd16_ge_r10_r11_r6,
},
{
ARRAY_SIZE(kInstruction_shadd16_hi_r0_r2_r2),
kInstruction_shadd16_hi_r0_r2_r2,
},
{
ARRAY_SIZE(kInstruction_shadd16_ge_r2_r0_r2),
kInstruction_shadd16_ge_r2_r0_r2,
},
{
ARRAY_SIZE(kInstruction_shadd16_vs_r11_r14_r0),
kInstruction_shadd16_vs_r11_r14_r0,
},
{
ARRAY_SIZE(kInstruction_shadd16_lt_r2_r0_r1),
kInstruction_shadd16_lt_r2_r0_r1,
},
{
ARRAY_SIZE(kInstruction_shadd16_cs_r2_r5_r11),
kInstruction_shadd16_cs_r2_r5_r11,
},
{
ARRAY_SIZE(kInstruction_shadd16_ls_r7_r14_r5),
kInstruction_shadd16_ls_r7_r14_r5,
},
{
ARRAY_SIZE(kInstruction_shadd16_pl_r0_r0_r3),
kInstruction_shadd16_pl_r0_r0_r3,
},
{
ARRAY_SIZE(kInstruction_shadd16_ge_r6_r8_r8),
kInstruction_shadd16_ge_r6_r8_r8,
},
{
ARRAY_SIZE(kInstruction_shadd16_le_r11_r1_r10),
kInstruction_shadd16_le_r11_r1_r10,
},
{
ARRAY_SIZE(kInstruction_shadd16_vs_r5_r2_r7),
kInstruction_shadd16_vs_r5_r2_r7,
},
{
ARRAY_SIZE(kInstruction_shadd16_ne_r4_r4_r8),
kInstruction_shadd16_ne_r4_r4_r8,
},
{
ARRAY_SIZE(kInstruction_shadd16_cc_r9_r14_r13),
kInstruction_shadd16_cc_r9_r14_r13,
},
{
ARRAY_SIZE(kInstruction_shadd16_hi_r14_r6_r3),
kInstruction_shadd16_hi_r14_r6_r3,
},
{
ARRAY_SIZE(kInstruction_shadd16_al_r0_r8_r0),
kInstruction_shadd16_al_r0_r8_r0,
},
{
ARRAY_SIZE(kInstruction_shadd16_lt_r6_r11_r1),
kInstruction_shadd16_lt_r6_r11_r1,
},
{
ARRAY_SIZE(kInstruction_shadd16_ge_r7_r6_r12),
kInstruction_shadd16_ge_r7_r6_r12,
},
{
ARRAY_SIZE(kInstruction_shadd16_cs_r4_r6_r14),
kInstruction_shadd16_cs_r4_r6_r14,
},
{
ARRAY_SIZE(kInstruction_shadd16_cs_r7_r6_r7),
kInstruction_shadd16_cs_r7_r6_r7,
},
{
ARRAY_SIZE(kInstruction_shadd16_cs_r3_r7_r10),
kInstruction_shadd16_cs_r3_r7_r10,
},
{
ARRAY_SIZE(kInstruction_shadd16_ne_r0_r2_r1),
kInstruction_shadd16_ne_r0_r2_r1,
},
{
ARRAY_SIZE(kInstruction_shadd16_vs_r9_r10_r13),
kInstruction_shadd16_vs_r9_r10_r13,
},
{
ARRAY_SIZE(kInstruction_shadd16_vc_r11_r14_r12),
kInstruction_shadd16_vc_r11_r14_r12,
},
{
ARRAY_SIZE(kInstruction_shadd16_ge_r14_r8_r7),
kInstruction_shadd16_ge_r14_r8_r7,
},
{
ARRAY_SIZE(kInstruction_shadd16_lt_r13_r0_r11),
kInstruction_shadd16_lt_r13_r0_r11,
},
{
ARRAY_SIZE(kInstruction_shadd16_lt_r14_r13_r4),
kInstruction_shadd16_lt_r14_r13_r4,
},
{
ARRAY_SIZE(kInstruction_shadd16_al_r1_r10_r9),
kInstruction_shadd16_al_r1_r10_r9,
},
{
ARRAY_SIZE(kInstruction_shadd16_ge_r11_r14_r11),
kInstruction_shadd16_ge_r11_r14_r11,
},
{
ARRAY_SIZE(kInstruction_shadd16_cs_r11_r4_r11),
kInstruction_shadd16_cs_r11_r4_r11,
},
{
ARRAY_SIZE(kInstruction_shadd16_ge_r0_r14_r7),
kInstruction_shadd16_ge_r0_r14_r7,
},
{
ARRAY_SIZE(kInstruction_shadd16_mi_r1_r2_r9),
kInstruction_shadd16_mi_r1_r2_r9,
},
{
ARRAY_SIZE(kInstruction_shadd16_eq_r5_r12_r3),
kInstruction_shadd16_eq_r5_r12_r3,
},
{
ARRAY_SIZE(kInstruction_shadd16_ge_r1_r5_r12),
kInstruction_shadd16_ge_r1_r5_r12,
},
{
ARRAY_SIZE(kInstruction_shadd16_lt_r10_r11_r4),
kInstruction_shadd16_lt_r10_r11_r4,
},
{
ARRAY_SIZE(kInstruction_shadd16_le_r1_r1_r5),
kInstruction_shadd16_le_r1_r1_r5,
},
{
ARRAY_SIZE(kInstruction_shadd16_al_r9_r1_r8),
kInstruction_shadd16_al_r9_r1_r8,
},
{
ARRAY_SIZE(kInstruction_shadd16_ne_r6_r8_r4),
kInstruction_shadd16_ne_r6_r8_r4,
},
{
ARRAY_SIZE(kInstruction_shadd16_ge_r12_r2_r9),
kInstruction_shadd16_ge_r12_r2_r9,
},
{
ARRAY_SIZE(kInstruction_shadd16_pl_r4_r3_r10),
kInstruction_shadd16_pl_r4_r3_r10,
},
{
ARRAY_SIZE(kInstruction_shadd16_eq_r14_r4_r11),
kInstruction_shadd16_eq_r14_r4_r11,
},
{
ARRAY_SIZE(kInstruction_shadd16_cc_r9_r7_r6),
kInstruction_shadd16_cc_r9_r7_r6,
},
{
ARRAY_SIZE(kInstruction_shadd16_ge_r12_r4_r5),
kInstruction_shadd16_ge_r12_r4_r5,
},
{
ARRAY_SIZE(kInstruction_shadd16_hi_r2_r3_r4),
kInstruction_shadd16_hi_r2_r3_r4,
},
{
ARRAY_SIZE(kInstruction_shadd16_cs_r0_r3_r1),
kInstruction_shadd16_cs_r0_r3_r1,
},
{
ARRAY_SIZE(kInstruction_shadd16_hi_r6_r2_r8),
kInstruction_shadd16_hi_r6_r2_r8,
},
{
ARRAY_SIZE(kInstruction_shadd16_cc_r3_r14_r13),
kInstruction_shadd16_cc_r3_r14_r13,
},
{
ARRAY_SIZE(kInstruction_shadd16_gt_r11_r4_r7),
kInstruction_shadd16_gt_r11_r4_r7,
},
{
ARRAY_SIZE(kInstruction_shadd16_hi_r5_r0_r12),
kInstruction_shadd16_hi_r5_r0_r12,
},
{
ARRAY_SIZE(kInstruction_shadd16_gt_r0_r14_r14),
kInstruction_shadd16_gt_r0_r14_r14,
},
{
ARRAY_SIZE(kInstruction_shadd16_hi_r9_r0_r10),
kInstruction_shadd16_hi_r9_r0_r10,
},
{
ARRAY_SIZE(kInstruction_shadd16_vc_r7_r11_r8),
kInstruction_shadd16_vc_r7_r11_r8,
},
{
ARRAY_SIZE(kInstruction_shadd16_pl_r11_r9_r6),
kInstruction_shadd16_pl_r11_r9_r6,
},
{
ARRAY_SIZE(kInstruction_shadd16_al_r3_r3_r7),
kInstruction_shadd16_al_r3_r3_r7,
},
{
ARRAY_SIZE(kInstruction_shadd16_mi_r5_r7_r9),
kInstruction_shadd16_mi_r5_r7_r9,
},
{
ARRAY_SIZE(kInstruction_shadd16_cc_r11_r2_r4),
kInstruction_shadd16_cc_r11_r2_r4,
},
{
ARRAY_SIZE(kInstruction_shadd16_cc_r9_r13_r10),
kInstruction_shadd16_cc_r9_r13_r10,
},
{
ARRAY_SIZE(kInstruction_shadd16_al_r5_r2_r6),
kInstruction_shadd16_al_r5_r2_r6,
},
{
ARRAY_SIZE(kInstruction_shadd16_ge_r9_r4_r6),
kInstruction_shadd16_ge_r9_r4_r6,
},
{
ARRAY_SIZE(kInstruction_shadd16_ls_r3_r3_r4),
kInstruction_shadd16_ls_r3_r3_r4,
},
{
ARRAY_SIZE(kInstruction_shadd16_ge_r14_r1_r8),
kInstruction_shadd16_ge_r14_r1_r8,
},
{
ARRAY_SIZE(kInstruction_shadd16_ls_r7_r12_r7),
kInstruction_shadd16_ls_r7_r12_r7,
},
{
ARRAY_SIZE(kInstruction_shadd16_al_r11_r10_r5),
kInstruction_shadd16_al_r11_r10_r5,
},
{
ARRAY_SIZE(kInstruction_shadd16_al_r7_r4_r6),
kInstruction_shadd16_al_r7_r4_r6,
},
{
ARRAY_SIZE(kInstruction_shadd16_vs_r12_r4_r10),
kInstruction_shadd16_vs_r12_r4_r10,
},
{
ARRAY_SIZE(kInstruction_shadd16_eq_r4_r4_r4),
kInstruction_shadd16_eq_r4_r4_r4,
},
{
ARRAY_SIZE(kInstruction_shadd16_vs_r6_r6_r12),
kInstruction_shadd16_vs_r6_r6_r12,
},
{
ARRAY_SIZE(kInstruction_shadd16_pl_r9_r3_r5),
kInstruction_shadd16_pl_r9_r3_r5,
},
{
ARRAY_SIZE(kInstruction_shadd16_eq_r6_r5_r13),
kInstruction_shadd16_eq_r6_r5_r13,
},
{
ARRAY_SIZE(kInstruction_shadd16_cc_r8_r2_r12),
kInstruction_shadd16_cc_r8_r2_r12,
},
{
ARRAY_SIZE(kInstruction_shadd16_le_r4_r2_r0),
kInstruction_shadd16_le_r4_r2_r0,
},
{
ARRAY_SIZE(kInstruction_shadd16_lt_r7_r9_r8),
kInstruction_shadd16_lt_r7_r9_r8,
},
{
ARRAY_SIZE(kInstruction_shadd16_le_r4_r7_r11),
kInstruction_shadd16_le_r4_r7_r11,
},
{
ARRAY_SIZE(kInstruction_shadd16_eq_r5_r7_r5),
kInstruction_shadd16_eq_r5_r7_r5,
},
{
ARRAY_SIZE(kInstruction_shadd16_vc_r10_r7_r12),
kInstruction_shadd16_vc_r10_r7_r12,
},
{
ARRAY_SIZE(kInstruction_shadd16_eq_r7_r10_r6),
kInstruction_shadd16_eq_r7_r10_r6,
},
{
ARRAY_SIZE(kInstruction_shadd16_pl_r1_r12_r2),
kInstruction_shadd16_pl_r1_r12_r2,
},
{
ARRAY_SIZE(kInstruction_shadd16_le_r14_r6_r6),
kInstruction_shadd16_le_r14_r6_r6,
},
{
ARRAY_SIZE(kInstruction_shadd16_ne_r3_r8_r8),
kInstruction_shadd16_ne_r3_r8_r8,
},
{
ARRAY_SIZE(kInstruction_shadd16_eq_r4_r12_r8),
kInstruction_shadd16_eq_r4_r12_r8,
},
{
ARRAY_SIZE(kInstruction_shadd16_ge_r11_r2_r3),
kInstruction_shadd16_ge_r11_r2_r3,
},
{
ARRAY_SIZE(kInstruction_shadd16_hi_r12_r6_r11),
kInstruction_shadd16_hi_r12_r6_r11,
},
{
ARRAY_SIZE(kInstruction_shadd16_cs_r4_r5_r10),
kInstruction_shadd16_cs_r4_r5_r10,
},
{
ARRAY_SIZE(kInstruction_shadd16_ge_r10_r2_r10),
kInstruction_shadd16_ge_r10_r2_r10,
},
{
ARRAY_SIZE(kInstruction_shadd16_ge_r5_r14_r6),
kInstruction_shadd16_ge_r5_r14_r6,
},
{
ARRAY_SIZE(kInstruction_shadd16_gt_r13_r7_r5),
kInstruction_shadd16_gt_r13_r7_r5,
},
{
ARRAY_SIZE(kInstruction_shadd16_ge_r13_r4_r12),
kInstruction_shadd16_ge_r13_r4_r12,
},
{
ARRAY_SIZE(kInstruction_shadd16_lt_r8_r10_r14),
kInstruction_shadd16_lt_r8_r10_r14,
},
{
ARRAY_SIZE(kInstruction_shadd16_le_r4_r3_r13),
kInstruction_shadd16_le_r4_r3_r13,
},
{
ARRAY_SIZE(kInstruction_shadd16_pl_r0_r9_r0),
kInstruction_shadd16_pl_r0_r9_r0,
},
{
ARRAY_SIZE(kInstruction_shadd16_eq_r2_r3_r1),
kInstruction_shadd16_eq_r2_r3_r1,
},
{
ARRAY_SIZE(kInstruction_shadd16_vc_r0_r0_r3),
kInstruction_shadd16_vc_r0_r0_r3,
},
{
ARRAY_SIZE(kInstruction_shadd16_mi_r10_r8_r11),
kInstruction_shadd16_mi_r10_r8_r11,
},
{
ARRAY_SIZE(kInstruction_shadd16_mi_r5_r14_r14),
kInstruction_shadd16_mi_r5_r14_r14,
},
{
ARRAY_SIZE(kInstruction_shadd16_gt_r5_r11_r2),
kInstruction_shadd16_gt_r5_r11_r2,
},
{
ARRAY_SIZE(kInstruction_shadd16_al_r4_r7_r11),
kInstruction_shadd16_al_r4_r7_r11,
},
};
#endif // VIXL_ASSEMBLER_COND_RD_RN_RM_SHADD16_A32_H_
| 34,359 |
1,350 | // Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
// Code generated by Microsoft (R) AutoRest Code Generator.
package com.azure.resourcemanager.timeseriesinsights.models;
import com.azure.core.util.Context;
import com.azure.resourcemanager.timeseriesinsights.fluent.models.AccessPolicyResourceInner;
import java.util.List;
/** An immutable client-side representation of AccessPolicyResource. */
public interface AccessPolicyResource {
/**
* Gets the id property: Fully qualified resource Id for the resource.
*
* @return the id value.
*/
String id();
/**
* Gets the name property: The name of the resource.
*
* @return the name value.
*/
String name();
/**
* Gets the type property: The type of the resource.
*
* @return the type value.
*/
String type();
/**
* Gets the principalObjectId property: The objectId of the principal in Azure Active Directory.
*
* @return the principalObjectId value.
*/
String principalObjectId();
/**
* Gets the description property: An description of the access policy.
*
* @return the description value.
*/
String description();
/**
* Gets the roles property: The list of roles the principal is assigned on the environment.
*
* @return the roles value.
*/
List<AccessPolicyRole> roles();
/**
* Gets the inner com.azure.resourcemanager.timeseriesinsights.fluent.models.AccessPolicyResourceInner object.
*
* @return the inner object.
*/
AccessPolicyResourceInner innerModel();
/** The entirety of the AccessPolicyResource definition. */
interface Definition
extends DefinitionStages.Blank, DefinitionStages.WithParentResource, DefinitionStages.WithCreate {
}
/** The AccessPolicyResource definition stages. */
interface DefinitionStages {
/** The first stage of the AccessPolicyResource definition. */
interface Blank extends WithParentResource {
}
/** The stage of the AccessPolicyResource definition allowing to specify parent resource. */
interface WithParentResource {
/**
* Specifies resourceGroupName, environmentName.
*
* @param resourceGroupName Name of an Azure Resource group.
* @param environmentName The name of the Time Series Insights environment associated with the specified
* resource group.
* @return the next definition stage.
*/
WithCreate withExistingEnvironment(String resourceGroupName, String environmentName);
}
/**
* The stage of the AccessPolicyResource definition which contains all the minimum required properties for the
* resource to be created, but also allows for any other optional properties to be specified.
*/
interface WithCreate
extends DefinitionStages.WithPrincipalObjectId,
DefinitionStages.WithDescription,
DefinitionStages.WithRoles {
/**
* Executes the create request.
*
* @return the created resource.
*/
AccessPolicyResource create();
/**
* Executes the create request.
*
* @param context The context to associate with this operation.
* @return the created resource.
*/
AccessPolicyResource create(Context context);
}
/** The stage of the AccessPolicyResource definition allowing to specify principalObjectId. */
interface WithPrincipalObjectId {
/**
* Specifies the principalObjectId property: The objectId of the principal in Azure Active Directory..
*
* @param principalObjectId The objectId of the principal in Azure Active Directory.
* @return the next definition stage.
*/
WithCreate withPrincipalObjectId(String principalObjectId);
}
/** The stage of the AccessPolicyResource definition allowing to specify description. */
interface WithDescription {
/**
* Specifies the description property: An description of the access policy..
*
* @param description An description of the access policy.
* @return the next definition stage.
*/
WithCreate withDescription(String description);
}
/** The stage of the AccessPolicyResource definition allowing to specify roles. */
interface WithRoles {
/**
* Specifies the roles property: The list of roles the principal is assigned on the environment..
*
* @param roles The list of roles the principal is assigned on the environment.
* @return the next definition stage.
*/
WithCreate withRoles(List<AccessPolicyRole> roles);
}
}
/**
* Begins update for the AccessPolicyResource resource.
*
* @return the stage of resource update.
*/
AccessPolicyResource.Update update();
/** The template for AccessPolicyResource update. */
interface Update extends UpdateStages.WithDescription, UpdateStages.WithRoles {
/**
* Executes the update request.
*
* @return the updated resource.
*/
AccessPolicyResource apply();
/**
* Executes the update request.
*
* @param context The context to associate with this operation.
* @return the updated resource.
*/
AccessPolicyResource apply(Context context);
}
/** The AccessPolicyResource update stages. */
interface UpdateStages {
/** The stage of the AccessPolicyResource update allowing to specify description. */
interface WithDescription {
/**
* Specifies the description property: An description of the access policy..
*
* @param description An description of the access policy.
* @return the next definition stage.
*/
Update withDescription(String description);
}
/** The stage of the AccessPolicyResource update allowing to specify roles. */
interface WithRoles {
/**
* Specifies the roles property: The list of roles the principal is assigned on the environment..
*
* @param roles The list of roles the principal is assigned on the environment.
* @return the next definition stage.
*/
Update withRoles(List<AccessPolicyRole> roles);
}
}
/**
* Refreshes the resource to sync with Azure.
*
* @return the refreshed resource.
*/
AccessPolicyResource refresh();
/**
* Refreshes the resource to sync with Azure.
*
* @param context The context to associate with this operation.
* @return the refreshed resource.
*/
AccessPolicyResource refresh(Context context);
}
| 2,659 |
368 | /*
Plugin-SDK (Grand Theft Auto San Andreas) source file
Authors: GTA Community. See more here
https://github.com/DK22Pac/plugin-sdk
Do not delete this comment block. Respect others' work!
*/
#include "CMatrixLink.h"
PLUGIN_SOURCE_FILE
int ctor_addr(CMatrixLink) = ADDRESS_BY_VERSION(0x54F0C0, 0, 0, 0, 0, 0);
int ctor_gaddr(CMatrixLink) = GLOBAL_ADDRESS_BY_VERSION(0x54F0C0, 0, 0, 0, 0, 0);
int dtor_addr(CMatrixLink) = ADDRESS_BY_VERSION(0x54E8E0, 0, 0, 0, 0, 0);
int dtor_gaddr(CMatrixLink) = GLOBAL_ADDRESS_BY_VERSION(0x54E8E0, 0, 0, 0, 0, 0);
int addrof(CMatrixLink::Insert) = ADDRESS_BY_VERSION(0x54E8F0, 0, 0, 0, 0, 0);
int gaddrof(CMatrixLink::Insert) = GLOBAL_ADDRESS_BY_VERSION(0x54E8F0, 0, 0, 0, 0, 0);
void CMatrixLink::Insert(CMatrixLink *where) {
plugin::CallMethodDynGlobal<CMatrixLink *, CMatrixLink *>(gaddrof(CMatrixLink::Insert), this, where);
}
int addrof(CMatrixLink::Remove) = ADDRESS_BY_VERSION(0x54E910, 0, 0, 0, 0, 0);
int gaddrof(CMatrixLink::Remove) = GLOBAL_ADDRESS_BY_VERSION(0x54E910, 0, 0, 0, 0, 0);
void CMatrixLink::Remove() {
plugin::CallMethodDynGlobal<CMatrixLink *>(gaddrof(CMatrixLink::Remove), this);
}
| 514 |
2,206 | /*
*
* Copyright (c) 2006-2020, Speedment, Inc. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License"); You may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
package com.speedment.common.codegen.internal.model;
import com.speedment.common.codegen.model.*;
import org.junit.jupiter.api.Test;
import java.lang.reflect.Type;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.Optional;
import static org.junit.jupiter.api.Assertions.*;
final class LicenseTermImplTest extends AbstractTest<LicenseTerm> {
private final static String TEXT = "A";
public LicenseTermImplTest() {
super(LicenseTermImpl::new,
a -> a.setParent(File.of("C")),
a -> a.setText(TEXT)
);
}
@Test
void constructor() {
final LicenseTerm licenseTerm = new LicenseTermImpl(TEXT);
assertEquals(TEXT, licenseTerm.getText());
}
@Test
void setParent() {
final File file = File.of("V");
instance().setParent(file);
assertEquals(file, instance().getParent().orElseThrow(NoSuchElementException::new));
}
@Test
void getParent() {
assertEquals(Optional.empty(), instance().getParent());
}
@Test
void getText() {
assertEquals("", instance().getText());
}
@Test
void setText() {
final String text = "V";
instance().setText(text);
assertEquals(text, instance().getText());
}
} | 684 |
2,753 | /*
* This software is distributed under BSD 3-clause license (see LICENSE file).
*
* Authors: <NAME>
*
*/
#include <shogun/lib/config.h>
#ifdef HAVE_TFLOGGER
#include <shogun/io/TBOutputFormat.h>
#include <shogun/lib/observers/ObservedValueTemplated.h>
#include <shogun/lib/observers/ParameterObserverHistogram.h>
using namespace shogun;
ParameterObserverHistogram::ParameterObserverHistogram()
: ParameterObserverTensorBoard()
{
}
ParameterObserverHistogram::ParameterObserverHistogram(
std::vector<std::string>& parameters,
std::vector<ParameterProperties>& properties)
: ParameterObserverTensorBoard(parameters, properties)
{
}
ParameterObserverHistogram::ParameterObserverHistogram(
const std::string& filename, std::vector<std::string>& parameters,
std::vector<ParameterProperties>& properties)
: ParameterObserverTensorBoard(filename, parameters, properties)
{
}
ParameterObserverHistogram::~ParameterObserverHistogram()
{
}
void ParameterObserverHistogram::on_next_impl(const TimedObservedValue& value)
{
auto node_name = std::string("node");
auto format = TBOutputFormat();
auto event_value = format.convert_vector(value, node_name);
m_writer.writeEvent(event_value);
}
void ParameterObserverHistogram::on_error(std::exception_ptr)
{
}
void ParameterObserverHistogram::on_complete()
{
}
ParameterObserverHistogram::ParameterObserverHistogram(
std::vector<std::string>& parameters)
: ParameterObserverTensorBoard(parameters)
{
}
ParameterObserverHistogram::ParameterObserverHistogram(
std::vector<ParameterProperties>& properties)
: ParameterObserverTensorBoard(properties)
{
}
#endif // HAVE_TFLOGGER
| 549 |
1,178 | /*
* Copyright 2020 Makani Technologies LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef LIB_PCAP_READER_UDP_READER_H_
#define LIB_PCAP_READER_UDP_READER_H_
#include <netinet/udp.h>
#include <stdint.h>
#include "lib/pcap_reader/ip_reader.h"
namespace lib {
namespace pcap_reader {
// Enum to interpret reason for processing failure.
enum class UdpStatus {
kBadIpProtocol,
kBadUdpHeader,
kValid,
};
// Class to read and validate UDP network packets.
class UdpReader {
public:
UdpReader(void);
~UdpReader(void) {}
// Reset stored state. Call this function before parsing unrelated files to
// clear the internal state.
void Reset(void);
UdpStatus HandleUdpPacket(int32_t packet_len, const uint8_t *packet);
UdpStatus HandleIpPacket(const IpReader &reader);
// UDP header accessor functions.
const struct udphdr &GetUdpHeader(void) const { return udp_header_; }
uint16_t GetDestination(void) const { return ntohs(udp_header_.dest); }
// UDP payload accessor functions.
int32_t GetPayloadLength(void) const { return payload_len_; }
const uint8_t *GetPayload(void) const {
return payload_len_ < 0 ? nullptr : payload_;
}
private:
UdpStatus Failure(UdpStatus status);
int32_t HandleUdpHeader(int32_t packet_len, const uint8_t *packet,
struct udphdr *header, const uint8_t **payload) const;
struct udphdr udp_header_;
int32_t payload_len_;
const uint8_t *payload_;
DISALLOW_COPY_AND_ASSIGN(UdpReader);
};
} // namespace pcap_reader
} // namespace lib
#endif // LIB_PCAP_READER_UDP_READER_H_
| 722 |
348 | <reponame>chamberone/Leaflet.PixiOverlay
{"nom":"Barret","circ":"2ème circonscription","dpt":"Charente","inscrits":790,"abs":424,"votants":366,"blancs":30,"nuls":13,"exp":323,"res":[{"nuance":"REM","nom":"<NAME>","voix":176},{"nuance":"LR","nom":"<NAME>","voix":147}]} | 107 |
678 | <filename>iOSOpenDev/frameworks/OpenCL.framework/ImageFormats/Headers/sint32_rgba.h<gh_stars>100-1000
/**
* This header is generated by class-dump-z 0.2b.
*
* Source: /System/Library/PrivateFrameworks/OpenCL.framework/ImageFormats/sint32_rgba.dylib
*/
#import <OpenCL/sint32_rgba-Structs.h>
| 111 |
1,056 | <gh_stars>1000+
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.netbeans.spi.java.hints;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Allows to further refine {@link TriggerTreeKind} and {@link TriggerPattern} with some
* options. The annotation is only processed for methods annotated with {@link TriggerTreeKind}, {@link TriggerPattern}
* and {@link TriggerPatterns} and applies to the method invocation - applies to all method triggers.
*
* @since 1.26
* @author sdedic
*/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface TriggerOptions {
/**
* Causes the trigger even on code which is locked for the user. Specifically
* will trigger the hint on guarded block code, which the user can not modify.
* However some supplemental information can be collected this way by the hint.
* <p/>
* Hint do not act on guarded blocks by default.
*/
public static final String PROCESS_GUARDED = "processGuarded"; // NOI18N
/**
* Options set for the trigger. See {@link TriggerOptions} constants.
* @return options tags.
*/
public String[] value();
}
| 571 |
1,564 | <reponame>kamilors/modelmapper
package org.modelmapper.bugs;
import static org.testng.Assert.assertEquals;
import java.lang.reflect.Type;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import org.modelmapper.AbstractTest;
import org.modelmapper.TypeToken;
import org.testng.annotations.Test;
@Test
public class GH547 extends AbstractTest {
public void shouldMap() {
Map<Integer, List<Product>> source = Collections.singletonMap(
1, Collections.singletonList(new Product()));
Type destType = new TypeToken<Map<Integer, List<ProductVo>>>(){}.getType();
Map<Integer, List<ProductVo>> result = modelMapper.map(source, destType);
assertEquals(result.get(1).get(0).getClass(), ProductVo.class);
assertEquals(result.get(1).get(0).id, 10);
}
private static class Product {
long id = 10;
}
private static class ProductVo {
long id;
}
}
| 315 |
317 | <gh_stars>100-1000
/*
$Id$
*/
#include <math.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "typesf2c.h"
#include "get_word.h"
extern double tetercc();
extern double cpi_Splint();
extern void cpi_Spline();
#if defined(CRAY) || defined(CRAY_T3D)
#include <fortran.h>
#if !defined(__crayx1)
#define USE_FCD
#endif
#endif
#if (defined(CRAY) || defined(WIN32)) && !defined(__crayx1) &&!defined(__MINGW32__)
#define teter_parse_ TETER_PARSE
#endif
void FATR teter_parse_
#if defined(USE_FCD)
(Integer *debug_ptr,
Integer *lmax_ptr,
Integer *locp_ptr,
double *rlocal_ptr,
const _fcd fcd_sdir_name,
Integer *n9,
const _fcd fcd_dir_name,
Integer *n0,
const _fcd fcd_in_filename,
Integer *n1,
const _fcd fcd_out_filename,
Integer *n2,
const _fcd fcd_atom,
Integer *n3)
{
char *sdir_name = _fcdtocp(fcd_sdir_name);
char *dir_name = _fcdtocp(fcd_dir_name);
char *in_filename = _fcdtocp(fcd_in_filename);
char *out_filename = _fcdtocp(fcd_out_filename);
char *atom = _fcdtocp(fcd_atom);
#else
(debug_ptr,lmax_ptr,locp_ptr,rlocal_ptr,
sdir_name,n9,dir_name,n0,in_filename,n1,out_filename,n2,atom,n3)
Integer *debug_ptr;
Integer *lmax_ptr;
Integer *locp_ptr;
double *rlocal_ptr;
char sdir_name[];
Integer *n9;
char dir_name[];
Integer *n0;
char in_filename[];
Integer *n1;
char out_filename[];
Integer *n2;
char atom[];
Integer *n3;
{
#endif
int debug;
int lmax_out,locp_out;
double rlocal_out;
double zatom,zion; /* local psp parameters */
double over_fourpi;
int *nl;
int i,k,l,p,p1;
int Ngrid,nrl;
double *rgrid,*psi,*psp;
double *rl, *tmp, *tmp2, *sc_rho, *sc_rhol, *sc_drho, *sc_drhol,
**psil,
**pspl;
double drl,rmax;
int lmax,locp,lmaxp;
double r0,xx;
int n[10];
int pspdat,pspcode,pspxc;
double r2well,rcore[10],e99,e999;
double rchrg,fchrg,qchrg,pi;
char *w,*tc;
FILE *fp;
char comment[255];
int argc;
int m9 = ((int) (*n9));
int m0 = ((int) (*n0));
int m1 = ((int) (*n1));
int m2 = ((int) (*n2));
int m3 = ((int) (*n3));
char *infile = (char *) malloc(m9+m1+5);
char *outfile = (char *) malloc(m0+m2+5);
char *atom_out = (char *) malloc(m3+5);
char *full_filename = (char *) malloc(m9+25+5);
debug = *debug_ptr;
lmax_out = *lmax_ptr;
locp_out = *locp_ptr;
rlocal_out = *rlocal_ptr;
(void) strncpy(infile, sdir_name, m9);
infile[m9] = '\0';
strcat(infile,"/");
infile[m9+1] = '\0';
strncat(infile,in_filename,m1);
infile[m9+m1+1] = '\0';
(void) strncpy(outfile, dir_name, m0);
outfile[m0] = '\0';
(void) strcat(outfile,"/");
outfile[m0+1] = '\0';
(void) strncat(outfile,out_filename,m2);
outfile[m0+m2+1] = '\0';
(void) strncpy(atom_out, atom, m3);
atom_out[m3] = '\0';
pi = 4.0*atan(1.0);
over_fourpi = 1.0/(4.0*pi);
/* define linear grid */
nrl = 2001;
rmax = 40.0;
drl = rmax/((double) (nrl-1));
fp = fopen(infile,"r+");
w = get_word(fp);
while ((w != ((char *) EOF)) && (strcmp("<linear>",w) != 0))
w = get_word(fp);
if (w!=((char *) EOF))
{
fscanf(fp,"%d %lf",&nrl,&drl);
rmax = ((double) (nrl-1))*drl;
}
fclose(fp);
/* Read TETER psp */
fp = fopen(infile,"r+");
w = get_word(fp);
while ((w!=NIL) && (strcmp("<TETER>",w)!=0))
w = get_word(fp);
/* Error occured */
if (w==NIL)
{
printf("Error: <TETER> section not found\n");
fclose(fp);
exit(99);
}
argc = to_eoln(fp);
argc= get_line(fp,comment,255);
fscanf(fp,"%lf %lf %d",&zatom,&zion,&pspdat);
argc=to_eoln(fp);
fscanf(fp,"%d %d %d %d %d %lf",&pspcode,&pspxc,&lmax,&locp,&Ngrid,&r2well);
lmaxp = lmax+1;
argc=to_eoln(fp);
for (p=0; p<=lmax; ++p)
{
fscanf(fp,"%d %lf %lf %d %lf",&l,&e99,&e999,&(n[p]),&(rcore[p]));
to_eoln(fp);
to_eoln(fp);
}
fscanf(fp,"%lf %lf %lf",&rchrg,&fchrg,&qchrg);
psi = (double *) malloc(Ngrid*sizeof(double));
psp = (double *) malloc(Ngrid*sizeof(double));
rgrid = (double *) malloc(Ngrid*sizeof(double));
tmp = (double *) malloc(Ngrid*sizeof(double));
tmp2 = (double *) malloc(Ngrid*sizeof(double));
sc_rho = (double *) malloc(Ngrid*sizeof(double));
sc_drho = (double *) malloc(Ngrid*sizeof(double));
/* define Teter grid */
for (i=0; i<Ngrid; ++i)
{
xx = ((double) i);
xx=xx/((double) (Ngrid-1));
xx = (xx+0.01);
xx = xx*xx*xx*xx*xx;
rgrid[i]=100.0*xx-1.0e-8;
}
/* check linear grid and redefine if necessary */
if (rmax > rgrid[Ngrid-5])
{
rmax = rgrid[Ngrid-5];
drl = rmax/((double) (nrl-1));
}
/* generate linear meshes */
rl = (double *) malloc(nrl*sizeof(double));
nl = (int *) malloc(nrl*sizeof(int));
psil = (double **) malloc(lmaxp*sizeof(double*));
pspl = (double **) malloc(lmaxp*sizeof(double*));
sc_rhol = (double *) malloc(nrl*sizeof(double));
sc_drhol = (double *) malloc(nrl*sizeof(double));
r0 = rgrid[280];
rl[0] = rgrid[280];
for (i=1; i<nrl; ++i)
{
rl[i] = drl*((double) i);
xx = (rl[i] + 1.0e-8)/100.0;
xx = pow(xx,0.2);
xx = xx-0.01;
xx = (Ngrid-1)*xx;
nl[i] = rint(xx-0.5);
}
/* read in pseudopotentials */
for (p=0; p<=lmax; ++p)
{
pspl[p] = (double *) malloc(nrl*sizeof(double));
to_eoln(fp);
to_eoln(fp);
for (i=0; i<Ngrid; ++i) fscanf(fp,"%lf",&(psp[i]));
cpi_Spline(rgrid,psp,Ngrid-4,0.0,0.0,tmp,tmp2);
pspl[p][0] = psp[280];
for (i=1; i<nrl; ++i)
{
pspl[p][i] = cpi_Splint(rgrid,psp,tmp,Ngrid-4,nl[i],rl[i]);
}
}
/* read in wavefunctions */
for (p=0; p<=lmax; ++p)
{
psil[p] = (double *) malloc(nrl*sizeof(double));
to_eoln(fp);
to_eoln(fp);
for (i=0; i<Ngrid; ++i) fscanf(fp,"%lf",&(psi[i]));
cpi_Spline(rgrid,psi,Ngrid-4,0.0,0.0,tmp,tmp2);
psil[p][0] = psi[280];
for (i=1; i<nrl; ++i)
{
psil[p][i] = cpi_Splint(rgrid,psi,tmp,Ngrid-4,nl[i],rl[i]);
}
}
/* define semicore */
if (rchrg>0.0)
{
for (i=0; i<Ngrid; ++i)
{
/*
xx = rgrid[i]/(rchrg);
gg=sin(2.0*pi*xx)/( (2.0*pi*xx)*(1.0-4.0*xx*xx)*(1.0-xx*xx) );
gg=gg*gg;
*/
xx = rgrid[i]/(rchrg);
sc_rho[i] = 4*pi*fchrg*tetercc(xx);
}
cpi_Spline(rgrid,sc_rho,Ngrid-4,0.0,0.0,tmp,tmp2);
sc_rhol[0] = sc_rho[280];
for (i=1; i<nrl; ++i)
{
sc_rhol[i] = cpi_Splint(rgrid,sc_rho,tmp,Ngrid-4,nl[i],rl[i]);
}
/* define to be zero for now since it is not used */
for (i=1; i<nrl; ++i)
{
sc_drhol[i] = 0.0;
}
}
fclose(fp);
free(tmp2);
free(tmp);
free(rgrid);
free(psp);
free(psi);
free(sc_rho);
free(sc_drho);
free(nl);
/* find the comment */
fp = fopen(infile,"r+");
w = get_word(fp);
while ((w!=NIL) && (strcmp("<comment>",w)!=0))
w = get_word(fp);
if (w!=NIL)
{
w = get_word(fp);
p = 0;
tc = comment;
while ((w!=NIL)&&(strcmp("<end>",w) != 0))
{
p = (strlen(w));
strcpy(tc, w);
for (p1=0;p1<p; ++p1) ++tc;
strcpy(tc, " ");
++tc;
w = get_word(fp);
}
}
fclose(fp);
/* write outfile */
fp = fopen(outfile,"w+");
fprintf(fp,"%s\n",atom_out);
if (locp_out!=-1) locp=locp_out;
fprintf(fp,"%lf %lf %d %d %d %lf\n",zion,0.0,lmax,lmax_out,locp,rlocal_out);
for (p=0; p<=lmax; ++p)
fprintf(fp,"%lf ", rcore[p]);
fprintf(fp,"\n");
fprintf(fp,"%d %lf\n",nrl,drl);
fprintf(fp,"%s",comment);
/* appending pseudopotentials */
for (k=0; k<nrl; ++k)
{
fprintf(fp,"%14.9lf", rl[k]);
for (p=0; p<=lmax; ++p)
fprintf(fp," %12.8lf", pspl[p][k]);
fprintf(fp,"\n");
}
for (p=0; p<=lmax; ++p) free(pspl[p]);
free(pspl);
/* appending pseudowavefunctions */
for (k=0; k<nrl; ++k)
{
fprintf(fp,"%14.9lf", rl[k]);
for (p=0; p<=lmax; ++p)
fprintf(fp," %12.8lf", psil[p][k]);
fprintf(fp,"\n");
}
for (p=0; p<=lmax; ++p) free(psil[p]);
free(psil);
/* append semicore corrections */
if (rchrg != 0.0)
{
fprintf(fp,"%lf\n",rchrg);
for (k=0; k<nrl; ++k)
fprintf(fp,"%14.9lf %12.8lf\n", rl[k],
fabs(sc_rhol[k]*over_fourpi));
for (k=0; k<nrl; ++k)
fprintf(fp,"%14.9lf %12.8lf\n", rl[k],
(sc_drhol[k]*over_fourpi));
}
free(sc_rhol);
free(sc_drhol);
free(rl);
fclose(fp);
if (debug)
{
printf("TETER pseudopotential Parameters\n\n");
printf("atom : %s\n",atom_out);
printf("Zatom= %lf\n",zatom);
printf("Zion = %lf\n",zion);
printf(" lmax= %d\n",lmax);
printf(" locp= %d\n",locp);
printf(" rlocal= %lf\n\n",rlocal_out);
printf(" rcrhg=%lf fchrg=%lf qchrg=%lf\n",rchrg,fchrg,qchrg);
printf("rcore: ");
for (p=0; p<=lmax; ++p)
printf("%lf ", rcore[p]);
printf("\n");
printf(" nrl=%d drl=%lf\n",nrl,drl);
printf("comment:%s\n",comment);
fflush(stdout);
}
/* free malloc memory */
free(infile);
free(outfile);
free(full_filename);
free(atom_out);
return;
} /* main */
double tetercc(double xx)
{
/*The c s are coefficients for Taylor expansion of the analytic form near xx=0, 1/2, and 1. */
double c21,c22,c23,c24;
double c31,c32,c33,c34;
/*local variables */
double pi,gg1cc,yy;
pi = 4.0*atan(1.0);
c21= 4.00/9.00;
c22= -40.00/27.00;
c23= 20.00/3.00-16.00*pi*pi/27.00;
c24= -4160.00/243.00+160.00*pi*pi/81.00;
c31= 1.00/36.00;
c32= -25.00/108.00;
c33= 485.00/432.00-pi*pi/27.00;
c34=-4055.00/972.00+25.00*pi*pi/81.00;
/* Cut off beyond 3/gcut=xcccrc */
if (xx>3.000)
gg1cc=0.000;
/* Take care of difficult limits near x=0, 1/2, and 1 */
else if (fabs(xx)<=1.e-9)
gg1cc=1.00;
else if (fabs(xx-0.500)<=1.0e-4)
gg1cc=c21+(xx-0.500)*(c22+(xx-0.500)*(c23+(xx-0.500)*c24));
else if (fabs(xx-1.00)<=1.e-04)
gg1cc=c31+(xx-1.000)*(c32+(xx-1.000)*(c33+(xx-1.000)*c34));
else
{
yy=sin(2.0*pi*xx)/( (2.0*pi*xx)*(1.0-4.0*xx*xx)*(1.0-xx*xx) );
gg1cc=yy*yy;
}
return gg1cc;
}
| 6,338 |
319 | <reponame>Celebrate-future/openimaj
/**
* Copyright (c) 2011, The University of Southampton and the individual contributors.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* * Neither the name of the University of Southampton nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package org.openimaj.image.feature.global;
import gnu.trove.map.hash.TObjectFloatHashMap;
import gnu.trove.procedure.TObjectFloatProcedure;
import org.openimaj.citation.annotation.Reference;
import org.openimaj.citation.annotation.ReferenceType;
import org.openimaj.feature.DoubleFV;
import org.openimaj.feature.FeatureVectorProvider;
import org.openimaj.image.MBFImage;
import org.openimaj.image.analyser.ImageAnalyser;
import org.openimaj.image.pixel.ConnectedComponent;
import org.openimaj.image.pixel.PixelSet;
import org.openimaj.image.saliency.AchantaSaliency;
import org.openimaj.image.saliency.YehSaliency;
import org.openimaj.image.segmentation.FelzenszwalbHuttenlocherSegmenter;
import org.openimaj.math.geometry.point.Point2dImpl;
/**
* Implementation of the rule-of-thirds algorithm described by Yeh et al.
* <p>
* I've assumed that the distances to the power-points should be normalized with
* respect to the image size - this isn't explicit in the paper, but given that
* the sigma of the gaussian is fixed, it seems likely...
*
* @author <NAME> (<EMAIL>)
*/
@Reference(
type = ReferenceType.Inproceedings,
author = { "<NAME>", "<NAME>", "<NAME>", "<NAME>" },
title = "Personalized Photograph Ranking and Selection System",
year = "2010",
booktitle = "Proceedings of ACM Multimedia",
pages = { "211", "220" },
month = "October",
customData = { "location", "Florence, Italy" })
public class RuleOfThirds implements ImageAnalyser<MBFImage>, FeatureVectorProvider<DoubleFV> {
private static final double SIGMA = 0.17;
private static final Point2dImpl[] powerPoints = getPowerPoints();
YehSaliency saliencyGenerator;
private double asSum;
private double aseSum;
/**
* Construct a new {@link RuleOfThirds} with the default settings for the
* {@link YehSaliency} algorithm.
*/
public RuleOfThirds() {
saliencyGenerator = new YehSaliency();
}
/**
* Construct a new {@link RuleOfThirds} with the given values for the
* {@link YehSaliency} algorithm.
*
* @param saliencySigma
* smoothing for the {@link AchantaSaliency} class
* @param segmenterSigma
* smoothing for {@link FelzenszwalbHuttenlocherSegmenter}.
* @param k
* k value for {@link FelzenszwalbHuttenlocherSegmenter}.
* @param minSize
* minimum region size for
* {@link FelzenszwalbHuttenlocherSegmenter}.
*/
public RuleOfThirds(float saliencySigma, float segmenterSigma, float k, int minSize) {
saliencyGenerator = new YehSaliency(saliencySigma, segmenterSigma, k, minSize);
}
@Override
public DoubleFV getFeatureVector() {
if (asSum == 0)
new DoubleFV(new double[] { 0 });
return new DoubleFV(new double[] { aseSum / asSum });
}
/*
* (non-Javadoc)
*
* @see
* org.openimaj.image.processor.ImageProcessor#processImage(org.openimaj
* .image.Image)
*/
@Override
public void analyseImage(MBFImage image) {
final int width = image.getWidth();
final int height = image.getHeight();
image.analyseWith(saliencyGenerator);
final TObjectFloatHashMap<ConnectedComponent> componentMap = saliencyGenerator.getSaliencyComponents();
asSum = 0;
aseSum = 0;
componentMap.forEachEntry(new TObjectFloatProcedure<ConnectedComponent>() {
@Override
public boolean execute(ConnectedComponent c, float s) {
final double as = c.calculateArea() * s;
final double D = closestDistance(c, width, height);
asSum += as;
aseSum += as * Math.exp(-(D * D) / (2 * SIGMA));
return true;
}
});
}
private double closestDistance(PixelSet cc, int width, int height) {
final double centroid[] = cc.calculateCentroid();
double minDistance = Double.MAX_VALUE;
for (final Point2dImpl pt : powerPoints) {
final double dx = (centroid[0] / width) - pt.x;
final double dy = (centroid[1] / width) - pt.y;
final double d = dx * dx + dy * dy;
if (d < minDistance)
minDistance = d;
}
return Math.sqrt(minDistance);
}
private static Point2dImpl[] getPowerPoints() {
return new Point2dImpl[] {
new Point2dImpl(1 / 3f, 1 / 3f),
new Point2dImpl(2 / 3f, 1 / 3f),
new Point2dImpl(1 / 3f, 2 / 3f),
new Point2dImpl(2 / 3f, 2 / 3f) };
}
}
| 1,998 |
324 | /*
* Copyright 2016-2018-2020 chronicle.software
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.openhft.chronicle.bytes;
import net.openhft.chronicle.bytes.internal.BytesInternal;
import net.openhft.chronicle.core.io.IORuntimeException;
import org.jetbrains.annotations.NotNull;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import java.io.IOException;
import java.nio.BufferUnderflowException;
import java.nio.ByteBuffer;
import java.util.Arrays;
import java.util.Collection;
import static org.junit.Assert.*;
@SuppressWarnings({"rawtypes"})
@RunWith(Parameterized.class)
public class BytesInternalGuardedTest extends BytesTestCommon {
private final boolean guarded;
public BytesInternalGuardedTest(String name, boolean guarded) {
this.guarded = guarded;
}
@Parameterized.Parameters(name = "{0}")
public static Collection<Object[]> data() {
return Arrays.asList(new Object[][]{
{"Unguarded", false},
{"Guarded", true}
});
}
/*
@BeforeClass
public static void notMacArm() {
assumeFalse(Jvm.isMacArm());
}
*/
@AfterClass
public static void resetGuarded() {
NativeBytes.resetNewGuarded();
}
@Before
public void setGuarded() {
NativeBytes.setNewGuarded(guarded);
}
@Test
public void testParse8bitAndStringBuilderWithUtf16Coder()
throws BufferUnderflowException, IOException {
@NotNull BytesStore bs = BytesStore.nativeStore(32);
bs.write(0, new byte[]{0x76, 0x61, 0x6c, 0x75, 0x65}); // "value" string
StringBuilder sb = new StringBuilder();
sb.append("你好");
BytesInternal.parse8bit(0, bs, sb, 5);
String actual = sb.toString();
assertEquals("value", actual);
assertEquals(5, actual.length());
bs.releaseLast();
}
@Test
public void testCompareUTF()
throws IORuntimeException {
@NotNull BytesStore bs = BytesStore.nativeStore(32);
bs.writeUtf8(0, "test");
assertTrue(BytesInternal.compareUtf8(bs, 0, "test"));
assertFalse(BytesInternal.compareUtf8(bs, 0, null));
bs.writeUtf8(0, null);
assertTrue(BytesInternal.compareUtf8(bs, 0, null));
assertFalse(BytesInternal.compareUtf8(bs, 0, "test"));
bs.writeUtf8(1, "£€");
@NotNull StringBuilder sb = new StringBuilder();
bs.readUtf8(1, sb);
assertEquals("£€", sb.toString());
assertTrue(BytesInternal.compareUtf8(bs, 1, "£€"));
assertFalse(BytesInternal.compareUtf8(bs, 1, "£"));
assertFalse(BytesInternal.compareUtf8(bs, 1, "£€$"));
bs.releaseLast();
}
@Test
public void shouldHandleDifferentSizedStores() {
Bytes<ByteBuffer> bytes = Bytes.elasticHeapByteBuffer(32);
final BytesStore storeOfThirtyTwoBytes = bytes.bytesStore();
storeOfThirtyTwoBytes.writeUtf8(0, "thirty_two_bytes_of_utf8_chars_");
Bytes<ByteBuffer> bytes2 = Bytes.elasticHeapByteBuffer(512);
final BytesStore longerBuffer = bytes2.bytesStore();
longerBuffer.writeUtf8(0, "thirty_two_bytes_of_utf8_chars_");
assertTrue(BytesInternal.equalBytesAny(storeOfThirtyTwoBytes, longerBuffer, 32));
bytes2.releaseLast();
bytes.releaseLast();
}
@Test
public void testWritingDecimalVsJava() {
Bytes bytes = Bytes.allocateElasticOnHeap(32);
bytes.clear();
double d = 0.04595828484241039; //Math.pow(1e9, rand.nextDouble()) / 1e3;
bytes.append(d);
String s = Double.toString(d);
if (s.length() != bytes.readRemaining()) {
assertEquals(d, Double.parseDouble(s), 0.0);
String s2 = bytes.toString();
// System.out.println(s + " != " + s2);
}
bytes.releaseLast();
}
@Test
public void contentsEqual() {
Bytes<?> a = Bytes.elasticByteBuffer(9, 20)
.append(Bytes.from("Hello"))
.readLimit(16);
Bytes b = Bytes.elasticByteBuffer(5, 20)
.append(Bytes.from("Hello"))
.readLimit(16);
Bytes c = Bytes.elasticByteBuffer(15, 20)
.append(Bytes.from("Hello"))
.readLimit(16);
String actual1 = a.toString();
assertEquals("Hello\0\0\0\0", actual1);
String actual2 = b.toString();
assertEquals("Hello", actual2);
String actual3 = c.toString();
assertEquals("Hello\0\0\0\0\0\0\0\0\0\0", actual3);
assertEquals(a, b);
assertEquals(b, c);
assertEquals(c, a);
a.releaseLast();
b.releaseLast();
c.releaseLast();
}
@Test
public void testStopBits() {
final VanillaBytes<Void> bytes = Bytes.allocateDirect(10);
for (int i = 0; i < (1L << (2 * 7)) + 1; i++) {
bytes.writePosition(0);
bytes.clearAndPad(10);
bytes.writePosition(0);
BytesInternal.writeStopBit(bytes, i);
bytes.readPosition(0);
final long l = BytesInternal.readStopBit(bytes);
// System.out.printf("0x%04x : %02x %02x %02x%n", i, bytes.readByte(0), bytes.readByte(1), bytes.readByte(3));
assertEquals(i, l);
}
bytes.releaseLast();
}
}
| 2,596 |
312 | <reponame>FMX/alchemy<gh_stars>100-1000
/**
* JPA domain objects.
*/
package com.dfire.platform.alchemy.domain;
| 44 |
5,272 | //
// BSJTopicViewController.h
// PLMMPRJK
//
// Created by HuXuPeng on 2017/5/14.
// Copyright © 2017年 GoMePrjk. All rights reserved.
//
#import "LMJRefreshTableViewController.h"
#import "BSJ.h"
@interface BSJTopicViewController : LMJRefreshTableViewController
/** <#digest#> */
@property (assign, nonatomic) BSJTopicType topicType;
/** <#digest#> */
@property (nonatomic, copy) NSString *areaType;
@end
| 156 |
9,717 | <filename>pkgs/os-specific/linux/kernel/hardened/update.py
#! /usr/bin/env nix-shell
#! nix-shell -i python -p "python38.withPackages (ps: [ps.PyGithub])" git gnupg
# This is automatically called by ../update.sh.
from __future__ import annotations
import json
import os
import re
import subprocess
import sys
from dataclasses import dataclass
from pathlib import Path
from tempfile import TemporaryDirectory
from typing import (
Dict,
Iterator,
List,
Optional,
Sequence,
Tuple,
TypedDict,
Union,
)
from github import Github
from github.GitRelease import GitRelease
VersionComponent = Union[int, str]
Version = List[VersionComponent]
PatchData = TypedDict("PatchData", {"name": str, "url": str, "sha256": str, "extra": str})
Patch = TypedDict("Patch", {
"patch": PatchData,
"version": str,
"sha256": str,
})
@dataclass
class ReleaseInfo:
version: Version
release: GitRelease
HERE = Path(__file__).resolve().parent
NIXPKGS_KERNEL_PATH = HERE.parent
NIXPKGS_PATH = HERE.parents[4]
HARDENED_GITHUB_REPO = "anthraxx/linux-hardened"
HARDENED_TRUSTED_KEY = HERE / "anthraxx.asc"
HARDENED_PATCHES_PATH = HERE / "patches.json"
MIN_KERNEL_VERSION: Version = [4, 14]
def run(*args: Union[str, Path]) -> subprocess.CompletedProcess[bytes]:
try:
return subprocess.run(
args,
check=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
encoding="utf-8",
)
except subprocess.CalledProcessError as err:
print(
f"error: `{err.cmd}` failed unexpectedly\n"
f"status code: {err.returncode}\n"
f"stdout:\n{err.stdout.strip()}\n"
f"stderr:\n{err.stderr.strip()}",
file=sys.stderr,
)
sys.exit(1)
def nix_prefetch_url(url: str) -> Tuple[str, Path]:
output = run("nix-prefetch-url", "--print-path", url).stdout
sha256, path = output.strip().split("\n")
return sha256, Path(path)
def verify_openpgp_signature(
*, name: str, trusted_key: Path, sig_path: Path, data_path: Path,
) -> bool:
with TemporaryDirectory(suffix=".nixpkgs-gnupg-home") as gnupg_home_str:
gnupg_home = Path(gnupg_home_str)
run("gpg", "--homedir", gnupg_home, "--import", trusted_key)
keyring = gnupg_home / "pubring.kbx"
try:
subprocess.run(
("gpgv", "--keyring", keyring, sig_path, data_path),
check=True,
stderr=subprocess.PIPE,
encoding="utf-8",
)
return True
except subprocess.CalledProcessError as err:
print(
f"error: signature for {name} failed to verify!",
file=sys.stderr,
)
print(err.stderr, file=sys.stderr, end="")
return False
def fetch_patch(*, name: str, release_info: ReleaseInfo) -> Optional[Patch]:
release = release_info.release
extra = f'-{release_info.version[-1]}'
def find_asset(filename: str) -> str:
try:
it: Iterator[str] = (
asset.browser_download_url
for asset in release.get_assets()
if asset.name == filename
)
return next(it)
except StopIteration:
raise KeyError(filename)
patch_filename = f"{name}.patch"
try:
patch_url = find_asset(patch_filename)
sig_url = find_asset(patch_filename + ".sig")
except KeyError:
print(f"error: {patch_filename}{{,.sig}} not present", file=sys.stderr)
return None
sha256, patch_path = nix_prefetch_url(patch_url)
_, sig_path = nix_prefetch_url(sig_url)
sig_ok = verify_openpgp_signature(
name=name,
trusted_key=HARDENED_TRUSTED_KEY,
sig_path=sig_path,
data_path=patch_path,
)
if not sig_ok:
return None
kernel_ver = release_info.release.tag_name.replace("-hardened1", "")
major = kernel_ver.split('.')[0]
sha256_kernel, _ = nix_prefetch_url(f"mirror://kernel/linux/kernel/v{major}.x/linux-{kernel_ver}.tar.xz")
return Patch(
patch=PatchData(name=patch_filename, url=patch_url, sha256=sha256, extra=extra),
version=kernel_ver,
sha256=sha256_kernel
)
def parse_version(version_str: str) -> Version:
version: Version = []
for component in re.split('\.|\-', version_str):
try:
version.append(int(component))
except ValueError:
version.append(component)
return version
def version_string(version: Version) -> str:
return ".".join(str(component) for component in version)
def major_kernel_version_key(kernel_version: Version) -> str:
return version_string(kernel_version[:-1])
def commit_patches(*, kernel_key: str, message: str) -> None:
new_patches_path = HARDENED_PATCHES_PATH.with_suffix(".new")
with open(new_patches_path, "w") as new_patches_file:
json.dump(patches, new_patches_file, indent=4, sort_keys=True)
new_patches_file.write("\n")
os.rename(new_patches_path, HARDENED_PATCHES_PATH)
message = f"linux/hardened/patches/{kernel_key}: {message}"
print(message)
if os.environ.get("COMMIT"):
run(
"git",
"-C",
NIXPKGS_PATH,
"commit",
f"--message={message}",
HARDENED_PATCHES_PATH,
)
# Load the existing patches.
patches: Dict[str, Patch]
with open(HARDENED_PATCHES_PATH) as patches_file:
patches = json.load(patches_file)
# Get the set of currently packaged kernel versions.
kernel_versions = {}
for filename in os.listdir(NIXPKGS_KERNEL_PATH):
filename_match = re.fullmatch(r"linux-(\d+)\.(\d+)\.nix", filename)
if filename_match:
nix_version_expr = f"""
with import {NIXPKGS_PATH} {{}};
(callPackage {NIXPKGS_KERNEL_PATH / filename} {{}}).version
"""
kernel_version_json = run(
"nix-instantiate", "--eval", "--json", "--expr", nix_version_expr,
).stdout
kernel_version = parse_version(json.loads(kernel_version_json))
if kernel_version < MIN_KERNEL_VERSION:
continue
kernel_key = major_kernel_version_key(kernel_version)
kernel_versions[kernel_key] = kernel_version
# Remove patches for unpackaged kernel versions.
for kernel_key in sorted(patches.keys() - kernel_versions.keys()):
commit_patches(kernel_key=kernel_key, message="remove")
g = Github(os.environ.get("GITHUB_TOKEN"))
repo = g.get_repo(HARDENED_GITHUB_REPO)
failures = False
# Match each kernel version with the best patch version.
releases = {}
for release in repo.get_releases():
version = parse_version(release.tag_name)
# needs to look like e.g. 5.6.3-hardened1
if len(version) < 4:
continue
if not (isinstance(version[-2], int)):
continue
kernel_version = version[:-1]
kernel_key = major_kernel_version_key(kernel_version)
try:
packaged_kernel_version = kernel_versions[kernel_key]
except KeyError:
continue
release_info = ReleaseInfo(version=version, release=release)
if kernel_version == packaged_kernel_version:
releases[kernel_key] = release_info
else:
# Fall back to the latest patch for this major kernel version,
# skipping patches for kernels newer than the packaged one.
if '.'.join(str(x) for x in kernel_version) > '.'.join(str(x) for x in packaged_kernel_version):
continue
elif (
kernel_key not in releases or releases[kernel_key].version < version
):
releases[kernel_key] = release_info
# Update hardened-patches.json for each release.
for kernel_key in sorted(releases.keys()):
release_info = releases[kernel_key]
release = release_info.release
version = release_info.version
version_str = release.tag_name
name = f"linux-hardened-{version_str}"
old_version: Optional[Version] = None
old_version_str: Optional[str] = None
update: bool
try:
old_filename = patches[kernel_key]["patch"]["name"]
old_version_str = old_filename.replace("linux-hardened-", "").replace(
".patch", ""
)
old_version = parse_version(old_version_str)
update = old_version < version
except KeyError:
update = True
if update:
patch = fetch_patch(name=name, release_info=release_info)
if patch is None:
failures = True
else:
patches[kernel_key] = patch
if old_version:
message = f"{old_version_str} -> {version_str}"
else:
message = f"init at {version_str}"
commit_patches(kernel_key=kernel_key, message=message)
missing_kernel_versions = kernel_versions.keys() - patches.keys()
if missing_kernel_versions:
print(
f"warning: no patches for kernel versions "
+ ", ".join(missing_kernel_versions),
file=sys.stderr,
)
if failures:
sys.exit(1)
| 4,010 |
66,985 | <reponame>techAi007/spring-boot<filename>spring-boot-project/spring-boot-tools/spring-boot-maven-plugin/src/test/java/org/springframework/boot/maven/PropertiesMergingResourceTransformerTests.java<gh_stars>1000+
/*
* Copyright 2012-2020 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.boot.maven;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.jar.JarEntry;
import java.util.jar.JarInputStream;
import java.util.jar.JarOutputStream;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests for {@link PropertiesMergingResourceTransformer}.
*
* @author <NAME>
*/
class PropertiesMergingResourceTransformerTests {
private final PropertiesMergingResourceTransformer transformer = new PropertiesMergingResourceTransformer();
@Test
void testProcess() throws Exception {
assertThat(this.transformer.hasTransformedResource()).isFalse();
this.transformer.processResource("foo", new ByteArrayInputStream("foo=bar".getBytes()), null, 0);
assertThat(this.transformer.hasTransformedResource()).isTrue();
}
@Test
void testMerge() throws Exception {
this.transformer.processResource("foo", new ByteArrayInputStream("foo=bar".getBytes()), null, 0);
this.transformer.processResource("bar", new ByteArrayInputStream("foo=spam".getBytes()), null, 0);
assertThat(this.transformer.getData().getProperty("foo")).isEqualTo("bar,spam");
}
@Test
void testOutput() throws Exception {
this.transformer.setResource("foo");
long time = 1592911068000L;
this.transformer.processResource("foo", new ByteArrayInputStream("foo=bar".getBytes()), null, time);
ByteArrayOutputStream out = new ByteArrayOutputStream();
JarOutputStream os = new JarOutputStream(out);
this.transformer.modifyOutputStream(os);
os.flush();
os.close();
byte[] bytes = out.toByteArray();
assertThat(bytes).hasSizeGreaterThan(0);
List<JarEntry> entries = new ArrayList<>();
try (JarInputStream is = new JarInputStream(new ByteArrayInputStream(bytes))) {
JarEntry entry;
while ((entry = is.getNextJarEntry()) != null) {
entries.add(entry);
}
}
assertThat(entries).hasSize(1);
assertThat(entries.get(0).getTime()).isEqualTo(time);
}
}
| 901 |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.