void check_sync(void){ int i; //check semaphore sem_init(&mutex, 1); for(i=0;i<N;i++){ sem_init(&s[i], 0); int pid = kernel_thread(philosopher_using_semaphore, (void *)i, 0); if (pid <= 0) { panic("create No.%d philosopher_using_semaphore failed.\n"); } philosopher_proc_sema[i] = find_proc(pid); set_proc_name(philosopher_proc_sema[i], "philosopher_sema_proc"); } //check condition variable monitor_init(&mt, N); for(i=0;i<N;i++){ state_condvar[i]=THINKING; int pid = kernel_thread(philosopher_using_condvar, (void *)i, 0); if (pid <= 0) { panic("create No.%d philosopher_using_condvar failed.\n"); } philosopher_proc_condvar[i] = find_proc(pid); set_proc_name(philosopher_proc_condvar[i], "philosopher_condvar_proc"); } }
int main(int argc, char *argv[]) { int n = ARRAY_SIZE; int *array; HANDLE(!(array = malloc(n * sizeof(int)))); monitor *m; make_array(&array, n, ARRAY_ALGO, RANGE); NOTIFY(print_array(&array, n, OUT_LINE_SIZE)); m = monitor_init(SELF); monitor_start(m); csort(array, n); monitor_end(m); NOTIFY(print_array(&array, n, OUT_LINE_SIZE)); assert(verify(&array, n)); free(array); monitor_print_stats(m, VERBOSE); monitor_free(m); return 0; }
void test_monitor(monitor_target who, bool all_verbosities, bool threaded) { monitor *m = monitor_init(who); monitor_start(m); if(threaded){ busy_threads(); } else { busy_loop(); } monitor_end(m); if(all_verbosities){ monitor_print_stats(m, SILENT); SMALL_SEP(); monitor_print_stats(m, QUIET); SMALL_SEP(); } monitor_print_stats(m, VERBOSE); monitor_free(m); }
extern "C" jstring JNICALL Java_com_iped_ipcam_gui_UdtTools_monitorSocket(JNIEnv *env, jobject thiz, jstring camId) { if (first) { LOGI("### UdtTools monitor_init!"); first = 0; monitor_init(0); } freeSocket(); LOGI("### start monitorSocke"); char* idTmp = jstringToChar(env,camId); id = idTmp; socket1 = monitor_socket_fusion(idTmp); while (1) { if(socket1 == NULL) { return env->NewStringUTF("fusion error"); } LOGI("### wait to connection."); stun_sleep_ms(100); if (socket_fusion_is_usable(socket1) || socket_fusion_is_done(socket1)) { break; } } if (socket_fusion_is_usable(socket1)) { LOGI("### connection success. %p", socket1); return getOK(env); } LOGI("### connection faliled."); return getError(env,socket1); }
int main( int argc, char **argv ) { int ret; if( getuid() ) { printf("You must be root to run the MOL debugger\n"); return 1; } mregs = &sv.mregs; res_manager_init(0, argc, argv ); atexit( res_manager_cleanup ); /* Initialize socket and connect to MOL */ sv.fd = -1; do_connect(); symbols_init(); monitor_init(); cmdline_init(); install_monitor_cmds(); printm("Mac-on-Linux debugger %s, ", MOL_RELEASE); printm("(C) 2001 Samuel Rydh <*****@*****.**>\n"); atexit(exit_hook); for( ;; ) { if( (ret = mon_debugger()) == kDbgExit ) break; send_dgram1( sv.fd, kMDG_debug_action, ret ); } send_dgram( sv.fd, kMDG_disconnect ); return 0; }
int main() { int size = SIZE; int *first, *result; monitor *m; first = make_square_matrix(size); result = make_square_matrix(size); initialize_matrix(first, size); NOTIFY(print_matrix(first, size, size)); m = monitor_init(SELF); monitor_start(m); multiply_matrix_symm_transp(first, result, size); monitor_end(m); monitor_print_stats(m, VERBOSE); NOTIFY(print_matrix(result, size, size)); NOTIFY(verify_matrix(first, result, size)); monitor_free(m); return 0; }
int main(int argc, char ** argv) { usb_cdc_class_t * cdc; DCC_LOG_INIT(); DCC_LOG_CONNECT(); DCC_LOG(LOG_TRACE, "1. cm3_udelay_calibrate()"); cm3_udelay_calibrate(); DCC_LOG(LOG_TRACE, "2. thinkos_init()"); thinkos_init(THINKOS_OPT_PRIORITY(8) | THINKOS_OPT_ID(7)); DCC_LOG(LOG_TRACE, "3. io_init()"); io_init(); DCC_LOG(LOG_TRACE, "4. external_bus_init()"); external_bus_init(); DCC_LOG(LOG_TRACE, "5. stdio_init()"); stdio_init(); printf("\n---\n"); DCC_LOG(LOG_TRACE, "6. trace_init()"); trace_init(); DCC_LOG(LOG_TRACE, "7. env_init()"); env_init(); /* create some threads */ DCC_LOG(LOG_TRACE, "8. monitor_init()"); monitor_init(); DCC_LOG(LOG_TRACE, "9. watchdog_init()"); watchdog_init(); DCC_LOG(LOG_TRACE, "10. net_init()"); net_init(); DCC_LOG(LOG_TRACE, "11. pkt_xmt_init()"); pkt_xmt_init(); net_pkt_mode(true); DCC_LOG(LOG_TRACE, "12. console_shell_init()"); console_shell_init(); DCC_LOG(LOG_TRACE, "13. usb_cdc_init()"); usb_cdc_sn_set(*((uint64_t *)STM32F_UID)); cdc = usb_cdc_init(&stm32f_otg_fs_dev, cdc_acm_def_str, cdc_acm_def_strcnt); DCC_LOG(LOG_TRACE, "14. usb_shell()"); for (;;) { usb_shell(cdc); } }
int main (int argc, char **argv) { GIOChannel *gio; GMainLoop *ml; gchar *path; gchar *tmp; xmmsc_connection_t *conn; xmmsc_result_t *res; xmonitor_t *mon; gint fd; conn = xmmsc_init ("xmms-medialib-updater"); path = getenv ("XMMS_PATH"); if (!xmmsc_connect (conn, path)) { ERR ("Could not connect to xmms2d %s", xmmsc_get_last_error (conn)); return EXIT_FAILURE; } ml = g_main_loop_new (NULL, FALSE); xmmsc_mainloop_gmain_init (conn); xmmsc_disconnect_callback_set (conn, quit, ml); mon = g_new0 (xmonitor_t, 1); fd = monitor_init (mon); mon->conn = conn; if (fd == -1) { ERR ("Couldn't initalize monitor"); return EXIT_FAILURE; } tmp = getenv("XMMS_DEBUG"); if (!tmp) { g_log_set_handler (NULL, G_LOG_LEVEL_MESSAGE | G_LOG_FLAG_RECURSION, message_handler, NULL); } gio = g_io_channel_unix_new (fd); g_io_add_watch (gio, G_IO_IN, s_callback, mon); res = xmmsc_configval_register (conn, "mlibupdater.watch_dirs", ""); xmmsc_result_notifier_set (res, handle_configval, mon); xmmsc_result_unref (res); res = xmmsc_broadcast_configval_changed (conn); xmmsc_result_notifier_set (res, handle_config_changed, mon); xmmsc_result_unref (res); g_main_loop_run (ml); return EXIT_SUCCESS; }
BOOL APIENTRY DllMain(HANDLE hModule, DWORD dwReason, LPVOID lpReserved) { (void) hModule; (void) lpReserved; if(dwReason == DLL_PROCESS_ATTACH && is_ignored_process() == 0) { monitor_init(hModule); monitor_hook(NULL); pipe("LOADED:%d,%d", get_current_process_id(), g_monitor_track); } return TRUE; }
static int ldetailreport(lua_State *L) { monitor_init(G); luaL_checktype(L, 1, LUA_TFUNCTION); lua_sethook(L, monitor_detailreport, LUA_MASKCALL | LUA_MASKRET | LUA_MASKLINE, 0); int args = lua_gettop(L) - 1; lua_call(L, args, 0); lua_sethook(L, NULL, 0 , 0); lua_pushinteger(L, G->max_depth); lua_pushinteger(L, G->calls); lua_pushlstring(L, G->buffer, G->ptr); return 3; }
void kernel_entry (multiboot_info* bootinfo) { clear_screen(); puts("Kernel loaded.\n"); gdt_install(); puts("GDT initialised.\n"); idt_install(); puts("IDT initialised.\n"); memman_init(bootinfo); kheap_init(); fat32_init(); // TODO: figure out how to do it safely //acpi_init(); apic_init(); ioapic_init(); // keyboard only for now register_handler(0x21, keyboard_handler); register_handler(0xD, gpf_handler); syscalls_init(); // maybe syscalls_init() like acpi_init, apic_init, etc... there should be common naming timer_init(0x20, 0x002fffff, 0xB, 1); // vector, counter, divider, periodic -- check manual before using // sets up kernel task and registers handler for timer scheduler_init(); // registers locking sys monitor_init(); keyboard_init(); // testing scheduler if (fork_kernel() == 0) { if (!exec("SHELL")) { // something horrible happend // exit() } exit(); } else { for(;;) { asm volatile("hlt"); } } asm ("sti"); // release monsters, it can be set earlier, but fails horribly if set before acpi_init for(;;); }
static Monitor* monitors_add_monitor (Plugin *p, MonitorsPlugin *mp, update_func update, tooltip_update_func update_tooltip, gchar *color) { ENTER; Monitor *m; m = g_new0(Monitor, 1); m = monitor_init(p, m, color); m->update = update; m->update_tooltip = update_tooltip; gtk_box_pack_start(GTK_BOX(p->pwid), m->da, FALSE, FALSE, 0); gtk_widget_show(m->da); RET(m); }
/* 意大利面条式代码,但是暂时还没什么好的错误处理方法 */ static int server_start(void) { int flag; #ifdef HAVE_DB flag = db_init(oracle_servername, oracle_username, oracle_password); if (flag == -1) { return -1; } INFO("Database initilize!"); #endif flag = spam_init(spam_thresold, spam_data); if (flag == -1) { return -1; } flag = match_init(); if (flag == -1) { return -1; } flag = kill_init(); if (flag == -1) { match_close(); return -1; } flag = log_init(); if (flag == -1) { match_close(); kill_close(); return -1; } flag = monitor_init(); if (flag == -1) { match_close(); kill_close(); log_close(); return -1; } flag = analy_init(netcard); if (flag == -1) { match_close(); kill_close(); log_close(); monitor_close(); } return 0; }
extern "C" jstring JNICALL Java_com_iped_ipcam_gui_UdtTools_monitorCmdSocket(JNIEnv *env, jobject thiz, jstring camId,jstring rand) { LOGI("### start config monitorCmdSocket"); if (first) { LOGI("### UdtTools cmd monitor_init!"); first = 0; monitor_init(0); } char* idTmp = jstringToChar(env,camId); if(id == NULL || strcmp( idTmp, id )!=0) { socket2 = monitor_socket_fusion(idTmp); if(socket2 == NULL) { return env->NewStringUTF("cmd fusion error"); } while (1) { LOGI("### wait config to connection."); stun_sleep_ms(100); if (socket_fusion_is_usable(socket2) || socket_fusion_is_done(socket2)) { break; } } if (socket_fusion_is_usable(socket2)) { LOGI("### configf connection success.%p", socket2); return getOK(env); } } else { if(socket1 == NULL) { return env->NewStringUTF("fusion2 error"); } if (socket_fusion_is_usable(socket1)) { LOGI("### config connection success.%p", socket2); return getOK(env); } else { return Java_com_iped_ipcam_gui_UdtTools_monitorSocket(env, thiz,camId); } } LOGI("### config connection faliled."); return getError(env, socket2); }
static void cbm2_monitor_init(void) { unsigned int dnr; monitor_cpu_type_t asm6502; monitor_interface_t *drive_interface_init[DRIVE_NUM]; monitor_cpu_type_t *asmarray[2]; asmarray[0]=&asm6502; asmarray[1]=NULL; asm6502_init(&asm6502); for (dnr = 0; dnr < DRIVE_NUM; dnr++) drive_interface_init[dnr] = drivecpu_monitor_interface_get(dnr); /* Initialize the monitor. */ monitor_init(maincpu_monitor_interface_get(), drive_interface_init, asmarray); }
static int ldepth(lua_State *L) { monitor_init(G); int args = lua_gettop(L) - 1; if (!lua_isfunction(L, 1)) { int n = luaL_checkinteger(L, 1); G->from = n; --args; lua_sethook(L, monitor_depthfrom, LUA_MASKCALL | LUA_MASKRET, 0); } else { lua_sethook(L, monitor_depth, LUA_MASKCALL | LUA_MASKRET, 0); } lua_call(L, args, 0); lua_sethook(L, NULL, 0 , 0); lua_pushinteger(L, G->max_depth); lua_pushinteger(L, G->calls); lua_pushlstring(L, G->buffer, G->ptr); return 3; }
int main(int argc, char *argv[]) { HRESULT ret = E_FAIL; INT32 id = 0; struct M_DAEMON_ModAttr_t attr = { MODULE_NAME, MODULE_TIMEOUT, MODULE_TYPE }; if (argc != 1) { if (argc != 2) { printf("Usage: %s continue/stop\n", argv[0]); exit(0); } else { if (strcmp(argv[1], "continue") == 0) ret = monitor_continue(); else if (strcmp(argv[1], "stop") == 0) ret = monitor_stop(); else ; exit(0); } } ret = monitor_init(); if (ret != S_OK) { printf("%s - init fail\n", MODULE_NAME); return E_FAIL; } id = M_DAEMON_RegisterModule(&attr, NULL); while (1) { M_OSAL_Task_Sleep(1000); ret = M_DAEMON_UpdateStatus(id, NULL); if (ret != S_OK) printf("%s - update status fail, ret = 0x%X\n", MODULE_NAME, ret); } return 0; }
static int privsep_preauth(Authctxt *authctxt) { int status; pid_t pid; /* Set up unprivileged child process to deal with network data */ pmonitor = monitor_init(); /* Store a pointer to the kex for later rekeying */ pmonitor->m_pkex = &xxx_kex; pid = fork(); if (pid == -1) { fatal("fork of unprivileged child failed"); } else if (pid != 0) { debug2("Network child is on pid %ld", (long)pid); close(pmonitor->m_recvfd); pmonitor->m_pid = pid; monitor_child_preauth(authctxt, pmonitor); close(pmonitor->m_sendfd); /* Sync memory */ monitor_sync(pmonitor); /* Wait for the child's exit status */ while (waitpid(pid, &status, 0) < 0) if (errno != EINTR) break; return (1); } else { /* child */ close(pmonitor->m_sendfd); /* Demote the child */ if (getuid() == 0 || geteuid() == 0) privsep_preauth_child(); setproctitle("%s", "[net]"); } return (0); }
/* * int * main(int argc, char **argv) * Start routine of pfc_modcache command. */ int main(int argc, char **argv) { /* Set up monitor process environment. */ setup(argc, argv); /* Initialize monitor context. */ monitor_init(); for (;;) { /* Send ping to the daemon. */ monitor_ping(); /* Wait until the interval time has passed. */ monitor_sleep(); } /* The program must not reach here. */ return MON_EX_FATAL; }
void proc_init(void) { LIST_INIT(&proc_ready_list); #if CONFIG_KERN_HEAP LIST_INIT(&zombie_list); heap_init(&proc_heap, heap_buf, sizeof(heap_buf)); #endif /* * We "promote" the current context into a real process. The only thing we have * to do is create a PCB and make it current. We don't need to setup the stack * pointer because it will be written the first time we switch to another process. */ proc_initStruct(&main_process); current_process = &main_process; #if CONFIG_KERN_MONITOR monitor_init(); monitor_add(current_process, "main"); #endif MOD_INIT(proc); }
/* ************************************************** */ int do_init(void) { if (das_init() || /* das */ sodas_init() || /* sodas */ spadas_init() || /* spadas */ hadas_init() || /* hadas */ rng_init() || /* rng */ timer_init() || /* timer */ bundle_init() || /* bundle */ entity_init() || /* entity */ monitor_init() || /* monitor */ measure_init() || /* mesure */ medium_init() || /* medium */ mobility_init() || /* mobility */ modulation_init() || /* modulation */ noise_init() || /* noise */ node_init() || /* node */ packet_init() || /* packet */ scheduler_init()) { /* scheduler */ return -1; } return 0; }
int main(int argc, char* argv[]) { int c, d, swap; monitor *m; int n = ARRAY_SIZE; int *array; array = malloc(n * sizeof(int)); make_array(array, n, ARRAY_ALGO); NOTIFY(print_array(array, n, OUT_LINE_SIZE)); m = monitor_init(SELF); monitor_start(m); NOTIFY("entering sorting algo\n"); for (c = 0 ; c < ( n - 1 ); c++) { for (d = 0 ; d < n - c - 1; d++) { if (array[d] > array[d+1]) /* For decreasing order use < */ { swap = array[d]; array[d] = array[d+1]; array[d+1] = swap; } } } monitor_end(m); assert(verify(array, n)); /* print_array(&array, n, OUT_LINE_SIZE); */ monitor_print_stats(m, VERBOSE); return 0; }
static void start(int thread) { struct worker_param wp[thread]; struct watcher watcher; watcher_init(&watcher, thread, wp); pthread_t pid[thread+3]; int i; for (i=0; i<thread; i++) { wp[i].watcher = &watcher; wp[i].thread = i; monitor_init(&wp[i].monitor); pthread_create(&pid[i], 0, worker, &wp[i]); } pthread_create(&pid[i++], 0, timer, &watcher); pthread_create(&pid[i++], 0, socket, &watcher); pthread_create(&pid[i++], 0, monitor, &watcher); for (i=0; i<thread+3; i++) pthread_join(pid[i], 0); watcher_unit(&watcher); }
int main(int argc, char* argv[]) { int n = ARRAY_SIZE; int array[ARRAY_SIZE]; monitor *m; make_array(&array, n, ARRAY_ALGO); NOTIFY(print_array(&array, n, OUT_LINE_SIZE)); m = monitor_init(SELF); monitor_start(m); bsort(&array, n); monitor_end(m); assert(verify(&array, n)); /* print_array(&array, n, OUT_LINE_SIZE); */ monitor_print_stats(m, VERBOSE); return 0; }
static void scpu64_monitor_init(void) { unsigned int dnr; monitor_cpu_type_t asm6502, asmR65C02, asm65816; monitor_interface_t *drive_interface_init[DRIVE_NUM]; monitor_cpu_type_t *asmarray[4]; asmarray[0] = &asm65816; asmarray[1] = &asmR65C02; asmarray[2] = &asm6502; asmarray[3] = NULL; asm6502_init(&asm65816); asmR65C02_init(&asmR65C02); asm65816_init(&asm6502); for (dnr = 0; dnr < DRIVE_NUM; dnr++) { drive_interface_init[dnr] = drive_cpu_monitor_interface_get(dnr); } /* Initialize the monitor. */ monitor_init(maincpu_monitor_interface_get(), drive_interface_init, asmarray); }
int _protocol_init(const char *prot_name, PROTO_PARA *ppp) { /* check whether the protocol version match the csf core version */ if (CORE_VER_REQUIRE > ppp->vcbp->lowest_ver) return PROTO_VER_ERR; logger_init(ppp->chp->logp, NULL, 0, 0); mp_init(20, 100); monitor_init(ppp->chp->mntp); submit_request_init(ppp->chp->sribp); g_pcp = ppp->pcp; set_protocol_name(prot_name); pthread_once(&init_done, pthr_key_create); pthread_setspecific(pthread_key, NULL); if (protocol_init(get_protocol_name()) < 0) return PROTO_INIT_ERR; return PROTO_INIT_OK; }
int main(int argc, char **argv) { pthread_t nthread; pthread_t sthread; pthread_t ethread; pthread_t wthread; char *dirs; int i; setvbuf(stdout, NULL, _IOLBF,0); if (argc != 2) { printf("usage: %s <directions>\n",argv[0]); return 1; } dirs = argv[1]; /*initialize four queues; one for each direction*/ q_init(); /*add carts to queues from command line args*/ for (i=0; dirs[i] != '\0'; ++i) { if (dirs[i] == 'n') q_putCart('n'); else if (dirs[i] == 's') q_putCart('s'); else if (dirs[i] == 'e') q_putCart('e'); else if (dirs[i] == 'w') q_putCart('w'); else printf("Invalid character %c supplied, ignoring...\n",dirs[i]); } printf("\nStarting queues:\n"); q_print('n'); q_print('w'); q_print('s'); q_print('e'); printf("\n"); /*init monitor*/ monitor_init(); /*start threads*/ if (pthread_create(&nthread,NULL,&north,NULL)) { printf("North thread creation failed.\n"); return -1; } if (pthread_create(&sthread,NULL,&south,NULL)) { printf("South thread creation failed.\n"); return -1; } if (pthread_create(ðread,NULL,&east,NULL)) { printf("East thread creation failed.\n"); return -1; } if (pthread_create(&wthread,NULL,&west,NULL)) { printf("West thread creation failed.\n"); return -1; } /*wait until all threads exit*/ pthread_join(nthread,NULL); pthread_join(sthread,NULL); pthread_join(ethread,NULL); pthread_join(wthread,NULL); printf("\nEnding queues (should all be NULL):\n"); q_print('n'); q_print('w'); q_print('s'); q_print('e'); printf("\n"); /*free up memory and exit program*/ q_shutdown(); monitor_shutdown(); return 0; }
int main() { pedal_node_state = pedal_state_neutral; LCD_Start(); CAN_invertor_init(); ADC_SAR_Start(); ADC_SAR_StartConvert(); EEPROM_Start(); //isr_Start(); //Timer_Start(); CAN_timer_Start(); CAN_Init(); CAN_Start(); isr_start_StartEx(&isr_start_handler); Start_Reset_Write(1); /* source of interrupt (reset) */ isr_start_ClearPending(); isr_neutral_StartEx(&isr_neutral_handler); Neutral_Reset_Write(1); isr_neutral_ClearPending(); isr_calibration_StartEx(&isr_calibration_handler); CyGlobalIntEnable; //enable global interrupts //Initialize terminal terminal_init(); monitor_init(); pedal_restore_calibration_data(); //set min and max values pedal_set_CAN(); //Setup tunnel from pedal control to CAN pedal_set_monitor(); //Setup tunnel from pedal control to USB Monitor // Initialize global variables EEPROM_ERROR_LED_Write(0); should_calibrate = false; // terminal_registerCommand("newCmd", &newCmdRout); sendNMT(NMT_command_startRemoteNode); CyDelay(1000); pedal_node_state = pedal_state_driving; for(;;){ pedal_fetch_data(); } for(;;) { CyDelay(50); terminal_run(); // Refresh terminal if (pedal_node_state == pedal_state_neutral) { if (should_calibrate) { pedal_node_state = pedal_state_calibrating; } else if (should_turn_to_drive) { pedal_node_state = pedal_state_driving; //Start sending can message for invertor CAN_invertor_resume(); } } else if (pedal_node_state == pedal_state_driving) { if (should_turn_to_neutral) { pedal_node_state = pedal_state_neutral; //Stop sending messages for invertor CAN_invertor_pause(); } } //Clear all flags after handling should_calibrate = false; should_turn_to_drive = false; should_turn_to_neutral = false; uint8_t out_of_range_flag; double brake_percent = 0, throttle_percent = 0; double brake_percent_diff = 0, throttle_percent_diff = 0; uint8_t torque_plausible_flag; uint8_t brake_plausible_flag; pedal_fetch_data(); //Update ADC readings CAN_invertor_update_pedal_state(pedal_node_state); monitor_update_vechicle_state(pedal_node_state); //Update vecicle state monitor_status_update_vehicle_state(pedal_node_state); switch (pedal_node_state) { case pedal_state_neutral: LCD_ClearDisplay(); LCD_Position(0,0); LCD_PrintString("NEUTRAL"); break; case pedal_state_driving: LCD_ClearDisplay(); LCD_Position(0,0); LCD_PrintString("DRIVING"); //out_of_range_flag = pedal_get_out_of_range_flag(); if (out_of_range_flag != 0) { pedal_node_state = pedal_state_out_of_range; break; } torque_plausible_flag = pedal_is_pedal_reading_matched(&brake_percent_diff, &throttle_percent_diff); if (torque_plausible_flag != 0) { pedal_node_state = pedal_state_discrepency; break; } brake_plausible_flag = pedal_is_brake_plausible(&brake_percent, &throttle_percent); if (brake_plausible_flag != 0) { pedal_node_state = pedal_state_implausible; break; } break; case pedal_state_calibrating: //clock_StopBlock(); //stop clock to disable interrupt pedal_calibrate(); LCD_ClearDisplay(); //isr_ClearPending(); //clock_Start(); // isr_calibration_Enable(); pedal_node_state = pedal_state_neutral; break; case pedal_state_out_of_range: LCD_ClearDisplay(); LCD_Position(0,0); LCD_PrintString("Pedal out of"); LCD_Position(1,0); LCD_PrintString("range"); out_of_range_flag = pedal_get_out_of_range_flag(); if (out_of_range_flag == 0) { pedal_node_state = pedal_state_driving; } break; case pedal_state_discrepency: LCD_ClearDisplay(); LCD_Position(0,0); LCD_PrintString("Pedal discrepency"); torque_plausible_flag = pedal_is_pedal_reading_matched(&brake_percent_diff, &throttle_percent_diff); if (torque_plausible_flag == 0) { pedal_node_state = pedal_state_driving; } break; case pedal_state_implausible: LCD_ClearDisplay(); LCD_Position(0,0); LCD_PrintString("Pedal implausible"); brake_plausible_flag = pedal_is_brake_plausible(&brake_percent, &throttle_percent); if (throttle_percent < PEDAL_BRAKE_IMPLAUSIBLE_EXIT_THROTTLE_PERCENT) { pedal_node_state = pedal_state_driving; } break; } // CyDelay(100); } return 0; }
/*---------------------------------------------------------------------------* * program entry *---------------------------------------------------------------------------*/ int main(int argc, char **argv) { int i; msg_vr_req_t mvr; #ifdef I4B_EXTERNAL_MONITOR int sockfd = -1; /* local monitor socket */ #ifndef I4B_NOTCPIP_MONITOR int remotesockfd = -1; /* tcp/ip monitor socket */ #endif #endif setlocale (LC_ALL, ""); while ((i = getopt(argc, argv, "mc:d:fFlL:Pr:s:t:u:")) != -1) { switch (i) { #ifdef I4B_EXTERNAL_MONITOR case 'm': inhibit_monitor = 1; break; #endif case 'c': configfile = optarg; break; #ifdef DEBUG case 'd': if(*optarg == 'n') debug_noscreen = 1; else if((sscanf(optarg, "%i", &debug_flags)) == 1) do_debug = 1; else usage(); break; #endif case 'f': do_fullscreen = 1; do_fork = 0; #ifndef USE_CURSES fprintf(stderr, "Sorry, no fullscreen mode available - daemon compiled without USE_CURSES\n"); exit(1); #endif break; case 'F': do_fork = 0; break; case 'l': uselogfile = 1; break; case 'L': strlcpy(logfile, optarg, sizeof(logfile)); break; case 'P': do_print = 1; break; case 'r': rdev = optarg; do_rdev = 1; break; case 's': if(isdigit(*optarg)) { int facility; logfacility = strtoul(optarg, NULL, 10); facility = logfacility << 3; if((facility < LOG_KERN) || (facility > LOG_FTP && facility < LOG_LOCAL0) || (facility > LOG_LOCAL7)) { fprintf(stderr, "Error, option -s has invalid logging facility %d", logfacility); usage(); } logfacility = facility; } else { fprintf(stderr, "Error: option -s requires a numeric argument!\n"); usage(); } break; case 't': ttype = optarg; do_ttytype = 1; break; case 'u': if(isdigit(*optarg)) { unit_length = strtoul(optarg, NULL, 10); if(unit_length < ULSRC_CMDLMIN) unit_length = ULSRC_CMDLMIN; else if(unit_length > ULSRC_CMDLMAX) unit_length = ULSRC_CMDLMAX; got_unitlen = 1; } else { fprintf(stderr, "Error: option -T requires a numeric argument!\n"); usage(); } break; case '?': default: usage(); break; } } #ifdef DEBUG if(!do_debug) debug_noscreen = 0; #endif if(!do_print) { umask(UMASK); /* set our umask ... */ init_log(); /* initialize the logging subsystem */ } check_pid(); /* check if we are already running */ if(!do_print) { if(do_fork || (do_fullscreen && do_rdev)) /* daemon mode ? */ daemonize(); write_pid(); /* write our pid to file */ /* set signal handler(s) */ signal(SIGCHLD, sigchild_handler); /* process handling */ signal(SIGHUP, rereadconfig); /* reread configuration */ signal(SIGUSR1, reopenfiles); /* reopen acct/log files*/ signal(SIGPIPE, SIG_IGN); /* handled manually */ signal(SIGINT, do_exit); /* clean up on SIGINT */ signal(SIGTERM, do_exit); /* clean up on SIGTERM */ signal(SIGQUIT, do_exit); /* clean up on SIGQUIT */ } /* open isdn device */ if((isdnfd = open(I4BDEVICE, O_RDWR)) < 0) { dolog(LL_ERR, "main: cannot open %s: %s", I4BDEVICE, strerror(errno)); exit(1); } /* check kernel and userland have same version/release numbers */ if((ioctl(isdnfd, I4B_VR_REQ, &mvr)) < 0) { dolog(LL_ERR, "main: ioctl I4B_VR_REQ failed: %s", strerror(errno)); do_exit(1); } if(mvr.version != VERSION) { dolog(LL_ERR, "main: version mismatch, kernel %d, daemon %d", mvr.version, VERSION); do_exit(1); } if(mvr.release != REL) { dolog(LL_ERR, "main: release mismatch, kernel %d, daemon %d", mvr.release, REL); do_exit(1); } if(mvr.step != STEP) { dolog(LL_ERR, "main: step mismatch, kernel %d, daemon %d", mvr.step, STEP); do_exit(1); } /* init controller state array */ init_controller(); /* read runtime configuration file and configure ourselves */ configure(configfile, 0); if(config_error_flag) { dolog(LL_ERR, "there were %d error(s) in the configuration file, terminating!", config_error_flag); exit(1); } /* set controller ISDN protocol */ init_controller_protocol(); /* init active controllers, if any */ signal(SIGCHLD, SIG_IGN); /*XXX*/ init_active_controller(); signal(SIGCHLD, sigchild_handler); /*XXX*/ /* handle the rates stuff */ if((i = readrates(ratesfile)) == ERROR) { if(rate_error != NULL) dolog(LL_ERR, "%s", rate_error); exit(1); } if(i == GOOD) { got_rate = 1; /* flag, ratesfile read and ok */ DBGL(DL_RCCF, (dolog(LL_DBG, "ratesfile %s read successfully", ratesfile))); } else { if(rate_error != NULL) dolog(LL_WRN, "%s", rate_error); } /* if writing accounting info, open file, set unbuffered */ if(useacctfile) { if((acctfp = fopen(acctfile, "a")) == NULL) { dolog(LL_ERR, "ERROR, can't open acctfile %s for writing, terminating!", acctfile); exit(1); } setvbuf(acctfp, NULL, _IONBF, 0); } /* initialize alias processing */ if(aliasing) init_alias(aliasfile); /* init holidays */ init_holidays(holidayfile); /* init remote monitoring */ #ifdef I4B_EXTERNAL_MONITOR if(do_monitor) { monitor_init(); sockfd = monitor_create_local_socket(); #ifndef I4B_NOTCPIP_MONITOR remotesockfd = monitor_create_remote_socket(monitorport); #endif } #endif /* in case fullscreendisplay, initialize */ #ifdef USE_CURSES if(do_fullscreen) { init_screen(); } #endif /* init realtime priority */ #ifdef USE_RTPRIO if(rt_prio != RTPRIO_NOTUSED) { struct rtprio rtp; rtp.type = RTP_PRIO_REALTIME; rtp.prio = rt_prio; if((rtprio(RTP_SET, getpid(), &rtp)) == -1) { dolog(LL_ERR, "rtprio failed: %s", strerror(errno)); do_exit(1); } } #endif starttime = time(NULL); /* get starttime */ srandom(580403); /* init random number gen */ mloop( /* enter loop of no return .. */ #ifdef I4B_EXTERNAL_MONITOR sockfd #ifndef I4B_NOTCPIP_MONITOR , remotesockfd #endif #endif ); do_exit(0); return(0); }
int main(int argc, char *argv[]) { char *directions; int i; pthread_t tid[4]; char *arg; int rc; /* get command line */ if (argc != 2) { fprintf(stderr, "usage: %s <string: any length/combination of n,e,w,s>\n", argv[0]); exit(1); } directions = argv[1]; /* init other modules */ q_init(); monitor_init(); pthread_barrier_init(&endBarrier, NULL, 4); /* 1. place all carts on appropriate queue */ for (i=0; i<strlen(directions); i++) q_putCart(directions[i]); #if 1 q_print(Q_NORTH); q_print(Q_SOUTH); q_print(Q_EAST); q_print(Q_WEST); #endif /* 2. create 4 threads, one for each direction */ arg = malloc(sizeof(char)); *arg = Q_NORTH; if ((rc = pthread_create(&tid[0], NULL, moveCart, (void *)arg)) != 0) fprintf(stderr, "thread create %c failed (%s)\n", *arg, strerror(rc)), exit(1); arg = malloc(sizeof(char)); *arg = Q_SOUTH; if ((rc = pthread_create(&tid[1], NULL, moveCart, (void *)arg)) != 0) fprintf(stderr, "thread create %c failed (%s)\n", *arg, strerror(rc)), exit(1); arg = malloc(sizeof(char)); *arg = Q_EAST; if ((rc = pthread_create(&tid[2], NULL, moveCart, (void *)arg)) != 0) fprintf(stderr, "thread create %c failed (%s)\n", *arg, strerror(rc)), exit(1); arg = malloc(sizeof(char)); *arg = Q_WEST; if ((rc = pthread_create(&tid[3], NULL, moveCart, (void *)arg)) != 0) fprintf(stderr, "thread create %c failed (%s)\n", *arg, strerror(rc)), exit(1); /* 3. join threads as they complete */ if ((rc = pthread_join(tid[0], NULL)) != 0) fprintf(stderr, "thread join 0 failed (%s)\n", strerror(rc)), exit(1); if ((rc = pthread_join(tid[1], NULL)) != 0) fprintf(stderr, "thread join 1 failed (%s)\n", strerror(rc)), exit(1); if ((rc = pthread_join(tid[2], NULL)) != 0) fprintf(stderr, "thread join 2 failed (%s)\n", strerror(rc)), exit(1); if ((rc = pthread_join(tid[3], NULL)) != 0) fprintf(stderr, "thread join 3 failed (%s)\n", strerror(rc)), exit(1); /* release resources */ q_shutdown(); monitor_shutdown(); pthread_barrier_destroy(&endBarrier); return 0; }