00001 #include <stdio.h>
00002 #include <string.h>
00003 #include <fcntl.h>
00004 #include <stdlib.h>
00005 #include <sys/types.h>
00006 #include <unistd.h>
00007 #include <stdint.h>
00008 #include <sys/socket.h>
00009 #include <netinet/in.h>
00010 #include <pthread.h>
00011 #include <signal.h>
00012 #include <stdio.h>
00013 #include <string.h>
00014 #include <sys/time.h>
00015
00016 #include "times_header.h"
00017 #include "network_header.h"
00018 #include "gpca_header.h"
00019
00023
00024 int servPort = 0;
00026 int sockfd = 0;
00028 int clnt_socket = 0;
00030 struct sockaddr_in serv_addr, clnt_addr;
00032 char sock_write_buf[SOCK_WRITE_BUF_SIZE];
00034 char sock_read_buf[SOCK_READ_BUF_SIZE];
00035
00037
00041
00042 int serial_fd;
00044 unsigned char serial_read_buf[SERIAL_READ_BUF_SIZE];
00045 char buf[1024];
00047 char devicename[80];
00048
00050
00054
00055 void *downstream_thread (void *ptr);
00057 void *upstream_thread (void *ptr);
00059 void *gpca_state_machine_thread (void *ptr);
00061 void *gpca_clock_manager (void *ptr);
00063 void *observer_adapter (void *ptr);
00064
00066
00070
00071 static void clear_and_set ( unsigned char sync );
00073 void setClock(time_t clockID, long value);
00075 time_t rdClock(time_t clockID);
00077 void assign(int trn);
00079 bool eval_guard(int trn);
00081 void check_trans(void);
00082
00087
00088 time_t GPCA_Instance_clk_x1;
00089
00094
00095 int E_RequestBolus=0;
00097 int E_StopInfusion=0;
00099 int E_PowerButton=0;
00101 int E_PauseInfusion=0;
00103 int E_ConfirmPauseInfusion=0;
00105 int E_ClearAlarm=0;
00107 int E_Cancel=0;
00109 int E_ChangeDoseRate=0;
00111 int E_ConfigureInfusionProgram=0;
00113 int E_ConfirmStopInfusion=0;
00115 int E_ConfirmDoseRate=0;
00117 int E_NewInfusion=0;
00119 int E_ChangeVTBI=0;
00121 int E_ConfirmVTBI=0;
00123 int E_StartInfusion=0;
00125 int E_CheckAdminSet=0;
00126 int E_CheckAdminSet_1=0;
00128 int E_CheckDrug=0;
00130 int E_ConfirmConcentration=0;
00132 int E_Prime=0;
00134 int T_Cond_6_6=0;
00136 int T_Cond_6_3=0;
00138 int T_Cond_6_4=0;
00140 int T_Cond_6_5=0;
00142 int MCond_6_6=0;
00143 int TCond_6_3=0;
00145 int Cond_6_3=0;
00147 int TCond_6_5=0;
00149 int TCond_6_4=0;
00151 int Cond_7_4=0;
00153 int Cond_7_3=0;
00155 int Cond_2=0;
00157 int Level_Two_Alarm=0;
00159 int Cond_4_1=0;
00161 int Cond_4_2=0;
00163 int Cond_4_3=0;
00165 int Cond_4_4=0;
00167 int Cond_4_5=0;
00169 int Cond_4_6=0;
00170 int Cond_5_1=0;
00171 int MCDR_In_Progress=0;
00173 int Cond_3_1=0;
00175 int Cond_3_2=0;
00177 int Cond_3_3=0;
00179 int Cond_3_4=0;
00181 int Cond_3_5=0;
00183 int Cond_3_6=0;
00185 int Cond_3_7=0;
00187 int Cond_3_8=0;
00189 int Cond_3_9=0;
00191 int Cond_3_11=0;
00193 int Cond_3_10=0;
00194 int Power_ON=0;
00195 int MCond_1_3=0;
00196 int MCond_1_4=0;
00197 int Cond_5_2=0;
00198 int Cond_6_2=0;
00199 int Cond_7_1=0;
00200 int Cond_7_2=0;
00201
00205 trans_t trans[NB_TRANS] = {
00206 {false,GPCA_Instance_Infusion_NormalOperation,GPCA_Instance_ConfirmPause,-1},
00207 {false,GPCA_Instance_ConfirmPause,GPCA_Instance_Infusion_NormalOperation,-1},
00208 {false,GPCA_Instance_ConfirmPause,GPCA_Instance_InfusionPaused,-1},
00209 {false,GPCA_Instance_InfusionPaused,GPCA_Instance_Alrm_TooLongInfusionPause,-1},
00210 {false,GPCA_Instance_Alrm_TooLongInfusionPause,GPCA_Instance_InfusionStopped,-1},
00211 {false,GPCA_Instance_Alrm_TooLongInfusionPause,GPCA_Instance_Infusion_NormalOperation,-1},
00212 {false,GPCA_Instance_Infusion_NormalOperation,GPCA_Instance_ConfirmStop,-1},
00213 {false,GPCA_Instance_ConfirmStop,GPCA_Instance_Infusion_NormalOperation,-1},
00214 {false,GPCA_Instance_ConfirmStop,GPCA_Instance_InfusionStopped,-1},
00215 {false,GPCA_Instance_Infusion_NormalOperation,GPCA_Instance_Alrm_LevelTwoHardwareFailure,-1},
00216 {false,GPCA_Instance_Alrm_LevelTwoHardwareFailure,GPCA_Instance_Infusion_NormalOperation,-1},
00217 {false,GPCA_Instance_Alrm_LevelTwoHardwareFailure,GPCA_Instance_InfusionStopped,-1},
00218 {false,GPCA_Instance_Infusion_NormalOperation,GPCA_Instance_Wrn_LowReservior,-1},
00219 {false,GPCA_Instance_Wrn_LowReservior,GPCA_Instance_Infusion_NormalOperation,-1},
00220 {false,GPCA_Instance_Infusion_NormalOperation,GPCA_Instance_Alrm_EmptyReservior,-1},
00221 {false,GPCA_Instance_Alrm_EmptyReservior,GPCA_Instance_CheckDrug,-1},
00222 {false,GPCA_Instance_CheckDrug,GPCA_Instance_Alrm_WrongDrug,-1},
00223 {false,GPCA_Instance_Alrm_WrongDrug,GPCA_Instance_CheckDrug,-1},
00224 {false,GPCA_Instance_CheckDrug,GPCA_Instance_InfusionStopped,-1},
00225 {false,GPCA_Instance_CheckDrug,GPCA_Instance_Infusion_NormalOperation,-1},
00226 {false,GPCA_Instance_Infusion_NormalOperation,GPCA_Instance_ChangeRate,-1},
00227 {false,GPCA_Instance_ChangeRate,GPCA_Instance_Infusion_NormalOperation,-1},
00228 {false,GPCA_Instance_ChangeRate,GPCA_Instance_CheckNewRate,-1},
00229 {false,GPCA_Instance_CheckNewRate,GPCA_Instance_ChangeRate,-1},
00230 {false,GPCA_Instance_CheckNewRate,GPCA_Instance_Alrm_UnsafeNewRate,-1},
00231 {false,GPCA_Instance_Alrm_UnsafeNewRate,GPCA_Instance_Alrm_LevelTwoHardwareFailure,-1},
00232 {false,GPCA_Instance_DisplayVTBI,GPCA_Instance_ChangeVTBI,-1},
00233 {false,GPCA_Instance_ChangeVTBI,GPCA_Instance_DisplayVTBI,-1},
00234 {false,GPCA_Instance_ChangeVTBI,GPCA_Instance_Alrm_LongWait_ChangeVTBI,-1},
00235 {false,GPCA_Instance_Alrm_LongWait_ChangeVTBI,GPCA_Instance_ChangeVTBI,-1},
00236 {false,GPCA_Instance_CheckVTBI,GPCA_Instance_Alrm_VTBIHardLimitsViolation,-1},
00237 {false,GPCA_Instance_Alrm_VTBIHardLimitsViolation,GPCA_Instance_ChangeVTBI,-1},
00238 {false,GPCA_Instance_ChangeVTBI,GPCA_Instance_CheckVTBI,-1},
00239 {false,GPCA_Instance_CheckVTBI,GPCA_Instance_Wrn_VTBISoftLimitsViolation,-1},
00240 {false,GPCA_Instance_CheckVTBI,GPCA_Instance_DisplayDoseRate,-1},
00241 {false,GPCA_Instance_Wrn_VTBISoftLimitsViolation,GPCA_Instance_DisplayDoseRate,-1},
00242 {false,GPCA_Instance_DisplayVTBI,GPCA_Instance_DisplayDoseRate,-1},
00243 {false,GPCA_Instance_Wrn_VTBISoftLimitsViolation,GPCA_Instance_ChangeVTBI,-1},
00244 {false,GPCA_Instance_DisplayDoseRate,GPCA_Instance_ChangeDoseRate,-1},
00245 {false,GPCA_Instance_ChangeDoseRate,GPCA_Instance_DisplayDoseRate,-1},
00246 {false,GPCA_Instance_ChangeDoseRate,GPCA_Instance_Alrm_LongWait_ChangeDoseRate,-1},
00247 {false,GPCA_Instance_Alrm_LongWait_ChangeDoseRate,GPCA_Instance_ChangeDoseRate,-1},
00248 {false,GPCA_Instance_ChangeDoseRate,GPCA_Instance_CheckDoseRate,-1},
00249 {false,GPCA_Instance_CheckDoseRate,GPCA_Instance_Alarming_DoseRate_OutOfBound,-1},
00250 {false,GPCA_Instance_Alarming_DoseRate_OutOfBound,GPCA_Instance_ChangeDoseRate,-1},
00251 {false,GPCA_Instance_CheckDoseRate,GPCA_Instance_Wrn_DoseRateSoftLimitsViolation,-1},
00252 {false,GPCA_Instance_Wrn_DoseRateSoftLimitsViolation,GPCA_Instance_ChangeDoseRate,-1},
00253 {false,GPCA_Instance_CheckDoseRate,GPCA_Instance_DisplaySetting,-1},
00254 {false,GPCA_Instance_DisplayDoseRate,GPCA_Instance_DisplaySetting,-1},
00255 {false,GPCA_Instance_Wrn_DoseRateSoftLimitsViolation,GPCA_Instance_DisplaySetting,-1},
00256 {false,GPCA_Instance_DisplaySetting,GPCA_Instance_Alrm_LongWait_StartInfusion,-1},
00257 {false,GPCA_Instance_Alrm_LongWait_StartInfusion,GPCA_Instance_DisplaySetting,-1},
00258 {false,GPCA_Instance_DisplaySetting,GPCA_Instance_ReadyToStart,-1},
00259 {false,GPCA_Instance_ReadyToStart,GPCA_Instance_DisplaySetting,-1},
00260 {false,GPCA_Instance_CDR_Init,GPCA_Instance_CheckAdministrationSet,-1},
00261 {false,GPCA_Instance_CheckAdministrationSet,GPCA_Instance_Alrm_IncorrectAdministrationSetup,-1},
00262 {false,GPCA_Instance_Alrm_IncorrectAdministrationSetup,GPCA_Instance_CheckAdministrationSet,-1},
00263 {false,GPCA_Instance_CheckAdministrationSet,GPCA_Instance_CheckPrime,-1},
00264 {false,GPCA_Instance_CheckPrime,GPCA_Instance_Alrm_PrimeFailure,-1},
00265 {false,GPCA_Instance_Alrm_PrimeFailure,GPCA_Instance_CheckPrime,-1},
00266 {false,GPCA_Instance_CheckPrime,GPCA_Instance_DisplayDrugInfo,-1},
00267 {false,GPCA_Instance_DisplayDrugInfo,GPCA_Instance_CheckDrugType,-1},
00268 {false,GPCA_Instance_CheckDrugType,GPCA_Instance_Alrm_UnknownDrug,-1},
00269 {false,GPCA_Instance_Alrm_UnknownDrug,GPCA_Instance_CheckDrugType,-1},
00270 {false,GPCA_Instance_CheckDrugType,GPCA_Instance_CheckDoseUnit,-1},
00271 {false,GPCA_Instance_CheckDoseUnit,GPCA_Instance_Alrm_DoseUnitMismatch,-1},
00272 {false,GPCA_Instance_Alrm_DoseUnitMismatch,GPCA_Instance_CheckDrugType,-1},
00273 {false,GPCA_Instance_CheckDoseUnit,GPCA_Instance_CheckConcentration,-1},
00274 {false,GPCA_Instance_CheckConcentration,GPCA_Instance_Wrn_ConcentrationSoftLimitsViolation,-1},
00275 {false,GPCA_Instance_Wrn_ConcentrationSoftLimitsViolation,GPCA_Instance_CheckDrugType,-1},
00276 {false,GPCA_Instance_CheckConcentration,GPCA_Instance_DisplayPatientProfile,-1},
00277 {false,GPCA_Instance_Wrn_ConcentrationSoftLimitsViolation,GPCA_Instance_DisplayPatientProfile,-1},
00278 {false,GPCA_Instance_DisplayPatientProfile,GPCA_Instance_DisplayDrugInfo,-1},
00279 {false,GPCA_Instance_Alrm_ConcentrationHardLimitsViolation,GPCA_Instance_CheckDrugType,-1},
00280 {true,GPCA_Instance_POST_Init,GPCA_Instance_Post_In_Progress,-1},
00281 {false,GPCA_Instance_Post_In_Progress,GPCA_Instance_CDR_Init,-1},
00282 {false,GPCA_Instance_Post_In_Progress,GPCA_Instance_Alrm_POSTFailure,-1},
00283 {false,GPCA_Instance_Alrm_POSTFailure,GPCA_Instance_POST_Init,-1},
00284 {false,GPCA_Instance_Post_In_Progress,GPCA_Instance_Alrm_POSTFailure,-1},
00285 {false,GPCA_Instance_CheckConcentration,GPCA_Instance_Alrm_ConcentrationHardLimitsViolation,-1},
00286 {false,GPCA_Instance_DisplayPatientProfile,GPCA_Instance_DisplayVTBI,-1},
00287 {false,GPCA_Instance_ReadyToStart,GPCA_Instance_Infusion_NormalOperation,-1},
00288 {false,GPCA_Instance_InfusionStopped,GPCA_Instance_CDR_Init,-1},
00289 {false,GPCA_Instance_InfusionPaused,GPCA_Instance_Infusion_NormalOperation,-1},
00290 {false,GPCA_Instance_ConfirmPause,GPCA_Instance_InfusionStopped,-1},
00291 {false,GPCA_Instance_InfusionPaused,GPCA_Instance_PausedStopConfirm,-1},
00292 {false,GPCA_Instance_PausedStopConfirm,GPCA_Instance_InfusionPaused,-1},
00293 {false,GPCA_Instance_PausedStopConfirm,GPCA_Instance_InfusionStopped,-1},
00294 {false,GPCA_Instance_Alrm_TooLongInfusionPause,GPCA_Instance_InfusionStopped,-1},
00295 {false,GPCA_Instance_ConfirmPause,GPCA_Instance_Alrm_LevelTwoHardwareFailure,-1},
00296 {false,GPCA_Instance_Alrm_LevelTwoHardwareFailure,GPCA_Instance_InfusionStopped,-1},
00297 {false,GPCA_Instance_ChangeRate,GPCA_Instance_Alrm_LevelTwoHardwareFailure,-1},
00298 {false,GPCA_Instance_ConfirmStop,GPCA_Instance_Alrm_LevelTwoHardwareFailure,-1},
00299 {false,GPCA_Instance_Alrm_UnsafeNewRate,GPCA_Instance_ChangeRate,-1},
00300 {false,GPCA_Instance_Alrm_UnsafeNewRate,GPCA_Instance_InfusionStopped,-1},
00301 {false,GPCA_Instance_ConfirmStop,GPCA_Instance_InfusionStopped,-1},
00302 {false,GPCA_Instance_Alrm_UnsafeNewRate,GPCA_Instance_Infusion_NormalOperation,-1},
00303 {false,GPCA_Instance_InfusionStopped,GPCA_Instance_Alrm_LevelTwoHardwareFailure,-1},
00304 {false,GPCA_Instance_ChangeRate,GPCA_Instance_InfusionStopped,-1},
00305 {false,GPCA_Instance_ChangeRate,GPCA_Instance_Alrm_LongWait_ChangeDoseRate_ISSM,-1},
00306 {false,GPCA_Instance_Alrm_LongWait_ChangeDoseRate_ISSM,GPCA_Instance_ChangeRate,-1},
00307 {false,GPCA_Instance_Infusion_NormalOperation,GPCA_Instance_InfusionStopped,-1},
00308 {false,GPCA_Instance_Alrm_WrongDrug,GPCA_Instance_InfusionStopped,-1},
00309 {false,GPCA_Instance_Alrm_EmptyReservior,GPCA_Instance_InfusionStopped,-1},
00310 {false,GPCA_Instance_Infusion_NormalOperation,GPCA_Instance_BolusRequest,-1},
00311 {false,GPCA_Instance_BolusRequest,GPCA_Instance_Infusion_NormalOperation,-1},
00312 {false,GPCA_Instance_BolusRequest,GPCA_Instance_Infusion_NormalOperation,-1}
00313 };
00314
00318 loc_t loc[NB_TRANS+NB_LOC] = {
00319 0,6,9,12,14,20,101,104,tid_NOP,
00320 1,2,84,89,tid_NOP,
00321 3,83,85,tid_NOP,
00322 4,5,88,tid_NOP,
00323 82,97,tid_NOP,
00324 7,8,92,95,tid_NOP,
00325 10,11,90,tid_NOP,
00326 13,tid_NOP,
00327 15,103,tid_NOP,
00328 16,18,19,tid_NOP,
00329 17,102,tid_NOP,
00330 21,22,91,98,99,tid_NOP,
00331 23,24,tid_NOP,
00332 25,93,94,96,tid_NOP,
00333 26,36,tid_NOP,
00334 27,28,32,tid_NOP,
00335 29,tid_NOP,
00336 30,33,34,tid_NOP,
00337 31,tid_NOP,
00338 35,37,tid_NOP,
00339 38,48,tid_NOP,
00340 39,40,42,tid_NOP,
00341 41,tid_NOP,
00342 43,45,47,tid_NOP,
00343 44,tid_NOP,
00344 46,49,tid_NOP,
00345 50,52,tid_NOP,
00346 51,tid_NOP,
00347 53,81,tid_NOP,
00348 72,80,tid_NOP,
00349 54,tid_NOP,
00350 55,57,tid_NOP,
00351 56,tid_NOP,
00352 58,60,tid_NOP,
00353 59,tid_NOP,
00354 61,tid_NOP,
00355 62,64,tid_NOP,
00356 63,tid_NOP,
00357 65,67,tid_NOP,
00358 66,tid_NOP,
00359 68,70,79,tid_NOP,
00360 69,71,tid_NOP,
00361 73,tid_NOP,
00362 74,tid_NOP,
00363 75,76,78,tid_NOP,
00364 77,tid_NOP,
00365 86,87,tid_NOP,
00366 100,tid_NOP,
00367 105,106,tid_NOP
00368 };
00369
00370
00371
00373
00377
00378 int current_GPCA_state = GPCA_Instance_POST_Init;
00379 int prev_GPCA_state = GPCA_Instance_POST_Init;
00381 int action_handler_on_state_change(int prev_state, int current_state);
00383 int getCurrentState(void);
00385 int activate_gpca_channel(unsigned char cmd);
00387
00388
00390
00395
00396 uint8_t MOTOR_SPEED_LEVEL = 1;
00398 uint8_t MOTOR_DIRECTION = CLOCKWISE;
00400 uint8_t MOTOR_STATE = MOTOR_STOP;
00402 uint8_t INFUSION_DURATION = 1;
00404 uint8_t REMAIN_VOL_PERCENT;
00406 uint8_t pkt_gpca[PKT_SIZE];
00408 int send_gpca_pkt_to_client(void);
00410 int send_channel_ack_to_client(void);
00412 int parsing_state = PARSE_INIT;
00414 int ctl_parsing_state = PARSE_CTL_INIT;
00416
00418 int write_byte_to_controller(int fd, char data);
00419
00427 int main(int Parm_Count, char* Parms[]){
00428 int i;
00429 pthread_t thread_downstream, thread_upstream, thread_gpcaStateMachine, thread_clockManager, thread_observer_adapter;
00430 int iret1, iret2, iret3, iret4, iret5;
00431
00433 if(Parm_Count != 3){
00434 printf("wrong parameters : [devicename] [server port]\n");
00435 return 0;
00436 }
00437
00438 strcpy(buf, Parms[1]);
00439 i = sscanf (buf, "%s", devicename);
00440 if (i != 1)
00441 printf("Error : sscanf\n");
00442
00444 serial_fd = open(devicename, O_RDWR | O_NOCTTY);
00445 if (serial_fd < 0) {
00446 printf("Error : open\n");
00447
00448 }else{
00449 printf("Serial open successful : %s \n", devicename);
00450 }
00451
00453 servPort = atoi(Parms[2]);
00454
00456 iret1 = pthread_create(&thread_downstream, NULL, downstream_thread, NULL);
00457 iret2 = pthread_create(&thread_upstream, NULL, upstream_thread, NULL);
00458 iret3 = pthread_create(&thread_gpcaStateMachine, NULL, gpca_state_machine_thread, NULL);
00459 iret4 = pthread_create(&thread_clockManager, NULL, gpca_clock_manager, NULL);
00460 iret5 = pthread_create(&thread_observer_adapter, NULL, observer_adapter, NULL);
00461
00462 pthread_join(thread_downstream, NULL);
00463 pthread_join(thread_upstream, NULL);
00464 pthread_join(thread_gpcaStateMachine, NULL);
00465 pthread_join(thread_clockManager, NULL);
00466 pthread_join(thread_observer_adapter, NULL);
00467
00468 exit(0);
00469 }
00470
00475 void *downstream_thread (void *ptr){
00476
00477 int clnt_len;
00478 uint8_t read_error = 0;
00479 int read_res, write_res, channel_res, cond_res;
00480
00481 printf("downstream_thread created\n");
00482 bzero((char*) &serv_addr, sizeof(serv_addr));
00483 bzero((char*) &clnt_addr, sizeof(clnt_addr));
00484 serv_addr.sin_family = AF_INET;
00485 serv_addr.sin_addr.s_addr = INADDR_ANY;
00486 serv_addr.sin_port = htons(servPort);
00487
00488 sockfd = socket(AF_INET, SOCK_STREAM, 0);
00489 if (sockfd < 0){
00490 printf("Error opening socket\n\r");
00491 }
00492
00493 if(bind(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0){
00494 printf("Error on binding\n\r");
00495 }
00496
00497 while(1){
00498 listen(sockfd, 5);
00499 printf("Waiting for client connection on port [%d]...\n", servPort);
00500 clnt_len = sizeof(clnt_addr);
00501 clnt_socket = accept(sockfd, (struct sockaddr *) &clnt_addr, &clnt_len);
00502 if(clnt_socket < 0){
00503 printf("Error on accept\n\r");
00504 read_error = 1;
00505 }else{
00506
00507 read_error = 0;
00508 }
00509
00510 while(read_error == 0){
00512 bzero((char*) sock_read_buf, SOCK_READ_BUF_SIZE);
00513 printf("Waiting for data from Client...\n\r");
00514 read_res = read(clnt_socket, sock_read_buf, 1);
00515 if(read_res <= 0){
00516 printf("Socket Error : READ \n\r");
00517 read_error = 1;
00518 }
00519 else{
00520 write_res = write(serial_fd, &sock_read_buf[0], 1);
00521 if(write_res <= 0){
00522 printf("Error in writing serial...\n\r");
00523 }else{
00524 printf("[%c] was written\n\r", sock_read_buf[0]);
00525 }
00526
00528 channel_res = activate_gpca_channel((unsigned char)sock_read_buf[0]);
00529 if(channel_res == 0){
00530 printf("Unknown channel or not in the valid state : %d\n", (unsigned char)sock_read_buf[0]);
00531 }
00532 }
00533 }
00534 printf("Client connection is closing : [%d]\n", clnt_socket);
00535 close(clnt_socket);
00536 }
00537
00538 close(serial_fd);
00539 pthread_exit(NULL);
00540
00541 }
00542
00547 void *upstream_thread(void *ptr){
00548 uint8_t serial_read_err = 0;
00549 int read_res, write_res;
00550 uint8_t tempMotorDir, tempSpdLevel, tempDuration, tempMotorState, tempRemainVol;
00551
00552 printf("upstream_thread created\n");
00553 while(1){
00554 serial_fd = open(devicename, O_RDWR | O_NOCTTY);
00555 if (serial_fd < 0) {
00556 printf("Error : open\n");
00557 serial_read_err = 1;
00558 sleep(1);
00559 }
00560 else{
00561 serial_read_err = 0;
00562 }
00563
00564 parsing_state = PARSE_INIT;
00565 while(serial_read_err == 0){
00566
00567 bzero((char*)serial_read_buf, SERIAL_READ_BUF_SIZE);
00568
00570 read_res = read(serial_fd, serial_read_buf, 1);
00571 if(read_res <=0){
00572 printf("Serial Error :READ \n\r");
00573 serial_read_err = 1;
00574 }else{
00575
00576 if((parsing_state == PARSE_INIT) && (serial_read_buf[0] == SOP)){
00577 parsing_state = PARSE_SOP_RCVD;
00578 }
00579
00580 else if((parsing_state == PARSE_SOP_RCVD)){
00581 parsing_state = PARSE_MOTOR_DIR_RCVD;
00582 tempMotorDir = serial_read_buf[0];
00583 }
00584
00585 else if((parsing_state == PARSE_MOTOR_DIR_RCVD)){
00586 parsing_state = PARSE_SPD_LEVEL_RCVD;
00587 tempSpdLevel = serial_read_buf[0];
00588 }
00589
00590 else if((parsing_state == PARSE_SPD_LEVEL_RCVD)){
00591 parsing_state = PARSE_DURATION_RCVD;
00592 tempDuration = serial_read_buf[0];
00593 }
00594
00595
00596 else if((parsing_state == PARSE_DURATION_RCVD)){
00597 parsing_state = PARSE_GPCA_STATE_RCVD;
00598 }
00599
00600 else if((parsing_state == PARSE_GPCA_STATE_RCVD)){
00601 parsing_state = PARSE_MOTOR_STATE_RCVD;
00602 tempMotorState = serial_read_buf[0];
00603 }
00604
00605 else if((parsing_state == PARSE_MOTOR_STATE_RCVD)){
00606 parsing_state = PARSE_RESERVE6_RCVD;
00607 tempRemainVol = serial_read_buf[0];
00608
00609 }
00610
00611 else if((parsing_state == PARSE_RESERVE6_RCVD)){
00612 parsing_state = PARSE_RESERVE7_RCVD;
00613
00614 }
00615
00616 else if((parsing_state == PARSE_RESERVE7_RCVD)){
00617 parsing_state = PARSE_RESERVE8_RCVD;
00618
00619 }
00620
00621 else if((parsing_state == PARSE_RESERVE8_RCVD) && serial_read_buf[0] == EOP ){
00622 parsing_state = PARSE_INIT;
00623 INFUSION_DURATION = tempDuration;
00624 MOTOR_SPEED_LEVEL = tempSpdLevel;
00625 MOTOR_STATE = tempMotorState;
00626 MOTOR_DIRECTION = tempMotorDir;
00627 REMAIN_VOL_PERCENT = tempRemainVol;
00628 printf("Get a packet, Duration : %x \t Spd Level : %x \t Motor state : %x \t Motor Dir : %x Remain Vol : %d\t\n", INFUSION_DURATION, MOTOR_SPEED_LEVEL, MOTOR_STATE, MOTOR_DIRECTION, REMAIN_VOL_PERCENT);
00629 }else{
00630 parsing_state = PARSE_INIT;
00631 printf("Parsing error received : %x\n", serial_read_buf[0]);
00632 }
00633
00634 }
00635
00636 }
00637
00638 close(serial_fd);
00639 }
00640
00641 close(serial_fd);
00642 pthread_exit(NULL);
00643
00644 }
00645
00646
00652 void *gpca_state_machine_thread (void *ptr){
00653 printf("GPCA State Machine crated \n");
00654
00656 setClock(GPCA_Instance_clk_x1,0);
00657
00658 while(1){
00659 check_trans();
00660 printf("Current state : %d \t Current clock %ld \n", getCurrentState(), rdClock(GPCA_Instance_clk_x1));
00661 sleep(1);
00662 }
00663
00664 }
00665
00670 void *gpca_clock_manager (void *ptr){
00671 printf("Clock manager has been created...\n");
00672
00673 while(1){
00674 sleep(1);
00675 GPCA_Instance_clk_x1 = (GPCA_Instance_clk_x1 + 1)% MAX_CLOCK_VALUE;
00676 }
00677
00678
00679 }
00680
00686 void *observer_adapter (void *ptr){
00687 int ret1;
00688 printf("Observer adapter has been created...\n");
00689 while(1){
00690 if(clnt_socket < 0){
00691 printf("Client Socket is not estabilished...\n\r");
00692 }else{
00693 ret1 = send_gpca_pkt_to_client();
00694 if(ret1 >= 0){
00695 printf("Success in GPCA reporting...\n\r");
00696 }else{
00697 printf("Err in writing client socket...\n\r");
00698 }
00699
00700 }
00701 sleep(1);
00702 }
00703 }
00704
00711 static void clear_and_set ( unsigned char trn ) {
00712 int jj;
00713
00714 jj=trans[trn].from;
00715 do {
00716 trans[loc[jj]].active=0;
00717 } while(loc[++jj]<tid_offset);
00718
00719 jj=trans[trn].to;
00720 while ( loc[jj]<tid_offset ) {
00721 trans[loc[jj]].active=1;
00722 jj++;
00723 }
00724
00725
00726
00727
00728 }
00729
00730
00739 void check_trans(){
00740
00741 int trn;
00742 #if NB_CHAN>0
00743 int compl_trn;
00744 #endif
00745 for(trn=0; trn<NB_TRANS; trn++) {
00746 if( trans[trn].active ) {
00747 if( eval_guard(trn) ) {
00748 #if NB_CHAN>0
00749 if( trans[trn].sync > -1 ) {
00750 if( (compl_trn =
00751 check_synch( trans[trn].sync )) ) {
00752 if( IS_SEND(trans[trn].sync) ) {
00753 assign( trn );
00754 assign( compl_trn );
00755
00756
00757
00758
00759 } else {
00760 assign( compl_trn );
00761 assign( trn );
00762
00763
00764
00765
00766 }
00767 clear_and_set( trn );
00768 clear_and_set( compl_trn );
00769 trn=-1;
00770 }
00771 } else
00772 #endif
00773 {
00774 assign( trn );
00775
00776 current_GPCA_state = trans[trn].to;
00777 printf("current trans : %d\t trans to : %d \n", trn, trans[trn].to);
00778
00779
00780 if(prev_GPCA_state != current_GPCA_state){
00781
00782 printf("==> GPCA state has been changed.\n");
00783 action_handler_on_state_change(prev_GPCA_state, current_GPCA_state);
00784
00785 prev_GPCA_state = current_GPCA_state;
00786 }
00787 clear_and_set( trn );
00788 trn=-1;
00789 }
00790 }
00791 }
00792 }
00793
00794 }
00795
00801 bool eval_guard(int trn) {
00802 switch(trn) {
00803 case 0: return (E_PauseInfusion==1);
00804 case 1: return (E_Cancel==1);
00805 case 2: return (E_ConfirmPauseInfusion==1);
00806 case 3: return (rdClock(GPCA_Instance_clk_x1)>=MAX_PAUSED_T);
00807 case 4: return (rdClock(GPCA_Instance_clk_x1)>=MAX_ALRM_T);
00808 case 5: return (E_ClearAlarm==1);
00809 case 6: return (E_StopInfusion==1);
00810 case 7: return (E_Cancel==1);
00811 case 8: return (E_ConfirmStopInfusion==1);
00812 case 9: return (Level_Two_Alarm==1);
00813 case 10: return (E_ClearAlarm==1);
00814 case 11: return (rdClock(GPCA_Instance_clk_x1)>=MAX_ALRM_T);
00815 case 12: return (MCond_6_6==1);
00816 case 14: return (Cond_6_3==1);
00817 case 15: return (E_CheckDrug==1);
00818 case 16: return (TCond_6_5==1);
00819 case 17: return (E_CheckDrug==1);
00820 case 18: return (rdClock(GPCA_Instance_clk_x1)>=MAX_CHECK_DRUG_T);
00821 case 19: return (TCond_6_4==1);
00822 case 20: return (E_ChangeDoseRate==1);
00823 case 21: return (E_Cancel==1);
00824 case 22: return (E_ConfirmDoseRate==1);
00825 case 23: return (Cond_7_4==1);
00826 case 24: return (Cond_7_3==1);
00827 case 26: return (E_ChangeVTBI==1);
00828 case 27: return (E_Cancel==1);
00829 case 28: return (rdClock(GPCA_Instance_clk_x1)>=MAX_WAIT_INPUT_T);
00830 case 30: return (Cond_4_1==1);
00831 case 31: return (E_ChangeVTBI==1);
00832 case 32: return (E_ConfirmVTBI==1);
00833 case 33: return (Cond_4_2==1);
00834 case 34: return (Cond_4_3==1);
00835 case 35: return (E_ConfirmVTBI==1);
00836 case 36: return (E_ConfirmVTBI==1);
00837 case 37: return (E_ChangeVTBI==1);
00838 case 38: return (E_ChangeDoseRate==1);
00839 case 39: return (E_Cancel==1);
00840 case 40: return (rdClock(GPCA_Instance_clk_x1)>=MAX_WAIT_INPUT_T);
00841 case 42: return (E_ConfirmDoseRate==1);
00842 case 43: return (Cond_4_4==1);
00843 case 44: return (E_ChangeDoseRate==1);
00844 case 45: return (Cond_4_5==1);
00845 case 46: return (E_ChangeDoseRate==1);
00846 case 47: return (Cond_4_6==1);
00847 case 48: return (E_ConfirmDoseRate==1);
00848 case 49: return (E_ConfirmDoseRate==1);
00849 case 50: return (rdClock(GPCA_Instance_clk_x1)>=MAX_WAIT_INPUT_T);
00850 case 52: return (E_StartInfusion==1);
00851 case 53: return (Cond_5_1==1);
00852 case 54: return (MCDR_In_Progress==0&&E_CheckAdminSet==1);
00853 case 55: return (Cond_3_1==1);
00854 case 56: return (E_CheckAdminSet_1==1);
00855 case 57: return (Cond_3_2==1);
00856 case 58: return (Cond_3_3==1);
00857 case 59: return (E_Prime==1);
00858 case 60: return (Cond_3_4==1);
00859 case 61: return (E_CheckDrug==1);
00860 case 62: return (Cond_3_5==1);
00861 case 63: return (E_CheckDrug==1);
00862 case 64: return (Cond_3_6==1);
00863 case 65: return (Cond_3_7==1);
00864 case 66: return (E_CheckDrug==1);
00865 case 67: return (Cond_3_8==1);
00866 case 68: return (Cond_3_9==1);
00867 case 69: return (E_CheckDrug==1);
00868 case 70: return (Cond_3_11==1);
00869 case 71: return (E_ConfirmConcentration==1);
00870 case 72: return (E_Cancel==1);
00871 case 73: return (E_CheckDrug==1);
00872 case 74: return (E_PowerButton==1);
00873 case 75: return (MCond_1_4==1);
00874 case 76: return (rdClock(GPCA_Instance_clk_x1)>=MAX_POST_WAIT);
00875 case 78: return (MCond_1_3==1);
00876 case 79: return (Cond_3_10==1);
00877 case 80: return (E_ConfigureInfusionProgram==1);
00878 case 81: return (Cond_5_2==1);
00879 case 82: return (E_NewInfusion==1);
00880 case 83: return (E_Cancel==1);
00881 case 84: return (Cond_6_2==1);
00882 case 85: return (E_StopInfusion==1);
00883 case 86: return (E_Cancel==1);
00884 case 87: return (E_ConfirmStopInfusion==1);
00885 case 88: return (E_StopInfusion==1);
00886 case 89: return (Level_Two_Alarm==1);
00887 case 90: return (E_StopInfusion==1);
00888 case 91: return (Level_Two_Alarm==1);
00889 case 92: return (Level_Two_Alarm==1);
00890 case 93: return (E_ChangeDoseRate==1);
00891 case 94: return (Cond_6_2==1);
00892 case 95: return (Cond_6_2==1);
00893 case 96: return (E_Cancel==1);
00894 case 97: return (Level_Two_Alarm==1);
00895 case 98: return (Cond_6_2==1);
00896 case 99: return (rdClock(GPCA_Instance_clk_x1)>=MAX_WAIT_INPUT_T);
00897 case 101: return (Cond_6_2==1);
00898 case 102: return (E_StopInfusion==1);
00899 case 103: return (E_StopInfusion==1);
00900 case 104: return (E_RequestBolus==1);
00901 case 105: return (Cond_7_1==1);
00902 case 106: return (Cond_7_2==1);
00903 case 13:
00904 case 25:
00905 case 29:
00906 case 41:
00907 case 51:
00908 case 77:
00909 case 100:
00910 return true;
00911 }
00912 return false;
00913 }
00914
00920 void assign(int trn) {
00921 switch(trn) {
00922 case 0:
00923 E_PauseInfusion=0; break;
00924 case 1:
00925 E_Cancel=0; break;
00926 case 2:
00927 E_ConfirmPauseInfusion=0;
00928 setClock(GPCA_Instance_clk_x1,0); break;
00929 case 3:
00930 setClock(GPCA_Instance_clk_x1,0); break;
00931 case 5:
00932 E_ClearAlarm=0; break;
00933 case 6:
00934 E_StopInfusion=0; break;
00935 case 7:
00936 E_Cancel=0; break;
00937 case 8:
00938 E_ConfirmStopInfusion=0; break;
00939 case 9:
00940 setClock(GPCA_Instance_clk_x1,0);
00941 Level_Two_Alarm=0; break;
00942 case 10:
00943 E_ClearAlarm=0; break;
00944 case 14:
00945 setClock(GPCA_Instance_clk_x1,0);
00946 Cond_6_3=0; break;
00947 case 15:
00948 E_CheckDrug=0; break;
00949 case 17:
00950 E_CheckDrug=0; break;
00951 case 20:
00952 E_ChangeDoseRate=0;
00953 setClock(GPCA_Instance_clk_x1,0); break;
00954 case 21:
00955 E_Cancel=0; break;
00956 case 22:
00957 E_ConfirmDoseRate=0; break;
00958 case 23:
00959 Cond_7_4=0; break;
00960 case 24:
00961 Cond_7_3=0; break;
00962 case 26:
00963 E_ChangeVTBI=0;
00964 setClock(GPCA_Instance_clk_x1,0); break;
00965 case 27:
00966 E_Cancel=0; break;
00967 case 28:
00968 setClock(GPCA_Instance_clk_x1,0); break;
00969 case 30:
00970 Cond_4_1=0; break;
00971 case 31:
00972 E_ChangeVTBI=0;
00973 setClock(GPCA_Instance_clk_x1,0); break;
00974 case 32:
00975 E_ConfirmVTBI=0; break;
00976 case 33:
00977 Cond_4_2=0; break;
00978 case 34:
00979 Cond_4_3=0; break;
00980 case 35:
00981 E_ConfirmVTBI=0; break;
00982 case 36:
00983 E_ConfirmVTBI=0; break;
00984 case 37:
00985 E_ChangeVTBI=0; break;
00986 case 38:
00987 setClock(GPCA_Instance_clk_x1,0);
00988 E_ChangeDoseRate=0; break;
00989 case 39:
00990 E_Cancel=0; break;
00991 case 40:
00992 setClock(GPCA_Instance_clk_x1,0); break;
00993 case 42:
00994 E_ConfirmDoseRate=0; break;
00995 case 43:
00996 Cond_4_4=0; break;
00997 case 44:
00998 E_ChangeDoseRate=0;
00999 setClock(GPCA_Instance_clk_x1,0); break;
01000 case 45:
01001 Cond_4_5=0; break;
01002 case 46:
01003 E_ChangeDoseRate=0; break;
01004 case 47:
01005 setClock(GPCA_Instance_clk_x1,0);
01006 Cond_4_6=0; break;
01007 case 48:
01008 E_ConfirmDoseRate=0;
01009 setClock(GPCA_Instance_clk_x1,0); break;
01010 case 49:
01011 E_ConfirmDoseRate=0;
01012 setClock(GPCA_Instance_clk_x1,0); break;
01013 case 50:
01014 setClock(GPCA_Instance_clk_x1,0); break;
01015 case 52:
01016 E_StartInfusion=0; break;
01017 case 53:
01018 Cond_5_1=0; break;
01019 case 54:
01020 MCDR_In_Progress=1;
01021 E_CheckAdminSet=0; break;
01022 case 55:
01023 Cond_3_1=0; break;
01024 case 56:
01025 E_CheckAdminSet_1=0; break;
01026 case 57:
01027 Cond_3_2=0; break;
01028 case 58:
01029 Cond_3_3=0; break;
01030 case 59:
01031 E_Prime=0; break;
01032 case 60:
01033 Cond_3_4=0; break;
01034 case 61:
01035 E_CheckDrug=0; break;
01036 case 62:
01037 Cond_3_5=0; break;
01038 case 63:
01039 E_CheckDrug=0; break;
01040 case 64:
01041 Cond_3_6=0; break;
01042 case 65:
01043 Cond_3_7=0; break;
01044 case 66:
01045 E_CheckDrug=0; break;
01046 case 67:
01047 Cond_3_8=0; break;
01048 case 68:
01049 Cond_3_9=0; break;
01050 case 69:
01051 E_CheckDrug=0; break;
01052 case 70:
01053 Cond_3_11=0; break;
01054 case 71:
01055 E_ConfirmConcentration=0; break;
01056 case 72:
01057 E_Cancel=0; break;
01058 case 73:
01059 E_CheckDrug=0; break;
01060 case 74:
01061 E_PowerButton=0;
01062 Power_ON=1;
01063 setClock(GPCA_Instance_clk_x1,0); break;
01064 case 75:
01065 MCond_1_4=0; break;
01066 case 78:
01067 MCond_1_3=0; break;
01068 case 79:
01069 Cond_3_10=0; break;
01070 case 80:
01071 MCDR_In_Progress=0;
01072 E_ConfigureInfusionProgram=0; break;
01073 case 81:
01074 Cond_5_2=0; break;
01075 case 82:
01076 E_NewInfusion=0; break;
01077 case 83:
01078 E_Cancel=0; break;
01079 case 84:
01080 Cond_6_2=0; break;
01081 case 85:
01082 E_StopInfusion=0; break;
01083 case 86:
01084 E_Cancel=0; break;
01085 case 87:
01086 E_ConfirmStopInfusion=0; break;
01087 case 88:
01088 E_StopInfusion=0; break;
01089 case 89:
01090 Level_Two_Alarm=0;
01091 setClock(GPCA_Instance_clk_x1,0); break;
01092 case 90:
01093 E_StopInfusion=0; break;
01094 case 91:
01095 Level_Two_Alarm=0;
01096 setClock(GPCA_Instance_clk_x1,0); break;
01097 case 92:
01098 Level_Two_Alarm=0;
01099 setClock(GPCA_Instance_clk_x1,0); break;
01100 case 93:
01101 E_ChangeDoseRate=0; break;
01102 case 94:
01103 Cond_6_2=0; break;
01104 case 95:
01105 Cond_6_2=0; break;
01106 case 96:
01107 E_Cancel=0; break;
01108 case 97:
01109 Level_Two_Alarm=0;
01110 setClock(GPCA_Instance_clk_x1,0); break;
01111 case 98:
01112 Cond_6_2=0; break;
01113 case 99:
01114 setClock(GPCA_Instance_clk_x1,0); break;
01115 case 101:
01116 Cond_6_2=0; break;
01117 case 102:
01118 E_StopInfusion=0; break;
01119 case 103:
01120 E_StopInfusion=0; break;
01121 case 104:
01122 E_RequestBolus=0; break;
01123 case 105:
01124 Cond_7_1=0; break;
01125 case 106:
01126 Cond_7_2=0; break;
01127
01128 }
01129 }
01130
01136 void setClock(time_t clockID, long value){
01137 GPCA_Instance_clk_x1 = value;
01138 }
01139
01145 time_t rdClock(time_t clockID){
01146
01147 return GPCA_Instance_clk_x1;
01148 }
01149
01154 int getCurrentState(void){
01155 return current_GPCA_state;
01156 }
01157
01162 int send_gpca_pkt_to_client(void)
01163 {
01164 int i, write_res;
01165 pkt_gpca[INDEX_SOP] = SOP;
01166 pkt_gpca[INDEX_MOTOR_DIR] = MOTOR_DIRECTION;
01167 pkt_gpca[INDEX_SPD_LEVEL] = MOTOR_SPEED_LEVEL;
01168 pkt_gpca[INDEX_DURATION] = INFUSION_DURATION;
01169 pkt_gpca[INDEX_GPCA_STATE] = getCurrentState();
01170 pkt_gpca[INDEX_MOTOR_STATE] = MOTOR_STATE;
01171 pkt_gpca[INDEX_CHANNEL_ACK] = CHAN_NO_ACK;
01172 pkt_gpca[INDEX_EOP] = EOP;
01173
01174 pkt_gpca[INDEX_REMAIN_VOL_PERCENT] = REMAIN_VOL_PERCENT;
01175
01176
01177 for(i = 0 ; i < PKT_SIZE ; i++){
01178 if(clnt_socket < 0){
01179 printf("Client Socket is not estabilished...\n\r");
01180 }else{
01181 write_res = write(clnt_socket, &pkt_gpca[i], 1);
01182 if(write_res >= 0){
01183 printf("%X ", pkt_gpca[i]);
01184 }else{
01185 printf("Err in writing client socket...\n\r");
01186 return -1;
01187 }
01188 }
01189 }
01190 return 1;
01191 }
01192
01197 int send_channel_ack_to_client(void){
01198 int i, write_res;
01199 pkt_gpca[INDEX_SOP] = SOP;
01200 pkt_gpca[INDEX_MOTOR_DIR] = MOTOR_DIRECTION;
01201 pkt_gpca[INDEX_SPD_LEVEL] = MOTOR_SPEED_LEVEL;
01202 pkt_gpca[INDEX_DURATION] = INFUSION_DURATION;
01203 pkt_gpca[INDEX_GPCA_STATE] = getCurrentState();
01204 pkt_gpca[INDEX_MOTOR_STATE] = MOTOR_STATE;
01205 pkt_gpca[INDEX_CHANNEL_ACK] = CHAN_ACK;
01206 pkt_gpca[INDEX_EOP] = EOP;
01207
01208
01209 for(i = 0 ; i < PKT_SIZE ; i++){
01210 if(clnt_socket < 0){
01211 printf("Client Socket is not estabilished...\n\r");
01212 }else{
01213 write_res = write(clnt_socket, &pkt_gpca[i], 1);
01214 if(write_res >= 0){
01215 printf("%X ", pkt_gpca[i]);
01216 }else{
01217 printf("Err in writing client socket...\n\r");
01218 return -1;
01219 }
01220 }
01221 }
01222 printf("=========Channel ack sent==========\n");
01223 return 1;
01224 }
01225
01226
01233 int activate_gpca_channel(unsigned char cmd){
01234
01235 int ret_val = 0;
01236
01237 if(cmd == CMD_EVT_RequestBolus){
01238
01239
01240 }
01241
01242 else if (cmd == CMD_EVT_StopInfusion){
01243 if(getCurrentState() == GPCA_Instance_Infusion_NormalOperation || getCurrentState() == GPCA_Instance_InfusionPaused || getCurrentState() == GPCA_Instance_Alrm_TooLongInfusionPause || getCurrentState() == GPCA_Instance_Alrm_LevelTwoHardwareFailure || getCurrentState() == GPCA_Instance_Alrm_WrongDrug || getCurrentState() == GPCA_Instance_Alrm_EmptyReservior){
01244 E_StopInfusion = 1;
01245 return cmd;
01246 }
01247 }
01248
01249 else if (cmd == CMD_EVT_PowerButton){
01250 if(getCurrentState() == GPCA_Instance_POST_Init){
01251 printf("PowerButton Received\n");
01252 E_PowerButton = 1;
01253 return cmd;
01254 }
01255 }
01256
01257 else if (cmd == CMD_EVT_PauseInfusion){
01258 if(getCurrentState() == GPCA_Instance_Infusion_NormalOperation){
01259 E_PauseInfusion = 1;
01260 return cmd;
01261 }
01262 }
01263
01264 else if (cmd == CMD_EVT_ConfirmPauseInfusion){
01265 if(getCurrentState() == GPCA_Instance_ConfirmPause){
01266 E_ConfirmPauseInfusion = 1;
01267 return cmd;
01268 }
01269 }
01270
01271 else if (cmd == CMD_EVT_ClearAlarm){
01272 if(getCurrentState() == GPCA_Instance_Alrm_TooLongInfusionPause || getCurrentState() == GPCA_Instance_Alrm_LevelTwoHardwareFailure){
01273 E_ClearAlarm = 1;
01274 return cmd;
01275 }
01276 }
01277
01278 else if (cmd == CMD_EVT_Cancel){
01279 if(getCurrentState() == GPCA_Instance_ConfirmPause || getCurrentState() == GPCA_Instance_InfusionPaused || getCurrentState() == GPCA_Instance_PausedStopConfirm || getCurrentState() == GPCA_Instance_ConfirmStop || getCurrentState() == GPCA_Instance_ChangeRate || getCurrentState() == GPCA_Instance_Alrm_UnsafeNewRate || getCurrentState() == GPCA_Instance_ChangeVTBI || getCurrentState() == GPCA_Instance_ChangeDoseRate || getCurrentState() == GPCA_Instance_DisplayPatientProfile ){
01280 E_Cancel = 1;
01281 return cmd;
01282 }
01283 }
01284
01285 else if (cmd == CMD_EVT_ChangeDoseRate){
01286 if(getCurrentState() == GPCA_Instance_DisplayDoseRate || getCurrentState() == GPCA_Instance_Infusion_NormalOperation || getCurrentState() == GPCA_Instance_Alarming_DoseRate_OutOfBound || getCurrentState() == GPCA_Instance_Wrn_DoseRateSoftLimitsViolation){
01287 E_ChangeDoseRate = 1;
01288 return cmd;
01289 }
01290 }
01291
01292 else if (cmd == CMD_EVT_ConfigureInfusionProgram){
01293 if(getCurrentState() == GPCA_Instance_DisplayPatientProfile){
01294 E_ConfigureInfusionProgram = 1;
01295 return cmd;
01296 }
01297 }
01298
01299 else if (cmd == CMD_EVT_ConfirmStopInfusion){
01300 if(getCurrentState() == GPCA_Instance_ConfirmStop || getCurrentState() == GPCA_Instance_PausedStopConfirm){
01301 E_ConfirmStopInfusion = 1;
01302 return cmd;
01303 }
01304 }
01305
01306 else if (cmd == CMD_EVT_ConfirmDoseRate){
01307 if(getCurrentState() == GPCA_Instance_ChangeRate || getCurrentState() == GPCA_Instance_DisplayDoseRate || getCurrentState() == GPCA_Instance_ChangeDoseRate || getCurrentState() == GPCA_Instance_Wrn_DoseRateSoftLimitsViolation){
01308 E_ConfirmDoseRate = 1;
01309 return cmd;
01310 }
01311 }
01312
01313 else if (cmd == CMD_EVT_NewInfusion){
01314 if(getCurrentState() == GPCA_Instance_InfusionStopped){
01315 E_NewInfusion = 1;
01316 return cmd;
01317 }
01318 }
01319
01320 else if (cmd == CMD_EVT_ChangeVTBI){
01321 if(getCurrentState() == GPCA_Instance_DisplayVTBI || getCurrentState() == GPCA_Instance_Alrm_VTBIHardLimitsViolation || getCurrentState() == GPCA_Instance_Wrn_VTBISoftLimitsViolation){
01322 E_ChangeVTBI = 1;
01323 return cmd;
01324 }
01325 }
01326
01327 else if (cmd == CMD_EVT_ConfirmVTBI){
01328 if(getCurrentState() == GPCA_Instance_ChangeVTBI || getCurrentState() == GPCA_Instance_DisplayVTBI || getCurrentState() == GPCA_Instance_Wrn_VTBISoftLimitsViolation){
01329 E_ConfirmVTBI = 1;
01330 return cmd;
01331 }
01332 }
01333
01334 else if (cmd == CMD_EVT_StartInfusion){
01335 if(getCurrentState() == GPCA_Instance_DisplaySetting){
01336 E_StartInfusion = 1;
01337 return cmd;
01338 }
01339 }
01340
01341 else if (cmd == CMD_EVT_CheckAdminSet){
01342 if(getCurrentState() == GPCA_Instance_CDR_Init){
01343 MCDR_In_Progress = 0;
01344 E_CheckAdminSet = 1;
01345 return cmd;
01346 }
01347 }
01348
01349 else if (cmd == CMD_EVT_CheckAdminSet_1){
01350 if(getCurrentState() == GPCA_Instance_Alrm_IncorrectAdministrationSetup){
01351 E_CheckAdminSet_1 = 1;
01352 return cmd;
01353 }
01354 }
01355
01356 else if (cmd == CMD_EVT_CheckDrug){
01357 if(getCurrentState() == GPCA_Instance_DisplayDrugInfo || getCurrentState() == GPCA_Instance_Alrm_UnknownDrug || getCurrentState() == GPCA_Instance_Alrm_DoseUnitMismatch || getCurrentState() == GPCA_Instance_Wrn_ConcentrationSoftLimitsViolation || getCurrentState() == GPCA_Instance_Alrm_ConcentrationHardLimitsViolation){
01358 E_CheckDrug = 1;
01359 return cmd;
01360 }
01361 }
01362
01363 else if (cmd == CMD_EVT_ConfirmConcentration){
01364 if(getCurrentState() == GPCA_Instance_Wrn_ConcentrationSoftLimitsViolation){
01365 E_ConfirmConcentration = 1;
01366 return cmd;
01367 }
01368 }
01369
01370 else if (cmd == CMD_EVT_Prime){
01371 if(getCurrentState() == GPCA_Instance_Alrm_PrimeFailure){
01372 E_Prime = 1;
01373 return cmd;
01374 }
01375 }
01376
01377 else if(cmd == CMD_V_MCond_1_4){
01378 if(getCurrentState() == GPCA_Instance_Post_In_Progress){
01379 MCond_1_4 = 1;
01380 MCDR_In_Progress = 0;
01381 return cmd;
01382 }
01383 }
01384
01385 else if(cmd == CMD_V_Cond_3_2){
01386 if(getCurrentState() == GPCA_Instance_CheckAdministrationSet){
01387 Cond_3_2 = 1;
01388 return cmd;
01389 }
01390 }
01391
01392 else if(cmd == CMD_V_Cond_3_4){
01393 if(getCurrentState() == GPCA_Instance_CheckPrime){
01394 Cond_3_4 = 1;
01395 return cmd;
01396 }
01397 }
01398
01399 else if(cmd == CMD_V_Cond_3_6){
01400 if(getCurrentState() == GPCA_Instance_CheckDrugType){
01401 Cond_3_6 = 1;
01402 return cmd;
01403 }
01404 }
01405
01406 else if(cmd == CMD_V_Cond_3_8){
01407 if(getCurrentState() == GPCA_Instance_CheckDoseUnit){
01408 Cond_3_8 = 1;
01409 return cmd;
01410 }
01411 }
01412
01413 else if(cmd == CMD_V_Cond_3_11){
01414 if(getCurrentState() == GPCA_Instance_CheckConcentration){
01415 Cond_3_11 = 1;
01416 return cmd;
01417 }
01418 }
01419
01420 else if(cmd == CMD_V_Cond_4_3){
01421 if(getCurrentState() == GPCA_Instance_CheckVTBI){
01422 Cond_4_3 = 1;
01423 return cmd;
01424 }
01425 }
01426
01427 else if(cmd == CMD_V_Cond_4_6){
01428 if(getCurrentState() == GPCA_Instance_CheckDoseRate){
01429 Cond_4_6 = 1;
01430 return cmd;
01431 }
01432 }
01433
01434 else if(cmd == CMD_V_Cond_5_2){
01435 if(getCurrentState() == GPCA_Instance_ReadyToStart){
01436 Cond_5_2 = 1;
01437 return cmd;
01438 }
01439 }
01440
01441 return -1;
01442 }
01449 int action_handler_on_state_change(int prev_state, int current_state){
01450
01451 if(prev_state == GPCA_Instance_POST_Init){
01452 if(current_state == GPCA_Instance_Post_In_Progress){
01453 printf(">>Do Post In Progress\n");
01454 return 1;
01455 }
01456 }
01457
01458 if(prev_state == GPCA_Instance_ReadyToStart){
01459 if(current_state == GPCA_Instance_Infusion_NormalOperation){
01460 printf(">>Start Motor\n");
01461 write_byte_to_controller(serial_fd, CONT_CMD_TOGGLE_MOTOR_OPERATION);
01462 return 1;
01463 }
01464 }
01465 if(prev_state == GPCA_Instance_ConfirmPause){
01466 if(current_state == GPCA_Instance_InfusionPaused){
01467 printf(">>Pause Motor\n");
01468 write_byte_to_controller(serial_fd, CONT_CMD_TOGGLE_MOTOR_OPERATION);
01469 return 1;
01470 }
01471 }
01472 if(prev_state == GPCA_Instance_Alrm_TooLongInfusionPause){
01473 if(current_state == GPCA_Instance_Infusion_NormalOperation){
01474 printf(">>Start Motor\n");
01475
01476 write_byte_to_controller(serial_fd, CONT_CMD_TOGGLE_MOTOR_OPERATION);
01477
01478 write_byte_to_controller(serial_fd, CONT_CMD_ALARM_BUZZ_OFF);
01479 write_byte_to_controller(serial_fd, CONT_CMD_ALARM_LED_OFF);
01480 return 1;
01481 }
01482 }
01483 if(prev_state == GPCA_Instance_InfusionPaused){
01484 if(current_state == GPCA_Instance_Alrm_TooLongInfusionPause){
01485 printf(">>Alarm !! Too Long Infused\n");
01486
01487 write_byte_to_controller(serial_fd, CONT_CMD_ALARM_BUZZ_ON);
01488 write_byte_to_controller(serial_fd, CONT_CMD_ALARM_LED_ON);
01489 return 1;
01490 }
01491 }
01492 if(prev_state == GPCA_Instance_Alrm_TooLongInfusionPause){
01493 if(current_state == GPCA_Instance_InfusionStopped){
01494 printf(">>Infusion Session is stopped\n");
01495
01496 write_byte_to_controller(serial_fd, CONT_CMD_ALARM_BUZZ_OFF);
01497 write_byte_to_controller(serial_fd, CONT_CMD_ALARM_LED_OFF);
01498 }
01499 }
01500 return 0;
01501 }
01502
01509 int write_byte_to_controller(int fd, char data){
01510 int write_res = 0;
01511 write_res = write(fd, &data, 1);
01512 if(write_res <= 0){
01513 printf("Error in writing to infusion controller...\n\r");
01514 return 0;
01515 }else{
01516 printf("[%c] has been delivered to infusion controller\n\r", data);
01517 return 1;
01518 }
01519 }