void schedule_handler(int fd, fd_set* reads) /************************************************************/ { //int i = 0; //int status = 0; int rxmsg_length = 0; SEND_DATA *pRx; memset(sched_rx_msg, 0, sizeof(sched_rx_msg)); rxmsg_length = recv(fd, sched_rx_msg, sizeof(sched_rx_msg), 0); if(rxmsg_length == 0) { g_msgWr = 0; memset(message, 0, sizeof(message)); FD_CLR(fd, reads); close(fd); if ( g_dbgShow ) printf("Schedule-Server Close\n"); return; } if ( (rxmsg_length + g_msgWr) > sizeof(message) - 2 ) { g_msgWr = 0; memset(message, 0, sizeof(message)); FD_CLR(fd, reads); close(fd); if ( g_dbgShow ) printf("Buffer Pull Schedule-Server Close\n"); return; } //printf("Handler RX msg[%d] : \n", rxmsg_length); memcpy(&message[g_msgWr], &sched_rx_msg, rxmsg_length); g_msgWr += rxmsg_length; pRx = (SEND_DATA *)&message; if(g_msgWr == pRx->length && Check_Message(pRx)) { Parsing_Data(pRx); SetDate(pRx); } }
/*********************************************************************//** * @brief CAN_IRQ Handler, control receive message operation * param[in] none * @return none **********************************************************************/ void CAN_IRQHandler() { uint8_t IntStatus; // uint32_t data1; /* Get CAN status */ IntStatus = CAN_GetCTRLStatus(LPC_CAN1, CANCTRL_STS); //check receive buffer status if((IntStatus>>0)&0x01) { CAN_ReceiveMsg(LPC_CAN1,&RXMsg); _DBG_("Received buffer:"); PrintMessage(&RXMsg); //Validate received and transmited message if(Check_Message(&TXMsg, &RXMsg)) _DBG_("Self test is SUCCESSFUL!!!"); else _DBG_("Self test is FAIL!!!"); } }
bool Network_Service::Turn_Processing (Db_File *fh) { bool node_flag, link_flag, ab_flag; int lvalue, num, node_num, link; char *str_ptr; Link_Data *link_ptr = NULL; Turn_Data *turn_ptr = NULL; Time_Step time_step; Turn_File *file = (Turn_File *) fh; node_flag = Network_Data_Flag (NODE); link_flag = Network_Data_Flag (LINK); ab_flag = file->Node_Based (); //---- reserve memory ---- if (turn_data.Max_Records () == 0) { if (!turn_data.Max_Records (file->Num_Records ())) goto mem_error; } //---- read and save the data ---- turn_ptr = turn_data.New_Record (); if (turn_ptr == NULL) goto mem_error; node_num = file->Node (); if (node_num == 0) return (false); if (node_flag) { num = node_data.Get_Index (node_num); if (num == 0) { return (Check_Message ("Turn Prohibition Node %d was Not Found in the Node file", node_num)); } if (!Renumber ()) { num = node_num; } } else { num = node_num; } if (ab_flag) { //---- node-based method ---- AB_Data *ab_ptr; Dir_Data *dir_ptr; lvalue = file->In_Node (); ab_ptr = ab_key.Get (lvalue, node_num); if (ab_ptr == NULL) { return (Check_Message ("A Link between %d and %d was Not Found", lvalue, node_num)); } dir_ptr = dir_data [ab_ptr->dir]; turn_ptr->In_Link_Dir (dir_ptr->Link_Dir ()); lvalue = file->Out_Node (); ab_ptr = ab_key.Get (node_num, lvalue); if (ab_ptr == NULL) { return (Check_Message ("A Link between %d and %d was Not Found", node_num, lvalue)); } dir_ptr = dir_data [ab_ptr->dir]; turn_ptr->Out_Link_Dir (dir_ptr->Link_Dir ()); } else { //---- link-based method ---- lvalue = file->In_Link (); if (link_flag) { link = link_data.Get_Index (lvalue); if (link == 0) { return (Check_Message ("Turn Prohibition In-Link %d was Not Found in the Link file", lvalue)); } link_ptr = link_data [link]; if (!Renumber ()) { link = lvalue; } turn_ptr->In_Link (link); if (link_ptr->Anode () == num) { turn_ptr->In_Dir (1); } else if (link_ptr->Bnode () == num) { turn_ptr->In_Dir (0); } else { return (Check_Message ("Turn Prohibition In-Link %d is Not Attached to Node %d", lvalue, node_num)); } } else { turn_ptr->In_Link (lvalue); } //---- check/convert the out-link number ---- lvalue = file->Out_Link (); if (link_flag) { link = link_data.Get_Index (lvalue); if (link == 0) { return (Check_Message ("Turn Prohibition Out-Link %d was Not Found in the Link file", lvalue)); } link_ptr = link_data [link]; if (!Renumber ()) { link = lvalue; } turn_ptr->Out_Link (link); if (link_ptr->Bnode () == num) { turn_ptr->Out_Dir (1); } else if (link_ptr->Anode () == num) { turn_ptr->Out_Dir (0); } else { return (Check_Message ("Turn Prohibition Out-Link %d is Not Attached to Node %d", lvalue, node_num)); } } else { turn_ptr->Out_Link (lvalue); } } str_ptr = file->Start (); if (*str_ptr == '\0') { turn_ptr->Start (0); } else { turn_ptr->Start (Round (time_step.Step (str_ptr))); } str_ptr = file->End (); if (*str_ptr == '\0') { turn_ptr->End (Round (MIDNIGHT)); } else { turn_ptr->End (Round (time_step.Step (str_ptr))); } str_ptr = file->Use (); if (*str_ptr == '\0') { str_ptr = "ANY"; } turn_ptr->Use (Use_Code (str_ptr)); turn_ptr->Penalty (file->Penalty ()); return (true); mem_error: Error ("Insufficient Memory for Turn Prohibition Records"); return (false); }
bool Network_Service::Line_Processing (Db_File *fh) { static int id, nstops, stop_num; int zone; bool stop_flag; Line_Data *line_ptr = NULL; Line_File *file = (Line_File *) fh; stop_flag = Network_Data_Flag (TRANSIT_STOP); //---- process a header line ---- if (!file->Nest ()) { id = file->Route (); if (id == 0) return (false); if (id < 1) { return (Check_Message ("Transit Route ID %d is Out of Range", id)); } line_ptr = line_data.New_Record (true); if (line_ptr == NULL) goto mem_error; line_ptr->Route (id); stop_num = 1; nstops = file->Stops (); if (nstops < 2) { return (Check_Message ("Number of Stops %d on Route %d is Out of Range", nstops, id)); } if (!line_ptr->Stops (nstops)) { Error ("Insufficient Memory for %d Stops on Router %d", nstops, id); } line_ptr->Mode (Transit_Code (file->Mode ())); line_ptr->Null_Name (); line_ptr->Null_Notes (); if (Notes_Name_Flag ()) { char *str_ptr = file->Name (); if (str_ptr != NULL && *str_ptr != '\0') { line_ptr->Name (str_ptr); } str_ptr = file->Notes (); if (str_ptr != NULL && *str_ptr != '\0') { line_ptr->Notes (str_ptr); } } } else { line_ptr = line_data.New_Record (false); if (line_ptr == NULL) goto mem_error; //---- process a stop record ---- int stop = file->Stop (); if (stop_flag) { int index = stop_data.Get_Index (stop); if (index == 0) { return (Check_Message ("Transit Stop %d on Route %d was Not Found in the Stop File", stop, id)); } if (Renumber ()) stop = index; } line_ptr->Stop (stop_num, stop); zone = file->Zone (); if (Num_Fare_Zones () > 0 && (zone < 1 || zone > Num_Fare_Zones ())) { if (zone != 0 || !Zero_Fare_Zone ()) { Warning ("Transit Zone %d on Route %d is Out of Range (1..%d)", zone, id, Num_Fare_Zones ()); if (zone == 0) Zero_Fare_Zone (true); } } line_ptr->Zone (stop_num, zone); line_ptr->Time_Flag (stop_num, file->Time_Flag ()); if (stop_num == nstops) { return (true); } else { stop_num++; return (false); } } return (false); mem_error: Error ("Insuffienct Memory for Transit Line Data"); return (false); }
void Parsing_Data(SEND_DATA *pRx) /****************************************************************/ { int i = 0; int j = 0; int k = 0; FILE *fp = NULL; unsigned char *p; int filesize = 0; pthread_mutex_lock(&schedule_mutex); if((fp = fopen("SchedGHP.dat", "w")) == NULL) { if (fp != NULL) fclose(fp); if ( g_dbgShow ) printf("[ERROR] File Open with Option 'w'\n"); pthread_mutex_unlock(&schedule_mutex); return; } if ( g_dbgShow ) printf("'SchedGHP.dat' File Open with Option 'w'\n"); p = (unsigned char *)pRx; for ( i=0; i<pRx->length; i++) fwrite(&p[i], sizeof(unsigned char), 1, fp); fclose(fp); pthread_mutex_unlock(&schedule_mutex); //////////////////////////////////////////////////////////////////// //Debug.. #if 1 if((fp = fopen("SchedGHP.dat", "r")) == NULL) { if (fp != NULL) fclose(fp); if ( g_dbgShow ) printf("[ERROR] File Open with Option 'r'\n"); return; } fseek(fp, 0L, SEEK_END); filesize = ftell( fp ); memset(&dbg_msg, 0x00, sizeof(dbg_msg)); fseek(fp, 0L, SEEK_SET); for ( i=0; i<filesize; i++) fread (&dbg_msg[i], 1, sizeof(unsigned char), fp); pRx = (SEND_DATA *)&dbg_msg; if(Check_Message(pRx) != SUCCESS) return; for ( i=0; i<200; i++ ) { if ( g_dbgShow ) { printf("Class = %d, %d, %d, %d\n", pRx->classData[i].index, pRx->classData[i].classNum, pRx->classData[i].startT, pRx->classData[i].stopT); } } for ( i=0; i<MAX_GROUP_COUNT; i++ ) { if ( g_dbgShow ) { printf("pRx->group[%d].group = %d\n", i, pRx->group[i].group); printf("pRx->group[%d].method = %d\n", i, pRx->group[i].method); printf("pRx->group[%d].mode = %d\n", i, pRx->group[i].mode); printf("pRx->group[%d].limitT = %d\n", i, pRx->group[i].limitT); } for ( j=0; j<DAY_COUNT; j++ ) { for ( k=0; k<MAX_SCHEDULE_COUNT; k++ ) { if ( g_dbgShow ) { printf("pRx->group[%d].startT[%d][%d] = %d\n", i, j, k ,pRx->group[i].startT[j][k]); printf("pRx->group[%d].stopT[%d][%d] = %d\n", i, j, k ,pRx->group[i].stopT[j][k]); } } } } for ( i=0; i<MAX_TIMETABLE_COUNT; i++ ) { if ( g_dbgShow ) { printf("pRx->time.startT[%d] = %d\n", i ,pRx->time.startT[i]); printf("pRx->time.stopT[%d] = %d\n", i ,pRx->time.stopT[i]); } } #endif }
int schedule_main(void) /****************************************************************/ { GHP_SCHED_T *pSched; SEND_DATA *pData; int nClientFd = -1; int nClientLength = 0; struct sockaddr_in client_addr; signal(SIGPIPE, SIG_IGN); // Ignore broken_pipe signal. pSched = new_sched(); if (pSched == NULL) { if ( g_dbgShow ) { fprintf( stdout, "Can't create SCHED Memory space.\n" ); fflush(stdout); } //exit(1); system("killall duksan"); } if ( shced_open(pSched) < 0 ) { exit(0); } while (1) { sched_sleep( 0, 500 ); // ready to accept socket nClientFd = accept(pSched->nFd, (struct sockaddr *)&client_addr, &nClientLength); if ( g_dbgShow ) { fprintf( stdout, "[SCHED] Socket Accept OK.\n"); fflush( stdout ); } // check accept error if ( nClientFd == -1 ) { if ( g_dbgShow ) { fprintf( stdout, "+ [SCHED] Accept Error.\n"); fflush( stdout ); } // kill application3 sched_sleep( 3, 0 ); system("killall duksan"); } for (;;) { // receive message sched_sleep(0, 100); pSched->nRecvByte = sched_recv_message(nClientFd, pSched->bRxBuf); // parsing message if( pSched->nRecvByte == 0 ) { if ( g_dbgShow ) { fprintf( stdout, "+ [SCHED] Socket Close.\n"); fflush( stdout ); } // close socket close(nClientFd); // init variable memset( pSched->bTxBuf, 0x00, MAX_BUF_LENGTH ); memset( pSched->bRxBuf, 0x00, MAX_BUF_LENGTH ); memset( pSched->bPrevBuf, 0x00, MAX_BUF_LENGTH ); pSched->nRecvByte = 0; pSched->nTempWp = 0; pSched->nIndexPrev = 0; // wait delay sched_sleep(3, 0); break; } else if ( pSched->nRecvByte > 0 ) { if ( g_dbgShow ) { fprintf( stdout, "+ [SCHED] Receive Byte %d\n", pSched->nRecvByte); fflush( stdout ); } if ( pSched->nIndexPrev + pSched->nRecvByte > MAX_BUF_LENGTH) { ; } else { // copy message memcpy(&pSched->bPrevBuf[pSched->nIndexPrev], pSched->bRxBuf, pSched->nRecvByte); pSched->nIndexPrev = pSched->nIndexPrev + pSched->nRecvByte; if ( g_dbgShow ) { fprintf( stdout, "+ [SCHED] Copy Byte %d\n", pSched->nIndexPrev); fflush( stdout ); } // check message length pData = (SEND_DATA *)pSched->bPrevBuf; if(pSched->nIndexPrev == pData->length && Check_Message(pData)) { Parsing_Data(pData); SetDate(pData); } } } } continue; } }
void Network_Service::Read_Schedule (void) { int i, route, time, stop, last_route, first_stop, nrun, nstop, index, npoints, tim; int num_runs, max_runs, num; bool stop_flag; Line_Data *line_ptr = NULL; Schedule_File *file = (Schedule_File *) Network_Db_File (TRANSIT_SCHEDULE); if (!Network_Data_Flag (TRANSIT_ROUTE)) { Error (file_error, "Transit Route", file->File_ID ()); } stop_flag = Network_Data_Flag (TRANSIT_STOP); if (Check_Data () || Renumber ()) { if (!Network_File_Flag (TRANSIT_STOP) && Network_Option_Flag (TRANSIT_STOP)) { Error (file_error, "Transit Stop", file->File_ID ()); } } Show_Message ("Reading %s -- Record", file->File_Type ()); //---- scan for number of runs per route ---- last_route = first_stop = nrun = nstop = npoints = num_runs = max_runs = 0; while (file->Read ()) { route = file->Route (); if (route == 0) continue; //---- check the stop data ---- stop = file->Stop (); if (stop_flag) { index = stop_data.Get_Index (stop); if (index == 0) { Check_Message ("Stop %d on Route %d was Not Found in the Stop File", stop, route); continue; } if (Renumber ()) stop = index; } if (route != last_route) { if (last_route > 0) { if (!line_ptr->Runs (nrun)) goto mem_error; if (nrun > max_runs) max_runs = nrun; num_runs += nrun; } first_stop = stop; last_route = route; nrun = 1; nstop = 1; line_ptr = line_data.Get (route); if (line_ptr == NULL) { Check_Message ("Transit Route %d was Not Found in the Route File", route); continue; } stop = line_ptr->Stop (1); if (first_stop != stop) { if (Renumber ()) stop = stop_data [stop]->ID (); Check_Message ("Transit Route %d First Stop %d Schedule was Not Found", route, stop); continue; } } else { for (nstop++; nstop <= line_ptr->Stops (); nstop++) { if (stop == line_ptr->Stop (nstop)) break; } if (nstop > line_ptr->Stops ()) { nstop = 1; if (stop == first_stop) { nrun++; } else { Check_Message ("Stop %d was Not Found on Route %d", file->Stop (), route); continue; } nstop = i = 1; } } } if (last_route > 0) { if (!line_ptr->Runs (nrun)) goto mem_error; if (nrun > max_runs) max_runs = nrun; num_runs += nrun; } file->Rewind (); line_data.Num_Runs (num_runs); line_data.Max_Runs (max_runs); //---- store the transit schedule data ---- Set_Progress (); last_route = first_stop = num = 0; nrun = nstop = 1; while (file->Read ()) { Show_Progress (); route = file->Route (); if (route == 0) continue; //---- check the stop id ---- stop = file->Stop (); if (Renumber ()) { stop = stop_data.Get_Index (stop); } time = Round (file->Time ()); //---- check for a new route ---- if (route != last_route) { first_stop = stop; last_route = route; nrun = nstop = i = 1; line_ptr = line_data.Get (route); } else { //---- find the stop id on the route ---- for (i=nstop; i <= line_ptr->Stops (); i++) { if (line_ptr->Stop (i) == stop) break; } if (i > line_ptr->Stops ()) { if (stop == first_stop) nrun++; nstop = i = 1; } } //---- add the time point ---- line_ptr->Schedule (nrun, i, time); num++; //---- interpolate time points ---- if (i > nstop) { if (nstop == 1) { Check_Message ("Stop %d is Not the First Stop for Route %d", file->Stop (), route); continue; } index = i; tim = line_ptr->Schedule (nrun, nstop-1); time = (time - tim) / (index - nstop + 1); for (i=nstop; i < index; i++) { tim += time; line_ptr->Schedule (nrun, i, tim); npoints++; } nstop = index; } nstop++; } End_Progress (); file->Close (); line_data.Schedule_Records (Progress_Count ()); Print (2, "Number of %s Records = %d", file->File_Type (), Progress_Count ()); if (num && num != Progress_Count ()) { Print (1, "Number of Transit Schedule Data Records = %d", num); } if (npoints > 0) { Print (1, "Number of Interpolated Time Points = %d", npoints); } if (num > 0) Network_Data_True (TRANSIT_SCHEDULE); return; mem_error: Error ("Insufficient Memory for %d Runs on Route %d", nrun, last_route); }
bool Network_Service::Phasing_Processing (Db_File *fh) { bool node_flag, link_flag, timing_flag, detector_flag; int lvalue, index, node_num, num; char *svalue, *ptr; Link_Data *link_ptr = NULL; Phasing_Data *phasing_ptr = NULL; Timing_Data timing_rec; Phasing_File *file = (Phasing_File *) fh; node_flag = Network_Data_Flag (NODE); link_flag = Network_Data_Flag (LINK); timing_flag = Network_Data_Flag (TIMING_PLAN); detector_flag = Network_Data_Flag (DETECTOR); //---- reserve memory ---- if (phasing_data.Max_Records () == 0) { if (!phasing_data.Max_Records (file->Num_Records ())) goto mem_error; } //---- read and save the data ---- phasing_ptr = phasing_data.New_Record (); if (phasing_ptr == NULL) goto mem_error; phasing_ptr->Reset (); node_num = file->Node (); if (node_num == 0) return (false); //---- store the node ---- if (node_flag) { num = node_data.Get_Index (node_num); if (num == 0) { return (Check_Message ("Phasing Plan Node %d was Not Found in the Node file", node_num)); } if (!Renumber ()) { num = node_num; } } else { num = node_num; } phasing_ptr->Node (num); //---- check the timing plan ---- if (timing_flag) { timing_rec.Timing (file->Timing ()); timing_rec.Phase (file->Phase ()); if (timing_data.Get_Index (&timing_rec) == 0) { return (Check_Message ("Timing Plan %d-%d was Not Found in the Timing Plan file", file->Timing (), file->Phase ())); } } phasing_ptr->Timing (file->Timing ()); phasing_ptr->Phase (file->Phase ()); //---- check/convert the in-link number ---- lvalue = file->In_Link (); if (lvalue <= 0) goto link_error; if (link_flag) { index = link_data.Get_Index (lvalue); if (index == 0) goto link_error; link_ptr = link_data [index]; if (!Renumber ()) { index = lvalue; } phasing_ptr->In_Link (index); if (link_ptr->Anode () == num) { phasing_ptr->In_Dir (1); index = link_ptr->BA_Dir (); } else if (link_ptr->Bnode () == num) { phasing_ptr->In_Dir (0); index = link_ptr->AB_Dir (); } else { index = 0; } if (index == 0) goto link_error; } else { phasing_ptr->In_Link (lvalue); } //---- check/convert the out-link number ---- lvalue = file->Out_Link (); if (lvalue <= 0) goto link_error; if (link_flag) { index = link_data.Get_Index (lvalue); if (index == 0) goto link_error; link_ptr = link_data [index]; if (!Renumber ()) { index = lvalue; } phasing_ptr->Out_Link (index); if (link_ptr->Bnode () == num) { phasing_ptr->Out_Dir (1); index = link_ptr->BA_Dir (); } else if (link_ptr->Anode () == num) { phasing_ptr->Out_Dir (0); index = link_ptr->AB_Dir (); } else { index = 0; } if (index == 0) goto link_error; } else { phasing_ptr->Out_Link (lvalue); } //---- convert the protection code ---- phasing_ptr->Protection (Protection_Code (file->Protection ())); //---- process the detectors ---- svalue = file->Detectors (); if (*svalue == '\0' || atoi (svalue) == 0) { phasing_ptr->Num_Detectors (0); return (true); } num = 1; ptr = svalue; while ((ptr = strchr (ptr, '/')) != NULL) { num++; ptr++; } if (!phasing_ptr->Num_Detectors (num)) { Error ("Insufficient Memory for %d Detectors on Phasing Plan %d", num, Progress_Count ()); } num = 0; while (svalue != NULL) { ptr = strchr (svalue, '/'); if (ptr != NULL) { *ptr++ = '\0'; } lvalue = atoi (svalue); if (lvalue <= 0) break; num++; if (detector_flag) { index = detector_data.Get_Index (lvalue); if (index == 0) { return (Check_Message ("Phasing Plan Detector %d was Not Found in the Detector file", lvalue)); } if (!Renumber ()) { index = lvalue; } phasing_ptr->Detector (num, index); } else { phasing_ptr->Detector (num, lvalue); } svalue = ptr; } if (phasing_ptr->Num_Detectors () != num) { return (Check_Message ("Phasing Plan %d Detector Numbers are Not Valid", Progress_Count ())); } return (true); link_error: return (Check_Message ("Phasing Plan Node %d Link %d was Not Found", node_num, lvalue)); mem_error: Error ("Insufficient Memory for Phasing Plan Data"); return (false); }