fly/flightgear
1
0
Fork 0
Code Activity

Add a generic, configurable communiction output option

Browse source
This commit is contained in:
ehofman 2003-03-25 18:47:30 +00:00
parent 81c9e14c7e
commit 5355d1b048
6 changed files with 335 additions and 1 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

44
docs-mini/README.IO
View file

@ -15,6 +15,50 @@ The general form of the command line option is as follows:
hz = number of times to process channel per second (floating
point values are ok.
Generic Communction:
--generic=params
With this option it is possible to output a pre-configured
ASCII string using a predefined seperator. The configuration is
defined in an XML file located in the Protocol directiory of
the base package.
params can be:
serial port communication: serial,dir,hz,device,baud,protocol
socket communication: socket,dir,hz,machine,port,style,protocol
output to a file: file,dir,hz,filename,,protocol
The confinfiguration file is defined as follows:
<?xml version="1.0"?>
<PropertyList>
<generic>
<output>
<seperator>\n</seperator>
<chunk>
<name>speed</name> <!-- for readabillity -->
<type>int</type> <!-- one of: bool,int,float,string -->
<format>V=%d</format> <!-- output format string -->
<node>/velocities/speed</node> <!-- location of the value -->
<offset>0.0</offset> <!-- add this to the value -->
<factor>1.0</factor> <!-- multiply by this value -->
</chunk>
<chunk>
...
</chunk>
...
</output>
</generic>
</PropertyList>
Serial Port Communication:
--nmea=serial,dir,hz,device,baud

4
src/Main/fg_io.cxx
View file

@ -56,6 +56,7 @@
#include <Network/pve.hxx>
#include <Network/ray.hxx>
#include <Network/rul.hxx>
#include <Network/generic.hxx>
#ifdef FG_MPLAYER_AS
#include <Network/multiplay.hxx>
@ -159,6 +160,9 @@ FGIO::parse_port_config( const string& config )
} else if ( protocol == "rul" ) {
FGRUL *rul = new FGRUL;
io = rul;
} else if ( protocol == "generic" ) {
FGGeneric *generic = new FGGeneric( tokens[6] );
io = generic;
#ifdef FG_MPLAYER_AS
} else if ( protocol == "multiplay" ) {\

1
src/Main/options.cxx
View file

@ -1166,6 +1166,7 @@ struct OptionDesc {
{"opengc", true, OPTION_CHANNEL, "", false, "", 0 },
{"garmin", true, OPTION_CHANNEL, "", false, "", 0 },
{"nmea", true, OPTION_CHANNEL, "", false, "", 0 },
{"generic", true, OPTION_CHANNEL, "", false, "", 0 },
{"props", true, OPTION_CHANNEL, "", false, "", 0 },
{"telnet", true, OPTION_CHANNEL, "", false, "", 0 },
{"pve", true, OPTION_CHANNEL, "", false, "", 0 },

3
src/Network/Makefile.am
View file

@ -31,6 +31,7 @@ libNetwork_a_SOURCES = \
props.cxx props.hxx \
pve.cxx pve.hxx \
ray.cxx ray.hxx \
rul.cxx rul.hxx
rul.cxx rul.hxx \
generic.hxx generic.cxx
INCLUDES = -I$(top_srcdir) -I$(top_srcdir)/src

202
src/Network/generic.cxx Normal file
View file

@ -0,0 +1,202 @@
// generic.cxx -- generic protocal class
//
// Written by Curtis Olson, started November 1999.
//
// Copyright (C) 1999 Curtis L. Olson - curt@flightgear.org
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License as
// published by the Free Software Foundation; either version 2 of the
// License, or (at your option) any later version.
//
// This program 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
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
//
// $Id$
#include <simgear/debug/logstream.hxx>
#include <simgear/io/iochannel.hxx>
#include <simgear/misc/exception.hxx>
#include <simgear/misc/sg_path.hxx>
#include <simgear/misc/props.hxx>
#include <simgear/misc/props_io.hxx>
#include <Main/globals.hxx>
#include <Main/fg_props.hxx>
#include "generic.hxx"
FGGeneric::FGGeneric(string& config) {
string file = config+".xml";
SGPath path( globals->get_fg_root() );
path.append("Protocol");
path.append(file.c_str());
SG_LOG(SG_GENERAL, SG_INFO, "Reading communication protocol from "
<< path.str());
SGPropertyNode root;
try {
readProperties(path.str(), &root);
} catch (const sg_exception &e) {
SG_LOG(SG_GENERAL, SG_ALERT,
"Unable to load the protocol configuration file");
return;
}
SGPropertyNode *output = root.getNode("generic/output");
seperator = output->getStringValue("seperator");
vector<SGPropertyNode_ptr> chunks = output->getChildren("chunk");
for (unsigned int i = 0; i < chunks.size(); i++) {
_serial_prot chunk;
// chunk.name = chunks[i]->getStringValue("name");
chunk.format = chunks[i]->getStringValue("format", "%d");
chunk.offset = chunks[i]->getDoubleValue("offset");
chunk.factor = chunks[i]->getDoubleValue("offset", 1.0);
string node = chunks[i]->getStringValue("node");
chunk.prop = fgGetNode(node.c_str(), true);
string type = chunks[i]->getStringValue("type");
if (type == "bool")
chunk.type = FG_BOOL;
else if (type == "float")
chunk.type = FG_DOUBLE;
else if (type == "string")
chunk.type = FG_STRING;
else
chunk.type = FG_INT;
_message.push_back(chunk);
}
}
FGGeneric::~FGGeneric() {
_message.clear();
}
// generate the message
bool FGGeneric::gen_message() {
string generic_sentence;
char tmp[255];
int v;
double d;
for (unsigned int i = 0; i < _message.size(); i++) {
if (i > 0)
generic_sentence += seperator;
switch (_message[i].type) {
case FG_INT:
v = _message[i].offset +
_message[i].prop->getIntValue() * _message[i].factor;
snprintf(tmp, 255, _message[i].format.c_str(), v);
break;
case FG_BOOL:
snprintf(tmp, 255, _message[i].format.c_str(),
_message[i].prop->getBoolValue());
break;
case FG_DOUBLE:
d = _message[i].offset +
_message[i].prop->getDoubleValue() * _message[i].factor;
snprintf(tmp, 255, _message[i].format.c_str(), d);
break;
default: // SG_STRING
snprintf(tmp, 255, _message[i].format.c_str(),
_message[i].prop->getStringValue());
}
generic_sentence += tmp;
}
length = generic_sentence.length();
strncpy( buf, generic_sentence.c_str(), length );
return true;
}
bool FGGeneric::parse_message() {
return true;
}
// open hailing frequencies
bool FGGeneric::open() {
if ( is_enabled() ) {
SG_LOG( SG_IO, SG_ALERT, "This shouldn't happen, but the channel "
<< "is already in use, ignoring" );
return false;
}
SGIOChannel *io = get_io_channel();
if ( ! io->open( get_direction() ) ) {
SG_LOG( SG_IO, SG_ALERT, "Error opening channel communication layer." );
return false;
}
set_enabled( true );
return true;
}
// process work for this port
bool FGGeneric::process() {
SGIOChannel *io = get_io_channel();
if ( get_direction() == SG_IO_OUT ) {
gen_message();
if ( ! io->write( buf, length ) ) {
SG_LOG( SG_IO, SG_ALERT, "Error writing data." );
return false;
}
} else if ( get_direction() == SG_IO_IN ) {
// Temporarliy disable this as output only!
//if ( (length = io->readline( buf, FG_MAX_MSG_SIZE )) > 0 ) {
// parse_message();
//} else {
// SG_LOG( SG_IO, SG_ALERT, "Error reading data." );
// return false;
//}
}
return true;
}
// close the channel
bool FGGeneric::close() {
SGIOChannel *io = get_io_channel();
set_enabled( false );
if ( ! io->close() ) {
return false;
}
return true;
}

82
src/Network/generic.hxx Normal file
View file

@ -0,0 +1,82 @@
// generic.hxx -- generic protocol class
//
// Written by Curtis Olson, started November 1999.
//
// Copyright (C) 1999 Curtis L. Olson - curt@flightgear.org
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License as
// published by the Free Software Foundation; either version 2 of the
// License, or (at your option) any later version.
//
// This program 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
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
//
// $Id$
#ifndef _FG_SERIAL_HXX
#define _FG_SERIAL_HXX
#include <simgear/compiler.h>
#include STL_STRING
#include "protocol.hxx"
SG_USING_STD(string);
class FGGeneric : public FGProtocol {
public:
FGGeneric(string&);
~FGGeneric();
bool gen_message();
bool parse_message();
// open hailing frequencies
bool open();
// process work for this port
bool process();
// close the channel
bool close();
protected:
enum e_type { FG_BOOL=0, FG_INT, FG_DOUBLE, FG_STRING };
typedef struct {
// string name;
string format;
e_type type;
double offset;
double factor;
SGPropertyNode *prop;
} _serial_prot;
private:
int length;
char buf[ FG_MAX_MSG_SIZE ];
string seperator;
vector<_serial_prot> _message;
};
#endif // _FG_SERIAL_HXX