int main (int argc, const char *argv[])
{
CmdArgParser parser(argc, argv);
parser.setHeader("Archive Benchmark\n");
parser.setArgumentsInfo("<index>");
CmdArgFlag old(parser, "old", "Use old directory file");
CmdArgInt samples(parser, "samples", "<count>",
"Number of samples to write");
CmdArgString channel_name(parser, "channel", "<name>",
"Channel Name");
CmdArgFlag do_read(parser, "read",
"Perform read test");
// defaults
samples.set(100000);
channel_name.set("fred");
if (parser.parse() == false)
return -1;
if (parser.getArguments().size() != 1)
{
parser.usage();
return -1;
}
stdString index_name = parser.getArgument(0);
size_t count;
epicsTime start, stop;
try
{
if (do_read)
{
start = epicsTime::getCurrent ();
if (old)
count = old_read_samples(index_name, channel_name.get());
else
count = read_samples(index_name, channel_name.get());
stop = epicsTime::getCurrent ();
}
else
{
count = samples.get();
start = epicsTime::getCurrent ();
if (old)
old_write_samples(index_name, channel_name.get(), count);
else
write_samples(index_name, channel_name.get(), count);
stop = epicsTime::getCurrent ();
}
double secs = stop - start;
printf("%zd values in %g seconds: %g vals/sec\n",
count, secs,
(double)count / secs);
}
catch (GenericException &e)
{
fprintf(stderr, "Error:\n%s\n", e.what());
}
return 0;
}
void cpu_info_handler(const lcm_recv_buf_t *rbuf, const char* channel, const lcmt_cpu_info *msg, void *user) {
// we just use this to figure out the hostname of the cam computer
std::string channel_name(channel);
computer_number_char = channel_name.back();
}
void cpu_info_handler(const lcm_recv_buf_t *rbuf, const char* channel, const lcmt_cpu_info *msg, void *user) {
RecordingManager *rec_m = (RecordingManager*) user;
// we just use this to figure out the hostname of the cam computer for video replay
std::string channel_name(channel);
std::string hostname = "odroid-cam";
hostname.push_back(channel_name.back());
rec_m->SetHostname(hostname);
}
void
EC_Driver::obtain_remote_ec (void)
{
CosNaming::NamingContext_var naming_context =
this->get_naming_context ();
CosNaming::Name channel_name (1);
channel_name.length (1);
channel_name[0].id = CORBA::string_dup (this->event_service_name_);
CORBA::Object_var tmp =
naming_context->resolve (channel_name);
this->event_channel_ =
RtecEventChannelAdmin::EventChannel::_narrow (tmp.in ());
}
bool stfio::exportHDF5File(const std::string& fName, const Recording& WData, ProgressInfo& progDlg) {
hid_t file_id = H5Fcreate(fName.c_str(), H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
const int NRECORDS = 1;
const int NFIELDS = 3;
/* Calculate the size and the offsets of our struct members in memory */
size_t rt_offset[NFIELDS] = { HOFFSET( rt, channels ),
HOFFSET( rt, date ),
HOFFSET( rt, time )};
/* Define an array of root tables */
rt p_data;
p_data.channels = WData.size();
struct tm t = WData.GetDateTime();
std::size_t date_length = snprintf(p_data.date, DATELEN, "%04i-%02i-%02i", t.tm_year+1900, t.tm_mon+1, t.tm_mday);
std::size_t time_length = snprintf(p_data.time, TIMELEN, "%02i:%02i:%02i", t.tm_hour, t.tm_min, t.tm_sec);
// ensure that an undefine string is set to "\0", and that the terminating \0 is counted in string length
p_data.date[date_length++] = 0;
p_data.time[time_length++] = 0;
/* Define field information */
const char *field_names[NFIELDS] = { "channels", "date", "time" };
hid_t field_type[NFIELDS];
/* Initialize the field field_type */
hid_t string_type1 = H5Tcopy( H5T_C_S1 );
hid_t string_type2 = H5Tcopy( H5T_C_S1 );
H5Tset_size( string_type1, date_length);
H5Tset_size( string_type2, time_length);
field_type[0] = H5T_NATIVE_INT;
field_type[1] = string_type1;
field_type[2] = string_type2;
std::ostringstream desc;
desc << "Description of " << fName;
herr_t status = H5TBmake_table( desc.str().c_str(), file_id, "description", (hsize_t)NFIELDS, (hsize_t)NRECORDS, sizeof(rt),
field_names, rt_offset, field_type, 10, NULL, 0, &p_data );
if (status < 0) {
std::string errorMsg("Exception while writing description in stfio::exportHDF5File");
H5Fclose(file_id);
H5close();
throw std::runtime_error(errorMsg);
}
hid_t comment_group = H5Gcreate2( file_id,"/comment", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
/* File comment. */
std::string description(WData.GetFileDescription());
if (description.length() <= 0) {
description = "No description";
}
status = H5LTmake_dataset_string(file_id, "/comment/description", description.c_str());
if (status < 0) {
std::string errorMsg("Exception while writing description in stfio::exportHDF5File");
H5Fclose(file_id);
H5close();
throw std::runtime_error(errorMsg);
}
std::string comment(WData.GetComment());
if (comment.length() <= 0) {
comment = "No comment";
}
status = H5LTmake_dataset_string(file_id, "/comment/comment", comment.c_str());
if (status < 0) {
std::string errorMsg("Exception while writing comment in stfio::exportHDF5File");
H5Fclose(file_id);
H5close();
throw std::runtime_error(errorMsg);
}
H5Gclose(comment_group);
std::vector<std::string> channel_name(WData.size());
hid_t channels_group = H5Gcreate2( file_id,"/channels", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
for ( std::size_t n_c=0; n_c < WData.size(); ++n_c) {
/* Channel descriptions. */
std::ostringstream ossname;
ossname << WData[n_c].GetChannelName();
if ( ossname.str() == "" ) {
ossname << "ch" << (n_c);
}
channel_name[n_c] = ossname.str();
hsize_t dimsc[1] = { 1 };
hid_t string_typec = H5Tcopy( H5T_C_S1 );
std::size_t cn_length = channel_name[n_c].length();
if (cn_length <= 0) cn_length = 1;
H5Tset_size( string_typec, cn_length );
std::vector<char> datac(channel_name[n_c].length());
std::copy(channel_name[n_c].begin(),channel_name[n_c].end(), datac.begin());
std::ostringstream desc_path; desc_path << "/channels/ch" << (n_c);
status = H5LTmake_dataset(file_id, desc_path.str().c_str(), 1, dimsc, string_typec, &datac[0]);
if (status < 0) {
std::string errorMsg("Exception while writing channel name in stfio::exportHDF5File");
H5Fclose(file_id);
H5close();
throw std::runtime_error(errorMsg);
}
std::ostringstream channel_path; channel_path << "/" << channel_name[n_c];
hid_t channel_group = H5Gcreate2( file_id, channel_path.str().c_str(), H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
if (channel_group < 0) {
std::ostringstream errorMsg;
errorMsg << "Exception while creating channel group for "
<< channel_path.str().c_str();
H5Fclose(file_id);
H5close();
throw std::runtime_error(errorMsg.str());
}
/* Calculate the size and the offsets of our struct members in memory */
size_t ct_size = sizeof( ct );
size_t ct_offset[1] = { HOFFSET( rt, channels ) };
/* Define an array of channel tables */
ct c_data = { (int)WData[n_c].size() };
/* Define field information */
const char *cfield_names[1] = { "n_sections" };
hid_t cfield_type[1] = {H5T_NATIVE_INT};
std::ostringstream c_desc;
c_desc << "Description of channel " << n_c;
status = H5TBmake_table( c_desc.str().c_str(), channel_group, "description", (hsize_t)1, (hsize_t)1, ct_size,
cfield_names, ct_offset, cfield_type, 10, NULL, 0, &c_data );
if (status < 0) {
std::string errorMsg("Exception while writing channel description in stfio::exportHDF5File");
H5Fclose(file_id);
H5close();
throw std::runtime_error(errorMsg);
}
int max_log10 = 0;
if (WData[n_c].size() > 1) {
max_log10 = int(log10((double)WData[n_c].size()-1.0));
}
for (std::size_t n_s=0; n_s < WData[n_c].size(); ++n_s) {
int progbar =
// Channel contribution:
(int)(((double)n_c/(double)WData.size())*100.0+
// Section contribution:
(double)(n_s)/(double)WData[n_c].size()*(100.0/WData.size()));
std::ostringstream progStr;
progStr << "Writing channel #" << n_c + 1 << " of " << WData.size()
<< ", Section #" << n_s << " of " << WData[n_c].size();
progDlg.Update(progbar, progStr.str());
// construct a number with leading zeros:
int n10 = 0;
if (n_s > 0) {
n10 = int(log10((double)n_s));
}
std::ostringstream strZero; strZero << "";
for (int n_z=n10; n_z < max_log10; ++n_z) {
strZero << "0";
}
// construct a section name:
std::ostringstream section_name; section_name << WData[n_c][n_s].GetSectionDescription();
if ( section_name.str() == "" ) {
section_name << "sec" << n_s;
}
// create a child group in the channel:
std::ostringstream section_path;
section_path << channel_path.str() << "/" << "section_" << strZero.str() << n_s;
hid_t section_group = H5Gcreate2( file_id, section_path.str().c_str(), H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
// add data and description, store as 32 bit little endian independent of machine:
hsize_t dims[1] = { WData[n_c][n_s].size() };
std::ostringstream data_path;
data_path << section_path.str() << "/data";
Vector_float data_cp(WData[n_c][n_s].get().size()); /* 32 bit */
for (std::size_t n_cp = 0; n_cp < WData[n_c][n_s].get().size(); ++n_cp) {
data_cp[n_cp] = float(WData[n_c][n_s][n_cp]);
}
status = H5LTmake_dataset(file_id, data_path.str().c_str(), 1, dims, H5T_IEEE_F32LE, &data_cp[0]);
if (status < 0) {
std::string errorMsg("Exception while writing data in stfio::exportHDF5File");
H5Fclose(file_id);
H5close();
throw std::runtime_error(errorMsg);
}
const int NSRECORDS = 1;
const int NSFIELDS = 3;
/* Calculate the size and the offsets of our struct members in memory */
size_t st_size = sizeof( st );
size_t st_offset[NSFIELDS] = { HOFFSET( st, dt ),
HOFFSET( st, xunits ),
HOFFSET( st, yunits )};
/* Define an array of root tables */
st s_data;
s_data.dt = WData.GetXScale();
if (WData.GetXUnits().length() < UNITLEN)
strcpy( s_data.xunits, WData.GetXUnits().c_str() );
if (WData[n_c].GetYUnits().length() < UNITLEN)
strcpy( s_data.yunits, WData[n_c].GetYUnits().c_str() );
/* Define field information */
const char *sfield_names[NSFIELDS] = { "dt", "xunits", "yunits" };
hid_t sfield_type[NSFIELDS];
/* Initialize the field field_type */
hid_t string_type4 = H5Tcopy( H5T_C_S1 );
hid_t string_type5 = H5Tcopy( H5T_C_S1 );
H5Tset_size( string_type4, 2);
std::size_t yu_length = WData[n_c].GetYUnits().length();
if (yu_length <= 0) yu_length = 1;
H5Tset_size( string_type5, yu_length );
sfield_type[0] = H5T_NATIVE_DOUBLE;
sfield_type[1] = string_type4;
sfield_type[2] = string_type5;
std::ostringstream sdesc;
sdesc << "Description of " << section_name.str();
status = H5TBmake_table( sdesc.str().c_str(), section_group, "description", (hsize_t)NSFIELDS, (hsize_t)NSRECORDS, st_size,
sfield_names, st_offset, sfield_type, 10, NULL, 0, &s_data );
if (status < 0) {
std::string errorMsg("Exception while writing section description in stfio::exportHDF5File");
H5Fclose(file_id);
H5close();
throw std::runtime_error(errorMsg);
}
H5Gclose(section_group);
}
H5Gclose(channel_group);
}
H5Gclose(channels_group);
/* Terminate access to the file. */
status = H5Fclose(file_id);
if (status < 0) {
std::string errorMsg("Exception while closing file in stfio::exportHDF5File");
throw std::runtime_error(errorMsg);
}
/* Release all hdf5 resources */
status = H5close();
if (status < 0) {
std::string errorMsg("Exception while closing file in stfio::exportHDF5File");
throw std::runtime_error(errorMsg);
}
return (status >= 0);
}
int
Event_Service::run (int argc, ACE_TCHAR* argv[])
{
try
{
// Check if -ORBDaemon is specified and if so, daemonize at this moment,
// -ORBDaemon in the ORB core is faulty, see bugzilla 3335
TAO_Daemon_Utility::check_for_daemon (argc, argv);
// Initialize ORB.
this->orb_ =
CORBA::ORB_init (argc, argv);
if (this->parse_args (argc, argv) == -1)
return 1;
CORBA::Object_var root_poa_object =
this->orb_->resolve_initial_references("RootPOA");
if (CORBA::is_nil (root_poa_object.in ()))
ORBSVCS_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Unable to initialize the root POA.\n"),
1);
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (root_poa_object.in ());
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
poa_manager->activate ();
// When we have a service name or a non local scheduler we must use the
// naming service.
bool use_name_service = bind_to_naming_service_ ||
this->scheduler_type_ != ES_SCHED_NONE;
CORBA::Object_var naming_obj;
RtecScheduler::Scheduler_var scheduler;
CosNaming::NamingContext_var naming_context;
if (use_name_service)
{
naming_obj=
this->orb_->resolve_initial_references ("NameService");
if (CORBA::is_nil (naming_obj.in ()))
ORBSVCS_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Unable to initialize the Naming Service.\n"),
1);
naming_context =
CosNaming::NamingContext::_narrow (naming_obj.in ());
}
// This is the name we (potentially) register the Scheduling
// Service in the Naming Service.
CosNaming::Name schedule_name (1);
schedule_name.length (1);
schedule_name[0].id = CORBA::string_dup ("ScheduleService");
// The old EC always needs a scheduler. If none is
// specified, we default to a local scheduler
if (this->scheduler_type_ == ES_SCHED_LOCAL)
{
// Create a local scheduler instance
ACE_NEW_RETURN (this->sched_impl_,
ACE_Config_Scheduler,
1);
scheduler = this->sched_impl_->_this ();
// Register the servant with the Naming Context....
if (!CORBA::is_nil (naming_context.in ()))
{
naming_context->rebind (schedule_name, scheduler.in ());
}
}
else if (this->scheduler_type_ == ES_SCHED_GLOBAL)
{
// Get reference to a scheduler from naming service
CORBA::Object_var tmp =
naming_context->resolve (schedule_name);
scheduler = RtecScheduler::Scheduler::_narrow (tmp.in ());
if (CORBA::is_nil (scheduler.in ()))
ORBSVCS_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Unable to resolve the Scheduling Service.\n"),
1);
}
TAO_EC_Event_Channel_Attributes attr (root_poa.in (),
root_poa.in ());
if (this->scheduler_type_ != ES_SCHED_NONE)
{
attr.scheduler = scheduler.in ();
}
TAO_EC_Event_Channel* ec_impl = 0;
ACE_NEW_RETURN (ec_impl,
TAO_EC_Event_Channel (attr),
1);
this->ec_impl_ = ec_impl;
ec_impl->activate ();
RtecEventChannelAdmin::EventChannel_var ec;
// If the object_id_ is empty and we don't use BiDIR GIOP, activate the
// servant under the default POA, else create a new child POA with
// the needed policies
int persistent = ACE_OS::strcmp(this->object_id_.c_str(), "");
if ((persistent == 0) && (this->use_bidir_giop_ == false))
{
// Notice that we activate *this* object with the POA, but we
// forward all the requests to the underlying EC
// implementation.
ec = this->_this ();
}
else
{
CORBA::ULong index = 0;
// Create child POA
CORBA::PolicyList policies (3);
if (persistent != 0)
{
policies.length (index++);
policies[index] =
root_poa->create_id_assignment_policy (PortableServer::USER_ID);
policies.length (index++);
policies[index] =
root_poa->create_lifespan_policy (PortableServer::PERSISTENT);
}
if (this->use_bidir_giop_ == true)
{
CORBA::Any pol;
pol <<= BiDirPolicy::BOTH;
policies.length (index++);
policies[index] =
this->orb_->create_policy (BiDirPolicy::BIDIRECTIONAL_POLICY_TYPE,
pol);
}
ACE_CString child_poa_name = "childPOA";
PortableServer::POA_var child_poa =
root_poa->create_POA (child_poa_name.c_str (),
poa_manager.in (),
policies);
// Creation of persistentPOA is over. Destroy the Policy objects.
for (CORBA::ULong i = 0;
i < policies.length ();
++i)
{
policies[i]->destroy ();
}
if (CORBA::is_nil (child_poa.in ()))
ORBSVCS_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Unable to initialize the child POA.\n"),
1);
PortableServer::ObjectId_var ec_object_id =
PortableServer::string_to_ObjectId(object_id_.c_str());
child_poa->activate_object_with_id(ec_object_id.in(), this);
CORBA::Object_var ec_obj =
child_poa->id_to_reference(ec_object_id.in());
ec =
RtecEventChannelAdmin::EventChannel::_narrow(ec_obj.in());
}
CORBA::String_var str =
this->orb_->object_to_string (ec.in ());
if (ACE_OS::strcmp(this->ior_file_name_.c_str(), ACE_TEXT("")) != 0)
{
FILE *output_file=
ACE_OS::fopen (this->ior_file_name_.c_str(),
ACE_TEXT("w"));
if (output_file == 0)
ORBSVCS_ERROR_RETURN ((LM_ERROR,
"Cannot open output file for writing IOR: %s",
this->ior_file_name_.c_str()),
1);
ACE_OS::fprintf (output_file, "%s", str.in ());
ACE_OS::fclose (output_file);
}
if (ACE_OS::strcmp(this->pid_file_name_.c_str(), ACE_TEXT("")) != 0)
{
FILE *pidf =
ACE_OS::fopen (this->pid_file_name_.c_str(),
ACE_TEXT("w"));
if (pidf != 0)
{
ACE_OS::fprintf (pidf,
"%ld\n",
static_cast<long> (ACE_OS::getpid ()));
ACE_OS::fclose (pidf);
}
}
ORBSVCS_DEBUG ((LM_DEBUG,
ACE_TEXT("The EC IOR is <%C>\n"),
str.in ()));
if (bind_to_naming_service_ && !CORBA::is_nil (naming_context.in ()))
{
CosNaming::Name channel_name (1);
channel_name.length (1);
channel_name[0].id = CORBA::string_dup (this->service_name_.c_str());
naming_context->rebind (channel_name, ec.in ());
}
ORBSVCS_DEBUG ((LM_DEBUG,
ACE_TEXT("%C; running event service\n"),
__FILE__));
this->orb_->run ();
if (bind_to_naming_service_ && !CORBA::is_nil (naming_context.in ()))
{
CosNaming::Name channel_name (1);
channel_name.length (1);
channel_name[0].id = CORBA::string_dup (this->service_name_.c_str());
naming_context->unbind (channel_name);
}
if (!CORBA::is_nil (scheduler.in ()) &&
!CORBA::is_nil (naming_context.in ()))
{
naming_context->unbind (schedule_name);
}
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("EC");
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
// ORB initialization boiler plate...
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
// Obtain the event channel using the Naming Service.
CORBA::Object_var nam_obj =
orb->resolve_initial_references ("NameService" );
CosNaming::NamingContext_var root_context =
CosNaming::NamingContext::_narrow(nam_obj.in ());
CosNaming::Name channel_name (1);
channel_name.length (1);
channel_name[0].id = CORBA::string_dup ("CountryEventChannel");
CORBA::Object_var ec_obj =
root_context->resolve(channel_name);
// Downcast the object reference to a TypedEventChannel reference
CosTypedEventChannelAdmin::TypedEventChannel_var typed_event_channel =
CosTypedEventChannelAdmin::TypedEventChannel::_narrow(ec_obj.in ());
// Connect to the typed channel
CosTypedEventChannelAdmin::TypedSupplierAdmin_var typed_supplier_admin =
typed_event_channel->for_suppliers ();
CosTypedEventChannelAdmin::TypedProxyPushConsumer_var typed_proxy_push_consumer =
typed_supplier_admin->obtain_typed_push_consumer (_tc_Country->id());
typed_proxy_push_consumer->connect_push_supplier (CosEventComm::PushSupplier::_nil());
// Obtain the interface from the event channel
CORBA::Object_var typed_consumer =
typed_proxy_push_consumer->get_typed_consumer();
// Narrow the interface
Country_var typed_supplier = Country::_narrow(typed_consumer.in () );
// Invoke the events...
for (int i = 0; i != 100; ++i)
{
typed_supplier->update_population ("England", i);
}
// Disconnect from the EC
typed_proxy_push_consumer->disconnect_push_consumer ();
// Destroy the EC....
typed_event_channel->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("main");
return 1;
}
return 0;
}
int main(int argc, const char *argv[])
{
CmdArgParser parser(argc, argv);
parser.setHeader("Archive Data Tool version " ARCH_VERSION_TXT ", "
EPICS_VERSION_STRING
", built " __DATE__ ", " __TIME__ "\n\n"
);
parser.setArgumentsInfo("<index-file>");
CmdArgFlag help (parser, "help", "Show help");
CmdArgInt verbosity (parser, "verbose", "<level>", "Show more info");
CmdArgFlag info (parser, "info", "Simple archive info");
CmdArgFlag list_index (parser, "list", "List channel name info");
CmdArgString copy_index (parser, "copy", "<new index>", "Copy channels");
CmdArgString start_time (parser, "start", "<time>",
"Format: \"mm/dd/yyyy[ hh:mm:ss[.nano-secs]]\"");
CmdArgString end_time (parser, "end", "<time>", "(exclusive)");
CmdArgDouble file_limit (parser, "file_limit", "<MB>", "File Size Limit");
CmdArgString basename (parser, "basename", "<string>", "Basename for new data files");
CmdArgFlag enforce_off (parser, "append_off", "Enforce a final 'Archive_Off' value when copying data");
CmdArgString dir2index (parser, "dir2index", "<dir. file>",
"Convert old directory file to index");
CmdArgString index2dir (parser, "index2dir", "<dir. file>",
"Convert index to old directory file");
CmdArgInt RTreeM (parser, "M", "<1-100>", "RTree M value");
CmdArgFlag dump_blocks (parser, "blocks", "List channel's data blocks");
CmdArgFlag all_blocks (parser, "Blocks", "List all data blocks");
CmdArgString dotindex (parser, "dotindex", "<dot filename>",
"Dump contents of RTree index into dot file");
CmdArgString channel_name(parser, "channel", "<name>", "Channel name");
CmdArgFlag hashinfo (parser, "hashinfo", "Show Hash table info");
CmdArgString seek_test (parser, "seek", "<time>", "Perform seek test");
CmdArgFlag test (parser, "test", "Perform some consistency tests");
try
{
// Defaults
RTreeM.set(50);
file_limit.set(100.0);
// Get Arguments
if (! parser.parse())
return -1;
if (help || parser.getArguments().size() != 1)
{
parser.usage();
return -1;
}
// Consistency checks
if ((dump_blocks ||
dotindex.get().length() > 0 ||
seek_test.get().length() > 0)
&& channel_name.get().length() <= 0)
{
fprintf(stderr,
"Options 'blocks' and 'dotindex' require 'channel'.\n");
return -1;
}
verbose = verbosity;
stdString index_name = parser.getArgument(0);
DataWriter::file_size_limit = (unsigned long)(file_limit*1024*1024);
if (file_limit < 10.0)
fprintf(stderr, "file_limit values under 10.0 MB are not useful\n");
// Start/end time
epicsTime *start = 0, *end = 0;
stdString txt;
if (start_time.get().length() > 0)
{
start = new epicsTime;
string2epicsTime(start_time.get(), *start);
if (verbose > 1)
printf("Using start time %s\n", epicsTimeTxt(*start, txt));
}
if (end_time.get().length() > 0)
{
end = new epicsTime();
string2epicsTime(end_time.get(), *end);
if (verbose > 1)
printf("Using end time %s\n", epicsTimeTxt(*end, txt));
}
// Base name
if (basename.get().length() > 0)
DataWriter::data_file_name_base = basename.get();
if (enforce_off)
do_enforce_off = true;
// What's requested?
if (info)
list_names(index_name, false);
else if (list_index)
list_names(index_name, true);
else if (copy_index.get().length() > 0)
{
copy(index_name, copy_index, RTreeM, start, end, channel_name);
return 0;
}
else if (hashinfo)
show_hash_info(index_name);
else if (dir2index.get().length() > 0)
{
convert_dir_index(RTreeM, dir2index, index_name);
return 0;
}
else if (index2dir.get().length() > 0)
{
convert_index_dir(index_name, index2dir);
return 0;
}
else if (all_blocks)
{
dump_all_datablocks(index_name);
return 0;
}
else if (dump_blocks)
{
dump_datablocks(index_name, channel_name);
return 0;
}
else if (dotindex.get().length() > 0)
{
dot_index(index_name, channel_name, dotindex);
return 0;
}
else if (seek_test.get().length() > 0)
{
seek_time(index_name, channel_name, seek_test);
return 0;
}
else if (test)
{
return check(index_name) ? 0 : -1;
}
else
{
parser.usage();
return -1;
}
}
catch (GenericException &e)
{
fprintf(stderr, "Error:\n%s\n", e.what());
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
// ORB initialization...
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
if (parse_args (argc, argv) != 0)
return 1;
CORBA::Object_var poa_obj =
orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var poa =
PortableServer::POA::_narrow (poa_obj.in ());
PortableServer::POAManager_var poa_manager =
poa->the_POAManager ();
poa_manager->activate ();
// Obtain the event channel using the Naming Service.
CORBA::Object_var nam_obj =
orb->resolve_initial_references ("NameService" );
CosNaming::NamingContext_var root_context =
CosNaming::NamingContext::_narrow(nam_obj.in ());
CosNaming::Name channel_name (1);
channel_name.length (1);
channel_name[0].id = CORBA::string_dup ("CountryEventChannel");
CORBA::Object_var ec_obj =
root_context->resolve(channel_name);
// Downcast the object reference to a TypedEventChannel reference
CosTypedEventChannelAdmin::TypedEventChannel_var typed_event_channel =
CosTypedEventChannelAdmin::TypedEventChannel::_narrow(ec_obj.in ());
// Initialise the Country Impl
Country_i country (orb.in ());
Country_var typed_consumer = country._this();
// Connect to the typed channel
CosTypedEventChannelAdmin::TypedConsumerAdmin_var typed_consumer_admin =
typed_event_channel->for_consumers ();
CosEventChannelAdmin::ProxyPushSupplier_var proxy_push_supplier =
typed_consumer_admin->obtain_typed_push_supplier (_tc_Country->id());
proxy_push_supplier->connect_push_consumer (typed_consumer.in () );
CORBA::String_var str =
orb->object_to_string (typed_consumer.in ());
FILE *output_file= ACE_OS::fopen (ACE_TEXT_ALWAYS_CHAR(ior_output_file),
ACE_TEXT("w"));
if (output_file == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open output file for writing IOR: %s",
ior_output_file),
1);
ACE_OS::fprintf (output_file, "%s", str.in ());
ACE_OS::fclose (output_file);
// Wait for events.
ACE_DEBUG ((LM_DEBUG, "Waiting on orb->run for events...\n"));
orb->run ();
ACE_DEBUG ((LM_DEBUG, "...ORB shutdown\n"));
// Destroy the POA
poa->destroy (1, 0);
// Destroy the ORB
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("main");
return 1;
}
return 0;
}
int
wifi_init(void)
{
struct links *channel = CHANNELS + CHANNEL_WIFI;
#ifdef _WIN32
WSADATA wsaData;
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR) {
confirm_error("WIFI: Error at WSAStartup()\n", 0);
return DSH_CONNECTION_FAILED;
}
#else
char readtext[33];
char iptext[33]; // ip address ONLY
int ret, i, j, oldstatus;
FILE *fp;
unsigned char BUF[6];
iprintf("WIFI: Finding AP...\n");
fp = fopen("DallShell_Conf.txt","rb");
if(fp == NULL)
{
ret = Wifi_InitDefault(WFC_CONNECT);
}
else
{
Wifi_InitDefault(INIT_ONLY);
Wifi_EnableWifi();
for(i=0;i<8;i++)
{
// DallShell Conf ������� txt���� ���,
// �ԷµǴ� ���ڿ� �迭�� ũ�⸦ �÷��� (11.08.29)
fgets(readtext,33,fp);
memset(iptext,0,33); // iptext�� memory�ʱ�ȭ (11.08.29)
switch(i){
case 0 : strcpy(ap.ssid,readtext); break;
case 1 : ap.ssid_len = atoi(readtext); break;
case 2 : ap.channel = atoi(readtext); break;
case 3 : memcpy(iptext, readtext, strlen(readtext)-1);
MyIP.s_addr = inet_addr(iptext);
break;
case 4 : memcpy(iptext, readtext, strlen(readtext)-1);
gateway.s_addr = inet_addr(iptext);
break;
case 5 : memcpy(iptext, readtext, strlen(readtext)-1);
mask.s_addr = inet_addr(iptext);
break;
case 6 : memcpy(iptext, readtext, strlen(readtext)-1);
dns1.s_addr = inet_addr(iptext);
break;
case 7 : memcpy(iptext, readtext, strlen(readtext)-1);
dns2.s_addr = inet_addr(iptext);
break;
}
}
ret = Wifi_ConnectAP(&ap,WEPMODE_NONE,0,0);
}
iprintf("MAC : ");
Wifi_GetData(WIFIGETDATA_MACADDRESS, 6, BUF);
for (i = 0; i < 6; i++) {
iprintf("%02X", BUF[i]);
if (i < 5)
iprintf(":");
}
iprintf("\n\n");
if(fp == NULL)
{
if(ret == 0)
{
confirm_error("WIFI:Failed to connect AP!\n", 0);
return DSH_CONNECTION_FAILED;
}
iprintf("NULL");
MyIP = Wifi_GetIPInfo(&gateway, &mask, &dns1, &dns2);
}
else
{
if(ret != -1)
{
iprintf("AP Connecting...\n");
while(j != ASSOCSTATUS_ASSOCIATED && j!= ASSOCSTATUS_CANNOTCONNECT)
{
oldstatus = j;
j = Wifi_AssocStatus();
if(oldstatus != j) {
iprintf("%s\n",ASSOCSTATUS_STRINGS[j]);
if(j == ASSOCSTATUS_ASSOCIATED )
{
Wifi_SetIP(MyIP.s_addr,gateway.s_addr,mask.s_addr,dns1.s_addr,dns2.s_addr);
}
}
}
}
}
iprintf("WIFI: Connected to AP\n"); // Mark that WIFI is available
iprintf("IP : %s\n", inet_ntoa(MyIP));
iprintf("SVIP: %s\n", DOWNLOAD_IP);
#endif
channel->name = channel_name(CHANNEL_WIFI);
channel->number =number_connect; // number connect
channel->connect = wifi_connect;
channel->read = wifi_read;
channel->write = wifi_write;
channel->disconnect = wifi_disconnect;
channel->cleanup = wifi_cleanup;
return 0;
}
