API 1.5 backward compatibility?



  • I just updated my MQTTClientGateway to version 1.5.
    The temperature data which my sensor - still running on version 1.4 - is sending is now being received as unknown type (=64). Battery Level messages are received properly however.

    Any ideas what the reasons could be? Did the message format change from 1.4 to 1.5, or is version 1.5 expected to be compatible? I cannot exclude that I did silly things in my adaption of the MQTT ClientGateway. However, any hints ideas would be highly appreciated.


  • Admin

    The numbering of variables is the same. But MQTT gateway uses a string representation. Post your old sketch if you did adoptions.



  • I adapted the MQTTClientGateway quite heavily. I realized now that my statement is not quite correct. I had two nodes. For the one which worked all the time only humidity seems to get through.

    Although the sketch is quite long I will post it

    /* 				MyMQTT Client Gateway 0.1b
     Created by Norbert Truchsess <norbert.truchsess@t-online.de>
     Based on MyMQTT-broker gateway created by Daniel Wiegert <daniel.wiegert@gmail.com>
     Based on MySensors Ethernet Gateway by Henrik Ekblad <henrik.ekblad@gmail.com>
     http://www.mysensors.org
     Requires MySensors lib 1.4b
     * Change below; TCP_IP, TCP_PORT, TCP_MAC
     This will listen on your selected TCP_IP:TCP_PORT below, Please change TCP_MAC your liking also.
     *1 -> NOTE: Keep first byte at x2, x6, xA or xE (replace x with any hex value) for using Local Ranges.
     *2 You can use standard pin set-up as MySensors recommends or if you own a IBOARD you may change
     the radio-pins below if you hardware mod your iBoard. see [URL BELOW] for more details.
     http://forum.mysensors.org/topic/224/iboard-cheap-single-board-ethernet-arduino-with-radio/5
     * Don't forget to look at the definitions in libraries\MySensors\MyMQTT.h!
     define TCPDUMP and connect serial interface if you have problems, please write on
     http://forum.mysensors.org/ and explain your problem, include serial output. Don't forget to
     turn on DEBUG in libraries\MySensors\MyConfig.h also.
     MQTT_FIRST_SENSORID is for 'DHCP' server in MyMQTT. You may limit the ID's with FIRST and LAST definition.
     If you want your manually configured below 20 set MQTT_FIRST_SENSORID to 20.
     To disable: set MQTT_FIRST_SENSORID to 255.
     MQTT_BROKER_PREFIX is the leading prefix for your nodes. This can be only one char if like.
     MQTT_SEND_SUBSCRIPTION is if you want the MyMQTT to send a empty payload message to your nodes.
     This can be useful if you want to send latest state back to the MQTT client. Just check if incoming
     message has any length or not.
     Example: if (msg.type==V_LIGHT && strlen(msg.getString())>0) otherwise the code might do strange things.
     * Address-layout is : [MQTT_BROKER_PREFIX]/[NodeID]/[SensorID]/V_[SensorType]
     NodeID and SensorID is uint8 (0-255) number.
     Last segment is translation of the sensor type, look inside MyMQTT.cpp for the definitions.
     User can change this to their needs. We have also left some space for custom types.
     Special: (sensor 255 reserved for special commands)
     You can receive a node sketch name with MyMQTT/20/255/V_Sketch_name (or version with _version)
     To-do:
     Special commands : clear or set EEPROM Values, Send REBOOT and Receive reboot for MyMQTT itself.
     Be able to send ACK so client returns the data being sent.
     ... Please come with ideas!
     What to do with publish messages.
     Test in more MQTT clients, So far tested in openhab and MyMQTT for Android (Not my creation)
     - http://www.openhab.org/
     - https://play.google.com/store/apps/details?id=at.tripwire.mqtt.client&hl=en
     ... Please notify me if you use this broker with other software.
     * How to set-up Openhab and MQTTGateway:
     http://forum.mysensors.org/topic/303/mqtt-broker-gateway
     
     Changes by Thomas Krebs <thkrebs@gmx.de>
     - Add signing support from MySensors 1.5 and update for MySensors 1.5; 
     - Restructured code back to a C like implementation following the existing MQTTGateway
     */
    
    #include <SPI.h>
    #include <MySensor.h>
    #include "MyMQTTClient.h"
    #include "PubSubClient.h"
    #include <Ethernet.h>
    #include <DigitalIO.h>
    #include <MsTimer2.h>
    #include <Time.h>
    
    
    //#define DSRTC
    #ifdef DSRTC
    #include <Wire.h>
    #include <DS1307RTC.h>  // a basic DS1307 library that returns time as a time_t
    #endif
    
    
    /*
     * To configure MQTTClientGateway.ino to use an ENC28J60 based board include
     * 'UIPEthernet.h' (SPI.h required for MySensors anyway). The UIPEthernet-library can be downloaded
     * from: https://github.com/ntruchsess/arduino_uip
     */
    
    //#include <UIPEthernet.h>
    /*
     * To execute MQTTClientGateway.ino on Yun uncomment Bridge.h and YunClient.h.
     * Do not include Ethernet.h or SPI.h in this case.
     * On Yun there's no need to configure local_ip and mac in the sketch
     * as this is configured on the linux-side of Yun.
     */
    
    //#include <Bridge.h>
    //#include <YunClient.h>
    // * Use this for IBOARD modded to use standard MISO/MOSI/SCK, see note *1 above!
    /*
     #define RADIO_CE_PIN        3			// radio chip enable
     #define RADIO_SPI_SS_PIN    8			// radio SPI serial select
     #define RADIO_ERROR_LED_PIN A2  		// Error led pin
     #define RADIO_RX_LED_PIN    A1  		// Receive led pin
     #define RADIO_TX_LED_PIN    A0  		// the PCB, on board LED*/
    
    // * Use this for default configured pro mini / nano etc :
    //
    
    //#define RADIO_CE_PIN        5		// radio chip enable
    //#define RADIO_SPI_SS_PIN    6		// radio SPI serial select
    //#define RADIO_ERROR_LED_PIN 7		// Error led pin
    //#define RADIO_RX_LED_PIN    8		// Receive led pin
    //#define RADIO_TX_LED_PIN    9		// the PCB, on board LED*/
    
    // CE_PIN and SPI_SS_PIN for Mega
    #define RADIO_CE_PIN        48			// radio chip enable
    #define RADIO_SPI_SS_PIN    49			// radio SPI serial select
    #define RADIO_ERROR_LED_PIN A2  		// Error led pin
    #define RADIO_RX_LED_PIN    A1  		// Receive led pin
    #define RADIO_TX_LED_PIN    A0  		// the PCB, on board LED*/
    
    //replace with ip of server you want to connect to, comment out if using 'remote_host'
    uint8_t remote_ip[] =  { 192, 168, 178, 74 };  // Mosquitto broker
    
    //replace with hostname of server you want to connect to, comment out if using 'remote_ip'
    //char* remote_ip = "server.local";
    //replace with the port that your server is listening on
    #define remote_port 1883
    //replace with arduinos ip-address. Comment out if Ethernet-startup should use dhcp. Is ignored on Yun
    uint8_t local_ip[] = {192, 168, 178, 11};
    //replace with ethernet shield mac. It's mandatory every device is assigned a unique mac. Is ignored on Yun
    uint8_t mac[] = { 0xA2, 0xAE, 0xAD, 0xA0, 0xA0, 0xA2 };
    
    //////////////////////////////////////////////////////////////////
    
    #if defined remote_ip && defined remote_host
    #error "cannot define both remote_ip and remote_host at the same time!"
    #endif
    
    #ifdef _YUN_CLIENT_H_
    YunClient ethClient;
    #else
    EthernetClient ethClient;
    #endif
    
    ////////////////////////////////////////////////////////////////
    // NRFRF24L01 radio driver (set low transmit power by default)
    MyTransportNRF24 transport(RADIO_CE_PIN, RADIO_SPI_SS_PIN, RF24_PA_LEVEL_GW);
    //MyTransportRFM69 transport;
    
    // Message signing driver (signer needed if MY_SIGNING_FEATURE is turned on in MyConfig.h)
    //MySigningNone signer;
    //MySigningAtsha204Soft signer;
    //MySigningAtsha204 signer;
    
    // Hardware profile
    MyHwATMega328 hw;
    
    MyMessage msg;
    char convBuf[MAX_PAYLOAD*2+1];
    uint8_t buffsize;
    char buffer[MQTT_MAX_PACKET_SIZE];
    
    ////////////////////////////////////////////////////////////////
    
    volatile uint8_t countRx;
    volatile uint8_t countTx;
    volatile uint8_t countErr;
    
    
    ////////////////////////////////////////////////////////////////
    
    void processMQTTMessages(char* topic, byte* payload, unsigned int length);
    PubSubClient client(remote_ip, remote_port, processMQTTMessages, ethClient);
    
    ////////////////////////////////////////////////////////////////
    
    
    // Declare and initialize MySensor instance
    // Construct MyMQTTClient (signer needed if MY_SIGNING_FEATURE is turned on in MyConfig.h, if signing
    // feature not to be used, uncomment)
    // To use LEDs blinking, uncomment WITH_LEDS_BLINKING in MyConfig.h
    MySensor gw(transport, hw
    #ifdef MY_SIGNING_FEATURE
                , signer
    #endif
    #ifdef WITH_LEDS_BLINKING
                , RADIO_RX_LED_PIN, RADIO_TX_LED_PIN, RADIO_ERROR_LED_PIN
    #endif
    );
    
    /* 
     * setup
     */
    void setup()
    {  
        countRx = 0;
        countTx = 0;
        countErr = 0;
        
        Ethernet.begin(mac, local_ip);
        //Bridge.begin();
        delay(1000);   // Wait for Ethernet to get configured.
        
        begin();
    }
    
    /* 
     * loop
     */
    void loop()
    {
        if (!client.connected())
        {
            client.connect("MySensor");
            client.subscribe("MyMQTT/#");
        }
        client.loop();
        processRadioMessage(msg);
    }
    
    /*
     * processRadioMessage
     *
     * Receives radio message, parses it and forwards it to the MQTT broker
     */
    void processRadioMessage(const MyMessage &message)
    {
        if (gw.process())
        {
            rxBlink(1);
            dumpMessage(message);
            sendMQTT(message);
        }
    }
    
    /*
     * sendMQTT
     * Handles processing of radio messages and eventually publishes it to the MQTT broker
     */
    void sendMQTT(const MyMessage &inMsg)
    { 
      dumpMessage(inMsg);
        MyMessage msg = inMsg;
      dumpMessage(msg);
        buffsize = 0;
        if (!client.connected()) {
            return;			//We have no connections - return
        }
        if (msg.isAck())
        {
    #ifdef DEBUG
            Serial.println("msg is ack!");
    #endif
            if (msg.sender == 255 && mGetCommand(msg) == C_INTERNAL
                && msg.type == I_ID_REQUEST)
            {
                // TODO: sending ACK request on id_response fucks node up. doesn't work.
                // The idea was to confirm id and save to EEPROM_LATEST_NODE_ADDRESS.
            }
        }
        else
        {
            // we have to check every message if its a newly assigned id or not.
            // Ack on I_ID_RESPONSE does not work, and checking on C_PRESENTATION isn't reliable.
            uint8_t newNodeID = gw.loadState(EEPROM_LATEST_NODE_ADDRESS) + 1;
            if (newNodeID <= MQTT_FIRST_SENSORID)
                newNodeID = MQTT_FIRST_SENSORID;
            if (msg.sender == newNodeID)
            {
                gw.saveState(EEPROM_LATEST_NODE_ADDRESS, newNodeID);
            }
            if (mGetCommand(msg) == C_INTERNAL)
            {
                if (msg.type == I_CONFIG)
                {
                    txBlink(1);
                    if (!gw.sendRoute(
                                   build(msg, GATEWAY_ADDRESS, msg.sender, 255, C_INTERNAL,
                                         I_CONFIG, 0).set("M")))
                        errBlink(1);
                }
                else if (msg.type == I_TIME)
                {
    #ifdef DEBUG
                    Serial.println("I_TIME requested!");
    #endif
                    txBlink(1);
                    if (!gw.sendRoute(
                                   build(msg, GATEWAY_ADDRESS, msg.sender, 255, C_INTERNAL,
                                         I_TIME, 0).set(now())))
                        errBlink(1);
                }
                else if (msg.type == I_ID_REQUEST && msg.sender == 255)
                {
                    uint8_t newNodeID = gw.loadState(EEPROM_LATEST_NODE_ADDRESS) + 1;
                    if (newNodeID <= MQTT_FIRST_SENSORID)
                        newNodeID = MQTT_FIRST_SENSORID;
                    if (newNodeID >= MQTT_LAST_SENSORID)
                        return; // Sorry no more id's left :(
                    txBlink(1);
                    if (!gw.sendRoute(
                                   build(msg, GATEWAY_ADDRESS, msg.sender, 255, C_INTERNAL,
                                         I_ID_RESPONSE, 0).set(newNodeID)))
                        errBlink(1);
                }
                else if (msg.type == I_BATTERY_LEVEL)
                {
                    strcpy_P(buffer, mqtt_prefix);
                    buffsize += strlen_P(mqtt_prefix);
                    buffsize += sprintf(&buffer[buffsize], "/%i/255/BATTERY_LEVEL\0", msg.sender );
                    msg.getString(convBuf);
    #ifdef DEBUG
                    Serial.print("publish: ");
                    Serial.print((char*) buffer);
                    Serial.print(" ");
                    Serial.println((char*) convBuf);
    #endif
                    client.publish(buffer, convBuf);
                }
                else if (msg.type == I_SKETCH_NAME)
                {
                    strcpy_P(buffer, mqtt_prefix);
                    buffsize += strlen_P(mqtt_prefix);
                    buffsize += sprintf(&buffer[buffsize], "/%i/255/SKETCH_NAME\0", msg.sender );
                    msg.getString(convBuf);
    #ifdef DEBUG
                    Serial.print("publish: ");
                    Serial.print((char*) buffer);
                    Serial.print(" ");
                    Serial.println((char*) convBuf);
    #endif
                    client.publish(buffer, convBuf);
                }
                else if (msg.type == I_SKETCH_VERSION)
                {
                    strcpy_P(buffer, mqtt_prefix);
                    buffsize += strlen_P(mqtt_prefix);
                    buffsize += sprintf(&buffer[buffsize], "/%i/255/SKETCH_VERSION\0", msg.sender );
                    msg.getString(convBuf);
    #ifdef DEBUG
                    Serial.print("publish: ");
                    Serial.print((char*) buffer);
                    Serial.print(" ");
                    Serial.println((char*) convBuf);
    #endif
                    client.publish(buffer, convBuf);
                }
                
            }
            else if (mGetCommand(msg) != C_PRESENTATION)
            {
                if (mGetCommand(msg) == C_INTERNAL)
                    msg.type = msg.type + (S_FIRSTCUSTOM - 10);	//Special message
                
                if (msg.type > VAR_TOTAL)
                    msg.type = VAR_TOTAL;		// If type > defined types set to unknown.
                strcpy_P(buffer, mqtt_prefix);
                buffsize += strlen_P(mqtt_prefix);
                buffsize += sprintf(&buffer[buffsize], "/%i/%i/V_%s\0", msg.sender,
                                    msg.sensor, getType(convBuf, &VAR_Type[msg.type]));
                msg.getString(convBuf);
    #ifdef DEBUG
                Serial.print("publish: ");
                Serial.print((char*) buffer);
                Serial.print(" ");
                Serial.println((char*) convBuf);
    #endif
                client.publish(buffer, convBuf);
            }
            else {
              Serial.println("here we are in not being handled else");
              
            }
        }
    }
    
    /*
     * build
     * Constructs a radio message
     */
    inline MyMessage& build(MyMessage &msg, uint8_t sender, uint8_t destination, uint8_t sensor,
          uint8_t command, uint8_t type, bool enableAck)
    {
        msg.destination = destination;
        msg.sender = sender;
        msg.sensor = sensor;
        msg.type = type;
        mSetCommand(msg, command);
        mSetRequestAck(msg, enableAck);
        mSetAck(msg, false);
        return msg;
    }
    
    /*
     * getType
     */
    char *getType(char *b, const char **index)
    {
        char *q = b;
        char *p = (char *) pgm_read_word(index);
        while (*q++ = pgm_read_byte(p++))
            ;
        *q = 0;
        return b;
    }
    
    /*
     * begin
     * wraps MySensors begin method; setup of RTC and led timers interrupt
     */
    void begin()
    {
    #ifdef DEBUG
        Serial.begin(BAUD_RATE);
    #endif
    #ifdef DSRTC
        // Attach RTC
        setSyncProvider(RTC.get);   // the function to get the time from the RTC
        setSyncInterval(60);
    #endif
        
        gw.begin(processRadioMessage, 0, true, 0);
        
        MsTimer2::set(200, ledTimersInterrupt);
        MsTimer2::start();
        
    #ifdef DEBUG
        Serial.print(getType(convBuf, &VAR_Type[S_FIRSTCUSTOM]));
    #endif
    }
    
    /*
     * processMQTTMessages
     * message handler for the PubSubClient
     */
    void processMQTTMessages(char* topic, byte* payload, unsigned int length)
    {
        processMQTTMessage(topic, payload, length);
    }
    
    /*
     * processMQTTMessage
     * processes MQTT messages, parses the topic, extracts radio address out of topic and sends them
     * to the respective radio
     */
    void processMQTTMessage(char* topic, byte* payload,
                       unsigned int length)
    {
        char *str, *p;
        uint8_t i = 0;
        buffer[0] = 0;
        buffsize = 0;
        
        for (str = strtok_r(topic, "/", &p); str && i < 4;
             str = strtok_r(NULL, "/", &p))
        {
            switch (i)
            {
                case 0:
                {
                    if (strcmp_P(str, mqtt_prefix) != 0)
                    { //look for MQTT_PREFIX
                        return;			//Message not for us or malformatted!
                    }
                    break;
                }
                case 1:
                {
                    msg.destination = atoi(str);	//NodeID
                    break;
                }
                case 2:
                {
                    msg.sensor = atoi(str);		//SensorID
                    break;
                }
                case 3:
                {
                    char match = 0;			//SensorType
                    //strcpy(str,(char*)&str[2]);  //Strip VAR_
                    
                    for (uint8_t j = 0;
                         strcpy_P(convBuf, (char*) pgm_read_word(&(VAR_Type[j]))); j++)
                    {
                        if (strcmp((char*) &str[2], convBuf) == 0)
                        { //Strip VAR_ and compare
                            match = j;
                            break;
                        }
                        if (j >= VAR_TOTAL)
                        { // No match found!
                            match = VAR_TOTAL;	// last item.
                            break;
                        }
                    }
                    msg.type = match;
                    break;
                }
            }
            i++;
        }						//Check if packge has payload
        
        char* ca;
        ca = (char *)payload;
        ca += length;
        *ca = '\0';
        
        msg.set((const char*)payload);			//Payload
        
        txBlink(1);
        // inject time
        if ((msg.destination == 0) && (msg.sensor == 199)) {
            unsigned long epoch = atol((char*)payload);
            if (epoch > 10000) {
    #ifdef DSRTC
                RTC.set(epoch); // this sets the RTC to the time from controller - which we do want periodically
    #endif
                setTime(epoch);
                
            }
    #ifdef DEBUG
            Serial.print("Time recieved ");
            Serial.println(epoch);
    #endif
        }
        //
        if (!gw.sendRoute(
                       build(msg, GATEWAY_ADDRESS, msg.destination, msg.sensor, C_SET, msg.type,
                             0)))
            errBlink(1);   
    }
    
    //////////////////////////////////////////////////////////////////////////////////////////////////////////////
    // Led handling
    //////////////////////////////////////////////////////////////////////////////////////////////////////////////
    
    /*
     * ledTimersIntterupt
     */
    void ledTimersInterrupt() {
        if(countRx && countRx != 255) {
            // switch led on
            digitalWrite(RADIO_RX_LED_PIN, LOW);
        } else if(!countRx) {
            // switching off
            digitalWrite(RADIO_RX_LED_PIN, HIGH);
        }
        if(countRx != 255) { countRx--; }
        
        if(countTx && countTx != 255) {
            // switch led on
            digitalWrite(RADIO_TX_LED_PIN, LOW);
        } else if(!countTx) {
            // switching off
            digitalWrite(RADIO_TX_LED_PIN, HIGH);
        }
        if(countTx != 255) { countTx--; }
        
        if(countErr && countErr != 255) {
            // switch led on
            digitalWrite(RADIO_ERROR_LED_PIN, LOW);
        } else if(!countErr) {
            // switching off
            digitalWrite(RADIO_ERROR_LED_PIN, HIGH);
        }
        if(countErr != 255) { countErr--; }   
    }
    
    
    void rxBlink(uint8_t cnt)
    {
        if (countRx == 255)
        {
            countRx = cnt;
        }
    }
    
    void txBlink(uint8_t cnt)
    {
        if (countTx == 255)
        {
            countTx = cnt;
        }
    }
    
    void errBlink(uint8_t cnt)
    {
        if (countErr == 255)
        {
            countErr = cnt;
        }
    }
    
    void dumpMessage(const MyMessage &msg) {
            Serial.println("-----Message Dump ----");
            Serial.print("Sender:  "); Serial.println(msg.sender);
            Serial.print("Dest:    "); Serial.println(msg.destination);
            Serial.print("Sensor : "); Serial.println(msg.sensor);
            Serial.print("Cmd:     "); Serial.println(mGetCommand(msg));
            Serial.print("Type:    "); Serial.println(msg.type);
            Serial.print("Length   "); Serial.println(mGetLength(msg));
            Serial.println("-----Message Dump ----");
    }
    
    

    The header file (I think this needs to be adapted)

    /*
    The MySensors library adds a new layer on top of the RF24 library.
    It handles radio network routing, relaying and ids.
    Created by Henrik Ekblad <henrik.ekblad@gmail.com>
    Modified by Daniel Wiegert
    Modified by Norbert Truchsess <norbert.truchsess@t-online.de>
    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public License
    version 2 as published by the Free Software Foundation.
    */
    
    
    #ifndef MyMQTTClient_h
    #define MyMQTTClient_h
    
    #include "MySensor.h"
    #include "MyTransport.h"
    #include "MySigning.h"
    #include "PubSubClient.h"
    
    
    //////////////////////////////////////////////////////////////////
    
    #ifdef DEBUG
    #define TCPDUMP					// Dump TCP packages.
    #endif
    #define MQTT_FIRST_SENSORID	20  		// If you want manually configured nodes below this value. 255 = Disable
    #define MQTT_LAST_SENSORID	254 		// 254 is max! 255 reserved.
    #define MQTT_PREFIX	"MyMQTT"	        // First prefix in MQTT tree, keep short!
    #define MQTT_SEND_SUBSCRIPTION 1		// Send empty payload (request) to node upon MQTT client subscribe request.
    
    // NOTE above : Beware to check if there is any length on payload in your incommingMessage code:
    // Example: if (msg.type==V_LIGHT && strlen(msg.getString())>0) otherwise the code might do strange things.
    
    //////////////////////////////////////////////////////////////////
    
    
    char VAR_0[] PROGMEM = "TEMP";		//V_TEMP
    char VAR_1[] PROGMEM = "HUM";		//V_HUM
    char VAR_2[] PROGMEM = "LIGHT";		//V_LIGHT
    char VAR_3[] PROGMEM = "DIMMER";		//V_DIMMER
    char VAR_4[] PROGMEM = "PRESSURE";	//V_PRESSURE
    char VAR_5[] PROGMEM = "FORECAST";	//V_FORECAST
    char VAR_6[] PROGMEM = "RAIN";		//V_RAIN
    char VAR_7[] PROGMEM = "RAINRATE";	//V_RAINRATE
    char VAR_8[] PROGMEM = "WIND";		//V_WIND
    char VAR_9[] PROGMEM = "GUST";		//V_GUST
    char VAR_10[] PROGMEM = "DIRECTON";	//V_DIRECTON
    char VAR_11[] PROGMEM = "UV";		//V_UV
    char VAR_12[] PROGMEM = "WEIGHT";		//V_WEIGHT
    char VAR_13[] PROGMEM = "DISTANCE";	//V_DISTANCE
    char VAR_14[] PROGMEM = "IMPEDANCE";	//V_IMPEDANCE
    char VAR_15[] PROGMEM = "ARMED";		//V_ARMED
    char VAR_16[] PROGMEM = "TRIPPED";	//V_TRIPPED
    char VAR_17[] PROGMEM = "WATT";		//V_WATT
    char VAR_18[] PROGMEM = "KWH";		//V_KWH
    char VAR_19[] PROGMEM = "SCENE_ON";	//V_SCENE_ON
    char VAR_20[] PROGMEM = "SCENE_OFF";	//V_SCENE_OFF
    char VAR_21[] PROGMEM = "HEATER";		//V_HEATER
    char VAR_22[] PROGMEM = "HEATER_SW";	//V_HEATER_SW
    char VAR_23[] PROGMEM = "LIGHT_LEVEL";	//V_LIGHT_LEVEL
    char VAR_24[] PROGMEM = "VAR1";		//V_VAR1
    char VAR_25[] PROGMEM = "VAR2";		//V_VAR2
    char VAR_26[] PROGMEM = "VAR3";		//V_VAR3
    char VAR_27[] PROGMEM = "VAR4";		//V_VAR4
    char VAR_28[] PROGMEM = "VAR5";		//V_VAR5
    char VAR_29[] PROGMEM = "UP";		//V_UP
    char VAR_30[] PROGMEM = "DOWN";		//V_DOWN
    char VAR_31[] PROGMEM = "STOP";		//V_STOP
    char VAR_32[] PROGMEM = "IR_SEND";	//V_IR_SEND
    char VAR_33[] PROGMEM = "IR_RECEIVE";	//V_IR_RECEIVE
    char VAR_34[] PROGMEM = "FLOW";		//V_FLOW
    char VAR_35[] PROGMEM = "VOLUME";		//V_VOLUME
    char VAR_36[] PROGMEM = "LOCK_STATUS";	//V_LOCK_STATUS
    char VAR_37[] PROGMEM = "DUST_LEVEL";	//V_DUST_LEVEL
    char VAR_38[] PROGMEM = "VOLTAGE";	//V_VOLTAGE
    char VAR_39[] PROGMEM = "CURRENT";	//V_CURRENT
    char VAR_40[] PROGMEM = "";		//
    char VAR_41[] PROGMEM = "";		//
    char VAR_42[] PROGMEM = "";		//
    char VAR_43[] PROGMEM = "";		//
    char VAR_44[] PROGMEM = "";		//
    char VAR_45[] PROGMEM = "";		//
    char VAR_46[] PROGMEM = "";		//
    char VAR_47[] PROGMEM = "";		//
    char VAR_48[] PROGMEM = "";		//
    char VAR_49[] PROGMEM = "";		//
    char VAR_50[] PROGMEM = "";		//
    char VAR_51[] PROGMEM = "";		//
    char VAR_52[] PROGMEM = "";		//
    char VAR_53[] PROGMEM = "";		//
    char VAR_54[] PROGMEM = "";		//
    char VAR_55[] PROGMEM = "";		//
    char VAR_56[] PROGMEM = "";		//
    char VAR_57[] PROGMEM = "";		//
    char VAR_58[] PROGMEM = "";		//
    char VAR_59[] PROGMEM = "";		//
    char VAR_60[] PROGMEM = "Started!\n";	//Custom for MQTTGateway
    char VAR_61[] PROGMEM = "SKETCH_NAME";	//Custom for MQTTGateway
    char VAR_62[] PROGMEM = "SKETCH_VERSION"; //Custom for MQTTGateway
    char VAR_63[] PROGMEM = "UNKNOWN"; 	//Custom for MQTTGateway
    
    //////////////////////////////////////////////////////////////////
    
    PROGMEM const char *VAR_Type[] =
    { VAR_0, VAR_1, VAR_2, VAR_3, VAR_4, VAR_5, VAR_6, VAR_7, VAR_8, VAR_9, VAR_10, VAR_11, VAR_12, VAR_13,
        VAR_14, VAR_15, VAR_16, VAR_17, VAR_18, VAR_19, VAR_20, VAR_21, VAR_22, VAR_23, VAR_24, VAR_25,
        VAR_26, VAR_27, VAR_28, VAR_29, VAR_30, VAR_31, VAR_32, VAR_33, VAR_34, VAR_35, VAR_36, VAR_37,
        VAR_38, VAR_39, VAR_40, VAR_41, VAR_42, VAR_43, VAR_44, VAR_45, VAR_46, VAR_47, VAR_48, VAR_49,
        VAR_50, VAR_51, VAR_52, VAR_53, VAR_54, VAR_55, VAR_56, VAR_57, VAR_58, VAR_59, VAR_60, VAR_61,
        VAR_62, VAR_63
    };
    
    char mqtt_prefix[] PROGMEM = MQTT_PREFIX;
    
    #define S_FIRSTCUSTOM 60
    #define TYPEMAXLEN 20
    #define VAR_TOTAL (sizeof(VAR_Type)/sizeof(char *))-1
    
    
    #define EEPROM_LATEST_NODE_ADDRESS ((uint8_t)EEPROM_LOCAL_CONFIG_ADDRESS)
    
    //#define DSRTC // RTC Dallas support -> disable debug and use isp programmer to free memory
    #endif
    
    

    Here is an excerpt of the serial output after resetting the temperature and humidity node:

    ;0;3;0;9;read: 20-20-0 s=255,c=3,t=12,pt=0,l=3,sg=0:1.0
    0;0;3;0;9;read: 20-20-0 s=1,c=0,t=6,pt=0,l=5,sg=0:1.4.1
    0;0;3;0;9;read: 20-20-0 s=2,c=0,t=7,pt=0,l=5,sg=0:1.4.1
    0;0;3;0;9;read: 20-20-0 s=1,c=1,t=0,pt=7,l=5,sg=0:28.2
    0;0;3;0;9;read: 20-20-0 s=2,c=1,t=1,pt=7,l=5,sg=0:46.5
    -----Message Dump ----
    Sender:  20
    Dest:    0
    Sensor : 2
    Cmd:     1
    Type:    1
    Length   5
    -----Message Dump ----
    -----Message Dump ----
    Sender:  20
    Dest:    0
    Sensor : 2
    Cmd:     1
    Type:    1
    Length   5
    -----Message Dump ----
    -----Message Dump ----
    Sender:  20
    Dest:    0
    Sensor : 2
    Cmd:     1
    Type:    1
    Length   5
    -----Message Dump ----
    publish: MyMQTT/20/2/V_HUM 46.5
    -----Message Dump ----
    Sender:  20
    Dest:    0
    Sensor : 2
    Cmd:     1
    Type:    1
    Length   5
    -----Message Dump ----
    -----Message Dump ----
    Sender:  20
    Dest:    0
    Sensor : 2
    Cmd:     1
    Type:    1
    Length   5
    -----Message Dump ----
    
    

    Thanks a lot for your support!!. That is highly appreciated!!!!!



  • Ok, I figured it out. My issue was related to the change with respect to the message callback which has been introduced with 1.5. I had the callback method registered in the call to the begin method of the gateway node but also called it directly in the loop function as well.

    So this one has been fixed. Sorry, bothering you.


 

296
Online

8.8k
Users

9.6k
Topics

100.3k
Posts