void StatusReporterModule::TimerEventHandler(u16 passedTime, u32 appTimer)
{
//Every reporting interval, the node should send its connections
if(configuration.connectionReportingIntervalMs != 0 && node->appTimerMs - lastConnectionReportingTimer > configuration.connectionReportingIntervalMs)
{
//Send connection info
SendAllConnections(NODE_ID_BROADCAST, MESSAGE_TYPE_MODULE_GENERAL);
lastConnectionReportingTimer = node->appTimerMs;
}
//Every reporting interval, the node should send its status
if(configuration.statusReportingIntervalMs != 0 && node->appTimerMs - lastStatusReportingTimer > configuration.statusReportingIntervalMs)
{
//Send status
SendStatus(NODE_ID_BROADCAST, MESSAGE_TYPE_MODULE_ACTION_RESPONSE);
SendDeviceInfo(NODE_ID_BROADCAST, MESSAGE_TYPE_MODULE_ACTION_RESPONSE);
lastStatusReportingTimer = node->appTimerMs;
}
}
bool DeviceProxy::SendResponse(unsigned short id, unsigned long cnt, const void* recvData, int recvDataLength)
{
CriticalSection::ScopedLocker locker(m_criSecConnect);
m_curCommand.id = id;
switch(id)
{
case RESULT_GET_DEVICE_INFO:
return SendDeviceInfo(cnt, recvData, recvDataLength);
break;
case RESULT_GET_CIS_CORRECTION_TABLE:
return SendCISCorrectionTable(cnt, recvData, recvDataLength);
break;
case RESULT_SET_TIME:
return SendSetTime(cnt, recvData, recvDataLength);
break;
case RESULT_ECHO:
return SendEcho(cnt, recvData, recvDataLength);
break;
case RESULT_UPGRADE:
return SendUpgrade(cnt, recvData, recvDataLength);
break;
case RESULT_UPGRADE_DATA:
return SendUpgradeData(cnt, recvData, recvDataLength);
break;
case RESULT_UPDATE_DEBUG_STATE:
return SendUpgradeDebugState(cnt, recvData, recvDataLength);
break;
case RESULT_RESTART:
return SendRestart(cnt, recvData, recvDataLength);
break;
case RESULT_SET_IR_PARAMETERS:
return SendSetIRParameters(cnt, recvData, recvDataLength);
break;
case RESULT_GET_IR_VALUES:
return SendGetIRValues(cnt, recvData, recvDataLength);
break;
case RESULT_UPDATE_IR_PARAMETERS:
return SendUpdateIRParameters(cnt, recvData, recvDataLength);
break;
case RESULT_START_MOTOR:
return SendStartMotor(cnt, recvData, recvDataLength);
break;
case RESULT_START_RUN_CASH_DETECT:
return SendStartRunCashDetect(cnt, recvData, recvDataLength);
default:
return false;
break;
}
}
void MQTT::on_message(const struct mosquitto_message *message)
{
std::string topic = message->topic;
std::string qMessage = std::string((char*)message->payload, (char*)message->payload + message->payloadlen);
_log.Log(LOG_NORM, "MQTT: Topic: %s, Message: %s", topic.c_str(), qMessage.c_str());
if (qMessage.empty())
return;
if (topic.find("MyMQTT") != std::string::npos)
{
//MySensors message
ProcessMySensorsMessage(qMessage);
return;
}
else if (topic != TOPIC_IN)
return;
Json::Value root;
Json::Reader jReader;
std::string szCommand = "udevice";
std::vector<std::vector<std::string> > result;
unsigned long long idx = 0;
bool ret = jReader.parse(qMessage, root);
if (!ret)
goto mqttinvaliddata;
if (!root["command"].empty())
{
if (!root["command"].isString())
goto mqttinvaliddata;
szCommand = root["command"].asString();
}
if ((szCommand == "udevice") || (szCommand == "switchlight") || (szCommand == "getdeviceinfo"))
{
if (root["idx"].empty())
goto mqttinvaliddata;
if (!root["idx"].isInt64())
goto mqttinvaliddata;
idx = (unsigned long long)root["idx"].asInt64();
//Get the raw device parameters
result = m_sql.safe_query("SELECT HardwareID, DeviceID, Unit, Type, SubType FROM DeviceStatus WHERE (ID==%llu)", idx);
if (result.empty())
{
_log.Log(LOG_ERROR, "MQTT: unknown idx received!");
return;
}
}
else if (szCommand == "switchscene")
{
if (root["idx"].empty())
goto mqttinvaliddata;
if (!root["idx"].isInt64())
goto mqttinvaliddata;
idx = (unsigned long long)root["idx"].asInt64();
result = m_sql.safe_query("SELECT Name FROM Scenes WHERE (ID==%llu)", idx);
if (result.empty())
{
_log.Log(LOG_ERROR, "MQTT: unknown idx received!");
return;
}
}
else if (szCommand == "setuservariable")
{
if (root["idx"].empty())
goto mqttinvaliddata;
if (!root["idx"].isInt64())
goto mqttinvaliddata;
idx = (unsigned long long)root["idx"].asInt64();
result = m_sql.safe_query("SELECT Name FROM UserVariables WHERE (ID==%llu)", idx);
if (result.empty())
{
_log.Log(LOG_ERROR, "MQTT: unknown idx received!");
return;
}
}
if (szCommand == "udevice")
{
int HardwareID = atoi(result[0][0].c_str());
std::string DeviceID = result[0][1];
int unit = atoi(result[0][2].c_str());
int devType = atoi(result[0][3].c_str());
int subType = atoi(result[0][4].c_str());
bool bnvalue = !root["nvalue"].empty();
bool bsvalue = !root["svalue"].empty();
bool bParseValue = !root["parse"].empty();
if (!bnvalue && !bsvalue)
goto mqttinvaliddata;
if (bnvalue)
{
if (!root["nvalue"].isInt())
goto mqttinvaliddata;
}
if (bsvalue)
{
if (!root["svalue"].isString())
goto mqttinvaliddata;
}
int nvalue = (bnvalue) ? root["nvalue"].asInt() : 0;
std::string svalue = (bsvalue) ? root["svalue"].asString() : "";
bool bParseTrigger = (bParseValue) ? root["parse"].asBool() : true;
int signallevel = 12;
int batterylevel = 255;
if (!m_mainworker.UpdateDevice(HardwareID, DeviceID, unit, devType, subType, nvalue, svalue, signallevel, batterylevel, bParseTrigger))
{
_log.Log(LOG_ERROR, "MQTT: Problem updating sensor (check idx, hardware enabled)");
return;
}
return;
}
else if (szCommand == "switchlight")
{
if (root["switchcmd"].empty())
goto mqttinvaliddata;
if (!root["switchcmd"].isString())
goto mqttinvaliddata;
std::string switchcmd = root["switchcmd"].asString();
if ((switchcmd != "On") && (switchcmd != "Off") && (switchcmd != "Toggle") && (switchcmd != "Set Level"))
goto mqttinvaliddata;
int level = 0;
if (!root["level"].empty())
{
if (root["level"].isString())
level = atoi(root["level"].asString().c_str());
else
level = root["level"].asInt();
}
if (!m_mainworker.SwitchLight(idx, switchcmd, level, -1, false, 0) == true)
{
_log.Log(LOG_ERROR, "MQTT: Error sending switch command!");
}
return;
}
else if (szCommand == "switchscene")
{
if (root["switchcmd"].empty())
goto mqttinvaliddata;
if (!root["switchcmd"].isString())
goto mqttinvaliddata;
std::string switchcmd = root["switchcmd"].asString();
if ((switchcmd != "On") && (switchcmd != "Off"))
goto mqttinvaliddata;
if (!m_mainworker.SwitchScene(idx, switchcmd) == true)
{
_log.Log(LOG_ERROR, "MQTT: Error sending scene command!");
}
return;
}
else if (szCommand == "setuservariable")
{
if (root["value"].empty())
goto mqttinvaliddata;
if (!root["value"].isString())
goto mqttinvaliddata;
std::string varvalue = root["value"].asString();
m_sql.SetUserVariable(idx, varvalue, true);
return;
}
else if (szCommand == "addlogmessage")
{
if (root["message"].empty())
goto mqttinvaliddata;
if (!root["message"].isString())
goto mqttinvaliddata;
std::string msg = root["message"].asString();
_log.Log(LOG_STATUS, "MQTT MSG: %s", msg.c_str());
return;
}
else if (szCommand == "sendnotification")
{
std::string subject(""), body(""), sound("");
int priority = 0;
if (!root["subject"].empty())
{
if (!root["subject"].isString())
goto mqttinvaliddata;
subject = root["subject"].asString();
}
if (!root["body"].empty())
{
if (!root["body"].isString())
goto mqttinvaliddata;
body = root["body"].asString();
}
if (!root["priority"].empty())
{
if (!root["priority"].isInt())
goto mqttinvaliddata;
priority = root["priority"].asInt();
}
if (!root["sound"].empty())
{
if (!root["sound"].isString())
goto mqttinvaliddata;
sound = root["sound"].asString();
}
m_notifications.SendMessageEx(NOTIFYALL, subject, body, "", priority, sound, true);
std::string varvalue = root["value"].asString();
m_sql.SetUserVariable(idx, varvalue, true);
return;
}
else if (szCommand == "getdeviceinfo")
{
int HardwareID = atoi(result[0][0].c_str());
SendDeviceInfo(HardwareID, idx, "request device", NULL);
return;
}
else
{
_log.Log(LOG_ERROR, "MQTT: Unknown command received: %s", szCommand.c_str());
return;
}
mqttinvaliddata:
_log.Log(LOG_ERROR, "MQTT: Invalid data received!");
}
void StatusReporterModule::ConnectionPacketReceivedEventHandler(connectionPacket* inPacket, Connection* connection, connPacketHeader* packetHeader, u16 dataLength)
{
//Must call superclass for handling
Module::ConnectionPacketReceivedEventHandler(inPacket, connection, packetHeader, dataLength);
if(packetHeader->messageType == MESSAGE_TYPE_MODULE_TRIGGER_ACTION){
connPacketModule* packet = (connPacketModule*)packetHeader;
//Check if our module is meant and we should trigger an action
if(packet->moduleId == moduleId){
//We were queried for our status
if(packet->actionType == StatusModuleTriggerActionMessages::GET_STATUS)
{
SendStatus(packet->header.sender, MESSAGE_TYPE_MODULE_ACTION_RESPONSE);
}//We were queried for our device info
else if(packet->actionType == StatusModuleTriggerActionMessages::GET_DEVICE_INFO)
{
SendDeviceInfo(packet->header.sender, MESSAGE_TYPE_MODULE_ACTION_RESPONSE);
}
//We were queried for our connections
else if(packet->actionType == StatusModuleTriggerActionMessages::GET_ALL_CONNECTIONS)
{
StatusReporterModule::SendAllConnections(packetHeader->sender, MESSAGE_TYPE_MODULE_ACTION_RESPONSE);
}
//We were queried for nearby nodes (nodes in the join_me buffer)
else if(packet->actionType == StatusModuleTriggerActionMessages::GET_NEARBY_NODES)
{
StatusReporterModule::SendNearbyNodes(packetHeader->sender, MESSAGE_TYPE_MODULE_ACTION_RESPONSE);
}
//We should set ourselves initialized
else if(packet->actionType == StatusModuleTriggerActionMessages::SET_INITIALIZED)
{
node->initializedByGateway = true;
SendModuleActionMessage(
MESSAGE_TYPE_MODULE_ACTION_RESPONSE,
packet->header.sender,
StatusModuleActionResponseMessages::SET_INITIALIZED_RESULT,
0,
NULL,
0,
false
);
}
}
}
//Parse Module responses
if(packetHeader->messageType == MESSAGE_TYPE_MODULE_ACTION_RESPONSE){
connPacketModule* packet = (connPacketModule*)packetHeader;
//Check if our module is meant and we should trigger an action
if(packet->moduleId == moduleId)
{
//Somebody reported its connections back
if(packet->actionType == StatusModuleActionResponseMessages::ALL_CONNECTIONS)
{
StatusReporterModuleConnectionsMessage* packetData = (StatusReporterModuleConnectionsMessage*) (packet->data);
uart("STATUSMOD", "{\"type\":\"connections\",\"nodeId\":%d,\"module\":%d,\"partners\":[%d,%d,%d,%d],\"rssiValues\":[%d,%d,%d,%d]}" SEP, packet->header.sender, moduleId, packetData->partner1, packetData->partner2, packetData->partner3, packetData->partner4, packetData->rssi1, packetData->rssi2, packetData->rssi3, packetData->rssi4);
}
else if(packet->actionType == StatusModuleActionResponseMessages::DEVICE_INFO)
{
//Print packet to console
StatusReporterModuleDeviceInfoMessage* data = (StatusReporterModuleDeviceInfoMessage*) (packet->data);
u8* addr = data->accessAddress.addr;
uart("STATUSMOD", "{\"nodeId\":%u,\"type\":\"device_info\",\"module\":%d,", packet->header.sender, moduleId);
uart("STATUSMOD", "\"dBmRX\":%u,\"dBmTX\":%u,", data->dBmRX, data->dBmTX);
uart("STATUSMOD", "\"deviceType\":%u,\"manufacturerId\":%u,", data->deviceType, data->manufacturerId);
uart("STATUSMOD", "\"networkId\":%u,\"nodeVersion\":%u,", data->networkId, data->nodeVersion);
uart("STATUSMOD", "\"chipId\":\"%02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X\",", data->chipId[0], data->chipId[1], data->chipId[2], data->chipId[3], data->chipId[4], data->chipId[5], data->chipId[6], data->chipId[7]);
uart("STATUSMOD", "\"serialNumber\":\"%.*s\",\"accessAddress\":\"%02X:%02X:%02X:%02X:%02X:%02X\"", SERIAL_NUMBER_LENGTH, data->serialNumber, addr[5], addr[4], addr[3], addr[2], addr[1], addr[0]);
uart("STATUSMOD", "}" SEP);
}
else if(packet->actionType == StatusModuleActionResponseMessages::STATUS)
{
//Print packet to console
StatusReporterModuleStatusMessage* data = (StatusReporterModuleStatusMessage*) (packet->data);
uart("STATUSMOD", "{\"nodeId\":%u,\"type\":\"status\",\"module\":%d,", packet->header.sender, moduleId);
uart("STATUSMOD", "\"batteryInfo\":%u,\"clusterSize\":%u,", data->batteryInfo, data->clusterSize);
uart("STATUSMOD", "\"connectionLossCounter\":%u,\"freeIn\":%u,", data->connectionLossCounter, data->freeIn);
uart("STATUSMOD", "\"freeOut\":%u,\"inConnectionPartner\":%u,", data->freeOut, data->inConnectionPartner);
uart("STATUSMOD", "\"inConnectionRSSI\":%d, \"initialized\":%u", data->inConnectionRSSI, data->initializedByGateway);
uart("STATUSMOD", "}" SEP);
}
else if(packet->actionType == StatusModuleActionResponseMessages::NEARBY_NODES)
{
//Print packet to console
uart("STATUSMOD", "{\"nodeId\":%u,\"type\":\"nearby_nodes\",\"module\":%u,\"nodes\":[", packet->header.sender, moduleId);
u16 nodeCount = (dataLength - SIZEOF_CONN_PACKET_MODULE) / 3;
bool first = true;
for(int i=0; i<nodeCount; i++){
u16 nodeId;
i8 rssi;
//TODO: Find a nicer way to access unaligned data in packets
memcpy(&nodeId, packet->data + i*3+0, 2);
memcpy(&rssi, packet->data + i*3+2, 1);
if(!first){
uart("STATUSMOD", ",");
}
uart("STATUSMOD", "{\"nodeId\":%u,\"rssi\":%d}", nodeId, rssi);
first = false;
}
uart("STATUSMOD", "]}" SEP);
}
else if(packet->actionType == StatusModuleActionResponseMessages::SET_INITIALIZED_RESULT)
{
uart("STATUSMOD", "{\"type\":\"set_init_result\",\"nodeId\":%u,\"module\":%u}" SEP, packet->header.sender, moduleId);
}
}
}
}
