II ANEXO II
endMIP:
do
:: pc_to_mip?connect -> mip_to_pc!ack;
printf("Relógio do MIP sendo sincronizado pelo PC\n");
:: pc_to_mip?sync1 -> mip_to_pc!sync123;
:: pc_to_mip?sync12345 -> mip_sync = true;
do
:: pc_to_mip?set_verify_mode -> mip_to_pc!ack;
// :: pc_to_mip?set_verify_mode ->
// mip_time++;
// if
// :: mip_time < MIP_TIME_B_MAX ->
// mip_to_pc!nak; // Enquanto não for zerado o Padrão de Energia ...
// :: else -> mip_to_pc!ack;
// mip_time = 0;
// fi;
:: pc_to_mip?start_verify -> mip_to_pc!verify_running;
mip_time = 0;
:: pc_to_mip?get_verify_stat ->
mip_time++;
if
:: mip_time < MIP_TIME_MAX -> mip_to_pc!verify_running;
:: else -> mip_to_pc!verify_finished;
fi;
:: pc_to_mip?get_verify_result -> mip_to_pc!verify_result;
:: pc_to_mip?disconnect -> mip_to_pc!ack;
mip_end_proc = true;
break;
od;
:: mip_end_proc -> break;
od;
}
/**************************************************************************/
active proctype PC() {
bool mip_connected = false, um_connected = false;
bool mip_verify_mode = false, um_verify_mode = false;
bool mip_verify_stat = false, um_verify_stat = false;
bool mip_verify_result = false, um_verify_result = false;
bool mip_disconnected = false, um_disconnected = false;
bool mip_sent_get_verify_stat = false, um_sent_get_verify_stat = false;
bool mip_pc_sync = false, um_pc_sync = false;
do
:: do // Conecta com o MIP e com a UM:
:: mip_connected == false -> pc_to_mip!connect;
mip_to_pc?ack -> mip_connected = true; printf("MIP conectado\n");
:: um_connected == false -> pc_to_um!connect;
um_to_pc?ack -> um_connected = true; printf("UM conectada\n");
:: mip_connected && um_connected -> break;
od;
//
printf("PC fazendo a sincronização do relógio do MIP\n");
pc_to_mip!sync1;
do
:: mip_to_pc?sync123 -> break;
od;
pc_to_mip!sync12345 -> mip_pc_sync = true;
//
printf("PC fazendo a sincronização do relógio da UM\n");
pc_to_um!sync1;
do
:: um_to_pc?sync123 -> break;
od;
pc_to_um!sync12345 -> um_pc_sync = true;
//
do // Configura o MIP e a UM no modo de verificação:
:: mip_verify_mode == false -> pc_to_mip!set_verify_mode;
mip_to_pc?ack -> mip_verify_mode = true;
:: um_verify_mode == false -> pc_to_um!set_verify_mode;
um_to_pc?ack -> um_verify_mode = true;
:: mip_verify_mode && um_verify_mode -> break;
od;
// Dá a partida no MIP e na UM:
do // Dá a partida no MIP:
:: pc_to_mip!start_verify; // Dá a partida no MIP if
:: mip_to_pc?verify_running -> break; // Deu a partida no MIP, após ser zerado o Padrão de Energia ...
:: mip_to_pc?nak -> printf("MIP não preparado!\n"); break;
//:: else -> skip;
fi;
printf("MIP partiu Ok!\n");
od;
do// Dá a partida na UM:
:: pc_to_um!start_verify; // Dá a partida na UM if
:: um_to_pc?verify_running -> break; // Deu a partida na UM:
:: um_to_pc?nak -> printf("UM não preparada!\n"); break;
//:: else -> skip;
fi;
printf("UM partiu Ok!\n");
od;
// Verifica se o MIP e a UM terminaram:
do
// Envia o comando para o MIP, se necessário:
:: mip_verify_stat == false;
if
:: !mip_sent_get_verify_stat -> pc_to_mip!get_verify_stat;
mip_sent_get_verify_stat = true;
:: else -> skip;
fi;
// Verifica se o MIP terminou:
/**/ :: mip_to_pc?verify_finished -> mip_verify_stat = true; // MIP terminou //mip_sent_get_verify_stat = false;
:: mip_to_pc?verify_running -> mip_sent_get_verify_stat = false; // MIP ainda não terminou
// Envia o comando para a UM, se necessário:
:: um_verify_stat == false;
if
:: !um_sent_get_verify_stat -> pc_to_um!get_verify_stat;
um_sent_get_verify_stat = true;
:: else -> skip;
fi;
// Verifica se a UM terminou:
:: um_to_pc?verify_finished -> um_verify_stat = true; // UM terminou //um_sent_get_verify_stat = false;
:: um_to_pc?verify_running -> um_sent_get_verify_stat = false; // UM ainda não terminou
//um_sent_get_verify_stat = false;
:: mip_verify_stat && um_verify_stat -> break;
od;
do // Obtem resultados das medidas do MIP e da UM:
:: mip_verify_result == false -> pc_to_mip!get_verify_result;
mip_to_pc?verify_result -> mip_verify_result = true;
:: um_verify_result == false -> pc_to_um!get_verify_result;
um_to_pc?verify_result -> um_verify_result = true;
:: mip_verify_result && um_verify_result -> break;
printf("Obtidos os resultados do MIP e da UM\n");
od;
do // Desconecta o MIP e a UM:
:: mip_disconnected == false -> pc_to_mip!disconnect;
um_to_pc?ack -> um_disconnected = true;
:: mip_disconnected && um_disconnected -> break;
printf("MIP e UM desconectados\n");
od;
mip_connected = false; um_connected = false;
mip_verify_mode = false; um_verify_mode = false;
mip_verify_stat = false; um_verify_stat = false;
mip_verify_result = false; um_verify_result = false;
mip_disconnected = false; um_disconnected = false;
break;
od;
printf("Finalizado o processo PC\n");
}
/**************************************************************************/
active proctype UM() {
int um_time = 0;
bool um_sync = false, um_end_proc = false;
printf("Iniciado o processo UM\n");
endUM:
do
:: pc_to_um?connect -> um_to_pc!ack;
printf("Relógio da UM sendo sincronizado pelo PC\n");
:: pc_to_um?sync1 -> um_to_pc!sync123;
:: pc_to_um?sync12345 -> um_sync = true;
do
:: pc_to_um?set_verify_mode -> um_to_pc!ack;
:: pc_to_um?start_verify -> um_to_pc!verify_running;
um_time = 0;
:: pc_to_um?get_verify_stat ->
um_time++;
if
:: um_time < UM_TIME_MAX -> um_to_pc!verify_running;
:: else -> um_to_pc!verify_finished;
fi;
:: pc_to_um?get_verify_result -> um_to_pc!verify_result;
:: pc_to_um?disconnect -> um_to_pc!ack;
um_end_proc = true;
break;
od;
:: um_end_proc -> break;
od;
}