uint8_t temp_ready(const temp_def *def) { if (converting && temp_read(def)) { converting = 0; return 1; } return 0; }
int main() { RCC* rcc = RCC::GetInstance(); rcc->SetAHBPrescalerDiv4(); rcc->SetAPB1PrescalerDiv1(); rcc->SetAPB2PrescalerDiv1(); rcc->SetADCPrescalerDiv2(); rcc->EnableHSI(3); temp_read() ; }
void main() { U16 temp; while(1) { temp=temp_read(); digit(2,table[temp/100]); digit(3,table[temp%100/10]&0x7f); digit(4,table[temp%10]); } }
void main() { U16 temp1,temp1_old,temp2,temp2_old; lcd_writecd(0,0x0c); lcd_string(0x80,"²âÊÔµã1:"); lcd_string(0x90,"²âÊÔµã2:"); uart_init(); while(1) { temp1=temp_read(0); temp2=temp_read(1); if(temp1!=temp1_old || temp2!=temp2_old) { lcd_temp(0x84,temp1); lcd_temp(0x94,temp2); temp1_old=temp1; temp2_old=temp2; } delay_1ms(5); } }
void collect(int signum) { //Block SIGCHLD during collect, so that collect takes //a full set of data. Subsequently, the program can //handle SIGCHLD. The final argument of sigprocmask, //the old sigset being replaced, is irrelevant here. sigprocmask(SIG_BLOCK, &mask_chld, 0); int i; for(i = 0; i < num_cores; i++) { double t; int temp_status = temp_read(i, &t); if(temp_status != 0) { die("error %d: reading core %d T", temp_status, i); } printf("%d: %f\n", i, t); } alarm(INTERVAL); sigprocmask(SIG_UNBLOCK, &mask_chld, 0); }
static int TEMPer_update(struct usense_device *dev, void *priv) { int16_t temp; struct temper *temper = priv; int err; /* Reset device */ temp_reset(&temper->adap); /* Dump temp */ err = temp_read(&temper->adap, REG_TEMP, &temp); if (err < 0) { fprintf(stderr, "%s: Can't read temperature\n", usense_device_name(dev)); return -EINVAL; } else { /* microKelvin */ char buff[48]; double kelvin = C_TO_K(temp / 256.0); snprintf(buff, sizeof(buff), "%g", kelvin); usense_prop_set(dev, "reading", buff); } return 0; }
/* @desc Prints collected data to an output file, and manages benchmark execution. @input int pid -- child process id @errors print_data will terminate the program if: -the output file already exists -the output file is invalid or can't be opened */ void collect_data() { //##launch benchmark## int *pids = (int *)malloc(sizeof(int)*options_opt.num_processes); //0 = not exited. 1 = exited. int *pid_exited = (int *)malloc(sizeof(int)*options_opt.num_processes); int k; for(k = 0; k < options_opt.num_processes; k++) { int pid = launch_command(options_opt.cmd); pid_exited[k] = 0; pids[k] = pid; } completed_ms = 0; //open file descriptors int freq_fds[num_cores]; char freq_buf[70]; for(k = 0; k < num_cores; k++) { snprintf(freq_buf, sizeof(freq_buf), "/sys/devices/system/cpu/cpu%d/cpufreq/cpuinfo_cur_freq", k); freq_fds[k] = open(freq_buf, O_RDONLY); if(freq_fds[k] < 0) { die("Opening cpu frequency failed. %s\n", strerror(errno)); } } //controller control_info_t control_data; //##output data## const struct timespec delay = {INTERVAL/1000,(INTERVAL%1000)*10e6}; int sent_kill = 0; while(!done) { if(options_opt.timeout && completed_ms>timeout_ms && !sent_kill) { for(k = 0; k < options_opt.num_processes; k++) { kill_command(pids[k]); } /*The purpose of marking sent_kill is to avoid sending kill signals twice. It's possible that the signal is sent, but that the process does not terminate immediately. Therefore, the data collection loop may occur one or more time subsequently; in these situations we do not want to resend the kill signal or collect new data. Initially, I did not have this variable, and I actually encountered this bug.*/ sent_kill = 1; } done = 1; for(k = 0; k < options_opt.num_processes; k++) { if(!pid_exited[k]) if(waitpid(pids[k], 0, WNOHANG)) pid_exited[k] = 1; } for(k = 0; k < options_opt.num_processes; k++) { if(!pid_exited[k]) { done = 0; break; } } if(!sent_kill) { //temperatures int i; for(i = 0; i < num_cores; i++) { double t; int temp_status = temp_read(i, &t); if(temp_status != 0) { die("error %d: reading core %d T", temp_status, i); } fprintf(output_file_handle, "%-15.1f", t); control_data.ts[i] = t; } //power control_data.pcpu = 0; for(i = 0; i < NUM_PWR_CHANNELS; i++) { fprintf(output_file_handle, "%-15.8f ", curr_pwr[i]); control_data.pcpu += curr_pwr[i]*MV_TO_CPU_POWER; } //fan speeds double fspeed; for(i = 0; i < NUM_FANS; i++) { fan_read(i,&fspeed); fprintf(output_file_handle, "%-15.5f", fspeed); } //power supplies. If we are not collecting data from //the power supplies, the globals are initialized to zero //and we will read these values. control_data.ptec = 0; for(i = 0; i < NUM_PWS_CHANNELS; i++) { fprintf(output_file_handle, "%-15.5f", curr_pws_v[i]); fprintf(output_file_handle, "%-15.5f", curr_pws_i[i]); control_data.ptec += curr_pws_v[i]*curr_pws_i[i]; } //timestamp [ms] fprintf(output_file_handle, "%-15d", (int)completed_ms); //frequencies [khz] for(i = 0; i < num_cores; i++) { if(lseek(freq_fds[i],0,SEEK_SET) < 0) die("Seeking cpu freq. %s\n", strerror(errno)); int bytesread = read(freq_fds[i], freq_buf, sizeof(freq_buf)); if(bytesread < 0) { die("Reading cpu frequency failed. %s\n", strerror(errno)); } //-1 to remove newline. TODO robust newline stripping freq_buf[bytesread-1] = 0; fprintf(output_file_handle, "%-15.2f", atoi(freq_buf)/1000000.0); } fprintf(output_file_handle, "\n"); //control #ifdef CONTROL_ENABLE if(completed_ms % (options_opt.control_params.interval*INTERVAL) == 0) { control_simple(control_data); } #endif } //nanosleep can be interrupted by signals, but //this case doesn't need to be handled in any special way. //If the child terminates, done will be set and data //collection will finish. nanosleep(&delay, NULL); completed_ms += INTERVAL; } for(k = 0; k < num_cores; k++) { if(close(freq_fds[k]) < 0) die("Could not close cpu freq fds %s\n", strerror(errno)); } free(pids); free(pid_exited); }
void main (void) { volatile unsigned int test = 0; volatile unsigned int flags = 0; msp430_init(); low_power_delay_ms(20); while (!(read_register(STATUS_REG) & READY)) { low_power_delay_ms(1); } /****************************************************************************/ /* Errata Fix : Unresponsive RF - recommended firmware */ /****************************************************************************/ /* * Versions C and D (0x0101, 0x0201) have this issue. * Read the version register and apply the fix accordingly. */ { unsigned int version; version = read_register(VERSION_REG); if (version == 0x0101 || version == 0x0201) { write_register(0xFFE0, 0x004E); write_register(0xFFFE, 0x0080); if (version == 0x0101) { // ver. C write_register(0x2a98, 0x0650); } else { // ver. D write_register(0x2a6e, 0x0650); } write_register(0x2814, 0); write_register(0xFFE0, 0); } /* Upon exit of this block, the control register is set to 0x0 */ } /* check if content is valid and set to default data if it is not */ if(FRAM_Message[0] != 0xD2) { memcpy(FRAM_Message, RF430_DEFAULT_DATA , 47); } while (1) { low_power_delay_ms(1); temp_read(); update_rf430(); low_power_delay_ms(3000); /* RF430CL330H reset */ PORT_RST_OUT &= ~RST; low_power_delay_ms(1); /* release */ PORT_RST_OUT |= RST; low_power_delay_ms(20); while(!(read_register(STATUS_REG) & READY)); } }
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 main (void) { sec_counter=0; ADCON0 = 0x01; ADCON1 = 0x0E; ADCON2 = 0xFF; T0CON = 0x80; INTCON = 0xE0; T1CON = 0x11; PIR1bits.TMR1IF = 0; PIE1bits.TMR1IE = 1; OSCCON = 0x70; TRISD = 0; TRISE = 0; LATE = 0; LATD = 0; BTN_T = 1; LEDR_T = 0; LEDY_T = 0; LEDG_T = 0; disp_array[0] = 0; disp_array[1] = 1; disp_array[2] = 2; temp_array_pointer = 0; FET = 0; FET_T = 0; state = 1; state_count = 5; minutes_set = 1; beeper = 0; err_counter = 0; BEEPER_T = 0; BEEPER = 0; temper_val=0; while (1) { temper = temp_read(); if ((temper>2)&(temper<200)) { Delay10KTCYx(10); err_counter = 0; temp_array[temp_array_pointer] = temper; temp_array_pointer++; if (temp_array_pointer==TEMP_ARRAY_SIZE) temp_array_pointer = 0; temper = calc_avg(temp_array,TEMP_ARRAY_SIZE); if (temper<temp_set) { LEDR = 1; FET = 1; } else { FET = 0; LEDR = 0; } if (state==0) { LEDG = 1; LEDY = 0; disp_array[0] = temper/100; disp_array[1] = (temper - (disp_array[0]*100))/10; disp_array[2] = temper - (disp_array[0]*100) - (disp_array[1]*10); state_count = 0; if (BTN==0) { state = 2; if (temper_val<(TEMPER_VAL_MAX-1)) temper_val++; else temper_val=0; } } temp_set = temperatures[temper_val]; if (state==1) { LEDG = 0; LEDY = 1; if (state_count>0) state_count--; else state = 0; disp_array[0] = temp_set/100; disp_array[1] = (temp_set - (disp_array[0]*100))/10; disp_array[2] = temp_set - (disp_array[0]*100) - (disp_array[1]*10); } if (state==2) { LEDG = 0; LEDY = 0; disp_array[0] = temp_set/100; disp_array[1] = (temp_set - (disp_array[0]*100))/10; disp_array[2] = temp_set - (disp_array[0]*100) - (disp_array[1]*10); state_count = 5; if (BTN==1) state = 1; } } else { } } }