MySmartHome/MySensors
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'development' of https://github.com/mysensors/Arduino into development

Browse Source
This commit is contained in:
Henrik Ekblad
2014-08-16 00:00:33 +02:00
parent f822f1aa31 31813b3712
commit cbd78d68cf
5 changed files with 591 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files
MQTTGateway/MQTTGateway.ino
Executable
+133
View File
@@ -0,0 +1,133 @@
/* MyMQTT Gateway 0.1b
Created by Daniel Wiegert <daniel.wiegert@gmail.com>
Based on Mysensors Ethernet Gateway by Henrik Ekblad <henrik.ekblad@gmail.com>
Requires MySensors lib 1.4b
http://www.mysensors.org
* Don't forget to look at the definitions in MyMQTT.h!
* Don't forget to configure Radio pins, IP and MAC-address!
* Address-layout is : [MQTT_BROKER_PREFIX]/[NodeID]/[SensorID]/Light
NodeID and SensorID is number (0-255).
Last segment is translation of the sensor type, look inside MyMQTT.cpp for
the definitions. User can change this to their needs.
Example openhab setup: http://www.openhab.org/
* openhab.cfg
---
mqtt:mysensor.url=tcp://192.168.0.234:1883
mqtt:mysensor.clientId=MQTT
---
* items/test.items
---
Group test
Number Temp_test "Temp [%.1f °C]" (test) {mqtt="<[mysensor:MyMQTT/20/#/Temperature:state:default]"}
Number Hum_test "Hum [%.1f %%]" (test) {mqtt="<[mysensor:MyMQTT/20/#/Humidity:state:default]"}
Number test_test "test [%s]" (test) {mqtt="<[mysensor:MyMQTT/20/3/#:state:default]"}
Switch sw1 "sw 1" (test) {<[mysensor:MyMQTT/21/1/Light:command:MAP(1.map)]"}
--- (Note; # = Wildcard character)
* sitemap/test.site
---
sitemap demo label="Menu"
Frame label="Openhab" {
Group item=test label="Test group"
}
---
* transform/1.map
---
1=ON
0=OFF
---
* Features:
- Supports automatic nodeID delegation
- Recieve sketchname and version Example: (openhab item)
String sketch20 "Node 20 Sketch name [%s]" (sketch,name,a) {mqtt="<[mysensor:MyMQTT/20/255/Sketch_name:state:default]"}
String sketch21 "Node 21 Sketch name [%s]" (sketch,name,a) {mqtt="<[mysensor:MyMQTT/21/255/Sketch_name:state:default]"}
[...]
* Todo:
- DOCUMENTATION...
- Special commands
Read and set EEPROM Values
Send Reboot, And reboot gateway itself.
...
Sketch uses 23,666 bytes (77%) of program storage space. Maximum is 30,720 bytes.
Global variables use 766 bytes (37%) of dynamic memory, leaving 1,282 bytes for local variables. Maximum is 2,048 bytes.
*/
#include <SPI.h>
#include <MyMQTT.h>
#include <Ethernet.h>
#include <MsTimer2.h>
// Use this for IBOARD modded to use standard MISO/MOSI/SCK More information see;
// http://forum.mysensors.org/topic/224/iboard-cheap-single-board-ethernet-arduino-with-radio/5
//#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
#define IP_PORT 1883 // MQTT Listening port
IPAddress myIp ( 192, 168, 0, 234 ); // Configure your static ip-address here
byte mac[] = { 0x02, 0xDE, 0xAD, 0x00, 0x00, 0x42 }; // Mac-address - Change this!
// * NOTE: Keep first byte at x2, x6, xA or xE (replace x with any hex value) for using Locally Administered Address Ranges.
EthernetServer server = EthernetServer(IP_PORT);
MyMQTT gw(RADIO_CE_PIN, RADIO_SPI_SS_PIN);
// Uncomment this constructor if you have leds and include button attached to your gateway
// MyMQTT gw(RADIO_CE_PIN, RADIO_SPI_SS_PIN, RADIO_RX_LED_PIN, RADIO_TX_LED_PIN, RADIO_ERROR_LED_PIN);
void processEthernetMessages() {
char inputString[MQTT_MAX_PACKET_SIZE] = "";
int inputSize = 0;
EthernetClient client = server.available();
if (client) {
while (client.available()) {
char inChar = client.read();
inputString[inputSize] = inChar;
inputSize++;
}
gw.processMQTTMessage(inputString, inputSize);
}
}
void writeEthernet(char *writeBuffer, int *writeSize) {
server.write(writeBuffer, *writeSize); // Should this really be *writeSize?
}
void ledTimersInterrupt() {
gw.ledTimersInterrupt();
}
int main(void) {
init();
Ethernet.begin(mac, myIp);
delay(1000); // Wait for Ethernet to get configured.
gw.begin(RF24_PA_LEVEL_GW, RF24_CHANNEL, RF24_DATARATE, writeEthernet);
server.begin();
if (gw.isLedMode()) {
// Add led timer interrupt
MsTimer2::set(300, ledTimersInterrupt);
MsTimer2::start();
}
while (1) {
processEthernetMessages();
gw.processRadioMessage();
}
}
libraries/MySensors/MyMQTT.cpp
Executable
+366
View File
@@ -0,0 +1,366 @@
/*
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
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.
*/
#include "MyMQTT.h"
char broker[] PROGMEM = MQTT_BROKER_PREFIX;
char S_0[] PROGMEM = "Temperature";
char S_1[] PROGMEM = "Humidity";
char S_2[] PROGMEM = "Light";
char S_3[] PROGMEM = "Dimmer";
char S_4[] PROGMEM = "Pressure";
char S_5[] PROGMEM = "Forecast";
char S_6[] PROGMEM = "Rain";
char S_7[] PROGMEM = "Rainrate";
char S_8[] PROGMEM = "Wind";
char S_9[] PROGMEM = "Gust";
char S_10[] PROGMEM = "Direction";
char S_11[] PROGMEM = "UV";
char S_12[] PROGMEM = "Weight";
char S_13[] PROGMEM = "Distance";
char S_14[] PROGMEM = "Impedance";
char S_15[] PROGMEM = "Armed";
char S_16[] PROGMEM = "Tripped";
char S_17[] PROGMEM = "Watt";
char S_18[] PROGMEM = "KWH";
char S_19[] PROGMEM = "Scene_ON";
char S_20[] PROGMEM = "Scene_OFF";
char S_21[] PROGMEM = "Heater";
char S_22[] PROGMEM = "Heater_SW";
char S_23[] PROGMEM = "LightLVL";
char S_24[] PROGMEM = "Var1";
char S_25[] PROGMEM = "Var2";
char S_26[] PROGMEM = "Var3";
char S_27[] PROGMEM = "Var4";
char S_28[] PROGMEM = "Var5,";
char S_29[] PROGMEM = "Up";
char S_30[] PROGMEM = "Down";
char S_31[] PROGMEM = "Stop";
char S_32[] PROGMEM = "IR_Send";
char S_33[] PROGMEM = "IR_Receive";
char S_34[] PROGMEM = "Flow";
char S_35[] PROGMEM = "Volume";
char S_36[] PROGMEM = "Lock_Status";
char S_37[] PROGMEM = "Volt_Batt"; // Does not exist in mysensors lib!
char S_38[] PROGMEM = "";
char S_39[] PROGMEM = "";
char S_40[] PROGMEM = "";
char S_41[] PROGMEM = "";
char S_42[] PROGMEM = "";
char S_43[] PROGMEM = "";
char S_44[] PROGMEM = "";
char S_45[] PROGMEM = "";
char S_46[] PROGMEM = "";
char S_47[] PROGMEM = "";
char S_48[] PROGMEM = "";
char S_49[] PROGMEM = "Sketch_name"; // Does not exist in mysensors lib!
char S_50[] PROGMEM = "Sketch_version"; // Does not exist in mysensors lib!
PROGMEM const char *sType[] =
{ S_0, S_1, S_2, S_3, S_4, S_5, S_6, S_7, S_8, S_9, S_10,
S_11, S_12, S_13, S_14, S_15, S_16, S_17, S_18, S_19, S_20,
S_21, S_22, S_23, S_24, S_25, S_26, S_27, S_28, S_29, S_30,
S_31, S_32, S_33, S_34, S_35, S_36, S_37, S_38, S_39, S_40,
S_41, S_42, S_43, S_44, S_45, S_46, S_47, S_48, S_49, S_50};
MyMQTT::MyMQTT(uint8_t _cepin, uint8_t _cspin, uint8_t _rx, uint8_t _tx, uint8_t _er) :
MySensor(_cepin, _cspin) {
if (_rx != NULL) {
pinRx = _rx;
pinMode(pinRx, OUTPUT);
ledMode = true;
}
if (_tx != NULL) {
pinTx = _tx;
pinMode(pinTx, OUTPUT);
ledMode = true;
}
if (_er != NULL) {
pinEr = _er;
pinMode(pinEr, OUTPUT);
ledMode = true;
}
}
void MyMQTT::begin(rf24_pa_dbm_e paLevel, uint8_t channel, rf24_datarate_e dataRate, void (*inDataCallback)(char *, int *)) {
Serial.begin(BAUD_RATE);
repeaterMode = true;
isGateway = true;
MQTTClientConnected = false;
setupRepeaterMode();
dataCallback = inDataCallback;
nc.nodeId = 0;
nc.distance = 0;
// Start up the radio library
setupRadio(paLevel, channel, dataRate);
RF24::openReadingPipe(WRITE_PIPE, BASE_RADIO_ID);
RF24::openReadingPipe(CURRENT_NODE_PIPE, BASE_RADIO_ID);
RF24::startListening();
// Send startup log message on serial
//Serial.print(PSTR("Started\n"));//TODO: progmem gives error..? error: sType causes a section type conflict with __c
Serial.print("Started\n");//TODO: fix this...
}
void MyMQTT::processRadioMessage() {
if (process()) {
// A new message was received from one of the sensors
MyMessage message = getLastMessage();
// Pass along the message from sensors to serial line
rxBlink(3);
SendMQTT(message);
}
}
void MyMQTT::processMQTTMessage(char *inputString, int inputPos) {
char *str, *p, *value=NULL;
char i = 0;
buffer[0]= 0;
buffsize = 0;
#ifdef TCPDUMP
Serial.print("<<");
char buf[4];
for (int a=0; a<inputPos; a++) { sprintf(buf,"%02X ",(byte)inputString[a]); Serial.print(buf); } Serial.println("");
#endif
if ((byte)inputString[0] >> 4 == MQTTCONNECT) {
buffer[buffsize++] = MQTTCONNACK << 4;
buffer[buffsize++] = 0x02; // Remaining length
buffer[buffsize++] = 0x00; // Connection accepted
buffer[buffsize++] = 0x00; // Reserved
MQTTClientConnected=true;
}
if ((byte)inputString[0] >> 4 == MQTTPINGREQ) {
buffer[buffsize++] = MQTTPINGRESP << 4;
buffer[buffsize++] = 0x00;
}
if ((byte)inputString[0] >> 4 == MQTTSUBSCRIBE) {
buffer[buffsize++] = MQTTSUBACK << 4; // Just ack everything, we actually dont really care!
buffer[buffsize++] = 0x03; // Remaining length
buffer[buffsize++] = (byte)inputString[2]; // Message ID MSB
buffer[buffsize++] = (byte)inputString[3]; // Message ID LSB
buffer[buffsize++] = MQTTQOS0; // QOS level
}
if ((byte)inputString[0] >> 4 == MQTTUNSUBSCRIBE) {
buffer[buffsize++] = MQTTUNSUBACK << 4;
buffer[buffsize++] = 0x02; // Remaining length
buffer[buffsize++] = (byte)inputString[2]; // Message ID MSB
buffer[buffsize++] = (byte)inputString[3]; // Message ID LSB
}
if ((byte)inputString[0] >> 4 == MQTTDISCONNECT) {
MQTTClientConnected=false;
}
if (buffsize > 0) {
#ifdef TCPDUMP
Serial.print(">>");
char buf[4];
for (int a=0; a<buffsize; a++) { sprintf(buf,"%02X ",(byte)buffer[a]); Serial.print(buf); } Serial.println("");
#endif
dataCallback(buffer,&buffsize);
}
// We publish everything we get, we dont care if its subscribed or not!
if ((byte)inputString[0] >> 4 == MQTTPUBLISH || (MQTT_SEND_SUBSCRIPTION && (byte)inputString[0] >> 4 == MQTTSUBSCRIBE)) {
buffer[0]= 0;
buffsize = 0;
if ((byte)inputString[0] >> 4 == MQTTSUBSCRIBE) {
strncat(buffer,inputString+6,inputString[5]);
} else {
strncat(buffer,inputString+4,inputString[3]);
}
msg.sender = GATEWAY_ADDRESS;
for (str = strtok_r(buffer, "/", &p); // split using semicolon
str && i < 4; str = strtok_r(NULL, "/", &p) //get subsequent tokens (?)
) {
switch (i) {
case 0: // Radioid (destination)
if (strcmp_P(str,broker)!=0) {
return; //Message not for us or malformatted!
}
break;
case 1:
msg.destination = atoi(str);
break;
case 2:
msg.sensor = atoi(str);
break;
case 3:
char match=0;
for (int j=0; strcpy_P(convBuf, (char*)pgm_read_word(&(sType[j]))) ; j++) {
if (strcmp(str,convBuf)==0) {
match=j;
break;
}
}
msg.type = match;
break;
}
i++;
}
if ((char)inputString[1] > (char)(inputString[3]+2) && !((byte)inputString[0] >> 4 == MQTTSUBSCRIBE)) {
strcpy(convBuf,inputString+(inputString[3]+4));
msg.set(convBuf);
} else {
msg.set("");
}
msg.sender = GATEWAY_ADDRESS;
mSetCommand(msg,C_SET);
mSetRequestAck(msg,false);
mSetAck(msg,false);
mSetVersion(msg, PROTOCOL_VERSION);
txBlink(1);
if (!sendRoute(msg)) errBlink(1);
}
}
void MyMQTT::SendMQTT(MyMessage &msg) {
//serial(PSTR("%d;%d;%d;%d;%s\n"),msg.sender, msg.sensor, mGetCommand(msg), msg.type, msg.getString(convBuf));
buffsize = 0;
if (!MQTTClientConnected) return;
if (msg.isAck()) {
Serial.println("msg is ack!");
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.
char newNodeID = loadState(EEPROM_LATEST_NODE_ADDRESS)+1;
if (newNodeID <= MQTT_FIRST_SENSORID) newNodeID = MQTT_FIRST_SENSORID;
if (msg.sender==newNodeID) {
saveState(EEPROM_LATEST_NODE_ADDRESS,newNodeID);
}
if (mGetCommand(msg)==C_INTERNAL && msg.type==I_CONFIG) { // CONFIG
// As for now there is only one 'config' request.
// We force SI! Resistance is futile!
//
// Todo : Support for more config types, Maybe just read from own EEPROM?
// Use internal EEPROM_CONTROLLER_CONFIG_ADDRESS and special MQTT address to write to
// EEPROM_CONTROLLER_CONFIG_ADDRESS & EEPROM_LOCAL_CONFIG_ADDRESS
msg.destination = msg.sender; //NodeID
msg.sender = GATEWAY_ADDRESS;
msg.sensor = 255; //SensorID
msg.type = I_CONFIG; //msgType
mSetCommand(msg,C_INTERNAL); //Subtype
mSetRequestAck(msg,false);
mSetAck(msg,false);
msg.set("M");
mSetVersion(msg, PROTOCOL_VERSION);
txBlink(1);
if (!sendRoute(msg)) errBlink(1);
} else if (mGetCommand(msg)==C_PRESENTATION && (msg.type==S_ARDUINO_NODE || msg.type==S_ARDUINO_REPEATER_NODE)) {
//Doesnt work to check new sensorID here, this message does not always arrive.. See above.
} else if (msg.sender==255 && mGetCommand(msg)==C_INTERNAL && msg.type==I_ID_REQUEST) {
char newNodeID = 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 :(
msg.destination = msg.sender; //NodeID
msg.sender = GATEWAY_ADDRESS;
msg.sensor = 255; //SensorID
msg.type = I_ID_RESPONSE; //MsgType
mSetCommand(msg,C_INTERNAL); //Subtype
mSetRequestAck(msg,false); //Request ack doesn't work, node/gateway gets stuck in enless loop.
mSetAck(msg,false);
msg.set((uint8_t)newNodeID); //Payload
mSetVersion(msg, PROTOCOL_VERSION);
txBlink(1);
if (!sendRoute(msg)) errBlink(1);
// if (sendRoute(msg)) saveState(EEPROM_LATEST_NODE_ADDRESS,newNodeID); // If send OK save to eeprom. DOES NOT ALWAYS RETURN 'OK'!?
} else if (mGetCommand(msg)!=0) {
if (mGetCommand(msg)==3) msg.type=msg.type+38;
buffer[buffsize++] = MQTTPUBLISH << 4; // 0:
buffer[buffsize++] = 0x09; // 1: Remaining length with no payload, we'll set this later to correct value, buffsize -2
buffer[buffsize++] = 0x00; // 2: Length MSB (Remaing length can never exceed ff,so MSB must be 0!)
buffer[buffsize++] = 0x08; // 3: Length LSB (ADDR), We'll set this later
strcpy_P(buffer+4, broker);
buffsize+=strlen_P(broker);
buffsize+=sprintf(&buffer[buffsize],"/%i/%i/",msg.sender,msg.sensor);
buffsize+=strncpysType_retL(buffer,msg.type,buffsize);
buffer[3]=buffsize-4; // Set correct address length on byte 4.
#ifdef DEBUG
Serial.println((char*)&buffer[4]);
#endif
msg.getString(convBuf);
for (int a=0; a<strlen(convBuf); a++) { // Payload
buffer[buffsize++] = convBuf[a];
}
buffer[1]=buffsize-2; // Set correct Remaining length on byte 2.
#ifdef TCPDUMP
Serial.print(">>");
char buf[4];
for (int a=0; a<buffsize; a++) { sprintf(buf,"%02X ",(byte)buffer[a]); Serial.print(buf); } Serial.println("");
#endif
dataCallback(buffer,&buffsize);
}
}
}
boolean MyMQTT::isLedMode() {
return ledMode;
}
void MyMQTT::ledTimersInterrupt() {
if(countRx && countRx != 255) {
// switch led on
digitalWrite(pinRx, LOW);
} else if(!countRx) {
// switching off
digitalWrite(pinRx, HIGH);
}
if(countRx != 255) { countRx--; }
if(countTx && countTx != 255) {
// switch led on
digitalWrite(pinTx, LOW);
} else if(!countTx) {
// switching off
digitalWrite(pinTx, HIGH);
}
if(countTx != 255) { countTx--; }
if(countErr && countErr != 255) {
// switch led on
digitalWrite(pinEr, LOW);
} else if(!countErr) {
// switching off
digitalWrite(pinEr, HIGH);
}
if(countErr != 255) { countErr--; }
}
void MyMQTT::rxBlink(uint8_t cnt) {
if(countRx == 255) { countRx = cnt; }
}
void MyMQTT::txBlink(uint8_t cnt) {
if(countTx == 255) { countTx = cnt; }
}
void MyMQTT::errBlink(uint8_t cnt) {
if(countErr == 255) { countErr = cnt; }
}
char MyMQTT::strncpysType_retL(char *str, char index, char start) {
char c;
char l;
char *p = (char *)pgm_read_word(&(sType[index]));
str+=start;
while ((c = pgm_read_byte(p))) {
*str=c;
str++;
p++;
l++;
}
*str=0;
return l;
}
libraries/MySensors/MyMQTT.h
Executable
+90
View File
@@ -0,0 +1,90 @@
/*
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
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 MyMQTT_h
#define MyMQTT_h
#include "MySensor.h"
///////////////////////////////////////////////////////////////////////////////////
#ifdef DEBUG
#define TCPDUMP // Dump TCP packages.
#endif
#define MQTT_FIRST_SENSORID 20 // If you want manually configured nodes below this value.
#define MQTT_LAST_SENSORID 254 // 254 is max! 255 reserved.
#define MQTT_BROKER_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.
///////////////////////////////////////////////////////////////////////////////////
#define EEPROM_LATEST_NODE_ADDRESS EEPROM_LOCAL_CONFIG_ADDRESS+0
#define MQTT_MAX_PACKET_SIZE 100
#define MQTTPROTOCOLVERSION 3
#define MQTTCONNECT 1 // Client request to connect to Server
#define MQTTCONNACK 2 // Connect Acknowledgment
#define MQTTPUBLISH 3 // Publish message
#define MQTTPUBACK 4 // Publish Acknowledgment
#define MQTTPUBREC 5 // Publish Received (assured delivery part 1)
#define MQTTPUBREL 6 // Publish Release (assured delivery part 2)
#define MQTTPUBCOMP 7 // Publish Complete (assured delivery part 3)
#define MQTTSUBSCRIBE 8 // Client Subscribe request
#define MQTTSUBACK 9 // Subscribe Acknowledgment
#define MQTTUNSUBSCRIBE 10 // Client Unsubscribe request
#define MQTTUNSUBACK 11 // Unsubscribe Acknowledgment
#define MQTTPINGREQ 12 // PING Request
#define MQTTPINGRESP 13 // PING Response
#define MQTTDISCONNECT 14 // Client is Disconnecting
#define MQTTReserved 15 // Reserved
#define MQTTQOS0 (0 << 1)
#define MQTTQOS1 (1 << 1)
#define MQTTQOS2 (2 << 1)
#define MyTestVar F("Test")
class MyMQTT :
public MySensor {
public:
MyMQTT(uint8_t _cepin=5, uint8_t _cspin=6, uint8_t _rx=NULL, uint8_t _tx=NULL, uint8_t _er=NULL);
void begin(rf24_pa_dbm_e paLevel=RF24_PA_LEVEL_GW, uint8_t channel=RF24_CHANNEL, rf24_datarate_e dataRate=RF24_DATARATE, void (*dataCallback)(char *, int *)=NULL);
void processRadioMessage();
void processMQTTMessage(char *inputString, int inputPos);
boolean isLedMode();
void ledTimersInterrupt();
private:
bool MQTTClientConnected;
char buffer[MQTT_MAX_PACKET_SIZE];
int buffsize;
char convBuf[MAX_PAYLOAD*2+1];
boolean useWriteCallback;
void (*dataCallback)(char *, int *);
void SendMQTT(MyMessage &msg);
char strncpysType_retL(char *str, char index, char start);
volatile uint8_t countRx;
volatile uint8_t countTx;
volatile uint8_t countErr;
uint8_t pinRx;
uint8_t pinTx;
uint8_t pinEr;
boolean ledMode;
void ledTimers();
void rxBlink(uint8_t cnt);
void txBlink(uint8_t cnt);
void errBlink(uint8_t cnt);
};
#endif
libraries/MySensors/MySensor.cpp
+1 -1
View File
@@ -275,7 +275,7 @@ boolean MySensor::process() {
msg.sender, msg.last, msg.destination, msg.sensor, mGetCommand(msg), msg.type, mGetPayloadType(msg), mGetLength(msg), msg.getString(convBuf));
if(!(mGetVersion(msg) == PROTOCOL_VERSION)) {
debug(PSTR("version mismatch"));
debug(PSTR("version mismatch\n"));
return false;
}
libraries/MySensors/examples/RelayWithButtonActuator/RelayWithButtonActuator.ino
+1 -1
View File
@@ -70,7 +70,7 @@ void incomingMessage(const MyMessage &message) {
Serial.println("This is an ack from gateway");
}
if (message.type==V_LIGHT) {
if (message.type == V_LIGHT && strlen(msg.getString()) != 0) {
// Change relay state
state = message.getBool();
digitalWrite(RELAY_PIN, state?RELAY_ON:RELAY_OFF);