Nachbau Energiezähler HM-ES-TX-WM
Moderator: Co-Administratoren
- Baxxy
- Beiträge: 10738
- Registriert: 18.12.2018, 15:45
- System: Alternative CCU (auf Basis OCCU)
- Hat sich bedankt: 599 Mal
- Danksagung erhalten: 2196 Mal
Re: Nachbau Energiezähler HM-ES-TX-WM
Guck dir mal den 3.Link in meiner Signatur an (NANOCul).
Da habe ich die nötigen vorbereitenden Schritte beschrieben.
Vielleicht hilft es.
Da habe ich die nötigen vorbereitenden Schritte beschrieben.
Vielleicht hilft es.
Grüße... Baxxy
- Raspberry Pi 4 als Homematic-Zentrale - Tipps und Informationen
- Analysescript für genutzte Funk-Adressen, Funkmodul-Hardware und Zentralen Hardware
- NANO CUL 868MHz - Stick zum AskSin Analyzer XS umflashen (Anleitung für ArduinoIDE unter Windows)
- Firmware Updates für IP-Aktoren / Sensoren... Info's, Tipps und Sonstiges
- CCU funkt nicht - CarrierSense (CS) Probleme erkennen und lösen
Re: Nachbau Energiezähler HM-ES-TX-WM
Super!!! Vielen Dank für die Anleitung. Es läuft.
Viele Grüße aus der Lüneburger Heide
Uwe Kuehn
Uwe Kuehn
Re: Nachbau Energiezähler HM-ES-TX-WM
Hallo, dank der tollen Anleitung von Bazzy (nochmals herzlichen Dank ) läuft mein Arduino nun mit dem Programm. Meine CCU hat ihn auch problemlos erkannt. Nun geht es an die Sensoren.
Viele Grüße aus der Lüneburger Heide
Uwe Kuehn
Uwe Kuehn
-
- Beiträge: 47
- Registriert: 28.04.2022, 23:41
- System: Alternative CCU (auf Basis OCCU)
- Hat sich bedankt: 11 Mal
- Danksagung erhalten: 1 Mal
Re: Nachbau Energiezähler HM-ES-TX-WM
Guten Morgen zusammen,real_Napster hat geschrieben: ↑25.01.2023, 22:07Ich hatte für die Verwendung am originalen HM-ES-TX-WM bereits ein ES-IEC Sensor gekauft, der liegt nun hier rum..
Laut meinem Verständnis, kann ich den aber nicht für den Askin Selbstbau nutzen, zumindest wüsste ich nicht welche Pins vom ES-IEC ich wo am Arduino anschließen sollte.
Daher meine Frage: Wie bringe ich den Asksin HM-ES-TX-WM Selbstbau dazu ein optisches Zählersignal zu lesen? Funktioniert das ähnlich einfach wie mit dem Reedkontakt mit einer Photodiode zwischen GND und Pin14? Wenn ja, könnte man ja den ES-IEC Sensor ausschlachten und entsprechend umbauen
ich hole das Thema ungern nochmal neu hoch nur um meine Frage zu wiederholen..
Aber ich kann wirklich keinen Hinweis, Anleitung oder gar Schaltplan finden, wie ich mit dem HM-ES-TX-WM Nachbau einen optischen Zählerimpuls auslesen kann? Ob ich den ES-IEC Sensor dafür nutzen kann und ob ich ihn dafür Umbauen muss oder wie er anzuschließen ist?
Hat jemand eine Idee, Link, o.Ä. für mich?
Danke und viele Grüße
Kai
-
- Beiträge: 539
- Registriert: 20.08.2019, 06:23
- Hat sich bedankt: 13 Mal
- Danksagung erhalten: 95 Mal
Re: Nachbau Energiezähler HM-ES-TX-WM
Hallo,
Du musst erstmal ueberlegen, ob Du 1. Blinkimpulse zaehlen willst, und dann den passenden Sensor -LED nehmen oder was basteln, oder ob Du 2. mit dem -IEC Sensor die Schnittstelle Deines Zaehlers auslesen willst. Im 2. Fall musst Du das Protokoll kennen (bspw SML), in Deinem Homematic Device implementieren und danach richtet sich dann der Anschluss des Sensors (den ich nicht habe und zu dem ich auch keinen Schaltplan kenne). Vielleicht erstmal etwas zum Thema lesen auf bspw volkszaehler.org
Viele Gruesse,
Stephan
Du musst erstmal ueberlegen, ob Du 1. Blinkimpulse zaehlen willst, und dann den passenden Sensor -LED nehmen oder was basteln, oder ob Du 2. mit dem -IEC Sensor die Schnittstelle Deines Zaehlers auslesen willst. Im 2. Fall musst Du das Protokoll kennen (bspw SML), in Deinem Homematic Device implementieren und danach richtet sich dann der Anschluss des Sensors (den ich nicht habe und zu dem ich auch keinen Schaltplan kenne). Vielleicht erstmal etwas zum Thema lesen auf bspw volkszaehler.org
Viele Gruesse,
Stephan
-
- Beiträge: 47
- Registriert: 28.04.2022, 23:41
- System: Alternative CCU (auf Basis OCCU)
- Hat sich bedankt: 11 Mal
- Danksagung erhalten: 1 Mal
Re: Nachbau Energiezähler HM-ES-TX-WM
Hallo Stephan,
danke für deinen Denkanstoß!
Ich denke ich habe nun etwas gefunden:
AskSin++ HM-ES-TX-WM SML: https://github.com/novag/HM-ES-TX-WM
Mit verlinkt ist der Hichi IR v1.1 IR-Lesekopf
Ich denke ich werde es damit mal versuchen und schauen was mein RaspberryMatic dazu sagt
Viele Grüße
Kai
danke für deinen Denkanstoß!
Ich denke ich habe nun etwas gefunden:
AskSin++ HM-ES-TX-WM SML: https://github.com/novag/HM-ES-TX-WM
Mit verlinkt ist der Hichi IR v1.1 IR-Lesekopf
Ich denke ich werde es damit mal versuchen und schauen was mein RaspberryMatic dazu sagt
Viele Grüße
Kai
Re: Nachbau Energiezähler HM-ES-TX-WM
Hallo, nochmal ein Nachtrag zu meinem Problem. Ich habe nun mal vom Arduino IDE die Version 1.8.19 installiert. Und siehe da, es läuft auf Anhieb alles ohne Probleme. Nun finde ich auch die richtigen Low Power Versionen.
Viele Grüße aus der Lüneburger Heide
Uwe Kuehn
Uwe Kuehn
-
- Beiträge: 280
- Registriert: 16.05.2018, 22:54
- Hat sich bedankt: 6 Mal
- Danksagung erhalten: 5 Mal
Re: Nachbau Energiezähler HM-ES-TX-WM
Ich habe auf einer Platine von Alex den HM-ES-TX-WM jetzt noch mal nachgebaut und das ino geflasht:
Die Anmeldung an der CCU funktioniert ohne Probleme.
Allerdings zählt mir der HM-ES-TX-WM immer um 0.04 m³ hoch obwohl ich A0 und GND nicht überbrücke:
Im seriellen Monitor sieht man auch bis zur 5 letzten Zeile das A0 und GND nicht überbrückt wurde.
Wenn ich den A0 und GND überbrücke kommt im seriellen Monitor die "00000001" und er zählt um 0.05 m³ hoch
Kann sich jemand das Verhalten erklären?
Code: Alles auswählen
//- -----------------------------------------------------------------------------------------------------------------------
// AskSin++
// 2016-10-31 papa Creative Commons - http://creativecommons.org/licenses/by-nc-sa/3.0/de/
//- -----------------------------------------------------------------------------------------------------------------------
// ci-test=yes board=328p aes=no
// define this to read the device id, serial and device type from bootloader section
// #define USE_OTA_BOOTLOADER
#define EI_NOTEXTERNAL
#include <EnableInterrupt.h>
#include <AskSinPP.h>
#include <LowPower.h>
#include <MultiChannelDevice.h>
// we use a Pro Mini
// Arduino pin for the LED
// D4 == PIN 4 on Pro Mini
#define LED_PIN 4
// Arduino pin for the config button
// B0 == PIN 8 on Pro Mini
#define CONFIG_BUTTON_PIN 8
// Arduino pin for the counter impulse
// A0 == PIN 14 on Pro Mini
#define COUNTER1_PIN 14
// we send the counter every 3 minutes
#define MSG_CYCLE seconds2ticks(60 * 3)
// number of available peers per channel
#define PEERS_PER_CHANNEL 1
// all library classes are placed in the namespace 'as'
using namespace as;
// define all device properties
const struct DeviceInfo PROGMEM devinfo = {
{0x90,0x12,0x34}, // Device ID
"papa555555", // Device Serial
{0x00,0xde}, // Device Model
0x10, // Firmware Version
as::DeviceType::PowerMeter, // Device Type
{0x01,0x00} // Info Bytes
};
/**
* Configure the used hardware
*/
typedef AvrSPI<10,11,12,13> SPIType;
typedef Radio<SPIType,2> RadioType;
typedef StatusLed<LED_PIN> LedType;
typedef AskSin<LedType,BatterySensor,RadioType> HalType;
class MeterList0Data : public List0Data {
uint8_t LocalResetDisbale : 1; // 0x18 - 24
uint8_t Baudrate : 8; // 0x23 - 35
uint8_t SerialFormat : 8; // 0x24 - 36
uint8_t MeterPowerMode : 8; // 0x25 - 37
uint8_t MeterProtocolMode : 8; // 0x26 - 38
uint8_t SamplesPerCycle : 8; // 0x27 - 39
public:
static uint8_t getOffset(uint8_t reg) {
switch (reg) {
case 0x18: return sizeof(List0Data) + 0;
case 0x23: return sizeof(List0Data) + 1;
case 0x24: return sizeof(List0Data) + 2;
case 0x25: return sizeof(List0Data) + 3;
case 0x26: return sizeof(List0Data) + 4;
case 0x27: return sizeof(List0Data) + 5;
default: break;
}
return List0Data::getOffset(reg);
}
static uint8_t getRegister(uint8_t offset) {
switch (offset) {
case sizeof(List0Data) + 0: return 0x18;
case sizeof(List0Data) + 1: return 0x23;
case sizeof(List0Data) + 2: return 0x24;
case sizeof(List0Data) + 3: return 0x25;
case sizeof(List0Data) + 4: return 0x26;
case sizeof(List0Data) + 5: return 0x27;
default: break;
}
return List0Data::getRegister(offset);
}
};
class MeterList0 : public ChannelList<MeterList0Data> {
public:
MeterList0(uint16_t a) : ChannelList(a) {}
operator List0& () const { return *(List0*)this; }
// from List0
HMID masterid () { return ((List0*)this)->masterid(); }
void masterid (const HMID& mid) { ((List0*)this)->masterid(mid); }
bool aesActive() const { return ((List0*)this)->aesActive(); }
bool localResetDisable () const { return isBitSet(sizeof(List0Data) + 0,0x01); }
bool localResetDisable (bool value) const { return setBit(sizeof(List0Data) + 0,0x01,value); }
uint8_t baudrate () const { return getByte(sizeof(List0Data) + 1); }
bool baudrate (uint8_t value) const { return setByte(sizeof(List0Data) + 1,value); }
uint8_t serialFormat () const { return getByte(sizeof(List0Data) + 2); }
bool serialFormat (uint8_t value) const { return setByte(sizeof(List0Data) + 2,value); }
uint8_t powerMode () const { return getByte(sizeof(List0Data) + 3); }
bool powerMode (uint8_t value) const { return setByte(sizeof(List0Data) + 3,value); }
uint8_t protocolMode () const { return getByte(sizeof(List0Data) + 4); }
bool protocolMode (uint8_t value) const { return setByte(sizeof(List0Data) + 4,value); }
uint8_t samplesPerCycle () const { return getByte(sizeof(List0Data) + 5); }
bool samplesPerCycle (uint8_t value) const { return setByte(sizeof(List0Data) + 5,value); }
uint8_t transmitDevTryMax () const { return 6; }
uint8_t ledMode () const { return 1; }
void defaults () {
((List0*)this)->defaults();
}
};
class MeterList1Data {
public:
uint8_t AesActive :1; // 0x08, s:0, e:1
uint8_t MeterType :8; // 0x95
uint8_t MeterSensibilityIR :8; // 0x9c
uint32_t TxThresholdPower :24; // 0x7C - 0x7E
uint8_t PowerString[16]; // 0x36 - 0x46 : 06 - 21
uint8_t EnergyCounterString[16]; // 0x47 - 0x57 : 22 - 37
uint16_t MeterConstantIR :16; // 0x96 - 0x97 : 38 - 39
uint16_t MeterConstantGas :16; // 0x98 - 0x99 : 40 - 41
uint16_t MeterConstantLed :16; // 0x9a - 0x9b : 42 - 43
static uint8_t getOffset(uint8_t reg) {
switch (reg) {
case 0x08: return 0;
case 0x95: return 1;
case 0x9c: return 2;
case 0x7c: return 3;
case 0x7d: return 4;
case 0x7e: return 5;
default: break;
}
if( reg >= 0x36 && reg <= 0x57 ) {
return reg - 0x36 + 6;
}
if( reg >= 0x96 && reg <= 0x9b ) {
return reg - 0x96 + 38;
}
return 0xff;
}
static uint8_t getRegister(uint8_t offset) {
switch (offset) {
case 0: return 0x08;
case 1: return 0x95;
case 2: return 0x9c;
case 3: return 0x7c;
case 4: return 0x7d;
case 5: return 0x7e;
default: break;
}
if( offset >= 6 && offset <= 37 ) {
return offset - 6 + 0x36;
}
if( offset >= 38 && offset <= 43 ) {
return offset - 38 + 0x96;
}
return 0xff;
}
};
class MeterList1 : public ChannelList<MeterList1Data> {
public:
MeterList1(uint16_t a) : ChannelList(a) {}
bool aesActive () const { return isBitSet(0,0x01); }
bool aesActive (bool s) const { return setBit(0,0x01,s); }
uint8_t meterType () const { return getByte(1); }
bool meterType (uint8_t value) const { return setByte(1,value); }
uint8_t meterSensibilty () const { return getByte(2); }
bool meterSensibilty (uint8_t value) const { return setByte(2,value); }
uint32_t thresholdPower () const { return ((uint32_t)getByte(3)<<16) + ((uint16_t)getByte(4)<<8) + getByte(5); }
bool thresholdPower (uint32_t value) const { return setByte(3,(value>>16)&0xff) && setByte(4,(value>>8)&0xff) && setByte(5,value&0xff); }
uint16_t constantIR () const { return ((uint16_t)getByte(38)<<8) + getByte(39); }
bool constantIR (uint16_t value) const { return setByte(38,(value>>8)&0xff) && setByte(39,value&0xff); }
uint16_t constantGas () const { return ((uint16_t)getByte(40)<<8) + getByte(41); }
bool constantGas (uint16_t value) const { return setByte(40,(value>>8)&0xff) && setByte(41,value&0xff); }
uint16_t constantLed () const { return ((uint16_t)getByte(42)<<8) + getByte(43); }
bool constantLed (uint16_t value) const { return setByte(42,(value>>8)&0xff) && setByte(43,value&0xff); }
void defaults () {
aesActive(false);
meterType(0xff);
meterSensibilty(0);
thresholdPower(100*100);
constantIR(100);
constantGas(10);
constantLed(10000);
}
};
class GasPowerEventMsg : public Message {
public:
void init(uint8_t msgcnt,bool boot,const uint64_t& counter,const uint32_t& power) {
uint8_t cnt1 = (counter >> 24) & 0x7f;
if( boot == true ) {
cnt1 |= 0x80;
}
Message::init(0x10,msgcnt,0x54,BIDI|WKMEUP,cnt1,(counter >> 16) & 0xff);
pload[0] = (counter >> 8) & 0xff;
pload[1] = counter & 0xff;
pload[2] = (power >> 16) & 0xff;
pload[3] = (power >> 8) & 0xff;
pload[4] = power & 0xff;
}
};
class GasPowerEventCycleMsg : public GasPowerEventMsg {
public:
void init(uint8_t msgcnt,bool boot,const uint64_t& counter,const uint32_t& power) {
GasPowerEventMsg::init(msgcnt,boot,counter,power);
typ = 0x53;
}
};
class PowerEventMsg : public Message {
public:
void init(uint8_t msgcnt,bool boot,const uint64_t& counter,const uint32_t& power) {
uint8_t cnt1 = (counter >> 16) & 0x7f;
if( boot == true ) {
cnt1 |= 0x80;
}
Message::init(0x0f,msgcnt,0x5f,BIDI|WKMEUP,cnt1,(counter >> 8) & 0xff);
pload[0] = counter & 0xff;
pload[1] = (power >> 16) & 0xff;
pload[2] = (power >> 8) & 0xff;
pload[3] = power & 0xff;
}
};
class PowerEventCycleMsg : public PowerEventMsg {
public:
void init(uint8_t msgcnt,bool boot,const uint64_t& counter,const uint32_t& power) {
PowerEventMsg::init(msgcnt,boot,counter,power);
typ = 0x5e;
}
};
class IECEventMsg : public Message {
public:
void init(uint8_t msgcnt,uint8_t channel,const uint64_t& counter,const uint32_t& power,bool lowbat) {
uint8_t cnt1 = channel & 0x3f;
if( lowbat == true ) {
cnt1 |= 0x40;
}
Message::init(0x15,msgcnt,0x61,BIDI|WKMEUP,cnt1,0x00);
pload[0] = (counter >> 32) & 0xff;
pload[1] = (counter >> 24) & 0xff;
pload[2] = (counter >> 16) & 0xff;
pload[3] = (counter >> 8) & 0xff;
pload[4] = counter & 0xff;
pload[5] = 0x00; //
pload[6] = (power >> 24) & 0xff;
pload[7] = (power >> 16) & 0xff;
pload[8] = (power >> 8) & 0xff;
pload[9] = power & 0xff;
}
};
class IECEventCycleMsg : public IECEventMsg {
public:
void init(uint8_t msgcnt,uint8_t channel,const uint64_t& counter,const uint32_t& power,bool lowbat) {
IECEventMsg::init(msgcnt,channel,counter,power,lowbat);
typ = 0x60;
}
};
class MeterChannel : public Channel<HalType,MeterList1,EmptyList,List4,PEERS_PER_CHANNEL,MeterList0>, public Alarm {
const uint32_t maxVal = 838860700;
uint64_t counterSum;
volatile uint32_t counter; // declare as volatile because of usage withing interrupt
Message msg;
uint8_t msgcnt;
bool boot;
private:
public:
MeterChannel () : Channel(), Alarm(MSG_CYCLE), counterSum(0), counter(0), msgcnt(0), boot(true) {}
virtual ~MeterChannel () {}
void firstinit () {
Channel<HalType,MeterList1,EmptyList,List4,PEERS_PER_CHANNEL,MeterList0>::firstinit();
getList1().meterType(number()==1 ? 1 : 8); // Channel 1 default Gas / Channel 2 default IEC
}
uint8_t status () const {
return 0;
}
uint8_t flags () const {
return device().battery().low() ? 0x80 : 0x00;
}
void next () {
// only count rotations/flashes and calculate real value when sending, to prevent inaccuracy
counter++;
device().led().ledOn(millis2ticks(300));
#ifndef NDEBUG
DHEXLN(counter);
#endif
}
virtual void trigger (AlarmClock& clock) {
tick = MSG_CYCLE;
clock.add(*this);
uint32_t consumptionSum;
uint32_t actualConsumption=0;
MeterList1 l1 = getList1();
uint8_t metertype = l1.meterType(); // cache metertype to reduce eeprom access
if( metertype == 0 ) {
return;
}
// copy value, to be consistent during calculation (counter may change when an interrupt is triggered)
uint32_t c;
ATOMIC_BLOCK( ATOMIC_RESTORESTATE )
{
c = counter;
counter = 0;
}
counterSum += c;
uint16_t sigs = 1;
switch( metertype ) {
case 1: sigs = l1.constantGas(); break;
case 2: sigs = l1.constantIR(); break;
case 4: sigs = l1.constantLed(); break;
default: break;
}
switch( metertype ) {
case 1:
consumptionSum = counterSum * sigs;
actualConsumption = (c * sigs * 10) / (MSG_CYCLE / seconds2ticks(60));
// TODO handle overflow
((GasPowerEventCycleMsg&)msg).init(msgcnt++,boot,consumptionSum,actualConsumption);
break;
case 2:
case 4:
// calculate sum
consumptionSum = (10000 * counterSum / sigs);
// TODO handle overflow
// calculate consumption whithin the last MSG_CYCLE period
actualConsumption = (60 * 100000 * c) / (sigs * (MSG_CYCLE / seconds2ticks(60)));
((PowerEventCycleMsg&)msg).init(msgcnt++,boot,consumptionSum,actualConsumption);
break;
case 8:
((IECEventCycleMsg&)msg).init(msgcnt++,number(),counterSum,actualConsumption,device().battery().low());
break;
default:
DPRINTLN("Unknown meter type");
return;
break;
}
device().sendPeerEvent(msg,*this);
boot = false;
}
};
typedef MultiChannelDevice<HalType,MeterChannel,1,MeterList0> MeterType;
HalType hal;
MeterType sdev(devinfo,0x20);
template <uint8_t pin, void (*isr)(), uint16_t millis>
class ISRWrapper : public Alarm {
uint8_t curstate;
public:
ISRWrapper () : Alarm(0), curstate(HIGH) {
pinMode(pin,INPUT_PULLUP);
}
virtual ~ISRWrapper () {}
bool checkstate () {
uint8_t oldstate = curstate;
curstate = digitalRead(pin);
return curstate != oldstate;
}
uint8_t state () const {
return curstate;
}
void attach() {
if( digitalPinToInterrupt(pin) == NOT_AN_INTERRUPT )
enableInterrupt(pin,isr,CHANGE);
else
attachInterrupt(digitalPinToInterrupt(pin),isr,CHANGE);
}
void detach () {
if( digitalPinToInterrupt(pin) == NOT_AN_INTERRUPT )
disableInterrupt(pin);
else
detachInterrupt(digitalPinToInterrupt(pin));
}
void debounce () {
detach();
tick = millis2ticks(millis);
sysclock.add(*this);
}
virtual void trigger (__attribute__ ((unused)) AlarmClock& clock) {
checkstate();
attach();
}
};
void counter1ISR();
ISRWrapper<COUNTER1_PIN,counter1ISR,200> c1ISR;
void counter1ISR () {
c1ISR.debounce();
if( c1ISR.checkstate() ) {
if( c1ISR.state() == LOW ) {
sdev.channel(1).next();
}
}
}
ConfigButton<MeterType> cfgBtn(sdev);
class CycleInfoAlarm : public Alarm {
public:
CycleInfoAlarm () : Alarm (0) {}
virtual ~CycleInfoAlarm () {}
void trigger (AlarmClock& clock) {
set(seconds2ticks(60UL*60));
clock.add(*this);
sdev.channel(1).changed(true);
}
} cycle;
void setup () {
DINIT(57600,ASKSIN_PLUS_PLUS_IDENTIFIER);
sdev.init(hal);
buttonISR(cfgBtn,CONFIG_BUTTON_PIN);
// measure battery every 1h
hal.battery.init(seconds2ticks(60UL*60),sysclock);
// set low voltage to 2.2V
hal.battery.low(22);
hal.battery.critical(19);
c1ISR.attach();
// add channel 1 to timer to send event
sysclock.add(sdev.channel(1));
sdev.initDone();
sysclock.add(cycle);
}
void loop() {
bool worked = hal.runready();
bool poll = sdev.pollRadio();
if( worked == false && poll == false ) {
hal.activity.savePower<Sleep<> >(hal);
}
}
Allerdings zählt mir der HM-ES-TX-WM immer um 0.04 m³ hoch obwohl ich A0 und GND nicht überbrücke:
Im seriellen Monitor sieht man auch bis zur 5 letzten Zeile das A0 und GND nicht überbrückt wurde.
Wenn ich den A0 und GND überbrücke kommt im seriellen Monitor die "00000001" und er zählt um 0.05 m³ hoch
Kann sich jemand das Verhalten erklären?
-
- Beiträge: 12108
- Registriert: 20.11.2016, 20:01
- Hat sich bedankt: 848 Mal
- Danksagung erhalten: 2148 Mal
- Kontaktdaten:
-
- Beiträge: 280
- Registriert: 16.05.2018, 22:54
- Hat sich bedankt: 6 Mal
- Danksagung erhalten: 5 Mal
Re: Nachbau Energiezähler HM-ES-TX-WM
Das einzige Kabel was an der Platine gerade angebracht ist, ist das USB Kabel vom IVR mit dem ich den Atmel geflasht habe und den Seriellen Monitor betrachte.
Am Funkmodul hab ich den gewickelten Draht angelötet der dabei lag. Der Sensor am A0 / GND ist nicht angeschlossen, simuliere ihn mit einem Kabel, aber er zählt halt trotzdem hoch.
Die Batterien auf der Platine habe ich nicht eingesteckt, Stromversorgung läuft über den IVR.
Am Funkmodul hab ich den gewickelten Draht angelötet der dabei lag. Der Sensor am A0 / GND ist nicht angeschlossen, simuliere ihn mit einem Kabel, aber er zählt halt trotzdem hoch.
Die Batterien auf der Platine habe ich nicht eingesteckt, Stromversorgung läuft über den IVR.