int
main(void)
{
struct kerberos_config *config;
struct remctl_result *result;
struct process *remctld;
const char *expected;
const char *test[] = { "help", NULL };
/* Unless we have Kerberos available, we can't really do anything. */
config = kerberos_setup(TAP_KRB_NEEDS_KEYTAB);
plan(12);
/* Run the tests with summaries. */
remctld = remctld_start(config, "data/conf-simple", NULL);
result = remctl("localhost", 14373, config->principal, test);
ok(result != NULL, "summary command works");
if (result == NULL)
bail("remctl returned NULL");
is_int(0, result->status, "...with correct status");
is_int(0, result->stderr_len, "...and no stderr");
is_int(32, result->stdout_len, "...and correct stdout_len");
if (result->stdout_buf == NULL)
ok(0, "...and correct data");
else {
expected = "summary text\nsubcommand summary\n";
ok(memcmp(expected, result->stdout_buf, 32) == 0,
"...and correct data");
}
is_string(NULL, result->error, "...and no error");
remctl_result_free(result);
process_stop(remctld);
/* Run the tests with the no-summary configuration. */
remctld = remctld_start(config, "data/conf-nosummary", NULL);
result = remctl("localhost", 14373, config->principal, test);
ok(result != NULL, "summary command works");
if (result == NULL)
bail("remctl returned NULL");
is_int(0, result->status, "...with correct status");
is_int(0, result->stderr_len, "...and no stderr");
is_int(0, result->stdout_len, "...and no stdout");
ok(result->error != NULL, "...and error");
is_string("Unknown command", result->error, "...and correct error text");
remctl_result_free(result);
process_stop(remctld);
return 0;
}
int process_action(const char *pidFilename, const char *action, bool *stop)
{
*stop = false;
if (action == NULL)
{
return 0;
}
if (strcmp(action, "stop") == 0)
{
*stop = true;
return process_stop(pidFilename);
}
else if (strcmp(action, "restart") == 0)
{
return process_restart(pidFilename);
}
else if (strcmp(action, "start") == 0)
{
return process_start(pidFilename);
}
else
{
fprintf(stderr, "invalid action: %s\n", action);
return EINVAL;
}
}
/*
* Stop all running processes. This is called as a cleanup handler during
* process shutdown. The first argument, which says whether the test was
* successful, is ignored, since the same actions should be performed
* regardless. The second argument says whether this is the primary process,
* in which case we do the full shutdown. Otherwise, we only free resources
* but don't stop the process.
*/
static void
process_stop_all(int success UNUSED, int primary)
{
while (processes != NULL) {
if (primary)
process_stop(processes);
else
process_free(processes);
}
}
void zmq::object_t::process_command (command_t &cmd_)
{
switch (cmd_.type) {
case command_t::revive:
process_revive ();
break;
case command_t::stop:
process_stop ();
break;
case command_t::plug:
process_plug ();
process_seqnum ();
return;
case command_t::own:
process_own (cmd_.args.own.object);
return;
case command_t::attach:
process_attach (cmd_.args.attach.engine);
process_seqnum ();
return;
case command_t::bind:
process_bind (cmd_.args.bind.in_pipe, cmd_.args.bind.out_pipe);
process_seqnum ();
return;
case command_t::pipe_term:
process_pipe_term ();
return;
case command_t::pipe_term_ack:
process_pipe_term_ack ();
return;
case command_t::term_req:
process_term_req (cmd_.args.term_req.object);
return;
case command_t::term:
process_term ();
return;
case command_t::term_ack:
process_term_ack ();
return;
default:
zmq_assert (false);
}
}
void process_free(Process* proc) {
MAGIC_ASSERT(proc);
process_stop(proc);
g_string_free(proc->arguments, TRUE);
if(proc->atExitFunctions) {
g_queue_free_full(proc->atExitFunctions, g_free);
}
MAGIC_CLEAR(proc);
g_free(proc);
}
/**
* \brief Control request event handler
*
* This implementation handles the control requests for the GuiderPort device
*/
void EVENT_USB_Device_ControlRequest() {
if (is_control()) {
if (is_incoming()) {
switch (USB_ControlRequest.bRequest) {
case FOCUSER_RESET:
process_reset();
break;
case FOCUSER_SET:
process_set();
break;
case FOCUSER_LOCK:
process_lock();
break;
case FOCUSER_STOP:
process_stop();
break;
case FOCUSER_SERIAL:
process_serial();
break;
}
}
if (is_outgoing()) {
switch (USB_ControlRequest.bRequest) {
case FOCUSER_GET:
process_get();
break;
case FOCUSER_RCVR:
process_rcvr();
break;
case FOCUSER_SAVED:
process_saved();
break;
}
}
}
}
int main(int argc, char *argv[]) {
SRunner *sr;
int_t failed = 0;
time_t prog_start, test_start, test_end;
if (process_kill(PLACER("magmad", 18), SIGTERM, 10) < 0) {
log_unit("Another instance of the Magma Daemon is already running and refuses to die.");
exit(EXIT_FAILURE);
}
// Setup
prog_start = time(NULL);
// Updates the location of the config file if it was specified on the command line.
check_args_parse(argc, argv);
if (do_virus_check && !virus_check_data_path) {
virus_check_data_path = ns_dupe(VIRUS_CHECK_DATA_PATH);
}
if (do_tank_check && !tank_check_data_path) {
tank_check_data_path = ns_dupe(TANK_CHECK_DATA_PATH);
}
if (do_dspam_check && !dspam_check_data_path) {
dspam_check_data_path = ns_dupe(DSPAM_CHECK_DATA_PATH);
}
/*if (do_virus_check) printf("doing virus check: [%s]\n", !virus_check_data_path ? "NONE" : virus_check_data_path); else printf ("skipping virus check\n");
if (do_tank_check) printf("doing tank check: [%s]\n", !tank_check_data_path ? "NONE" : tank_check_data_path); else printf ("skipping tank check\n");
if (do_dspam_check) printf("doing dspam check: [%s]\n", !dspam_check_data_path ? "NONE" : dspam_check_data_path); else printf ("skipping dspam check\n");
printf("config file: [%s]\n", magma.config.file);
exit(EXIT_SUCCESS);*/
if (!process_start()) {
log_unit("Initialization error. Exiting.\n");
status_set(-1);
process_stop();
exit(EXIT_FAILURE);
}
// Only during development...
cache_flush();
// Unit Test Config
sr = srunner_create(suite_check_magma());
// Add the suites.
srunner_add_suite(sr, suite_check_core());
srunner_add_suite(sr, suite_check_provide());
srunner_add_suite(sr, suite_check_network());
srunner_add_suite(sr, suite_check_objects());
srunner_add_suite(sr, suite_check_users());
// If were being run under Valgrind, we need to disable forking and increase the default timeout.
// Under Valgrind, forked checks appear to improperly timeout.
if (RUNNING_ON_VALGRIND == 0 && (failed = running_on_debugger()) == 0) {
log_unit("Not being traced or profiled...\n");
srunner_set_fork_status (sr, CK_FORK);
case_timeout = RUN_TEST_CASE_TIMEOUT;
}
else {
// Trace detection attempted was thwarted.
if (failed == -1) log_unit("Trace detection was thwarted.\n");
else log_unit("Tracing or debugging is active...\n");
srunner_set_fork_status (sr, CK_NOFORK);
case_timeout = PROFILE_TEST_CASE_TIMEOUT;
}
// Execute
log_unit("--------------------------------------------------------------------------\n");
test_start = time(NULL);
srunner_run_all(sr, CK_SILENT);
test_end = time(NULL);
// Output timing.
log_unit("--------------------------------------------------------------------------\n");
log_unit("%-63.63s %9lus\n", "TEST DURATION:", test_end - test_start);
log_unit("%-63.63s %9lus\n", "TOTAL DURATION:", test_end - prog_start);
// Summary
log_unit("--------------------------------------------------------------------------\n");
failed = srunner_ntests_failed(sr);
srunner_print(sr, CK_NORMAL);
// The Check Output Ending
log_unit("--------------------------------------------------------------------------\n");
// Cleanup and free the resources allocated by the check code.
status_set(-1);
srunner_free(sr);
ns_cleanup(virus_check_data_path);
ns_cleanup(tank_check_data_path);
ns_cleanup(dspam_check_data_path);
// Cleanup and free the resources allocated by the magma code.
process_stop();
system_init_umask();
exit((failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE);
}
//
// 如何处理各种Command呢?
// 一般用于不同对象之间的通信，包括cross thread的通信
// 各种相关的函数实现已经定义好
//
void zmq::object_t::process_command(command_t &cmd_) {
switch (cmd_.type) {
case command_t::activate_read:
process_activate_read();
break;
case command_t::activate_write:
process_activate_write(cmd_.args.activate_write.msgs_read);
break;
case command_t::stop:
process_stop();
break;
case command_t::plug:
process_plug();
process_seqnum();
break;
case command_t::own:
process_own(cmd_.args.own.object);
process_seqnum();
break;
case command_t::attach:
process_attach(cmd_.args.attach.engine);
process_seqnum();
break;
case command_t::bind:
process_bind(cmd_.args.bind.pipe);
process_seqnum();
break;
case command_t::hiccup:
process_hiccup(cmd_.args.hiccup.pipe);
break;
case command_t::pipe_term:
process_pipe_term();
break;
case command_t::pipe_term_ack:
process_pipe_term_ack();
break;
case command_t::term_req:
process_term_req(cmd_.args.term_req.object);
break;
case command_t::term:
process_term(cmd_.args.term.linger);
break;
case command_t::term_ack:
process_term_ack();
break;
case command_t::reap:
process_reap(cmd_.args.reap.socket);
break;
case command_t::reaped:
process_reaped();
break;
case command_t::inproc_connected:
process_seqnum();
break;
case command_t::done:
default:
zmq_assert (false);
}
}
int main(int argc, char *argv[])
{
uint8_t *tab_rp_bits;
uint16_t *tab_rp_registers;
uint16_t *rd_position_registers;
uint16_t *tab_rp_registers_bad;
modbus_t *ctx;
/***********************************************************************
* feedback is used to store the return value of every called function
* rc is used to store the return value of the modbus command
* resend is used to define the resend times if the command is failed
* i is used for the loop parameter
* insert_bit is used to indicate the calibarate function if there is value to set
* num is used to store the number of data blocks in database
* use_backend is used to indicate the modbus mode is rtu
* next_option is used to take the command options
* pre_step, curr_step are used to indicate the previous step number and current position step number
* pre_length and value indicate the latest posiotion in database and current position
* SLEN is a kind of struct used to store the database blocks
************************************************************************/
int feedback,i;
int insert_bit, nb_points,num =0;
int next_option;
long curr_step;
long pystep = -1;
double value;
double pdepth,pspacing,pdwell,pinterval;
double profiled,stopped;
double depth,dwell,spacing,interval;
double last_position;
int profilebit =0,feedback1,feedback2;
int modbus=0;
int motor_stop = 0;
char * command_arg = "";
char * return_value;
double in_position = 0;
SLEN *examp;
ARF *config, *profile,*off_set;
modbus_mapping_t *mb_mapping;
int ShmID;
int *ShmPTR;
int stop_indicator = 0;
key_t MyKey;
MyKey = ftok(".", 's');
ShmID = shmget(MyKey, sizeof(int), IPC_CREAT | 0666);
ShmPTR = (int *) shmat(ShmID, NULL, 0);
tab_rp_registers = (uint16_t *) malloc(4 * sizeof(uint16_t));
rd_position_registers = (uint16_t *) malloc(2 * sizeof(uint16_t));
tab_rp_registers_bad = (uint16_t *) malloc(2 * sizeof(uint16_t));
config = (ARF*)malloc( 10 * sizeof(ARF) );
if ( config == NULL )
{
printf("Error: Out of Memory, use ./master reset to reset memory\n");
exit(1);
}
const char *const short_options = "hd::u::l:p::cD::w::s::i::gSmt::";
const struct option long_options[] = {
{ "help", 0,NULL, 'h'},
{ "down", 2,NULL, 'd'},
{ "up", 2,NULL, 'u'},
{ "length", 1,NULL, 'l'},
{ "position", 2,NULL, 'p'},
{ "count", 0,NULL, 'c'},
{ "Depth", 2,NULL, 'D'},
{ "well", 2,NULL, 'w'},
{ "spacing", 2,NULL, 's'},
{ "interval", 2,NULL, 'i'},
{ "go", 0,NULL, 'g'},
{ "System", 0,NULL, 'S'},
{ "motor", 0,NULL, 'm'},
{ "time", 2,NULL, 't'},
{ NULL, 0, NULL, 0 },
};
if (argc < 2)
{
print_comusage (stderr, 1);
return_value = json_option("status:",-1);
return return_value;
}
program_name = argv[0];
/*Get the first argument that passed through main function but does not contain*/
command_name = argv[1];
if(argc > 2)
{
command_arg = argv[2];
}
/*******************************************************************************************
* The next three command_name are used to control the motor through modbus (need modbus) *
********************************************************************************************/
if ( strcmp(command_name, "go") == 0 ) {
double curr_position;
char *recd = (char*)malloc(10*sizeof(char));
double offset;
int re_send = 0;
*ShmPTR = 0;
modbus = 0;
next_option = getopt_long (argc, argv, short_options, long_options, NULL);
if (next_option == -1) print_comusage (stderr, 1);
while (next_option != -1)
{
switch (next_option)
{
case 'h':
print_comusage(stdout, 0);
case 'd':
godown:
enable(0);
initbus(1);
/* sleep(1);
ctx = modbusconnection(ctx);
modbus = 1;
feedback = godown(ctx);
if((feedback == -1)&&(re_send <1))
{
enable(0);
initbus(0);
re_send++;
goto godown;
}
return_value = json_option("status",feedback);
printf("%s\n",return_value);
*/
feedback = process_go_down(1);
if((feedback == 0) && (re_send < 1))
{
printf("get false recycle power\n");
enable(0);
initbus(0);
re_send++;
goto godown;
}
return_value = json_option("status",feedback);
printf("%s\n",return_value);
break;
case 'u':
goup:
enable(0);
initbus(1);
/*
sleep(1);
ctx = modbusconnection(ctx);
modbus = 1;
feedback = goup(ctx);
if((feedback == -1)&&(re_send <1))
{
enable(0);
initbus(0);
re_send++;
goto goup;
}
*/
feedback = process_go_up(1);
if((feedback == 0) && (re_send < 1))
{
printf("Get false recycle power\n");
enable(0);
initbus(0);
re_send++;
goto goup;
}
return_value = json_option("status",feedback);
printf("%s\n",return_value);
break;
case 'p':
enable(0);
initbus(1);
sleep(1);
ctx = modbusconnection(ctx);
modbus = 1;
in_position = atof(optarg);
off_set = (ARF*)malloc(15*sizeof(ARF));
off_set = getconfig(&num,off_set);
offset = off_set[10].value;
in_position = in_position - offset;
//printf("inposition is %f offset is %f\n",in_position,offset);
free(off_set);
//system("/home/sampler/kingkong.sh");
gotoposition:
if (in_position <= 0)
{
if( process_read_home_switch(1) == 0)
{
feedback = process_go_home(1);
}
else
feedback = 1;
}
else
{
pystep = process_read_step(1);
curr_position = process_position(pystep);
if ( !(( (in_position -0.1) <= curr_position ) && ( curr_position <= (in_position + 0.1) )) )
{
feedback = process_go_position(1,in_position);
return_value = json_option("status",feedback);
}
}
if((feedback == 0)&&(re_send <1))
{
printf("get false recycle power");
enable(0);
initbus(0);
enable(0);
initbus(1);
re_send++;
goto gotoposition;
}
break;
case '?':
print_comusage (stderr, 1);
default:
abort ();
}
next_option = getopt_long (argc, argv, short_options, long_options, NULL);
}
//If the go command is failed, then exit the current process and power off the controller
if(feedback == 0)
{
printf("1\n");
//*ShmPTR = 1;
enable(0);
initbus(0);
return_value = json_option("status",-1);
return return_value;
}
do{
usleep(5000);
stop_indicator = process_check(1);
}while(stop_indicator != 0);
//printf("stop\n");
sleep(1);
pystep = process_read_step(1);
curr_position = process_position(pystep);
//printf("cur position is %f\n",curr_position);
if(curr_position != -1)
{
login("Go to command set last position");
curr_position = curr_position + offset;
setconfig(9,curr_position);
// In order to avoid "Read status command shutdown the power by accident
enable(0);
initbus(0);
return_value = json_option("status",1);
}
else return_value = json_option("status",-1);
}
if ( strcmp(command_name, "stop") == 0 )
{
if(check_power() == 1)
{
/*sleep(1);
ctx = modbusconnection(ctx);
modbus = 1;
feedback = stop(ctx);
if(feedback == -1)stop(ctx);
*/
process_stop(1);
}
}
if ( strcmp(command_name, "position") == 0 )
{
login("Check position command");
int resend = 0;
double temp_position,offset;
char *rec = (char*)malloc(10*sizeof(char));
stop_indicator = *ShmPTR;
uint16_t * position_registers = (uint16_t *) malloc(2 * sizeof(uint16_t));
off_set = (ARF*)malloc(15*sizeof(ARF));
off_set = getconfig(&num,off_set);
offset = off_set[10].value;
checkposition:
if (check_power()== 1)
{
ctx = modbusconnection(ctx);
modbus = 1;
temp_position = checkposition(ctx,position_registers);
sprintf(rec,"The position read is %f",temp_position);
login(rec);
if(temp_position != -1)
{
login("Check position set last position");
//This sentence is used to show the position with offset
temp_position = temp_position + offset;
feedback = setconfig(9,temp_position);
}
else
{
if(resend < 2)
{
resend++;
goto checkposition;
}
else return -100;
}
}
else
{
config = getconfig(&num,config);
temp_position = config[8].value;
}
return_value = json_float_option("status",temp_position);
printf("%s\n",return_value);
}
/***********************************************************************
* 0: motor is stopped *
* 1: motor is going down *
* 2: motor is going up *
* 3: motor is ramp up *
* 4: motor is ramp down *
* (need modbus) *
* *
************************************************************************/
if(strcmp(command_name, "status") == 0)
{
stop_indicator = *ShmPTR;
if (check_power()== 1)
{
sleep(1);
ctx = modbusconnection(ctx);
modbus = 1;
next_option = getopt_long (argc, argv, short_options, long_options, NULL);
if(next_option == -1) print_comusage (stderr, 1);
while(next_option != -1)
{
switch (next_option)
{
case 'h':
print_comusage(stdout, 0);
case 'S':
feedback = checksystemstatus(ctx,tab_rp_registers);
return_value = json_option("status",feedback);
break;
case 'm':
feedback = checkmotorstatus(ctx,tab_rp_registers);
return_value = json_option("status",feedback);
break;
case '?':
print_comusage (stderr, 1);
default:
abort ();
}
next_option = getopt_long (argc, argv, short_options, long_options, NULL);
}
if(feedback == -1)
{
return_value = json_option("status",0);
}
}
else
{
return_value = json_option("status",0);
//login("Check status from database");
}
printf("%s\n",return_value);
}
/****************************************************************************************
* The next three command_name are used to control the database through sqlite3 *
*****************************************************************************************/
if ( strcmp(command_name, "factory_default") == 0 )
{
feedback1 = reset(0);
feedback2 = dbinit(0);
if ( (feedback1 == 1) && (feedback2 == 1))
{
return_value = json_float_option("status",1);
printf("%s\n",return_value);
}
else
{
return_value = json_float_option("status",-1);
printf("%s\n",return_value);
}
}
if ( strcmp(command_name, "reset") == 0 )
{
feedback = reset(0);
if(feedback == 1)
{
feedback = expected_time_reset();
}
return_value = json_float_option("status",feedback);
printf("%s\n",return_value);
}
if ( strcmp(command_name, "init") == 0 )
{
feedback = -1;
if ( strcmp(command_arg, "all") == 0 )
{
feedback = dbinit(0);
if(feedback == 1)
{
feedback = expected_time_init();
}
}
if ( strcmp(command_arg, "calibrate" ) == 0 )
{
setconfig(6,0);
feedback = dbinit(1);
}
if ( strcmp(command_arg, "configure" ) == 0 )
{
feedback = dbinit(2);
}
if ( feedback == -1 )
{
return_value = json_float_option("status",-1);
print_comusage (stderr, 1);
}
else return_value = json_float_option("status",feedback);
printf("%s\n",return_value);
}
if ( strcmp(command_name,"get") == 0 )
{
examp = getall(&num,examp);
return_value = json_array_option(num,examp);
free(examp);
printf("%s",return_value);
}
if ( strcmp(command_name,"set_offset") == 0 )
{
double offset;
next_option = getopt_long (argc, argv, short_options, long_options, NULL);
if ( next_option == -1 ) print_comusage (stderr, 1);
while( next_option != -1 )
{
switch (next_option)
{
case 'h':
print_comusage(stdout, 0);
case 'l':
if(optarg!=0)offset = strtod(optarg,NULL);
insert_bit = 1;
break;
case '?':
print_comusage (stderr, 1);
default:
abort ();
}
next_option = getopt_long (argc, argv, short_options, long_options, NULL);
}
feedback = setconfig(11,offset);
return_value = json_option("status",feedback);
printf("%s",return_value);
}
if ( strcmp(command_name,"get_offset") == 0 )
{
double offset;
off_set = (ARF*)malloc(15*sizeof(ARF));
off_set = getconfig(&num,off_set);
offset = off_set[10].value;
return_value = json_float_option("status",offset);
printf("%s",return_value);
free(off_set);
}
/**************************************************************************
* The next three command_name are used to calibrate (need modbus) *
***************************************************************************/
if ( strcmp(command_name, "calibrate") == 0 )
{
double calibrate;
enable(0);
initbus(1);
sleep(1);
ctx = modbusconnection(ctx);
modbus = 1;
next_option = getopt_long (argc, argv, short_options, long_options, NULL);
if ( next_option == -1 ) print_comusage (stderr, 1);
config = getconfig(&num,config);
calibrate = config[5].value;
if ( calibrate == 0 )
{
reset(1);
setconfig(6,1.0);
set(num,0,0);
}
while( next_option != -1 )
{
switch (next_option)
{
case 'h':
print_comusage(stdout, 0);
case 'l':
if(optarg!=0)value = atof(optarg);
insert_bit = 1;
break;
case 'c':
getall(&num,examp);
return_value = json_option("status",num);
printf("%s\n",return_value);
break;
case '?':
print_comusage (stderr, 1);
default:
abort ();
}
next_option = getopt_long (argc, argv, short_options, long_options, NULL);
}
if ( insert_bit == 1 )
{
curr_step = checksteps(ctx,rd_position_registers);
if ( curr_step < 0 ) curr_step =0;//do not need
feedback = checkvalue(curr_step,value);
if ( feedback == 1 )
{
feedback = set(num,curr_step,value);
return_value = json_option("status",feedback);
}
else
{
return_value = json_option("status",-1);
}
}
/*if ( checkmotorstatus(ctx,tab_rp_registers) == 0 )
{
enable(0);
initbus(0);
}*/
printf("%s\n",return_value);
}
/***********************************************************************
* The following functions are used for profile *
* *
************************************************************************/
if ( strcmp(command_name, "profile") == 0 )
{
next_option = getopt_long (argc, argv, short_options, long_options, NULL);
if ( next_option == -1 ) print_comusage (stderr, 1);
while ( next_option != -1 )
{
switch (next_option) {
case 'h':
print_comusage(stdout, 0);
case 'd':
if(optarg!=0)depth = atof(optarg);
profilebit = 1;
break;
case 's':
if(optarg!=0)spacing = atof(optarg);
profilebit = 1;
break;
case 'w':
if(optarg!=0)dwell = atof(optarg);
profilebit = 1;
break;
case 'i':
//if(optarg!=0)interval = atof(optarg);
if(optarg!=0)interval = strtod(optarg,NULL);
profilebit = 1;
break;
case '?':
print_comusage (stderr, 1);
default:
abort ();
}
next_option = getopt_long (argc, argv, short_options, long_options, NULL);
}
if ( profilebit == 1 )
{
feedback = set_profile(depth,spacing,dwell,interval);
}
//Want to get the expected profile time and save it in database
profile_time_check(interval);
return_value = json_float_option("status",feedback);
printf("%s\n",return_value);
}
if ( strcmp(command_name, "profileget" ) == 0)
{
profile = getconfig(&num,config);
return_value = json_profile_option(num-2,profile);
free(profile);
printf("%s",return_value);
}
if ( strcmp(command_name, "profile_check" ) == 0)
{
int *expected_profile_time;
long remain_profile_time;
config = getconfig(&num,config);
pinterval = config[3].value;
if(pinterval == 0)
{
printf("-999\n");
return -999;
}
expected_profile_time = (int*)malloc(10*sizeof(int));
if(expected_profile_time == NULL){printf("error\n");exit(1);}
expected_time_get(expected_profile_time);
remain_profile_time = auto_run(0,expected_profile_time);
if(remain_profile_time <=0 )remain_profile_time = 0;
printf("%d\n",remain_profile_time);
free(expected_profile_time);
return remain_profile_time;
}
if ( strcmp(command_name, "profile_reset") == 0 )
{
//feedback = dbinit(2);
//reading_hourly();
system("ps aux | grep -e 'master profilego' | grep -v grep | awk '{print $2}' | xargs -i kill {}");
feedback = set_profile(0,0,0,0);
return_value = json_float_option("status",feedback);
printf("%s\n",return_value);
}
if ( strcmp(command_name, "profilego") == 0 )
{
double stayposition, curr_position,tmp,cal_position;
double sdl_read,offset;
long wait_time,motor_status;
int year;
time_t fail_time;
int stop_check = -1;
int count,fini_count,re_try1 = 0,re_power1 =0,re_try = 0,re_send=0;
int i=1,sample = 0,profile_times,sample_indicator;
int * expected_tm, *curr_time,inter_val;
setconfig(10,0);
profile:
/* The following eight lines are used to get profile arguments from database */
config = getconfig(&num,config);
pdepth = config[0].value;
pspacing = config[1].value;
pdwell = config[2].value;
pinterval = config[3].value;
profiled = config[4].value;
sample = config[9].value;
offset = config[10].value;
profile_times = 1+(pdepth - offset)/pspacing; // Caculate the profile times
inter_val = (int)pinterval;
if(pinterval == 0){schedule_reading();goto profile;}
if(profiled == 0 )
{
config = getconfig(&num,config);
pdepth = config[0].value;
pspacing = config[1].value;
pdwell = config[2].value;
pinterval = config[3].value;
profiled = config[4].value;
sample = config[9].value;
/*
The following part are used to get the expected profile time and
compare with current time
*/
expected_tm = (int*)malloc(10*sizeof(int));
curr_time = (int*)malloc(10*sizeof(int));
if(curr_time == NULL){printf("error\n");exit(1);}
if(expected_tm == NULL){printf("error\n");exit(1);}
do{
config = getconfig(&num,config);
sample = config[9].value;
expected_time_get(expected_tm);
wait_time= auto_run(0,expected_tm);
curr_time = check_time(curr_time);
sample_indicator = curr_time[3]%inter_val;
printf("Wait for next profile\n");
//because the board will boot up 3 minutes after clock time
if(wait_time < -600)
{
profile_time_check(pinterval);
goto profile;
}
sleep(1);
}while(wait_time>0);
free(expected_tm);
four_minute_delay:
sleep(1);
curr_time = check_time(curr_time);
if((curr_time[4]>=4) &&(curr_time[4]<=10))goto start_profile;
if(curr_time[4]<4)goto four_minute_delay;
if(curr_time[4]>10)goto profile;
}
start_profile:
enable(0);
initbus(1);
sleep(1);
ctx = modbusconnection(ctx);
if(ctx == NULL)goto profile;
modbus = 1;
sleep(9);
if ( profiled == 0 )
{
if (process_syncclock() == 0)
{
login("Failed in connectting with SDL");
return;
}
if (process_expression(3,1,profile_times,0) == 0)
{
login("Failed in send profile to SDL");
return;
}
login("Start Profiling");
if( process_read_home_switch(1) == 0)
{
gotoposition(ctx, 0,rd_position_registers); //Do not need to check if it is home because we want it home anyway
do{
usleep(5000);
stop_check = process_check(1);
}while(stop_check != 0);
if(process_pass_through_check() == 0)initbus(0);
setconfig(5,1); //Set the profile flag
sleep(pdwell);
}
else
{
setconfig(5,1);
sleep(pdwell);
}
}
enable(0);
initbus(1);
sleep(1);
ctx = modbusconnection(ctx);
/* This following part is used to determine where is destination */
curr_position = checkposition(ctx,tab_rp_registers) + offset;
cal_position = i*pspacing + offset;
if ( cal_position < pdepth )
{
stayposition = cal_position;
}
else
stayposition = pdepth;
i++;
stayposition = stayposition - offset;
gotoposition(ctx,stayposition,tab_rp_registers);
position1:
sleep(1);
ctx = modbusconnection(ctx);
curr_position = checkposition(ctx,tab_rp_registers) + offset;
if(curr_position == -1)
{
if(re_power1 < 3)
{
if(re_try1 < 2)
{
sleep(3);
re_try1++;
goto position1;
}
else
{
re_try1 = 0;
enable(0);
initbus(0);
sleep(3);
initbus(1);
sleep(1);
re_power1++;
goto position1;
}
}
else
{
enable(0);
initbus(0);
enable(1);
re_power1 = 0;
return -1;
}
}
if (!((stayposition -0.1) <= curr_position ) && (curr_position <= (stayposition + 0.1)))goto position1;
wait_for_stop(ctx, tab_rp_registers);
//Here check position in order to determine if it is destination now
curr_position = checkposition(ctx,tab_rp_registers)+offset;
setconfig(9,curr_position);
printf("Go to sleep for dwell time\n");
if(process_pass_through_check() == 0)initbus(0); // Add this part to check if it is passing command
sleep(pdwell);
if (((pdepth -0.1) <= curr_position) && (curr_position <= (pdepth + 0.1)))
{
setconfig(5,0); //Set profile flag here to avoid reprofile if something wrong happens during following
profile_time_check(pinterval); // Set next profile time
enable(0);
initbus(1);
ctx = modbusconnection(ctx);
gotoposition(ctx,0,rd_position_registers); // After finish profile, go home
wait_for_stop(ctx, tab_rp_registers);
sleep(1);
enable(0);
if(process_pass_through_check() == 0) initbus(0); //Check is pass through
enable(1);
setconfig(9,offset); //Save the position 0
sleep(40);
goto profile;
}
goto profile;
}
/***********************************************************************
* The next three command_name are used *
* to control the date and time *
************************************************************************/
if ( strcmp(command_name, "checktime") == 0 )
{
/*
char *sdate;
if ( (sdate = malloc( 80 * sizeof(char) ) )== NULL)return NULL;
sdate = current_time(sdate);
return_value = json_option_string("status",sdate);
printf("%s\n",return_value);
free(sdate);
*/
//long pystep = process_read_step(1);
//process_position(pystep);
//process_expression(3,1,3,1);
//process_pass_through_check();
//process_syncclock();
process_expression(3,1,3,0);
process_read_home_switch(1);
}
if ( strcmp(command_name, "settime") == 0 )
{
if ( argc < 4 )
{
print_comusage (stderr, 1);
}
char *date = argv[2];
char *time = argv[3];
int *buf = (int*)malloc(6*sizeof(int));
parse(buf,date,time);
int i,m_buf[6];
for(i=0;i<=5;i++)
{
m_buf[i]=*(buf+i);
}
feedback = set_time(&m_buf);
return_value = json_option("status:",feedback);
printf("%s\n",return_value);
login("Set local time");
login(return_value);
sleep(5);
}
if ( strcmp(command_name, "voltage") == 0 )
{
double voltage;
voltage = voltage_read();
return_value = json_float_option("status",voltage);
printf("%s\n",return_value);
}
if ( strcmp(command_name, "temp") == 0 )
{
double temp;
temp = temp_read();
return_value = json_float_option("status",temp);
printf("%s\n",return_value);
}
if(strcmp(command_name, "enable_power") == 0)
{
enable(0);
initbus(1);
return_value = json_option("status:",1);
}
if(strcmp(command_name, "disable_power") == 0)
{
enable(0);
initbus(0);
return_value = json_option("status:",1);
}
if ( strcmp(command_name, "backup") == 0 )
{
feedback = system("cp /home/sampler/lr.sl3 /home/sampler/lr_default.sl3");
if(feedback == -1)
{
return_value = json_float_option("status",-1);
}
else return_value = json_float_option("status",1);
printf("%s\n",return_value);
}
if ( strcmp(command_name, "restore") == 0 )
{
feedback = system("cp /home/sampler/lr_default.sl3 /home/sampler/lr.sl3");
if(feedback == -1)
{
return_value = json_float_option("status",-1);
}
else return_value = json_float_option("status",1);
printf("%s\n",return_value);
}
if ( strcmp(command_name, "debug") == 0 )
{
long return_steps;
char *debug_result;
enable(0);
initbus(1);
sleep(1);
ctx = modbusconnection(ctx);
modbus = 1;
uint16_t *debug_position_registers = (uint16_t*)malloc(2*sizeof(uint16_t));
debug_result = (char*)malloc(50*sizeof(char));
return_steps = checksteps(ctx,debug_position_registers);
sprintf(debug_result,"%x,%x,%x\n",debug_position_registers[0],debug_position_registers[1],return_steps);
json_option_string("status",debug_result);
printf("%s\n",debug_result);
initbus(0);
}
if ( strcmp(command_name, "power_check") == 0 )
{
int power_status = check_power();
printf("Power is %d\n",power_status);
}
if ( strcmp(command_name, "sdl") == 0 )
{
modbus_t * sdl;
sdl = sdl_connection(sdl);
if(sdl != NULL)
{
double vol = sdltest(sdl);
return_value = json_float_option("status",vol);
printf("%s\n",return_value);
setsdl(30000,vol);
login("Read SDL");
login(return_value);
}
else setsdl(30000,-100000);
modbus_close(sdl);
modbus_free(sdl);
}
if ( strcmp(command_name, "sdl_reset") == 0 )
{
resetsdl();
}
if ( strcmp(command_name, "sdl_get") == 0 )
{
int num_records;
SLEN * sdl_records;
sdl_records = (SLEN*)malloc(100*sizeof(SLEN));
sdl_records = getsdl(&num_records, sdl_records);
return_value = json_sdl_option(num_records,sdl_records);
printf("%s\n",return_value);
free(sdl_records);
}
if ( strcmp(command_name, "sdl_uploadtime") == 0 )
{
modbus_t * sdl;
sdl = sdl_connection(sdl);
if(sdl == NULL)
{
setsdl(30000,-100000);
}
else sdl_setuploadtime(sdl,12,5,21,12,50,0);
}
if ( strcmp(command_name, "sdl_settime") == 0 )
{
modbus_t * sdl;
sdl = sdl_connection(sdl);
if(sdl == NULL)
{
setsdl(30000,-100000);
}
else sdl_rtc_time(sdl,12,5,25,7,58,0);
}
if ( strcmp(command_name, "sdl_readsize") == 0 )
{
modbus_t * sdl;
sdl = sdl_connection(sdl);
if(sdl == NULL)
{
setsdl(30000,-100000);
}
else sdl_readbuffsize(sdl);
}
if ( strcmp(command_name, "sdl_readsensor") == 0 )
{
modbus_t * sdl;
sdl = sdl_connection(sdl);
if(sdl == NULL)
{
setsdl(30000,-100000);
}
else sdl_read_sensor(sdl,1,1);
}
if ( strcmp(command_name, "sdl_upload") == 0 )
{
//sdl_read_log_data(16);
int number;
modbus_t * sdl;
sdl = sdl_connection(sdl);
if(sdl == NULL)
{
setsdl(30000,-100000);
}
else
{
profile_save_data(sdl);
}
modbus_close(sdl);
}
if ( strcmp(command_name, "sdl_sample") == 0 )
{
int number;
modbus_t * sdl;
sdl = sdl_connection(sdl);
if(sdl == NULL)
{
setsdl(30000,-100000);
}
else
{
sdl_read_sensor(sdl,1,1);
sleep(60);
sample_save_data(sdl);
//sdl_start_profile(sdl,2);
}
modbus_close(sdl);
}
if ( strcmp(command_name, "shutdown") == 0 )
{
feedback = system("/sbin/shutdown now");
}
if ( strcmp(command_name, "maxstep") == 0 )
{
enable(0);
initbus(1);
sleep(1);
ctx = modbusconnection(ctx);
modbus = 1;
feedback = set_max_step(ctx,rd_position_registers);
return_value = json_option("status",feedback);
initbus(0);
}
if(strcmp(command_name, "slave") == 0)
{
slave();
}
if(strcmp(command_name, "motor_status") == 0)
{
if (check_power()== 1)
{
sleep(1);
ctx = modbusconnection(ctx);
modbus = 1;
feedback = checkmotorstatus(ctx,tab_rp_registers);
if(feedback == -1)
{
printf("0\n");
return 0;
}
else
{
printf("%d\n",feedback);
return feedback;
}
}
else
{
printf("0\n");
return 0;
}
}
close:
/* Free the memory */
free(config);
free(tab_rp_registers);
free(rd_position_registers);
//modbus_mapping_free(mb_mapping);
/* Close the connection */
if (modbus == 1)
{
modbus_close(ctx);
}
if (motor_stop == 1)
{
printf("stop setting\n");
setconfig(9,last_position);
}
return return_value;
}
void host_stopApplication(Host* host, Process* application) {
MAGIC_ASSERT(host);
process_stop(application);
}
void zmq::object_t::process_command (command_t &cmd_)
{
switch (cmd_.type) {
case command_t::revive:
process_revive ();
break;
case command_t::stop:
process_stop ();
break;
case command_t::plug:
process_plug ();
process_seqnum ();
return;
case command_t::own:
process_own (cmd_.args.own.object);
process_seqnum ();
break;
case command_t::attach:
process_attach (cmd_.args.attach.engine,
blob_t (cmd_.args.attach.peer_identity,
cmd_.args.attach.peer_identity_size));
process_seqnum ();
break;
case command_t::bind:
process_bind (cmd_.args.bind.in_pipe, cmd_.args.bind.out_pipe,
cmd_.args.bind.peer_identity ? blob_t (cmd_.args.bind.peer_identity,
cmd_.args.bind.peer_identity_size) : blob_t ());
process_seqnum ();
break;
case command_t::reader_info:
process_reader_info (cmd_.args.reader_info.msgs_read);
break;
case command_t::pipe_term:
process_pipe_term ();
return;
case command_t::pipe_term_ack:
process_pipe_term_ack ();
break;
case command_t::term_req:
process_term_req (cmd_.args.term_req.object);
break;
case command_t::term:
process_term ();
break;
case command_t::term_ack:
process_term_ack ();
break;
default:
zmq_assert (false);
}
// The assumption here is that each command is processed once only,
// so deallocating it after processing is all right.
deallocate_command (&cmd_);
}
void zmq::object_t::process_command (command_t &cmd_)
{
switch (cmd_.type) {
case command_t::activate_read:
process_activate_read ();
break;
case command_t::activate_write:
process_activate_write (cmd_.args.activate_write.msgs_read);
break;
case command_t::stop:
process_stop ();
break;
case command_t::plug:
process_plug ();
process_seqnum ();
break;
case command_t::own:
process_own (cmd_.args.own.object);
process_seqnum ();
break;
case command_t::attach:
process_attach (cmd_.args.attach.engine,
cmd_.args.attach.peer_identity ?
blob_t (cmd_.args.attach.peer_identity,
cmd_.args.attach.peer_identity_size) : blob_t ());
process_seqnum ();
break;
case command_t::bind:
process_bind (cmd_.args.bind.pipe, cmd_.args.bind.peer_identity ?
blob_t (cmd_.args.bind.peer_identity,
cmd_.args.bind.peer_identity_size) : blob_t ());
process_seqnum ();
break;
case command_t::hiccup:
process_hiccup (cmd_.args.hiccup.pipe);
break;
case command_t::pipe_term:
process_pipe_term ();
break;
case command_t::pipe_term_ack:
process_pipe_term_ack ();
break;
case command_t::term_req:
process_term_req (cmd_.args.term_req.object);
break;
case command_t::term:
process_term (cmd_.args.term.linger);
break;
case command_t::term_ack:
process_term_ack ();
break;
case command_t::reap:
process_reap (cmd_.args.reap.socket);
break;
case command_t::reaped:
process_reaped ();
break;
default:
zmq_assert (false);
}
// The assumption here is that each command is processed once only,
// so deallocating it after processing is all right.
deallocate_command (&cmd_);
}
