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;
}
