//-----------------------------------------------------------------------------
// <SensorAlarm::RequestValue>
// Get the sensor alarm details from the device
//-----------------------------------------------------------------------------
bool SensorAlarm::RequestValue
(
uint32 const _requestFlags,
uint8 const _alarmType,
uint8 const _instance,
Driver::MsgQueue const _queue
)
{
if( _alarmType == 0xff )
{
// Request the supported alarm types
Msg* msg = new Msg( "Request Supported Alarm Types", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true, true, FUNC_ID_APPLICATION_COMMAND_HANDLER, GetCommandClassId() );
msg->SetInstance( this, _instance );
msg->Append( GetNodeId() );
msg->Append( 2 );
msg->Append( GetCommandClassId() );
msg->Append( SensorAlarmCmd_SupportedGet );
msg->Append( TRANSMIT_OPTION_ACK | TRANSMIT_OPTION_AUTO_ROUTE );
GetDriver()->SendMsg( msg, _queue );
}
else
{
// Request the alarm state
Msg* msg = new Msg( "Request alarm state", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true, true, FUNC_ID_APPLICATION_COMMAND_HANDLER, GetCommandClassId() );
msg->SetInstance( this, _instance );
msg->Append( GetNodeId() );
msg->Append( 3 );
msg->Append( GetCommandClassId() );
msg->Append( SensorAlarmCmd_Get );
msg->Append( _alarmType );
msg->Append( TRANSMIT_OPTION_ACK | TRANSMIT_OPTION_AUTO_ROUTE );
GetDriver()->SendMsg( msg, _queue );
}
return true;
}
//-----------------------------------------------------------------------------
// <Protection::SetValue>
// Set the device's protection state
//-----------------------------------------------------------------------------
bool Protection::SetValue
(
Value const& _value
)
{
if( ValueID::ValueType_List == _value.GetID().GetType() )
{
ValueList const* value = static_cast<ValueList const*>(&_value);
ValueList::Item const& item = value->GetItem();
Log::Write( LogLevel_Info, GetNodeId(), "Protection::Set - Setting protection state to '%s'", item.m_label.c_str() );
Msg* msg = new Msg( "Protection Set", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true );
msg->SetInstance( this, _value.GetID().GetInstance() );
msg->Append( GetNodeId() );
msg->Append( 3 );
msg->Append( GetCommandClassId() );
msg->Append( ProtectionCmd_Set );
msg->Append( (uint8)item.m_value );
msg->Append( GetDriver()->GetTransmitOptions() );
GetDriver()->SendMsg( msg, Driver::MsgQueue_Send );
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// <ZWavePlusInfo::RequestValue>
// Request current value from the device
//-----------------------------------------------------------------------------
bool ZWavePlusInfo::RequestValue
(
uint32 const _requestFlags,
uint8 const _dummy1, // = 0 (not used)
uint8 const _instance,
Driver::MsgQueue const _queue
)
{
if( _instance != 1 )
{
// This command class doesn't work with multiple instances
return false;
}
if ( IsGetSupported() )
{
Msg* msg = new Msg( "ZWavePlusInfoCmd_Get", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true, true, FUNC_ID_APPLICATION_COMMAND_HANDLER, GetCommandClassId() );
msg->SetInstance( this, _instance );
msg->Append( GetNodeId() );
msg->Append( 2 );
msg->Append( GetCommandClassId() );
msg->Append( ZWavePlusInfoCmd_Get );
msg->Append( GetDriver()->GetTransmitOptions() );
GetDriver()->SendMsg( msg, _queue );
return true;
} else {
Log::Write( LogLevel_Info, GetNodeId(), "ZWavePlusInfoCmd_Get Not Supported on this node");
}
return false;
}
//-----------------------------------------------------------------------------
// <Basic::SetValue>
// Set a value on the Z-Wave device
//-----------------------------------------------------------------------------
bool Basic::SetValue
(
Value const& _value
)
{
Log::Write(LogLevel_Info,"Basic set");
if( ValueID::ValueType_Byte == _value.GetID().GetType() )
{
ValueByte const* value = static_cast<ValueByte const*>(&_value);
Log::Write(LogLevel_Info,"send a basic value out");
Msg* msg = new Msg( "Basic Set", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true );
msg->SetInstance( this, _value.GetID().GetInstance() );
msg->Append( GetNodeId() );
msg->Append( 3 );
msg->Append( GetCommandClassId() );
msg->Append( BasicCmd_Set );
msg->Append( value->GetValue() );
msg->Append( GetDriver()->GetTransmitOptions() );
if (m_has485) {
GetDriver()->Send485(GetNodeId(),msg,Driver::MsgQueue_Send);
return true;
} else {
GetDriver()->SendMsg( msg, Driver::MsgQueue_Send );
return true;
}
webdebug_add(TYPE_ZWAVE, ZWAVE_COMMAND, GetCommandClassId(), GetNodeId(), _value.GetID().GetInstance(), value->GetValue());
} else {
Log::Write(LogLevel_Info,"Type error %d", _value.GetID().GetType());
}
return false;
}
//-----------------------------------------------------------------------------
// <SwitchMultilevel::RequestValue>
// Request current value from the device
//-----------------------------------------------------------------------------
bool SwitchMultilevel::RequestValue
(
uint32 const _requestFlags,
uint8 const _index,
uint8 const _instance,
Driver::MsgQueue const _queue
)
{
if( _index == SwitchMultilevelIndex_Level )
{
if ( IsGetSupported() )
{
Msg* msg = new Msg( "SwitchMultilevelCmd_Get", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true, true, FUNC_ID_APPLICATION_COMMAND_HANDLER, GetCommandClassId() );
msg->SetInstance( this, _instance );
msg->Append( GetNodeId() );
msg->Append( 2 );
msg->Append( GetCommandClassId() );
msg->Append( SwitchMultilevelCmd_Get );
msg->Append( GetDriver()->GetTransmitOptions() );
GetDriver()->SendMsg( msg, _queue );
return true;
} else {
Log::Write( LogLevel_Info, GetNodeId(), "SwitchMultilevelCmd_Get Not Supported on this node");
}
}
return false;
}
//-----------------------------------------------------------------------------
// <SwitchAll::SetValue>
// Set the device's response to SWITCH_ALL commands
//-----------------------------------------------------------------------------
bool SwitchAll::SetValue
(
Value const& _value
)
{
if( ValueID::ValueType_List == _value.GetID().GetType() )
{
ValueList const* value = static_cast<ValueList const*>(&_value);
ValueList::Item const *item = value->GetItem();
if (item == NULL)
return false;
Log::Write( LogLevel_Info, GetNodeId(), "SwitchAll::Set - %s on node %d", item->m_label.c_str(), GetNodeId() );
Msg* msg = new Msg( "SwitchAllCmd_Set", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true );
msg->SetInstance( this, _value.GetID().GetInstance() );
msg->Append( GetNodeId() );
msg->Append( 3 );
msg->Append( GetCommandClassId() );
msg->Append( SwitchAllCmd_Set );
msg->Append( (uint8)item->m_value );
msg->Append( GetDriver()->GetTransmitOptions() );
GetDriver()->SendMsg( msg, Driver::MsgQueue_Send );
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// <SensorMultilevel::RequestState>
// Request current state from the device
//-----------------------------------------------------------------------------
bool SensorMultilevel::RequestState
(
uint32 const _requestFlags,
uint8 const _instance,
Driver::MsgQueue const _queue
)
{
bool res = false;
if( GetVersion() > 4 )
{
if( _requestFlags & RequestFlag_Static )
{
Msg* msg = new Msg( "SensorMultilevelCmd_SupportedGet", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true, true, FUNC_ID_APPLICATION_COMMAND_HANDLER, GetCommandClassId() );
msg->SetInstance( this, _instance );
msg->Append( GetNodeId() );
msg->Append( 2 );
msg->Append( GetCommandClassId() );
msg->Append( SensorMultilevelCmd_SupportedGet );
msg->Append( GetDriver()->GetTransmitOptions() );
GetDriver()->SendMsg( msg, _queue );
res = true;
}
}
if( _requestFlags & RequestFlag_Dynamic )
{
res |= RequestValue( _requestFlags, 0, _instance, _queue );
}
return res;
}
//-----------------------------------------------------------------------------
// <ManufacturerProprietary::SetValue>
// Set the lock's state
//-----------------------------------------------------------------------------
bool ManufacturerProprietary::SetValue
(
Value const& _value
)
{
uint64 value_id = _value.GetID().GetIndex();
Msg* msg = new Msg( "ManufacturerProprietary_SetValue", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true, true, FUNC_ID_APPLICATION_COMMAND_HANDLER, GetCommandClassId() );
if (FibaroVenetianBlindsValueIds_Blinds == value_id || FibaroVenetianBlindsValueIds_Tilt == value_id){
ValueByte const* value = static_cast<ValueByte const*>(&_value);
msg->SetInstance( this, _value.GetID().GetInstance() );
msg->Append( GetNodeId() );
msg->Append( 2 + // length of data
sizeof(MANUFACTURER_ID_FIBARO) +
sizeof(FIBARO_VENETIAN_BLINDS_GET_POSITION_TILT) );
msg->Append( GetCommandClassId() );
msg->AppendArray( MANUFACTURER_ID_FIBARO, sizeof(MANUFACTURER_ID_FIBARO) );
if (FibaroVenetianBlindsValueIds_Blinds == value_id) {
msg->AppendArray( FIBARO_VENETIAN_BLINDS_SET_POSITION, sizeof(FIBARO_VENETIAN_BLINDS_SET_POSITION) );
msg->Append( value->GetValue() );
msg->Append( 0x00 );
} else if (FibaroVenetianBlindsValueIds_Tilt == value_id) {
msg->AppendArray( FIBARO_VENETIAN_BLINDS_SET_TILT, sizeof(FIBARO_VENETIAN_BLINDS_SET_TILT) );
msg->Append( value->GetValue() );
}
msg->Append( GetDriver()->GetTransmitOptions() );
GetDriver()->SendMsg( msg, Driver::MsgQueue_Send );
return true;
} else {
Log::Write( LogLevel_Info, GetNodeId(), "ManufacturerProprietary_SetValue %d not supported on node %d", value_id, GetNodeId());
return false;
}
}
//-----------------------------------------------------------------------------
// <ManufacturerProprietary::RequestValue>
// Request current value from the device
//-----------------------------------------------------------------------------
bool ManufacturerProprietary::RequestValue
(
uint32 const _requestFlags,
uint16 const _index,
uint8 const _instance,
Driver::MsgQueue const _queue
)
{
if ( IsGetSupported() )
{
Msg* msg = new Msg( "ManufacturerProprietary_RequestValue", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true, true, FUNC_ID_APPLICATION_COMMAND_HANDLER, GetCommandClassId() );
if (FibaroVenetianBlindsValueIds_Blinds == _index || FibaroVenetianBlindsValueIds_Tilt == _index){
msg->SetInstance( this, _instance );
msg->Append( GetNodeId() );
msg->Append( 1+sizeof(MANUFACTURER_ID_FIBARO)+sizeof(FIBARO_VENETIAN_BLINDS_GET_POSITION_TILT) ); // length of data
msg->Append( GetCommandClassId() );
msg->AppendArray( MANUFACTURER_ID_FIBARO, sizeof(MANUFACTURER_ID_FIBARO) );
msg->AppendArray( FIBARO_VENETIAN_BLINDS_GET_POSITION_TILT, sizeof(FIBARO_VENETIAN_BLINDS_GET_POSITION_TILT) );
msg->Append( GetDriver()->GetTransmitOptions() );
GetDriver()->SendMsg( msg, _queue );
return true;
} else {
Log::Write( LogLevel_Info, GetNodeId(), "ManufacturerProprietary_RequestValue Not Supported for value index %d",
_index);
}
} else {
Log::Write( LogLevel_Info, GetNodeId(), "ManufacturerProprietary_RequestValue Not Supported on this node");
}
return false;
}
//-----------------------------------------------------------------------------
// <ThermostatFanState::RequestValue>
// Get the thermostat fan state details from the device
//-----------------------------------------------------------------------------
bool ThermostatFanState::RequestValue
(
uint32 const _requestFlags,
uint8 const _dummy1, // = 0 (not used)
uint8 const _instance,
Driver::MsgQueue const _queue
)
{
if ( IsGetSupported() )
{
// Request the current state
Msg* msg = new Msg( "ThermostatFanStateCmd_Get", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true, true, FUNC_ID_APPLICATION_COMMAND_HANDLER, GetCommandClassId() );
msg->SetInstance( this, _instance );
msg->Append( GetNodeId() );
msg->Append( 2 );
msg->Append( GetCommandClassId() );
msg->Append( ThermostatFanStateCmd_Get );
msg->Append( GetDriver()->GetTransmitOptions() );
GetDriver()->SendMsg( msg, _queue );
return true;
} else {
Log::Write( LogLevel_Info, GetNodeId(), "ThermostatFanStateCmd_Get Not Supported on this node");
}
return false;
}
//-----------------------------------------------------------------------------
// <BasicWindowCovering::SetValue>
// Set a value on the Z-Wave device
//-----------------------------------------------------------------------------
bool BasicWindowCovering::SetValue
(
Value const& _value
)
{
if( ValueID::ValueType_Button == _value.GetID().GetType() )
{
ValueButton const* button = static_cast<ValueButton const*>(&_value);
uint8 action = 0x40;
if( button->GetID().GetIndex() ) // Open is index zero, so non-zero is close.
{
// Close
action = 0;
}
if( button && button->IsPressed() )
{
Log::Write( LogLevel_Info, GetNodeId(), "BasicWindowCovering - Start Level Change (%s)", action ? "Open" : "Close" );
Msg* msg = new Msg( "Basic Set", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true );
msg->SetInstance( this, _value.GetID().GetInstance() );
msg->Append( GetNodeId() );
msg->Append( 3 );
msg->Append( GetCommandClassId() );
msg->Append( BasicWindowCoveringCmd_StartLevelChange );
msg->Append( action );
msg->Append( GetDriver()->GetTransmitOptions() );
GetDriver()->SendMsg( msg, Driver::MsgQueue_Send );
return true;
}
else
{
Log::Write( LogLevel_Info, GetNodeId(), "BasicWindowCovering - Stop Level Change" );
Msg* msg = new Msg( "Basic Set", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true );
msg->SetInstance( this, _value.GetID().GetInstance() );
msg->Append( GetNodeId() );
msg->Append( 2 );
msg->Append( GetCommandClassId() );
msg->Append( BasicWindowCoveringCmd_StopLevelChange );
msg->Append( GetDriver()->GetTransmitOptions() );
GetDriver()->SendMsg( msg, Driver::MsgQueue_Send );
return true;
}
}
return false;
}
//-----------------------------------------------------------------------------
// <SensorMultilevel::RequestValue>
// Request current value from the device
//-----------------------------------------------------------------------------
bool SensorMultilevel::RequestValue
(
uint32 const _requestFlags,
uint8 const _dummy, // = 0 (not used)
uint8 const _instance,
Driver::MsgQueue const _queue
)
{
bool res = false;
if( GetVersion() < 5 )
{
Msg* msg = new Msg( "SensorMultilevelCmd_Get", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true, true, FUNC_ID_APPLICATION_COMMAND_HANDLER, GetCommandClassId() );
msg->SetInstance( this, _instance );
msg->Append( GetNodeId() );
msg->Append( 2 );
msg->Append( GetCommandClassId() );
msg->Append( SensorMultilevelCmd_Get );
msg->Append( GetDriver()->GetTransmitOptions() );
GetDriver()->SendMsg( msg, _queue );
res = true;
}
else
{
for( uint8 i = 1; i < SensorType_MaxType; i++ )
{
Value* value = GetValue( _instance, i );
if( value != NULL )
{
value->Release();
Msg* msg = new Msg( "SensorMultilevelCmd_Get", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true, true, FUNC_ID_APPLICATION_COMMAND_HANDLER, GetCommandClassId() );
msg->SetInstance( this, _instance );
msg->Append( GetNodeId() );
msg->Append( 3 );
msg->Append( GetCommandClassId() );
msg->Append( SensorMultilevelCmd_Get );
msg->Append( i );
msg->Append( GetDriver()->GetTransmitOptions() );
GetDriver()->SendMsg( msg, _queue );
res = true;
}
}
}
return res;
}
//-----------------------------------------------------------------------------
// <ThermostatMode::RequestValue>
// Get the static thermostat mode details from the device
//-----------------------------------------------------------------------------
bool ThermostatMode::RequestValue
(
uint32 const _requestFlags,
uint8 const _getTypeEnum,
uint8 const _instance,
Driver::MsgQueue const _queue
)
{
if( _getTypeEnum == ThermostatModeCmd_SupportedGet )
{
// Request the supported modes
Msg* msg = new Msg( "ThermostatModeCmd_SupportedGet", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true, true, FUNC_ID_APPLICATION_COMMAND_HANDLER, GetCommandClassId() );
msg->SetInstance( this, _instance );
msg->Append( GetNodeId() );
msg->Append( 2 );
msg->Append( GetCommandClassId() );
msg->Append( ThermostatModeCmd_SupportedGet );
msg->Append( GetDriver()->GetTransmitOptions() );
GetDriver()->SendMsg( msg, _queue );
return true;
}
if( _getTypeEnum == 0 ) // get current mode
{
if ( IsGetSupported() )
{
// Request the current mode
Msg* msg = new Msg( "ThermostatModeCmd_Get", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true, true, FUNC_ID_APPLICATION_COMMAND_HANDLER, GetCommandClassId() );
msg->SetInstance( this, _instance );
msg->Append( GetNodeId() );
msg->Append( 2 );
msg->Append( GetCommandClassId() );
msg->Append( ThermostatModeCmd_Get );
msg->Append( GetDriver()->GetTransmitOptions() );
GetDriver()->SendMsg( msg, _queue );
return true;
} else {
Log::Write( LogLevel_Info, GetNodeId(), _instance, "ThermostatModeCmd_Get Not Supported on this node");
}
}
return false;
}
//-----------------------------------------------------------------------------
// <SwitchMultilevel::StopLevelChange>
// Stop the level changing
//-----------------------------------------------------------------------------
bool SwitchMultilevel::StopLevelChange
(
uint8 const _instance
)
{
Log::Write( LogLevel_Info, GetNodeId(), "SwitchMultilevel::StopLevelChange - Stopping the level change" );
Msg* msg = new Msg( "SwitchMultilevel StopLevelChange", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true );
msg->SetInstance( this, _instance );
msg->Append( GetNodeId() );
msg->Append( 2 );
msg->Append( GetCommandClassId() );
msg->Append( SwitchMultilevelCmd_StopLevelChange );
msg->Append( GetDriver()->GetTransmitOptions() );
GetDriver()->SendMsg( msg, Driver::MsgQueue_Send );
return true;
}
//-----------------------------------------------------------------------------
// <SwitchToggleBinary::SetValue>
// Toggle the state of the switch
//-----------------------------------------------------------------------------
bool SwitchToggleBinary::SetValue
(
Value const& _value
)
{
Log::Write( LogLevel_Info, GetNodeId(), "SwitchToggleBinary::Set - Toggling the state" );
Msg* msg = new Msg( "SwitchToggleBinary Set", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true );
msg->SetInstance( this, _value.GetID().GetInstance() );
msg->Append( GetNodeId() );
msg->Append( 2 );
msg->Append( GetCommandClassId() );
msg->Append( SwitchToggleBinaryCmd_Set );
msg->Append( TRANSMIT_OPTION_ACK | TRANSMIT_OPTION_AUTO_ROUTE );
GetDriver()->SendMsg( msg, Driver::MsgQueue_Send );
return true;
}
//-----------------------------------------------------------------------------
// <SwitchMultilevel::SetLevel>
// Set a new level for the switch
//-----------------------------------------------------------------------------
bool SwitchMultilevel::SetLevel
(
uint8 const _instance,
uint8 const _level
)
{
Log::Write( LogLevel_Info, GetNodeId(), "SwitchMultilevel::Set - Setting to level %d", _level );
Msg* msg = new Msg( "SwitchMultiLevel Set", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true );
msg->SetInstance( this, _instance );
msg->Append( GetNodeId() );
if( ValueByte* durationValue = static_cast<ValueByte*>( GetValue( _instance, SwitchMultilevelIndex_Duration ) ) )
{
uint8 duration = durationValue->GetValue();
durationValue->Release();
if( duration == 0xff )
{
Log::Write( LogLevel_Info, GetNodeId(), " Duration: Default" );
}
else if( duration >= 0x80 )
{
Log::Write( LogLevel_Info, GetNodeId(), " Duration: %d minutes", duration - 0x7f );
}
else
{
Log::Write( LogLevel_Info, GetNodeId(), " Duration: %d seconds", duration );
}
msg->Append( 4 );
msg->Append( GetCommandClassId() );
msg->Append( SwitchMultilevelCmd_Set );
msg->Append( _level );
msg->Append( duration );
}
else
{
msg->Append( 3 );
msg->Append( GetCommandClassId() );
msg->Append( SwitchMultilevelCmd_Set );
msg->Append( _level );
}
msg->Append( GetDriver()->GetTransmitOptions() );
GetDriver()->SendMsg( msg, Driver::MsgQueue_Send );
return true;
}
//-----------------------------------------------------------------------------
// <SwitchAll::RequestValue>
// Request current value from the device
//-----------------------------------------------------------------------------
bool SwitchAll::RequestValue
(
uint32 const _requestFlags,
uint8 const _dummy1, // = 0 (not used)
uint8 const _instance,
Driver::MsgQueue const _queue
)
{
Msg* msg = new Msg( "SwitchAllCmd_Get", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true, true, FUNC_ID_APPLICATION_COMMAND_HANDLER, GetCommandClassId() );
msg->SetInstance( this, _instance );
msg->Append( GetNodeId() );
msg->Append( 2 );
msg->Append( GetCommandClassId() );
msg->Append( SwitchAllCmd_Get );
msg->Append( GetDriver()->GetTransmitOptions() );
GetDriver()->SendMsg( msg, _queue );
return true;
}
//-----------------------------------------------------------------------------
// <SwitchToggleBinary::RequestValue>
// Request current value from the device
//-----------------------------------------------------------------------------
bool SwitchToggleBinary::RequestValue
(
uint32 const _requestFlags,
uint8 const _dummy1, // = 0 (not used)
uint8 const _instance,
Driver::MsgQueue const _queue
)
{
Msg* msg = new Msg( "SwitchToggleBinaryCmd_Get", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true, true, FUNC_ID_APPLICATION_COMMAND_HANDLER, GetCommandClassId() );
msg->SetInstance( this, _instance );
msg->Append( GetNodeId() );
msg->Append( 2 );
msg->Append( GetCommandClassId() );
msg->Append( SwitchToggleBinaryCmd_Get );
msg->Append( TRANSMIT_OPTION_ACK | TRANSMIT_OPTION_AUTO_ROUTE );
GetDriver()->SendMsg( msg, _queue );
return true;
}
//-----------------------------------------------------------------------------
// <ClimateControlSchedule::RequestValue>
// Request current value from the device
//-----------------------------------------------------------------------------
bool ClimateControlSchedule::RequestValue
(
uint32 const _requestFlags,
uint8 const _dummy1, // = 0 (not used)
uint8 const _instance,
Driver::MsgQueue const _queue
)
{
// See if the schedule has changed since last time
Msg* msg = new Msg( "ClimateControlScheduleCmd_ChangedGet", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true, true, FUNC_ID_APPLICATION_COMMAND_HANDLER, GetCommandClassId() );
msg->SetInstance( this, _instance );
msg->Append( GetNodeId() );
msg->Append( 2 );
msg->Append( GetCommandClassId() );
msg->Append( ClimateControlScheduleCmd_ChangedGet );
msg->Append( GetDriver()->GetTransmitOptions() );
GetDriver()->SendMsg( msg, _queue );
return true;
}
//-----------------------------------------------------------------------------
// <UserCode::SetValue>
// Set a User Code value
//-----------------------------------------------------------------------------
bool UserCode::SetValue
(
Value const& _value
)
{
if( (ValueID::ValueType_Raw == _value.GetID().GetType()) && (_value.GetID().GetIndex() < UserCodeIndex_Refresh) )
{
ValueRaw const* value = static_cast<ValueRaw const*>(&_value);
uint8* s = value->GetValue();
uint8 len = value->GetLength();
if( len > UserCodeLength )
{
return false;
}
m_userCodesStatus[value->GetID().GetIndex()] = UserCode_Occupied;
Msg* msg = new Msg( "UserCodeCmd_Set", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true );
msg->SetInstance( this, _value.GetID().GetInstance() );
msg->Append( GetNodeId() );
msg->Append( 4 + m_userCodeLength );
msg->Append( GetCommandClassId() );
msg->Append( UserCodeCmd_Set );
msg->Append( value->GetID().GetIndex() );
msg->Append( UserCode_Occupied );
for( uint8 i = 0; i < m_userCodeLength; i++ )
{
msg->Append( s[i] );
}
msg->Append( GetDriver()->GetTransmitOptions() );
GetDriver()->SendMsg( msg, Driver::MsgQueue_Send );
return true;
}
if ( (ValueID::ValueType_Button == _value.GetID().GetType()) && (_value.GetID().GetIndex() == UserCodeIndex_Refresh) )
{
m_refreshUserCodes = true;
m_currentCode = 1;
m_queryAll = true;
RequestValue( 0, m_currentCode, _value.GetID().GetInstance(), Driver::MsgQueue_Query );
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// <Basic::SetValue>
// Set a value on the Z-Wave device
//-----------------------------------------------------------------------------
bool Basic::SetValue
(
Value const& _value
)
{
if( ValueID::ValueType_Byte == _value.GetID().GetType() )
{
ValueByte const* value = static_cast<ValueByte const*>(&_value);
Log::Write( LogLevel_Info, GetNodeId(), "Basic::Set - Setting node %d to level %d", GetNodeId(), value->GetValue() );
Msg* msg = new Msg( "Basic Set", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true );
msg->SetInstance( this, _value.GetID().GetInstance() );
msg->Append( GetNodeId() );
msg->Append( 3 );
msg->Append( GetCommandClassId() );
msg->Append( BasicCmd_Set );
msg->Append( value->GetValue() );
msg->Append( GetDriver()->GetTransmitOptions() );
GetDriver()->SendMsg( msg, Driver::MsgQueue_Send );
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// <SwitchBinary::SetValue>
// Set the state of the switch
//-----------------------------------------------------------------------------
bool SwitchBinary::SetValue
(
Value const& _value
)
{
if( ValueID::ValueType_Bool == _value.GetID().GetType() )
{
ValueBool const* value = static_cast<ValueBool const*>(&_value);
Log::Write( LogLevel_Info, GetNodeId(), "SwitchBinary::Set - Setting node %d to %s", GetNodeId(), value->GetValue() ? "On" : "Off" );
Msg* msg = new Msg( "SwitchBinary Set", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true );
msg->SetInstance( this, _value.GetID().GetInstance() );
msg->Append( GetNodeId() );
msg->Append( 3 );
msg->Append( GetCommandClassId() );
msg->Append( SwitchBinaryCmd_Set );
msg->Append( value->GetValue() ? 0xff : 0x00 );
msg->Append( GetDriver()->GetTransmitOptions() );
GetDriver()->SendMsg( msg, Driver::MsgQueue_Send );
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// <Indicator::SetValue>
// Set the device's indicator value
//-----------------------------------------------------------------------------
bool Indicator::SetValue
(
Value const& _value
)
{
if( ValueID::ValueType_Byte == _value.GetID().GetType() )
{
ValueByte const* value = static_cast<ValueByte const*>(&_value);
Log::Write( LogLevel_Info, GetNodeId(), "Indicator::SetValue - Setting indicator to %d", value->GetValue());
Msg* msg = new Msg( "Basic Set", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true );
msg->SetInstance( this, _value.GetID().GetInstance() );
msg->Append( GetNodeId() );
msg->Append( 3 );
msg->Append( GetCommandClassId() );
msg->Append( IndicatorCmd_Set );
msg->Append( value->GetValue() );
msg->Append( TRANSMIT_OPTION_ACK | TRANSMIT_OPTION_AUTO_ROUTE );
GetDriver()->SendMsg( msg, Driver::MsgQueue_Send );
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// <Lock::SetValue>
// Set the lock's state
//-----------------------------------------------------------------------------
bool Lock::SetValue
(
Value const& _value
)
{
if( ValueID::ValueType_Bool == _value.GetID().GetType() )
{
ValueBool const* value = static_cast<ValueBool const*>(&_value);
Log::Write( LogLevel_Info, GetNodeId(), "Lock::Set - Requesting lock to be %s", value->GetValue() ? "Locked" : "Unlocked" );
Msg* msg = new Msg( "LockCmd_Get", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true );
msg->SetInstance( this, _value.GetID().GetInstance() );
msg->Append( GetNodeId() );
msg->Append( 3 );
msg->Append( GetCommandClassId() );
msg->Append( LockCmd_Set );
msg->Append( value->GetValue() ? 0x01:0x00 );
msg->Append( GetDriver()->GetTransmitOptions() );
GetDriver()->SendMsg( msg, Driver::MsgQueue_Send );
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// <ThermostatFanMode::SetValue>
// Set the device's thermostat fan mode
//-----------------------------------------------------------------------------
bool ThermostatFanMode::SetValue
(
Value const& _value
)
{
if( ValueID::ValueType_List == _value.GetID().GetType() )
{
ValueList const* value = static_cast<ValueList const*>(&_value);
uint8 state = (uint8)value->GetItem().m_value;
Msg* msg = new Msg( "ThermostatFanModeCmd_Set", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true );
msg->SetInstance( this, _value.GetID().GetInstance() );
msg->Append( GetNodeId() );
msg->Append( 3 );
msg->Append( GetCommandClassId() );
msg->Append( ThermostatFanModeCmd_Set );
msg->Append( state );
msg->Append( GetDriver()->GetTransmitOptions() );
GetDriver()->SendMsg( msg, Driver::MsgQueue_Send );
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// <ClimateControlSchedule::SetValue>
// Set a value in the device
//-----------------------------------------------------------------------------
bool ClimateControlSchedule::SetValue
(
Value const& _value
)
{
// bool res = false;
uint8 instance = _value.GetID().GetInstance();
uint8 idx = _value.GetID().GetIndex();
if( idx < 8 )
{
// Set a schedule
ValueSchedule const* value = static_cast<ValueSchedule const*>(&_value);
Log::Write( LogLevel_Info, GetNodeId(), instance, "Set the climate control schedule for %s", c_dayNames[idx]);
Msg* msg = new Msg( "ClimateControlScheduleCmd_Set", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true, true, FUNC_ID_APPLICATION_COMMAND_HANDLER, GetCommandClassId() );
msg->SetInstance( this, instance );
msg->Append( GetNodeId() );
msg->Append( 30 );
msg->Append( GetCommandClassId() );
msg->Append( ClimateControlScheduleCmd_Set );
msg->Append( idx ); // Day of week
for( uint8 i=0; i<9; ++i )
{
uint8 hours;
uint8 minutes;
int8 setback;
if( value->GetSwitchPoint( i, &hours, &minutes, &setback ) )
{
msg->Append( hours );
msg->Append( minutes );
msg->Append( setback );
}
else
{
// Unused switch point
msg->Append( 0 );
msg->Append( 0 );
msg->Append( 0x7f );
}
}
msg->Append( GetDriver()->GetTransmitOptions() );
GetDriver()->SendMsg( msg, Driver::MsgQueue_Send );
}
else
{
// Set an override
ValueList* state = static_cast<ValueList*>( GetValue( instance, ClimateControlScheduleIndex_OverrideState ) );
ValueByte* setback = static_cast<ValueByte*>( GetValue( instance, ClimateControlScheduleIndex_OverrideSetback ) );
if( state && setback )
{
ValueList::Item const *item = state->GetItem();
if (item == NULL) {
return false;
}
Msg* msg = new Msg( "ClimateControlScheduleCmd_OverrideSet", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true, true, FUNC_ID_APPLICATION_COMMAND_HANDLER, GetCommandClassId() );
msg->SetInstance( this, instance );
msg->Append( GetNodeId() );
msg->Append( 4 );
msg->Append( GetCommandClassId() );
msg->Append( ClimateControlScheduleCmd_OverrideSet );
msg->Append( (uint8)item->m_value );
msg->Append( setback->GetValue() );
msg->Append( GetDriver()->GetTransmitOptions() );
GetDriver()->SendMsg( msg, Driver::MsgQueue_Send );
}
}
return true;
}
//-----------------------------------------------------------------------------
// <SwitchMultilevel::SwitchMultilevelCmd_StartLevelChange>
// Start the level changing
//-----------------------------------------------------------------------------
bool SwitchMultilevel::StartLevelChange
(
uint8 const _instance,
SwitchMultilevelDirection const _direction
)
{
Log::Write( LogLevel_Info, GetNodeId(), "SwitchMultilevel::StartLevelChange - Starting a level change" );
uint8 length = 4;
uint8 direction = c_directionParams[_direction];
Log::Write( LogLevel_Info, GetNodeId(), " Direction: %s", c_directionDebugLabels[_direction] );
if( ValueBool* ignoreStartLevel = static_cast<ValueBool*>( GetValue( _instance, SwitchMultilevelIndex_IgnoreStartLevel ) ) )
{
if( ignoreStartLevel->GetValue() )
{
ignoreStartLevel->Release();
// Set the ignore start level flag
direction |= 0x20;
}
}
Log::Write( LogLevel_Info, GetNodeId(), " Ignore Start Level: %s", (direction & 0x20) ? "True" : "False" );
uint8 startLevel = 0;
if( ValueByte* startLevelValue = static_cast<ValueByte*>( GetValue( _instance, SwitchMultilevelIndex_StartLevel ) ) )
{
startLevel = startLevelValue->GetValue();
startLevelValue->Release();
}
Log::Write( LogLevel_Info, GetNodeId(), " Start Level: %d", startLevel );
uint8 duration = 0;
if( ValueByte* durationValue = static_cast<ValueByte*>( GetValue( _instance, SwitchMultilevelIndex_Duration ) ) )
{
length = 5;
duration = durationValue->GetValue();
durationValue->Release();
Log::Write( LogLevel_Info, GetNodeId(), " Duration: %d", duration );
}
uint8 step = 0;
if( ( SwitchMultilevelDirection_Inc == _direction ) || ( SwitchMultilevelDirection_Dec == _direction ) )
{
if( ValueByte* stepValue = static_cast<ValueByte*>( GetValue( _instance, SwitchMultilevelIndex_Step ) ) )
{
length = 6;
step = stepValue->GetValue();
stepValue->Release();
Log::Write( LogLevel_Info, GetNodeId(), " Step Size: %d", step );
}
}
Msg* msg = new Msg( "SwitchMultilevel StartLevelChange", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true );
msg->SetInstance( this, _instance );
msg->Append( GetNodeId() );
msg->Append( length );
msg->Append( GetCommandClassId() );
msg->Append( SwitchMultilevelCmd_StartLevelChange );
msg->Append( direction );
msg->Append( startLevel );
if( length >= 5 )
{
msg->Append( duration );
}
if( length == 6 )
{
msg->Append( step );
}
msg->Append( GetDriver()->GetTransmitOptions() );
GetDriver()->SendMsg( msg, Driver::MsgQueue_Send );
return true;
}
