update esppilight lib
content of the library is not filtered on 433mhz only
This commit is contained in:
Florian committed
1 parent
a275e48ee1
commit
67dd7ac078
1030 files changed
+203335
-116
No files matched your search
@@ -0,0 +1,481 @@
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// Scene.cpp
|
||||
//
|
||||
// A collection of ValueIDs to be used together.
|
||||
//
|
||||
// Copyright (c) 2011 Greg Satz <satz@iranger.com>
|
||||
//
|
||||
// SOFTWARE NOTICE AND LICENSE
|
||||
//
|
||||
// This file is part of OpenZWave.
|
||||
//
|
||||
// OpenZWave is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Lesser General Public License as published
|
||||
// by the Free Software Foundation, either version 3 of the License,
|
||||
// or (at your option) any later version.
|
||||
//
|
||||
// OpenZWave is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU Lesser General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Lesser General Public License
|
||||
// along with OpenZWave. If not, see <http://www.gnu.org/licenses/>.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <cstring>
|
||||
#include "Manager.h"
|
||||
#include "platform/Log.h"
|
||||
#include "value_classes/Value.h"
|
||||
#include "value_classes/ValueID.h"
|
||||
#include "Scene.h"
|
||||
#include "Options.h"
|
||||
|
||||
#include "tinyxml.h"
|
||||
|
||||
using namespace OpenZWave;
|
||||
|
||||
uint32 const c_sceneVersion = 1;
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Statics
|
||||
//-----------------------------------------------------------------------------
|
||||
uint8 Scene::s_sceneCnt = 0;
|
||||
Scene* Scene::s_scenes[256] = { 0 };
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// <Scene::Scene>
|
||||
// Constructor
|
||||
//-----------------------------------------------------------------------------
|
||||
Scene::Scene
|
||||
(
|
||||
uint8 const _sceneId
|
||||
):
|
||||
m_sceneId( _sceneId ),
|
||||
m_label( "" )
|
||||
{
|
||||
s_scenes[_sceneId] = this;
|
||||
s_sceneCnt++;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// <Scene::~Scene>
|
||||
// Destructor
|
||||
//-----------------------------------------------------------------------------
|
||||
Scene::~Scene
|
||||
(
|
||||
)
|
||||
{
|
||||
while( !m_values.empty() )
|
||||
{
|
||||
SceneStorage* ss = m_values.back();
|
||||
m_values.pop_back();
|
||||
delete ss;
|
||||
}
|
||||
|
||||
s_sceneCnt--;
|
||||
s_scenes[m_sceneId] = NULL;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// <Scene::WriteXML>
|
||||
// Write ourselves to an XML document
|
||||
//-----------------------------------------------------------------------------
|
||||
void Scene::WriteXML
|
||||
(
|
||||
string const& _name
|
||||
)
|
||||
{
|
||||
char str[16];
|
||||
|
||||
// Create a new XML document to contain the driver configuration
|
||||
TiXmlDocument doc;
|
||||
TiXmlDeclaration* decl = new TiXmlDeclaration( "1.0", "utf-8", "" );
|
||||
TiXmlElement* scenesElement = new TiXmlElement( "Scenes" );
|
||||
doc.LinkEndChild( decl );
|
||||
doc.LinkEndChild( scenesElement );
|
||||
|
||||
scenesElement->SetAttribute( "xmlns", "http://code.google.com/p/open-zwave/" );
|
||||
|
||||
snprintf( str, sizeof(str), "%d", c_sceneVersion );
|
||||
scenesElement->SetAttribute( "version", str);
|
||||
|
||||
for( int i = 1; i < 256; i++ )
|
||||
{
|
||||
if( s_scenes[i] == NULL )
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
TiXmlElement* sceneElement = new TiXmlElement( "Scene" );
|
||||
|
||||
snprintf( str, sizeof(str), "%d", i );
|
||||
sceneElement->SetAttribute( "id", str );
|
||||
sceneElement->SetAttribute( "label", s_scenes[i]->m_label.c_str() );
|
||||
|
||||
for( vector<SceneStorage*>::iterator vt = s_scenes[i]->m_values.begin(); vt != s_scenes[i]->m_values.end(); ++vt )
|
||||
{
|
||||
TiXmlElement* valueElement = new TiXmlElement( "Value" );
|
||||
|
||||
snprintf( str, sizeof(str), "0x%.8x", (*vt)->m_id.GetHomeId() );
|
||||
valueElement->SetAttribute( "homeId", str );
|
||||
|
||||
snprintf( str, sizeof(str), "%d", (*vt)->m_id.GetNodeId() );
|
||||
valueElement->SetAttribute( "nodeId", str );
|
||||
|
||||
valueElement->SetAttribute( "genre", Value::GetGenreNameFromEnum((*vt)->m_id.GetGenre()) );
|
||||
|
||||
snprintf( str, sizeof(str), "%d", (*vt)->m_id.GetCommandClassId() );
|
||||
valueElement->SetAttribute( "commandClassId", str );
|
||||
|
||||
snprintf( str, sizeof(str), "%d", (*vt)->m_id.GetInstance() );
|
||||
valueElement->SetAttribute( "instance", str );
|
||||
|
||||
snprintf( str, sizeof(str), "%d", (*vt)->m_id.GetIndex() );
|
||||
valueElement->SetAttribute( "index", str );
|
||||
|
||||
valueElement->SetAttribute( "type", Value::GetTypeNameFromEnum((*vt)->m_id.GetType()) );
|
||||
|
||||
TiXmlText* textElement = new TiXmlText( (*vt)->m_value.c_str() );
|
||||
valueElement->LinkEndChild( textElement );
|
||||
|
||||
sceneElement->LinkEndChild( valueElement );
|
||||
}
|
||||
|
||||
scenesElement->LinkEndChild( sceneElement );
|
||||
}
|
||||
|
||||
string userPath;
|
||||
Options::Get()->GetOptionAsString( "UserPath", &userPath );
|
||||
|
||||
string filename = userPath + _name;
|
||||
|
||||
doc.SaveFile( filename.c_str() );
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// <Scene::ReadScene>
|
||||
// Read scene configuration from an XML document
|
||||
//-----------------------------------------------------------------------------
|
||||
bool Scene::ReadScenes
|
||||
(
|
||||
)
|
||||
{
|
||||
int32 intVal;
|
||||
char const* str;
|
||||
|
||||
// Load the XML document that contains the driver configuration
|
||||
string userPath;
|
||||
Options::Get()->GetOptionAsString( "UserPath", &userPath );
|
||||
|
||||
string filename = userPath + "zwscene.xml";
|
||||
|
||||
TiXmlDocument doc;
|
||||
if( !doc.LoadFile( filename.c_str(), TIXML_ENCODING_UTF8 ) )
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
TiXmlElement const* scenesElement = doc.RootElement();
|
||||
|
||||
// Version
|
||||
if( TIXML_SUCCESS == scenesElement->QueryIntAttribute( "version", &intVal ) )
|
||||
{
|
||||
if( (uint32)intVal != c_sceneVersion )
|
||||
{
|
||||
Log::Write( LogLevel_Alert, "Driver::ReadScenes - %s is from an older version of OpenZWave and cannot be loaded.", filename.c_str() );
|
||||
return false;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
Log::Write( LogLevel_Alert, "Driver::ReadScenes - %s is from an older version of OpenZWave and cannot be loaded.", filename.c_str() );
|
||||
return false;
|
||||
}
|
||||
|
||||
TiXmlElement const* sceneElement = scenesElement->FirstChildElement();
|
||||
while( sceneElement )
|
||||
{
|
||||
Scene* scene = NULL;
|
||||
|
||||
if( TIXML_SUCCESS == sceneElement->QueryIntAttribute( "id", &intVal ) )
|
||||
{
|
||||
scene = new Scene( (uint8)intVal );
|
||||
}
|
||||
|
||||
if( scene == NULL )
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
str = sceneElement->Attribute( "label" );
|
||||
if( str )
|
||||
{
|
||||
scene->m_label = str;
|
||||
}
|
||||
|
||||
// Read the ValueId for this scene
|
||||
TiXmlElement const* valueElement = sceneElement->FirstChildElement();
|
||||
while( valueElement )
|
||||
{
|
||||
char const* elementName = valueElement->Value();
|
||||
if( elementName && !strcmp( elementName, "Value" ) )
|
||||
{
|
||||
uint32 homeId = 0;
|
||||
str = valueElement->Attribute( "homeId" );
|
||||
if( str )
|
||||
{
|
||||
char *p;
|
||||
homeId = (uint32)strtol( str, &p, 0 );
|
||||
}
|
||||
uint8 nodeId = 0;
|
||||
if (TIXML_SUCCESS == valueElement->QueryIntAttribute( "nodeId", &intVal ) )
|
||||
{
|
||||
nodeId = intVal;
|
||||
}
|
||||
ValueID::ValueGenre genre = Value::GetGenreEnumFromName( valueElement->Attribute( "genre" ) );
|
||||
uint8 commandClassId = 0;
|
||||
if (TIXML_SUCCESS == valueElement->QueryIntAttribute( "commandClassId", &intVal ) )
|
||||
{
|
||||
commandClassId = intVal;
|
||||
}
|
||||
uint8 instance = 0;
|
||||
if (TIXML_SUCCESS == valueElement->QueryIntAttribute( "instance", &intVal ) )
|
||||
{
|
||||
instance = intVal;
|
||||
}
|
||||
uint8 index = 0;
|
||||
if (TIXML_SUCCESS == valueElement->QueryIntAttribute( "index", &intVal ) )
|
||||
{
|
||||
index = intVal;
|
||||
}
|
||||
ValueID::ValueType type = Value::GetTypeEnumFromName( valueElement->Attribute( "type" ) );
|
||||
char const* data = valueElement->GetText();
|
||||
|
||||
scene->m_values.push_back( new SceneStorage( ValueID(homeId, nodeId, genre, commandClassId, instance, index, type), data ) );
|
||||
}
|
||||
|
||||
valueElement = valueElement->NextSiblingElement();
|
||||
}
|
||||
sceneElement = sceneElement->NextSiblingElement();
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// <Scene::Get>
|
||||
// Return the Scene object given the Scene Id
|
||||
//-----------------------------------------------------------------------------
|
||||
Scene* Scene::Get
|
||||
(
|
||||
uint8 const _sceneId
|
||||
)
|
||||
{
|
||||
if ( s_scenes[_sceneId] != NULL )
|
||||
{
|
||||
return s_scenes[_sceneId];
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// <Scene::GetAllScenes>
|
||||
// Return an array of uint8 of used Scene IDs and the count
|
||||
//-----------------------------------------------------------------------------
|
||||
uint8 Scene::GetAllScenes
|
||||
(
|
||||
uint8** _sceneIds
|
||||
)
|
||||
{
|
||||
if( s_sceneCnt > 0 )
|
||||
{
|
||||
*_sceneIds = new uint8[s_sceneCnt];
|
||||
int j = 0;
|
||||
for( int i = 1; i < 256; i++ )
|
||||
{
|
||||
if (s_scenes[i] != NULL)
|
||||
{
|
||||
(*_sceneIds)[j++] = s_scenes[i]->m_sceneId;
|
||||
}
|
||||
}
|
||||
}
|
||||
return s_sceneCnt;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// <Scene::AddValue>
|
||||
// Add a ValueID and a string to the scene.
|
||||
//-----------------------------------------------------------------------------
|
||||
bool Scene::AddValue
|
||||
(
|
||||
ValueID const& _valueId,
|
||||
string const& _value
|
||||
)
|
||||
{
|
||||
m_values.push_back( new SceneStorage( _valueId, _value ) );
|
||||
return true;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// <Scene::RemoveValue>
|
||||
// Remove the first ValueID found
|
||||
//-----------------------------------------------------------------------------
|
||||
bool Scene::RemoveValue
|
||||
(
|
||||
ValueID const& _valueId
|
||||
)
|
||||
{
|
||||
for( vector<SceneStorage*>::iterator it = m_values.begin(); it != m_values.end(); ++it )
|
||||
{
|
||||
if( (*it)->m_id == _valueId )
|
||||
{
|
||||
delete *it;
|
||||
m_values.erase( it );
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// <Scene::RemoveValues>
|
||||
// Remove all ValueIDs from given Home ID
|
||||
//-----------------------------------------------------------------------------
|
||||
void Scene::RemoveValues
|
||||
(
|
||||
uint32 const _homeId
|
||||
)
|
||||
{
|
||||
again:
|
||||
for( vector<SceneStorage*>::iterator it = m_values.begin(); it != m_values.end(); ++it )
|
||||
{
|
||||
if( (*it)->m_id.GetHomeId() == _homeId )
|
||||
{
|
||||
delete *it;
|
||||
m_values.erase( it );
|
||||
goto again;
|
||||
}
|
||||
}
|
||||
// If the scene is now empty, delete it.
|
||||
if( m_values.empty() )
|
||||
{
|
||||
delete this;
|
||||
}
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// <Scene::RemoveValues>
|
||||
// Remove all ValueIDs from given Home ID and node ID
|
||||
//-----------------------------------------------------------------------------
|
||||
void Scene::RemoveValues
|
||||
(
|
||||
uint32 const _homeId,
|
||||
uint8 const _nodeId
|
||||
)
|
||||
{
|
||||
for( int i = 1; i < 256; i++ )
|
||||
{
|
||||
Scene *scene = Scene::Get( i );
|
||||
if( scene != NULL )
|
||||
{
|
||||
again:
|
||||
for( vector<SceneStorage*>::iterator it = scene->m_values.begin(); it != scene->m_values.end(); ++it )
|
||||
{
|
||||
if( (*it)->m_id.GetHomeId() == _homeId && (*it)->m_id.GetNodeId() == _nodeId )
|
||||
{
|
||||
delete *it;
|
||||
scene->m_values.erase( it );
|
||||
goto again;
|
||||
}
|
||||
}
|
||||
// If the scene is now empty, delete it.
|
||||
if( scene->m_values.empty() )
|
||||
{
|
||||
delete scene;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// <Scene::GetValues>
|
||||
// Return all ValueIDs for the given scene.
|
||||
//-----------------------------------------------------------------------------
|
||||
int Scene::GetValues
|
||||
(
|
||||
vector<ValueID>* o_value
|
||||
)
|
||||
{
|
||||
int size = (int) m_values.size();
|
||||
if( size > 0 )
|
||||
{
|
||||
for( vector<SceneStorage*>::iterator it = m_values.begin(); it != m_values.end(); ++it )
|
||||
{
|
||||
o_value->push_back( (*it)->m_id );
|
||||
}
|
||||
}
|
||||
return size;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// <Scene::GetValue>
|
||||
// Return a ValueID's value as string
|
||||
//-----------------------------------------------------------------------------
|
||||
bool Scene::GetValue
|
||||
(
|
||||
ValueID const& _valueId,
|
||||
string* o_value
|
||||
)
|
||||
{
|
||||
for( vector<SceneStorage*>::iterator it = m_values.begin(); it != m_values.end(); ++it )
|
||||
{
|
||||
if( (*it)->m_id == _valueId )
|
||||
{
|
||||
*o_value = (*it)->m_value;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// <Scene::SetValue>
|
||||
// Set a ValueID's value as string
|
||||
//-----------------------------------------------------------------------------
|
||||
bool Scene::SetValue
|
||||
(
|
||||
ValueID const& _valueId,
|
||||
string const& _value
|
||||
)
|
||||
{
|
||||
for( vector<SceneStorage*>::iterator it = m_values.begin(); it != m_values.end(); ++it )
|
||||
{
|
||||
if( (*it)->m_id == _valueId )
|
||||
{
|
||||
(*it)->m_value = _value;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// <Scene::Activate>
|
||||
// Execute scene activation by running each ValueId/value
|
||||
//-----------------------------------------------------------------------------
|
||||
bool Scene::Activate
|
||||
(
|
||||
)
|
||||
{
|
||||
bool res = true;
|
||||
for( vector<SceneStorage*>::iterator it = m_values.begin(); it != m_values.end(); ++it )
|
||||
{
|
||||
if ( !Manager::Get()->SetValue( (*it)->m_id, (*it)->m_value ) )
|
||||
{
|
||||
res = false;
|
||||
}
|
||||
}
|
||||
return res;
|
||||
}
|
||||
Reference in new issue
Block a user