275 lines
7 KiB
C++
275 lines
7 KiB
C++
// ATC-Main.cxx -- FGFS interface to ATC hardware
|
|
//
|
|
// Written by Curtis Olson, started January 2002
|
|
//
|
|
// Copyright (C) 2002 Curtis L. Olson - http://www.flightgear.org/~curt
|
|
//
|
|
// 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$
|
|
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
# include <config.h>
|
|
#endif
|
|
|
|
#include <simgear/compiler.h>
|
|
|
|
#include <stdlib.h> // atoi() atof() abs()
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <fcntl.h>
|
|
#include <stdio.h> //snprintf
|
|
#if defined( _MSC_VER ) || defined(__MINGW32__)
|
|
# include <io.h> //lseek, read, write
|
|
#endif
|
|
|
|
#include STL_STRING
|
|
|
|
#include <plib/ul.h>
|
|
|
|
#include <simgear/debug/logstream.hxx>
|
|
#include <simgear/io/iochannel.hxx>
|
|
#include <simgear/math/sg_types.hxx>
|
|
#include <simgear/misc/sg_path.hxx>
|
|
#include <simgear/props/props.hxx>
|
|
|
|
#include <Scripting/NasalSys.hxx>
|
|
#include <Main/fg_props.hxx>
|
|
#include <Main/globals.hxx>
|
|
|
|
#include "ATC-Main.hxx"
|
|
|
|
SG_USING_STD(string);
|
|
|
|
|
|
// Lock the ATC hardware
|
|
static int fgATCMainLock( int fd ) {
|
|
// rewind
|
|
lseek( fd, 0, SEEK_SET );
|
|
|
|
char tmp[2];
|
|
int result = read( fd, tmp, 1 );
|
|
if ( result != 1 ) {
|
|
SG_LOG( SG_IO, SG_DEBUG, "Lock failed" );
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
// Write a radios command
|
|
static int fgATCMainRelease( int fd ) {
|
|
// rewind
|
|
lseek( fd, 0, SEEK_SET );
|
|
|
|
char tmp[2];
|
|
tmp[0] = tmp[1] = 0;
|
|
int result = write( fd, tmp, 1 );
|
|
|
|
if ( result != 1 ) {
|
|
SG_LOG( SG_IO, SG_DEBUG, "Release failed" );
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
void FGATCMain::init_config() {
|
|
#if defined( unix ) || defined( __CYGWIN__ )
|
|
// Next check home directory for .fgfsrc.hostname file
|
|
char *envp = ::getenv( "HOME" );
|
|
if ( envp != NULL ) {
|
|
SGPath atcsim_config( envp );
|
|
atcsim_config.append( ".fgfs-atc610x.xml" );
|
|
readProperties( atcsim_config.str(), globals->get_props() );
|
|
}
|
|
#endif
|
|
}
|
|
|
|
|
|
// Open and initialize ATC hardware
|
|
bool FGATCMain::open() {
|
|
if ( is_enabled() ) {
|
|
SG_LOG( SG_IO, SG_ALERT, "This shouldn't happen, but the channel "
|
|
<< "is already in use, ignoring" );
|
|
return false;
|
|
}
|
|
|
|
SG_LOG( SG_IO, SG_ALERT,
|
|
"Initializing ATC hardware, please wait ..." );
|
|
|
|
// This loads the config parameters generated by "simcal"
|
|
init_config();
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
// Open the /proc files
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
string lock0_file = "/proc/atcflightsim/board0/lock";
|
|
string lock1_file = "/proc/atcflightsim/board1/lock";
|
|
|
|
lock0_fd = ::open( lock0_file.c_str(), O_RDWR );
|
|
if ( lock0_fd == -1 ) {
|
|
SG_LOG( SG_IO, SG_ALERT, "errno = " << errno );
|
|
char msg[256];
|
|
snprintf( msg, 256, "Error opening %s", lock0_file.c_str() );
|
|
perror( msg );
|
|
exit( -1 );
|
|
}
|
|
|
|
lock1_fd = ::open( lock1_file.c_str(), O_RDWR );
|
|
if ( lock1_fd == -1 ) {
|
|
SG_LOG( SG_IO, SG_ALERT, "errno = " << errno );
|
|
char msg[256];
|
|
snprintf( msg, 256, "Error opening %s", lock1_file.c_str() );
|
|
perror( msg );
|
|
exit( -1 );
|
|
}
|
|
|
|
if ( input0_path.str().length() ) {
|
|
input0 = new FGATCInput( 0, input0_path );
|
|
input0->open();
|
|
}
|
|
if ( input1_path.str().length() ) {
|
|
input1 = new FGATCInput( 1, input1_path );
|
|
input1->open();
|
|
}
|
|
if ( output0_path.str().length() ) {
|
|
output0 = new FGATCOutput( 0, output0_path );
|
|
output0->open( lock0_fd );
|
|
}
|
|
if ( output1_path.str().length() ) {
|
|
output1 = new FGATCOutput( 1, output1_path );
|
|
output1->open( lock1_fd );
|
|
}
|
|
|
|
set_hz( 30 ); // default to processing requests @ 30Hz
|
|
set_enabled( true );
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
// Finished initing hardware
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
SG_LOG( SG_IO, SG_ALERT,
|
|
"Done initializing ATC hardware." );
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool FGATCMain::process() {
|
|
// cout << "Main::process()\n";
|
|
|
|
bool board0_locked = false;
|
|
bool board1_locked = false;
|
|
|
|
if ( input0 != NULL || output0 != NULL ) {
|
|
// Lock board0 if we have a configuration for it
|
|
if ( fgATCMainLock( lock0_fd ) > 0 ) {
|
|
board0_locked = true;
|
|
}
|
|
}
|
|
|
|
if ( input1 != NULL || output1 != NULL ) {
|
|
// Lock board1 if we have a configuration for it
|
|
if ( fgATCMainLock( lock1_fd ) > 0 ) {
|
|
board1_locked = true;
|
|
}
|
|
}
|
|
|
|
// cout << " locks: ";
|
|
// if ( board0_locked ) { cout << "board0 "; }
|
|
// if ( board1_locked ) { cout << "board1 "; }
|
|
// cout << endl;
|
|
|
|
// process the ATC inputs
|
|
if ( input0 != NULL && board0_locked ) {
|
|
input0->process();
|
|
}
|
|
if ( input1 != NULL && board1_locked ) {
|
|
input1->process();
|
|
}
|
|
|
|
// run our custom nasal script. This is a layer above the raw
|
|
// hardware inputs. It handles situations where there isn't a
|
|
// direct 1-1 linear mapping between ATC functionality and FG
|
|
// functionality, and handles situations where FG expects more
|
|
// functionality from the interface than the ATC hardware can
|
|
// directly provide.
|
|
|
|
FGNasalSys *n = (FGNasalSys*)globals->get_subsystem("nasal");
|
|
bool result = n->parseAndRun( "atcsim.update()" );
|
|
if ( !result ) {
|
|
SG_LOG( SG_GENERAL, SG_ALERT, "Nasal: atcsim.update() failed!" );
|
|
}
|
|
|
|
// process the ATC outputs
|
|
if ( output0 != NULL && board0_locked ) {
|
|
output0->process();
|
|
}
|
|
if ( output1 != NULL && board1_locked ) {
|
|
output1->process();
|
|
}
|
|
|
|
if ( board0_locked ) {
|
|
fgATCMainRelease( lock0_fd );
|
|
}
|
|
if ( board1_locked ) {
|
|
fgATCMainRelease( lock1_fd );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool FGATCMain::close() {
|
|
cout << "FGATCMain::close()" << endl;
|
|
|
|
int result;
|
|
|
|
if ( input0 != NULL ) {
|
|
input0->close();
|
|
}
|
|
if ( input1 != NULL ) {
|
|
input1->close();
|
|
}
|
|
if ( output0 != NULL ) {
|
|
output0->close();
|
|
}
|
|
if ( output1 != NULL ) {
|
|
output1->close();
|
|
}
|
|
|
|
result = ::close( lock0_fd );
|
|
if ( result == -1 ) {
|
|
SG_LOG( SG_IO, SG_ALERT, "errno = " << errno );
|
|
char msg[256];
|
|
snprintf( msg, 256, "Error closing lock0_fd" );
|
|
perror( msg );
|
|
exit( -1 );
|
|
}
|
|
|
|
result = ::close( lock1_fd );
|
|
if ( result == -1 ) {
|
|
SG_LOG( SG_IO, SG_ALERT, "errno = " << errno );
|
|
char msg[256];
|
|
snprintf( msg, 256, "Error closing lock1_fd" );
|
|
perror( msg );
|
|
exit( -1 );
|
|
}
|
|
|
|
return true;
|
|
}
|