---

DmxALClient.cc

#include <math.h>  
#include <string>
#include <iostream>
#include <unistd.h>

#include "ace/Get_Opt.h"
#include "ace/OS.h"
#include "ace/streams.h"
#include "ace/Log_Msg.h"
#include "ace/Reactor.h"

#include "PDmxSteerableDevice.h"
#include "DmxControlBlock.h"
#include "PDmxLightDevice.h"
#include <RectangularRegion.h>  
#include <Vectors.h>  
#include <algorithm>

#include "DmxALClient.h"

ACE_RCSID(dmxlib_src,DmxClient,"$Id: DmxALClient.cc,v 1.3 2002/03/14 13:56:52 abaebler Exp $");

DmxClient::DmxClient() :
    finished_(0),
    devnum_(0),
    hostname_("zach"),
    lampoff_(false),
    usval_(2000000),
    amplitude_(1.0),
    base_(0)
{
}

void DmxClient::stop() {
  finished_=1;
}

int DmxClient::handle_signal(int signum, siginfo_t*, ucontext_t*) {
    std::string s;
    switch(signum) {
    case SIGINT:
        ACE_DEBUG((DMX_DEBUG(Signal handler caught SIGINT.\n)));
        // Following is commented out because code is blocking and because 
        // underlying client-server application logic relies
        // on immediate handling of incoming messages. Waiting for user's response
        // causes this logic to fail. Would need a separate thread or a call to handle_input()
        // within the disconnect() method in PDmxBaseDevice. (vb)
//        cout << "Are you really sure you want to shut the client down?! yes or no?" << endl;
//        cin >> s;
//        transform(s.begin(),s.end(), s.begin(), tolower);
//        if (s.compare(std::string("yes"))==0) {       
//            stop();
//        }
        stop();
        break;
    case SIGPIPE:
        ACE_DEBUG((DMX_DEBUG(Signal handler caught SIGPIPE. Do nothing.\n)));
        // do nothing
        // handled by DmxSocketStream and callees.
        break;
    default:
        ACE_ERROR((DMX_ERROR(Caught unknown signal %i\n),signum));
        break;
    }
    return 0;
}

int DmxClient::handle_timeout(const ACE_Time_Value &tv, const void* arg) {
    int i;

    for (i=base_;i<devnum_+base_;i++) {
       

       dvec_[i]->color(f);
       dvec_[i]->gobo(f);
       dvec_[i]->prism(f);
       dvec_[i]->dimmer(f);
       if (f<=100){
         f++;
}
       else{
         f=0;
}
        if (dvec_[i]->push()==-1) {
            ACE_ERROR_RETURN ((DMX_ERROR(Client could not update device %i!\n),i),-1);
        }       
        phase_+=delta_;
        
    }
    ACE_Reactor::instance()->schedule_timer(this, (const void*) 0, ACE_Time_Value(0l,usval_));
}

int DmxClient::init(int argc, char* argv[]) {
    if ((ACE_LOG_MSG->open(argv[0]))==-1){
        ACE_ERROR ((DMX_ERROR(Cannot open messager logger!\n)));
        exit(1);
    }

    int mpmask=ACE_LOG_MSG->priority_mask();
    ACE_CLR_BITS(mpmask,LM_DEBUG);
    ACE_SET_BITS(mpmask,LM_INFO);
    ACE_SET_BITS(mpmask,LM_ERROR);


    ACE_Get_Opt get_opt(argc,argv,"hdn:s:lt:a:b:");
    int c;
    char temp[100];

    while ((c=get_opt())!=EOF) {
        switch (c) {
        case 'h':
            printf("\nUsage: DmxClient [-h] [-d] [-n int] ... \n  h : usage\n  d : debug messages\n  s hostname : server hostname\n  n int : number of devices to create\n  l : lamp off upon exit\n  t usval : time interval between updates\n  a float : amplitude of sinuosidal excitation\n  b int : uid of first device to be created\n");
            exit(0);
            break;

        case 'd':
            ACE_DEBUG((DMX_INFO(Debug info verbose\n)));
            ACE_SET_BITS(mpmask,LM_DEBUG);
            break;
        case 'n':
            if ((devnum_=atoi(get_opt.optarg))<0) {
                ACE_ERROR_RETURN ((DMX_ERROR(Invalid number of devices: %i\n),devnum_),-1);
            }
            break;
        case 's':
            strcpy(temp,get_opt.optarg);
            hostname_=temp;
            break;
        case 'l':
            lampoff_=true;
            break;
        case 't':
            if ((usval_=atoi(get_opt.optarg))<0) {
                ACE_ERROR_RETURN ((DMX_ERROR(Invalid time constant: %i\n),usval_),-1);
            }
            break;
        case 'a':
            if ((amplitude_=atof(get_opt.optarg))<0) {
                ACE_ERROR_RETURN ((DMX_ERROR(Invalid amplitude: %f\n),amplitude_),-1);
            }           
            break;
        case 'b':
            if ((base_=atoi(get_opt.optarg))<0) {
                ACE_ERROR_RETURN ((DMX_ERROR(Invalid base uid: %i\n),base_),-1);
            } 
            break;

        default:
            ACE_DEBUG((DMX_INFO(Unknown command-line option -%c\n),c));
            break;
        }
    }

    ACE_DEBUG((DMX_INFO(%i devices to be created.\n),devnum_));
    ACE_DEBUG((DMX_INFO(Client expect running dmx server on %s.\n),hostname_.c_str()));           

    ACE_LOG_MSG->priority_mask(mpmask);
    ACE_LOG_MSG->priority_mask(mpmask,ACE_Log_Msg::PROCESS);

    const u_short PORT = DMX_SERVER_DEFAULT_PORT ;
    
    int i;

    dvec_.resize(devnum_);

    PlanarObject *p1;
    p1=new RectangularRegion;
    p1->setXYPlane(0);
    p1->setRegion(Vector2d(2,2),Vector2d(4,4));
  
    for (i=base_;i<devnum_+base_;i++) {
        ACE_DEBUG ((DMX_INFO(Creating Device with uid %i\n),i));
        dvec_[i]=new PDmxLightDevice(i);
    }

    ACE_INET_Addr addr(PORT, hostname_.c_str());

    for (i=base_;i<devnum_+base_;i++) {
        ACE_DEBUG((DMX_INFO(Connecting Device %i\n),i));
        if (dvec_[i]->connect(addr)==-1) {
            ACE_ERROR_RETURN ((DMX_ERROR(Client could not connect device %i!\n),i),-1);
        }
    
        dvec_[i]->color(0);
        dvec_[i]->gobo(0);
        dvec_[i]->prism(0);
        dvec_[i]->dimmer(0);
  //      dvec_[i]->setOrientation(Vector2d(4,4),p1);
        if (dvec_[i]->push()==-1) {
            ACE_ERROR_RETURN ((DMX_ERROR(Client could not initialize device %i!\n),i),-1);
        }
    }

    ACE_Reactor* preactor = ACE_Reactor::instance();

    preactor->register_handler(SIGINT,this);
    preactor->register_handler(SIGPIPE,this);
    preactor->schedule_timer(this, (const void*) 0, ACE_Time_Value(0l,usval_));

    delta_=M_PI/16;
    phase_=0.0;
}

int DmxClient::wrapup() {
    int i;
    for (i=base_;i<devnum_+base_;i++) {
        ACE_DEBUG((DMX_INFO(Disconnecting Device %i\n),i));
        if (lampoff_) {
            ACE_DEBUG((DMX_INFO(Lamp Off %i\n),i));
            dvec_[i]->shutter(false);
            dvec_[i]->lamp(false);
        }
        if (dvec_[i]->disconnect()==-1) {
            ACE_ERROR_RETURN ((DMX_ERROR(Client could not disconnect device %i!\n),i),-1);
        }
    }
}
int main(int argc, char* argv[]) {
    DmxClient client;
    
    client.init(argc,argv);

    while (!client.finished()){   
      ACE_Reactor::instance()->handle_events();
    }

    client.wrapup();

    return 0;
}

/*
 * $Log: DmxALClient.cc,v $
 * Revision 1.3  2002/03/14 13:56:52  abaebler
 * these are test c++ clients.
 * warning for missing return statement fxd.
 *
 * Revision 1.2  2002/02/28 18:56:32  abaebler
 * gcc3.0 compatible.
 *
 * Revision 1.1  2001/10/31 18:31:49  abaebler
 * Ambientlight standalone client to test Ambient light
 *
 * Revision 1.12  2001/08/16 17:36:39  expodev
 * dimmer set to 10% dimming instead of 90%
 *
 * Revision 1.11  2001/06/19 18:40:50  vincent
 * many changes. see release-0-1-5 in RELEASE
 *
 * Revision 1.10  2001/05/14 10:28:17  expodev
 * Added science et cite changes
 *
 * Revision 1.9  2001/04/17 22:59:27  abaebler
 * geolib works + more. See RELEASE files dmxlib
 *
 * Revision 1.8  2001/04/04 18:53:12  vincent
 * Many changes. See RELEASE file.
 *
 * Revision 1.7  2001/03/22 13:04:20  vincent
 * Added RCSID to cc files. Consolidated log messages. Updated client.
 *
 * Revision 1.6  2001/03/21 12:39:39  vincent
 * New client. New error logging macros. New file id macro. 
 * Exceptions are now throw by DmxSocketStream and 
 * DmxDevicePool and caught by others.
 *
 */

---