/* (1 s pause) +++ (1 s pause) ATH0 <LF> * ans Modem schicken und zweimal auf OK warten */ static int hayes_hangup(int lmodem) { /* returns: * 0: ok * 1: Fehler bei +++ * 2: Fehler bei ATH0 */ int t_nocarr; int t_ok; int t_error; int ok; free_all_tracks(); t_nocarr = init_track("NO CARRIER"); t_ok = init_track("OK"); t_error = init_track("ERROR"); alarm(10); sleep(1); write( lmodem, "+++", 3 ); sleep(1); ok = do_hayes("", lmodem); if(ok != t_ok) { return 1; } ok = do_hayes("ATH0", lmodem); if(ok != t_ok) { return 2; } return 0; }
int process_string(const char* str) { LOGI("Processing string '%s'", str); if (isalpha(*str)) { if (current_sprite == NULL) { current_sprite = &sprites[0]; nframes = 0; } else { current_sprite->animation.ntracks = 4; current_sprite->animation.tracks = malloc(current_sprite->animation.ntracks * sizeof(animation_track_t)); init_track(TRACK_SPRITE_IMAGE, ATT_UINT32, ATI_LINEAR, image_frames); init_track(TRACK_SPRITE_OFFSET, ATT_VEC3F, ATI_LINEAR, offset_frames); init_track(TRACK_SPRITE_SCALE, ATT_VEC3F, ATI_LINEAR, scale_frames); init_track(TRACK_SPRITE_ROTATION, ATT_QUAT, ATI_LINEAR, rotation_frames); current_sprite->nsprite_names = nframes; current_sprite->sprite_names = malloc(nframes * sizeof(sprite_id_t)); memcpy(current_sprite->sprite_names, image_names, nframes * sizeof(sprite_id_t)); ++current_sprite; nframes = 0; } return process_sprite(current_sprite, str); } else if (isspace(*str)) { const char* ptr = str + 1; while (isspace(*ptr)) ++ptr; if (*ptr == '\n' || *ptr == '\0') { // EOL or EOF ocurred return 0; } if (current_sprite != NULL) { return process_frame(current_sprite, ptr); } } else if (*str == '#') { // skip comment return 0; } return -1; }
void init_disk(disk_t& disk) { disk.comment = ""; disk.num_phys_cyls = 0; disk.num_phys_heads = 0; for (int cyl = 0; cyl < MAX_CYLS; cyl++) { for (int head = 0; head < MAX_HEADS; head++) { init_track(cyl, head, disk.tracks[cyl][head]); } } }
void go() { int result; int tr; int trtid; char buf[4]; char ch; track_edge *edge; unsigned int dist; track_node track[TRACK_MAX]; init_track(track); printf("Enter Train Number: "); gets(IO, buf, 4); tr = atoin(buf, &result); trtid = TrCreate(6, tr, &track[24].edge[DIR_AHEAD]); TrSpeed(trtid, 0); while (true) { ch = getchar(); switch (ch) { case 's': TrSpeed(trtid, 8); break; case 't': TrSpeed(trtid, 0); break; case 'r': TrReverse(trtid); break; case 'g': TrGetLocation(trtid, &edge, &dist); printf("train %d at %d after sensor %s\n", trtid, dist, edge->src->name); break; case 'q': turnOffTrainSet(); Delay(10); SigTerm(0); Exit(); break; default: break; } } }
void train_process(PROCESS self, PARAM param) { COM_Message msg; char buffer [128]; msg.input_buffer = buffer; // clear train window clear_window(&train_wnd); // set up track to ensure safety of trains init_track(); // determine disposition of Zamboni int zamboniConfig = get_zamboni_condition(); //int zamboniConfig = 0; // determine config of train/wagon int trainConfig = get_train_wagon_config(); get_wagon(trainConfig, zamboniConfig); while(1); }
void track_server_code (){ RegisterAs("TRACKSERVER"); // Server data sw_info sw_infos [NUM_SWITCHES]; int sensor_info [NUM_SENSORS]; // time when the sensor is hit int broken_sensors[NUM_SENSORS] = {0}; // Server's track data track_node track[TRACK_MAX]; init_track(track); init_broken_sensors(broken_sensors); track_node *src, *dst; // Received stuff track_receive rcv_buff; int sender_tid; int request_type; int sensor_index = 0; //Reply buffs int reply_dist = 0; int reply_index = 0; struct track_loc reply_loc; char reply_buff; int reply_buff_loc_dist [2]; struct train_server_request tsr; int train_server_id; while((train_server_id = WhoIs("TRAINSERVER")) == -1); int track_to_train_courier_tid = Create(PR_COURIER, track_to_train_courier_code); int track_to_train_courier_ready = 0; Queue train_serverQ; struct train_server_request allocated_buff[TRACK_TO_TRAIN_QUEUE_SIZE]; Queue_init (&train_serverQ, allocated_buff, TRACK_TO_TRAIN_QUEUE_SIZE, sizeof(struct train_server_request)); //things for shortest path request track_node* path[TRACK_MAX] = {0}; int dist[TRACK_MAX] = {0}; int shortest_dist = 0; routing_command commands[TRACK_MAX]; init_routing_commands(commands); // switch_command sw_commands[NUM_MAX_SWITCH_ROUTE_COMMANDS]; // memset(sw_commands, 0, NUM_MAX_SWITCH_ROUTE_COMMANDS * sizeof(switch_command)); //things for changing switches when train goes //within a specified route Queue switch_queues[NUM_TRAINS]; Queue *Q; switch_command switch_queue_buffers[NUM_TRAINS][NUM_MAX_SWITCH_ROUTE_COMMANDS]; memset(switch_queue_buffers, 0, NUM_TRAINS * NUM_MAX_SWITCH_ROUTE_COMMANDS * sizeof(switch_command)); int trnum; for (trnum = 0; trnum < NUM_TRAINS; trnum++) { Queue_init(&switch_queues[trnum], switch_queue_buffers[trnum], NUM_MAX_SWITCH_ROUTE_COMMANDS, sizeof(switch_command)); } // //Reservation data structures track_reservation track_reservations[TRACK_MAX]; train_reservation_info tr_reservation_infos[NUM_TRAINS]; memset(track_reservations, 0, TRACK_MAX * sizeof(track_reservation)); memset(tr_reservation_infos, -1, NUM_TRAINS * sizeof(train_reservation_info)); // Queue isReservableQueue; isReservableQueueItem isReservableQueueItems[NUM_TRAINS]; Queue_init(&isReservableQueue, isReservableQueueItems, NUM_TRAINS, sizeof(isReservableQueueItem)); isReservableQueueItem irqi; int reserve_ret = -1; int ret; while(1){ Receive(&sender_tid, &rcv_buff, sizeof(track_receive)); request_type = rcv_buff.type; switch (request_type){ case TRACK_TYPE_COURIER_RTS: track_to_train_courier_ready = 1; break; case TRACK_TYPE_SENSOR_INFO: sensor_index = (rcv_buff.data.track_data.data2 - 'A')*16+rcv_buff.data.track_data.data1-1; //if (sensor_index == 56) {HardDebug("D9 is hit. Hit time:%d. Rcv Time:%d", rcv_buff.data.track_data.time, Time());} sensor_info[sensor_index] = rcv_buff.data.track_data.time; Reply(sender_tid, &reply_buff, sizeof(char)); tsr.type = TRAIN_TYPE_SENSOR_UPDATE; memcpy(&tsr.data, &rcv_buff.data.track_data, sizeof(track_info)); if (!broken_sensors[sensor_index]) { //Send(train_server_id, &tsr, sizeof(struct train_server_request), &reply_buff, sizeof(char)); ret = Queue_push(&train_serverQ, &tsr); Warning(ret == 0, "TRACKSERVER: Queue_push failed"); } break; case TRACK_TYPE_SWITCH_INFO: (sw_infos[(int)rcv_buff.data.track_data.data1]).swdir = rcv_buff.data.track_data.data2; (sw_infos[(int)rcv_buff.data.track_data.data1]).time = rcv_buff.data.track_data.time; Reply(sender_tid, &reply_buff, sizeof(char)); tsr.type = TRAIN_TYPE_SWITCH_UPDATE; memcpy(&tsr.data, &rcv_buff.data.track_data, sizeof(track_info)); //Send(train_server_id, &tsr, sizeof(struct train_server_request), &reply_buff, sizeof(char)); ret = Queue_push(&train_serverQ, &tsr); Warning(ret == 0, "TRACKSERVER: Queue_push failed"); break; case TRACK_TYPE_DIST: if((int)rcv_buff.data.track_data.data1 >= TRACK_MAX || (int)rcv_buff.data.track_data.data2 >= TRACK_MAX) { reply_dist = 0; } else { src = &track[(int)rcv_buff.data.track_data.data1]; dst = &track[(int)rcv_buff.data.track_data.data2]; reply_dist = get_dist_between_nodes(src, dst, sw_infos); } Reply(sender_tid, &reply_dist, sizeof(int)); break; case TRACK_TYPE_NEXT_LOC: //get current loc_index and find next node __get_next_node((int)rcv_buff.data.track_data.data1, track, sw_infos, &reply_loc.index, reply_loc.name); Reply(sender_tid, &reply_loc, sizeof(struct track_loc)); break; case TRACK_TYPE_NEXT_SENSOR: reply_index = get_next_sensor_index((int)rcv_buff.data.track_request_data.data1, track, sw_infos, broken_sensors, &tsr.data.spd.spd_val); Assert(reply_index == tsr.data.spd.spd_val.next_expected_sensor_index, "reply_index != result->next_expected_sensor_index"); //Debug("TRACKSERVER: Got next expected sensor %d, after that %d", tsr.data.spd.spd_val.next_expected_sensor_index, tsr.data.spd.spd_val.sensor_after_expected_sensor); Reply(sender_tid, &reply_index, sizeof(int)); tsr.type = TRAIN_TYPE_SENSOR_PREDICTION; tsr.data.spd.trnum = (int)rcv_buff.data.track_request_data.data2; if (rcv_buff.data.track_request_data.data3) { //Send(train_server_id, &tsr, sizeof(train_server_request), &reply_buff, sizeof(char)); ret = Queue_push(&train_serverQ, &tsr); Warning(ret == 0, "TRACKSERVER: Queue_push failed"); } break; case TRACK_TYPE_LOC_NAME: Reply(sender_tid, (char*)track[(int)rcv_buff.data.track_data.data1].name, 6 * sizeof(char)); break; case TRACK_TYPE_SENSOR_REVERSE: reply_index = get_reverse_sensor((int)rcv_buff.data.track_request_data.data1, track, sw_infos, broken_sensors, &tsr.data.spd.spd_val); Reply(sender_tid, &reply_index, sizeof(int)); tsr.data.spd.trnum = (int)rcv_buff.data.track_request_data.data2; if (rcv_buff.data.track_request_data.data3) { //Send(train_server_id, &tsr, sizeof(train_server_request), &reply_buff, sizeof(char)); ret = Queue_push(&train_serverQ, &tsr); Warning(ret == 0, "TRACKSERVER: Queue_push failed"); } break; case TRACK_TYPE_UPDATE_LOC_AND_DISTANCE: translate_sensor_loc(rcv_buff.data.track_request_data.data1, rcv_buff.data.track_request_data.data2, track, sw_infos, reply_buff_loc_dist); Reply(sender_tid, reply_buff_loc_dist, 2*sizeof(int)); break; case TRACK_TYPE_FIND_ROUTE: Warning(((0 <= rcv_buff.data.track_request_data.data2 && rcv_buff.data.track_request_data.data2 < TRACK_MAX) && (0 <= rcv_buff.data.track_request_data.data3 && rcv_buff.data.track_request_data.data3 < TRACK_MAX)), "TRACKSERVER: TRACK_TYPE_FIND_ROUTE - Source(%d) or destination(%d) is invalid", rcv_buff.data.track_request_data.data2, rcv_buff.data.track_request_data.data3); //Debug("FINDING ROUTE:trnum:%d ~ src:%s ~ dest:%s ~ offset:%d",rcv_buff.data.track_request_data.data1, track[rcv_buff.data.track_request_data.data2].name, track[rcv_buff.data.track_request_data.data3].name, rcv_buff.data.track_request_data.data4); shortest_dist = shortest_path((int)rcv_buff.data.track_request_data.data2, (int)rcv_buff.data.track_request_data.data3, track, path, dist, track_reservations); if (shortest_dist == __INFINITY) { shortest_path((int)rcv_buff.data.track_request_data.data2, (int)rcv_buff.data.track_request_data.data3, track, path, dist, 0); } generate_commands(path, track, commands); print_commands(commands); pull_out_switch_orders(commands, tsr.data.path_commands.sw_commands, &switch_queues[rcv_buff.data.track_request_data.data1]); pull_out_reverse_orders(commands, tsr.data.path_commands.rv_commands); tsr.type = TRAIN_TYPE_ROUTE_SWITCH_ORDERS; Reply(sender_tid, &tsr, sizeof(train_server_request)); break; case TRACK_TYPE_RESERVATION_INIT: reserve_ret = reserve_inital_piece (track_reservations, track, tr_reservation_infos, sw_infos, &switch_queues[rcv_buff.data.track_request_data.data1], rcv_buff.data.track_request_data.data1, rcv_buff.data.track_request_data.data2, rcv_buff.data.track_request_data.data3, rcv_buff.data.track_request_data.data4); Debug("TRACKSERVER: Received reservation initialization request for train %d", rcv_buff.data.track_request_data.data1); tsr.type = TRAIN_TYPE_RESERVATION_SUCCESS; Reply(sender_tid, &tsr, sizeof(train_server_request)); break; case TRACK_TYPE_RESERVATION: Q = &switch_queues[rcv_buff.data.track_request_data.data1]; reserve_ret = reserve_track(track_reservations, track, tr_reservation_infos, sw_infos, Q, rcv_buff.data.track_request_data.data1, rcv_buff.data.track_request_data.data2); ret = release_track(track_reservations, track, tr_reservation_infos, sw_infos, rcv_buff.data.track_request_data.data1, rcv_buff.data.track_request_data.data3); Assert (ret != -1, "TRACKSERVER: release failed: ret:%d", ret); tsr.type = (reserve_ret == -1) ? TRAIN_TYPE_RESERVATION_FAILURE : TRAIN_TYPE_RESERVATION_SUCCESS; Reply(sender_tid, &tsr, sizeof(train_server_request)); if (/*rcv_buff.data.track_request_data.data2 < 0 ||*/ rcv_buff.data.track_request_data.data3 > 0) { check_isReservableRequests(&isReservableQueue, &train_serverQ, track, sw_infos, track_reservations, tr_reservation_infos, train_server_id); } print_total_reserved_dist(track_reservations, tr_reservation_infos, rcv_buff.data.track_request_data.data1); break; case TRACK_TYPE_RESERVATION_REVERSE: reserve_ret = reverse_reservation (track, tr_reservation_infos, sw_infos, rcv_buff.data.track_request_data.data1); tsr.type = TRAIN_TYPE_RESERVATION_SUCCESS; Reply(sender_tid, &tsr, sizeof(train_server_request)); break; case TRACK_TYPE_RESERVATION_SENSOR_UPDATE: reserve_ret = reservation_sensor_update(track_reservations, track, tr_reservation_infos, sw_infos, &switch_queues[rcv_buff.data.track_request_data.data1], rcv_buff.data.track_request_data.data1, rcv_buff.data.track_request_data.data2, rcv_buff.data.track_request_data.data3, rcv_buff.data.track_request_data.data4, rcv_buff.data.track_request_data.data5); tsr.type = (reserve_ret == -1) ? TRAIN_TYPE_RESERVATION_FAILURE : TRAIN_TYPE_RESERVATION_SUCCESS; Reply(sender_tid, &tsr, sizeof(train_server_request)); //check_isReservableRequests(&isReservableQueue, &train_serverQ, track, sw_infos, track_reservations, tr_reservation_infos, train_server_id); break; case TRACK_TYPE_RESERVATION_STOP_UPDATE: reserve_ret = reservation_stop_update ( track_reservations, track, tr_reservation_infos, sw_infos, &switch_queues[rcv_buff.data.track_request_data.data1], rcv_buff.data.track_request_data.data1, rcv_buff.data.track_request_data.data2, rcv_buff.data.track_request_data.data3, rcv_buff.data.track_request_data.data4, rcv_buff.data.track_request_data.data5); tsr.type = /*(reserve_ret == -1) ? TRAIN_TYPE_RESERVATION_FAILURE :*/ TRAIN_TYPE_RESERVATION_SUCCESS; Reply(sender_tid, &tsr, sizeof(train_server_request)); break; case TRACK_TYPE_IS_RESERVABLE: tsr.type = TRAIN_TYPE_REQ_IN_PROGRESS; Reply(sender_tid, &tsr, sizeof(train_server_request)); irqi.trnum = rcv_buff.data.track_request_data.data1; irqi.mm = rcv_buff.data.track_request_data.data2; ret = Queue_push(&isReservableQueue, &irqi); Warning(ret == 0, "TRACKSERVER: Queue_push failed"); break; case TRACK_TYPE_PRINT_RESERVATIONS: Reply(sender_tid, &reply_buff, sizeof(char)); print_reservations(track_reservations, track, tr_reservation_infos); break; default: Reply(sender_tid, &reply_buff, sizeof(char)); Warning(0,"Unknown receive in track_server_code: type=%d from %d", request_type, sender_tid); break; } if (track_to_train_courier_ready && !Queue_pop(&train_serverQ, &tsr)){ Reply(track_to_train_courier_tid, &tsr, sizeof(train_server_request)); track_to_train_courier_ready = 0; } } Exit(); Warning(0,"Unexpected return from Exit() at track_server_code\n\r"); }
static int login(int lmodem, int verfahren, const char *myname, const char *passwd) { int t_ogin, t_ame, t_wort, t_word, t_begin, found, t_esc, t_sysname, t_arc, t_verweigert, err; char z, pw[40]; if (verfahren == ZCONNECT) strcpy(pw, "0zconnec\r"); else sprintf(pw, "%s\r", passwd); free_all_tracks(); t_esc = init_track(EMSI_REQ); t_ogin = init_track("OGIN:"); if (verfahren == ZCONNECT) t_ame = init_track("AME"); else t_ame = init_track("USERNAME:"******"WORT"); t_word = init_track("WORD"); t_sysname = -1; t_begin = -1; t_arc = -1; t_verweigert = -1; alarm(2*60); while (1) { do { } while (read(lmodem, &z, 1) != 1); found = track_char(toupper(z)); if (!isascii(z) || !iscntrl(z)) { putc(z, stderr); fflush(stderr); } else if (z == '\r') putc('\n', stderr); if (found == -1) continue; if (found == t_esc) { write(lmodem, EMSI_CLI, sizeof(EMSI_CLI)); flush_modem(lmodem); } else if (found == t_ogin || found == t_ame) { #ifdef SLOW_MODEM sleep(2); /* fflush auf der Gegenseite? */ #endif write(lmodem, logstr[verfahren], strlen(logstr[verfahren])); flush_modem(lmodem); if (verfahren < ZCONNECT && t_sysname == -1) t_sysname = init_track("SYSTEMNAME:"); } else if (found == t_word || found == t_wort) { write(lmodem, pw, strlen(pw)); flush_modem(lmodem); if (verfahren == ZCONNECT && t_begin == -1) { t_begin = init_track("BEGIN"); }else { t_arc = init_track("ARC"); t_verweigert = init_track("VERWEIGER"); } } else if (found == t_sysname) { write(lmodem, myname, strlen(myname)); write(lmodem, "\r", 1); flush_modem(lmodem); } else if (found == t_begin) { err = 0; break; } else if (found == t_arc) { err = 0; break; } else if (found == t_verweigert) { err = 1; break; } } free_all_tracks(); alarm(0); return err; }