mitk::BaseProperty::Pointer TestSerialize(mitk::BaseProperty *property)
{
std::string serializername = std::string(property->GetNameOfClass()) + "Serializer";
std::list<itk::LightObject::Pointer> allSerializers =
itk::ObjectFactoryBase::CreateAllInstance(serializername.c_str());
CPPUNIT_ASSERT_EQUAL(size_t(1), allSerializers.size());
auto *serializer =
dynamic_cast<mitk::BasePropertySerializer *>(allSerializers.begin()->GetPointer());
CPPUNIT_ASSERT(serializer != nullptr);
if (!serializer)
return nullptr;
serializer->SetProperty(property);
TiXmlElement *serialization(nullptr);
try
{
serialization = serializer->Serialize();
}
catch (...)
{
}
CPPUNIT_ASSERT(serialization != nullptr);
if (!serialization)
return nullptr;
mitk::BaseProperty::Pointer restoredProperty = serializer->Deserialize(serialization);
CPPUNIT_ASSERT(restoredProperty.IsNotNull());
return restoredProperty;
}
void reallocate_orders(int number_of_clients){
if(number_of_clients == 1){
for(int i = 0;i<6;i++){
if(queue[i][0] == 1){
queue[i][1] = 0;
}
}
}
else if(number_of_clients == 2){
for(int i = 0;i<3;i++){
if(queue[i][0] == 1)
queue[i][1] = 0;
}
for(int i = 3;i<6;i++){
if(queue[i][0] == 1){
queue[i][1] = 1;
}
}
}
Message message_send;
char server_message[BUFSIZE];
for(int i = 0;i<6;i++){
message_send.orders[i][0] = queue[i][0];
message_send.orders[i][1] = queue[i][1];
}
serialization(ORDER_UPDATE, message_send, server_message);
for(int i = 0;i<clients;i++){
write(client_sockets[i], server_message, strlen(server_message));
}
}
SYSTEM::CSmartPtr<IRender> IRender::CopyNewRender()
{
Carto::IRenderPtr pRend;
SYSTEM::CBinArchive ar;
serialization( ar );
ar.SetReadState();
ar.SetPosToBegin();
pRend = CreateRenderFromStream( ar );
return pRend;
}
void check_clients(){
int x[3] = {0};
sleep(3);
while(1){
char net_check[BUFSIZE];
Message message_send;
serialization(NETCHECK, message_send, net_check);
if(clients){
for(int i = 0;i<clients;i++){
write(client_sockets[i],net_check, strlen(net_check));
}
puts("NETCHECK");
sleep(10);
/*for(int i = 0;i<clients;i++){
if(client_checkin[i] == 0){
printf("Client: %d didn't check in\n", i);
//Remove from network
x[i]++;
if(x[i] == 2){
close(client_sockets[i]);
printf("Socket: %d closed\n", i );
clients--;
if((clients+1)==2 && i == 1){//Client 1 disconnected, client 2 will now be client 1
elev_client[1].floor_current = elev_client[2].floor_current;
Message message_send;
message_send.type = ID_UPDATE;
message_send.ID = i;
client_sockets[1] = client_sockets[2];
char server_message[BUFSIZE];
serialization(ID_UPDATE, message_send, server_message);
write(client_sockets[1], server_message, strlen(server_message));
}
//sleep(1);
reallocate_orders(clients);
}
}
else
{
client_checkin[i] = 0;
}
}
*/
}
if(clients == 0){
exit(1);
}
}
}
void button_check(){
Message message_send;
elev_button_type_t button_type;
int floor;
int button_is_pressed=0;
puts("Button check thread started");
while (1){
for(floor = 0;floor<N_FLOORS;floor++){
for(button_type = 0;button_type<N_BUTTONS;button_type++){
if(elev_get_button_signal(button_type,floor)==1){
if(button_type==BUTTON_INSIDE){
elev_set_button_lamp(BUTTON_INSIDE,floor,1);
elevator.queue[floor]=1;
}
pthread_mutex_lock(&mutex);
button_is_pressed=1;
message_send.button.floor=floor;
message_send.button.type=button_type;
pthread_mutex_unlock(&mutex);
while(elev_get_button_signal(button_type,floor));
break;
}
}
if(button_is_pressed)
break;
}
if(button_is_pressed){
puts("Button is pressed, creating thread\n");
button_is_pressed=0;
char transmit[BUFSIZE];
serialization(BUTTON_CHECK, message_send, transmit);
pthread_t message_send_thread;
pthread_create(&message_send_thread, NULL , tcp_send, (void*)transmit);
if(message_send.button.type==BUTTON_INSIDE){
FILE *fp;
fp = fopen("local_order_queue.txt", "w+");
fprintf(fp,"%d %d %d %d", elevator.queue[0], elevator.queue[1], elevator.queue[2], elevator.queue[3] );
fclose(fp);
}
}
if(!connection){
break;
}
}
}
void check_clients(){
sleep(3);
while(1){
char net_check[BUFSIZE];
Message message_send;
serialization(NETCHECK, message_send, net_check);
if(clients){
for(int i = 0;i<clients;i++){
write(client_sockets[i],net_check, strlen(net_check));
}
puts("NETCHECK");
sleep(10);
}
if(clients == 0){
exit(1);
}
}
}
void *order_counter(void *x){
char *buf = (char*)x;
char server_message[BUFSIZE];
Message message_send;
char order_and_ID[2];
for(int i = 0;i<2;i++){
order_and_ID[i] = buf[i];
}
puts("Order counter");
sleep(20);
if(queue[order_and_ID[0]][0]!=0 && queue[order_and_ID[0]][1]==order_and_ID[1]){//Check if order is not taken and ID is correct
printf("Client: %d did not finish order", order_and_ID[1]);
if(clients == 1){
queue[order_and_ID[0]][1] = 0;
for(int i = 0;i<6;i++){
message_send.orders[i][0] = queue[i][0];
message_send.orders[i][1] = queue[i][1];
}
}
else{
if(queue[order_and_ID[0]][1] == 0){
queue[order_and_ID[0]][1] = 1;
for(int i = 0;i<6;i++){
message_send.orders[i][0] = queue[i][0];
message_send.orders[i][1] = queue[i][1];
}
}
else{
queue[order_and_ID[0]][1] = 0;
for(int i = 0;i<6;i++){
message_send.orders[i][0] = queue[i][0];
message_send.orders[i][1] = queue[i][1];
}
}
}
serialization(ORDER_UPDATE, message_send, server_message);
write(client_sockets[0], server_message, strlen(server_message));
}
else
puts("order done");
}
void elevator_thread(){
int sum=0;
int stop=0;
Message message_send;
elevator.queue[0] = 0;
elevator.queue[1] = 0;
elevator.queue[2] = 0;
elevator.queue[3] = 0;
FILE *fp;
char buff[255];
fp = fopen("local_order_queue.txt", "a+");
for(int i=0;i<N_FLOORS;i++){
fscanf(fp, "%s", buff);
printf("%d : %s\n", i, buff );
if(buff[0] == '1'){
elevator.queue[i]=1;
sum++;
}
else
elevator.queue[i]=0;
}
fclose(fp);
if(!sum){
elev_init();
elevator.floor_current = 0;
elevator.direction=DIRN_STOP;
}
message_send.elevator.direction = elevator.direction;
message_send.elevator.floor_current = elevator.floor_current;
char transmit[BUFSIZE];
serialization(ELEV_UPDATE, message_send, transmit);
pthread_t message_send_thread;
pthread_create(&message_send_thread, NULL , tcp_send, (void*)transmit);
int floor_update_not_sent=1;
while(1){
if(sum != 0){
elevator.floor_current = elev_get_floor_sensor_signal();
int orders_up=0;
int orders_down=0;
if(elevator.direction == DIRN_STOP){
for(int i=elevator.floor_current+1;i<N_FLOORS;i++){
if(elevator.queue[i] != 0){
orders_up++;
puts("Order up");
}
}
for( int i=elevator.floor_current-1;i>=0;i--){
if(elevator.queue[i] != 0){
orders_down++;
puts("Order down");
}
}
if (orders_up == 0 && orders_down == 0){
elevator.direction=DIRN_STOP;
}
else if(orders_up>orders_down){
elevator.direction=DIRN_UP;
puts("DIRN UP");
}
else{
elevator.direction=DIRN_DOWN;
puts("DIRN DOWN");
}
}
for(int i=0;i<N_FLOORS;i++){
message_send.elevator.queue[i]=elevator.queue[i];
}
message_send.elevator.direction = elevator.direction;
message_send.elevator.floor_current = elevator.floor_current;
char transmit[BUFSIZE];
serialization(ELEV_UPDATE, message_send, transmit);
pthread_t message_send_thread;
pthread_create(&message_send_thread, NULL , tcp_send, (void*)transmit);
elev_set_motor_direction(elevator.direction);
}
while(sum){
elevator.floor_current=elev_get_floor_sensor_signal();
if(elevator.floor_current!=-1){
elev_set_floor_indicator(elevator.floor_current);
if((elevator.floor_current==0 && elevator.direction==DIRN_DOWN) || (elevator.floor_current==N_FLOORS&&elevator.direction==DIRN_UP)){
elevator.direction=DIRN_STOP;
elev_set_motor_direction(elevator.direction);
stop=1;
}
if(elevator.queue[elevator.floor_current]==1){
stop=1;
}
else if(elevator.queue[elevator.floor_current]==2){
sum=0;
if(elevator.direction==DIRN_UP){
for(int i=elevator.floor_current;i<N_FLOORS;i++){
if(elevator.queue[i]==1){
sum++;
}
}
switch (elevator.floor_current){
case 1:
if(elev_orders[elevator.floor_current][1]==my_ID){
stop=1;
break;
}
case 2:
if(elev_orders[elevator.floor_current][1]==my_ID){
stop=1;
break;
}
default:
if(sum==0){
stop=1;
}
}
}
else if(elevator.direction==DIRN_DOWN){
for(int i=elevator.floor_current;i>=0;i--){
if(elevator.queue[i]==1){
sum++;
}
}
switch (elevator.floor_current){
case 1:
if(elev_orders[elevator.floor_current+2][1]==my_ID){
stop=1;
break;
}
case 2:
if(elev_orders[elevator.floor_current+2][1]==my_ID){
stop=1;
break;
}
default:
if(sum==0){
stop=1;
}
}
}
}
if(stop){
stop=0;
elev_set_motor_direction(DIRN_STOP);
elev_set_button_lamp(BUTTON_INSIDE,elevator.floor_current,0);
elevator.queue[elevator.floor_current]=0;
printf("Elevator queue updated: \t");
sum = 0;
for(int i=0;i<N_FLOORS;i++){
message_send.elevator.queue[i]=elevator.queue[i];
sum+=elevator.queue[i];
printf("%d ", elevator.queue[i]);
}
FILE *fp;
fp = fopen("local_order_queue.txt", "w+");
fprintf(fp,"%d %d %d %d", elevator.queue[0], elevator.queue[1], elevator.queue[2], elevator.queue[3] );
fclose(fp);
message_send.elevator.prev_direction = elevator.direction;
elevator.direction = DIRN_STOP;
message_send.elevator.direction = elevator.direction;
message_send.elevator.floor_current = elevator.floor_current;
printf("Floor current: %d\n", message_send.elevator.floor_current);
for(int i = 0;i<6;i++){
message_send.orders[i][0] = elev_orders[i][0];
message_send.orders[i][1] = elev_orders[i][1];
}
switch (elevator.floor_current){
case 0:
message_send.orders[0][0] = 0;
message_send.orders[0][1] = my_ID;
elevator.next_direction = DIRN_UP;
break;
case 1:
if(elev_orders[1][1] == my_ID){
message_send.orders[1][0] = 0;
message_send.orders[1][1] = my_ID;
elevator.next_direction = DIRN_UP;
}
else {
message_send.orders[3][0] = 0;
message_send.orders[3][1] = my_ID;
elevator.next_direction = DIRN_DOWN;
}
break;
case 2:
if(elev_orders[2][1] == my_ID){
message_send.orders[2][0] = 0;
message_send.orders[2][1] = my_ID;
elevator.next_direction = DIRN_UP;
}
else {
message_send.orders[4][0] = 0;
message_send.orders[4][1] = my_ID;
elevator.next_direction = DIRN_DOWN;
}
break;
case 3:
message_send.orders[5][0] = 0;
message_send.orders[5][1] = my_ID;
elevator.next_direction = DIRN_DOWN;
break;
}
puts("ORDER UPDATE");
for(int i = 0;i<6;i++){
printf("Order: %d \t ID: %d\n",message_send.orders[i][0], message_send.orders[i][1]);
}
char transmit[BUFSIZE];
serialization(ORDER_UPDATE, message_send, transmit);
pthread_t message_send_thread;
pthread_create(&message_send_thread, NULL , tcp_send, (void*)transmit);
floor_update_not_sent=0;
elev_set_door_open_lamp(1);
elev_set_button_lamp(BUTTON_INSIDE,elevator.floor_current,0);
sleep(2);
elev_set_door_open_lamp(0);
sum = 0;
switch (elevator.next_direction){
case DIRN_DOWN:
for(int i = elevator.floor_current;i>=0;i--){
sum += elevator.queue[i];
}
if(sum!=0){
elevator.direction = DIRN_DOWN;
}
else {
for(int i = elevator.floor_current;i<N_FLOORS;i++){
sum+=elevator.queue[i];
}
if(sum!=0)
elevator.direction = DIRN_UP;
}
break;
case DIRN_UP:
for(int i = elevator.floor_current;i<N_FLOORS;i++){
sum += elevator.queue[i];
}
if(sum!=0){
elevator.direction = DIRN_UP;
}
else {
for(int i = elevator.floor_current;i>=0;i--){
sum+=elevator.queue[i];
}
if(sum!=0)
elevator.direction = DIRN_DOWN;
}
break;
}
elev_set_motor_direction(elevator.direction);
}
else if(floor_update_not_sent){
message_send.elevator.direction = elevator.direction;
message_send.elevator.prev_direction = elevator.direction;
message_send.elevator.floor_current = elevator.floor_current;
char transmit[BUFSIZE];
serialization(ELEV_UPDATE, message_send, transmit);
pthread_t message_send_thread;
pthread_create(&message_send_thread, NULL , tcp_send, (void*)transmit);
floor_update_not_sent=0;
}
}
else
floor_update_not_sent=1;
}
for(int i=0;i<N_FLOORS;i++){
sum+=elevator.queue[i];
}
if(!connection){
break;
}
}
}
IGL_INLINE void deserialize(igl::viewer::ViewerCore& obj,const std::vector<char>& buffer)
{
serialization(false,obj,const_cast<std::vector<char>&>(buffer));
}
IGL_INLINE void serialize(const igl::viewer::ViewerCore& obj,std::vector<char>& buffer)
{
serialization(true,const_cast<igl::viewer::ViewerCore&>(obj),buffer);
}
IGL_INLINE void deserialize(ViewerData& obj,const std::vector<char>& buffer)
{
serialization(false,obj,const_cast<std::vector<char>&>(buffer));
obj.dirty = ViewerData::DIRTY_ALL;
}
IGL_INLINE void serialize(const ViewerData& obj,std::vector<char>& buffer)
{
serialization(true,const_cast<ViewerData&>(obj),buffer);
}
void *master_connection_handler(void *socket_desc){ //Connection handler for TCP connections
//Get the socket descriptor
int client_id = clients-1;
int sock = *(int*)socket_desc;
int read_size;
char client_message[BUFSIZE], *message;
sleep(1);
client_message[0] = (clients-1)+'0';
write(sock , client_message , strlen(client_message)); //Give client ID
bzero(client_message,BUFSIZE);
struct timeval tv;
tv.tv_sec = 11; // 11 Secs Timeout
tv.tv_usec = 0;
setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO,(char *)&tv,sizeof(tv));
//Receive a message from client
while( (read_size = recv(sock , client_message , BUFSIZE , 0)) > 0 ){
Message message_send,message_receive;
message_receive = deserialization(client_message);
switch(message_receive.type){
case BUTTON_CHECK:
printf("Reciever Button floor & type: ");
printf("%d ",message_receive.button.floor);
printf("%d \n",message_receive.button.type);
switch(message_receive.button.type){
case BUTTON_INSIDE:
break;
default:
if(add_to_queue(message_receive.button.type, message_receive.button.floor)){
char server_message[BUFSIZE];
for(int i = 0;i<6;i++){
message_send.orders[i][0] = queue[i][0];
message_send.orders[i][1] = queue[i][1];
}
message_send.ID = cost_function(message_receive.button.type, message_receive.button.floor);
printf("Which client gets the order: %d",message_send.ID);
message_send.elevator.new_floor_order=message_receive.button.floor;
pthread_t order_counter_thread;
char order_and_ID[2];
order_and_ID[1] = message_send.ID;
if(message_receive.button.type==BUTTON_CALL_UP){
queue[message_receive.button.floor][1] = message_send.ID;
queue[message_receive.button.floor][0] = 1;
message_send.orders[message_receive.button.floor][1] = message_send.ID;
order_and_ID[0] = message_receive.button.floor;
pthread_create(&order_counter_thread, NULL, order_counter, (void*)order_and_ID);
}
else{
queue[message_receive.button.floor+2][1] = message_send.ID;
queue[message_receive.button.floor+2][0] = 1;
message_send.orders[message_receive.button.floor+2][1] = message_send.ID;
order_and_ID[0] = message_receive.button.floor+2;
pthread_create(&order_counter_thread, NULL, order_counter, (void*)order_and_ID);
}
serialization(ELEV_ORDER, message_send, server_message);
for(int i = 0;i<clients;i++){
write(client_sockets[i], server_message, strlen(server_message));
}
}
}
break;
case ELEV_UPDATE:
//Only updates elevator location
printf("ELEV FLOOR UPDATE BY ELEVATOR #%d\n",client_id);
elev_client[client_id].floor_current = message_receive.elevator.floor_current;
elev_client[client_id].direction = message_receive.elevator.direction;
for(int i = 0;i<clients;i++){
printf("Elevator #%d \t Floor current: %d \t Direction: %1d\n", i,elev_client[i].floor_current,(int)elev_client[i].direction);
}
break;
case ORDER_UPDATE:
//Clears orders that are done and sets lamps
elev_client[client_id].floor_current = message_receive.elevator.floor_current;
elev_client[client_id].direction = message_receive.elevator.direction;
for(int i = 0;i<clients;i++){
printf("Elevator #%d \t Floor current: %d \t Direction: %1d\n", i,elev_client[i].floor_current,(int)elev_client[i].direction);
}
for(int i = 0;i<6;i++){
queue[i][0] &= message_receive.orders[i][0];
if(!(queue[i][0]&&message_receive.orders[i][0]))
queue[i][1] = -1;
}
puts("\nNew queue");
for(int i = 0;i<6;i++){
printf("Order: %d \t ID: %d\n",queue[i][0],queue[i][1]);
}
message_send.ID = -1;
for(int i = 0;i<6;i++){
message_send.orders[i][0] = queue[i][0];
message_send.orders[i][1] = queue[i][1];
}
char server_message[BUFSIZE];
serialization(ELEV_ORDER, message_send, server_message);
for(int i = 0;i<clients;i++){
write(client_sockets[i], server_message, strlen(server_message));
}
break;
case NETCHECK:
client_checkin[client_id] = 1;
break;
case ID_UPDATE:
client_id = message_receive.ID;
break;
}
bzero(client_message,BUFSIZE);
}
if(read_size == 0){
puts("Client disconnected");
clients--;
fflush(stdout);
printf("#Clients: %d\n",clients);
if(client_id == 0){
system("gnome-terminal -x ./elevator 0");
}
else{
if((clients+1)==2 && client_id == 1){//Client 1 disconnected, client 2 will now be client 1
elev_client[1].floor_current = elev_client[2].floor_current;
Message message_send;
message_send.type = ID_UPDATE;
message_send.ID = client_id;
client_sockets[1] = client_sockets[2];
char server_message[BUFSIZE];
serialization(ID_UPDATE, message_send, server_message);
write(client_sockets[1], server_message, strlen(server_message));
}
reallocate_orders(clients);
}
}
else if(read_size == -1){
clients--;
perror("recv failed, handler");
printf("Client id: %d", client_id);
printf("#Clients: %d\n",clients);
if((clients+1)==2 && client_id == 1){//Client 1 disconnected, client 2 will now be client 1
elev_client[1].floor_current = elev_client[2].floor_current;
Message message_send;
message_send.type = ID_UPDATE;
message_send.ID = client_id;
client_sockets[1] = client_sockets[2];
char server_message[BUFSIZE];
serialization(ID_UPDATE, message_send, server_message);
write(client_sockets[1], server_message, strlen(server_message));
}
reallocate_orders(clients);
}
//Free the socket pointer
free(socket_desc);
return 0;
}
void* client_message_handler(void *msg_recv){
puts("Client message handler started");
pthread_mutex_init(&mutex,NULL);
char receive[BUFSIZE];
bzero(receive,BUFSIZE);
char *buf = (char*)msg_recv;
for(int i = 0;i<BUFSIZE;i++){
receive[i] = buf[i];
}
Message message_receive = deserialization(receive);
switch(message_receive.type){
case ELEV_ORDER:
puts("ELEV ORDER");
elev_set_button_lamp(BUTTON_CALL_UP, 0, message_receive.orders[0][0]);
elev_set_button_lamp(BUTTON_CALL_UP, 1, message_receive.orders[1][0]);
elev_set_button_lamp(BUTTON_CALL_UP, 2, message_receive.orders[2][0]);
elev_set_button_lamp(BUTTON_CALL_DOWN, 1, message_receive.orders[3][0]);
elev_set_button_lamp(BUTTON_CALL_DOWN, 2, message_receive.orders[4][0]);
elev_set_button_lamp(BUTTON_CALL_DOWN, 3, message_receive.orders[5][0]);
for(int i=0;i<6;i++){ //Global queue
elev_orders[i][0] = message_receive.orders[i][0];
elev_orders[i][1] = message_receive.orders[i][1];
queue[i][0] = message_receive.orders[i][0];
queue[i][1] = message_receive.orders[i][1];
}
puts("\nNew queue");
for(int i = 0;i<6;i++){
printf("Order: %d \t ID: %d\n",queue[i][0],queue[i][1]);
}
printf("Message_recieve.ID: %d\n", message_receive.ID);
printf("My ID: %d\n", my_ID);
if(message_receive.ID==my_ID){ //Sets local queue based on ID
puts("Order recieved");
pthread_mutex_lock(&mutex);
if(elevator.queue[elevator.floor_current]==0){
elevator.queue[message_receive.elevator.new_floor_order]=2;
}
pthread_mutex_unlock(&mutex);
//elevator.new_floor_order=1;
}
break;
case ORDER_UPDATE:
puts("ORDER UPDATE");
for(int i=0;i<6;i++){ //Global queue
elev_orders[i][0] = message_receive.orders[i][0];
elev_orders[i][1] = message_receive.orders[i][1];
if(my_ID == message_receive.orders[i][1]){
if(i == 0){
if(elevator.queue[0]==0){
elevator.queue[0] = 1;
}
}
else if(i == 1 || i == 3){
if(elevator.queue[1]==0){
elevator.queue[1] = 1;
}
}
else if(i == 2 || i == 4){
if(elevator.queue[2]==0){
elevator.queue[2] = 1;
}
}
else if(i == 5)
if(elevator.queue[3]==0){
elevator.queue[3] = 1;
}
}
}
printf("Elev queue: ");
for(int i = 0;i<N_FLOORS;i++){
printf("%d ",elevator.queue[i]);
}
printf("\n");
break;
case BUTTON_LAMP:
puts("BUTTON LAMP");
elev_set_button_lamp(BUTTON_CALL_UP, 0, message_receive.orders[0][0]);
elev_set_button_lamp(BUTTON_CALL_UP, 1, message_receive.orders[1][0]);
elev_set_button_lamp(BUTTON_CALL_UP, 2, message_receive.orders[2][0]);
elev_set_button_lamp(BUTTON_CALL_DOWN, 1, message_receive.orders[3][0]);
elev_set_button_lamp(BUTTON_CALL_DOWN, 2, message_receive.orders[4][0]);
elev_set_button_lamp(BUTTON_CALL_DOWN, 3, message_receive.orders[5][0]);
break;
case ID_UPDATE:
puts("ID UPDATE");
my_ID = message_receive.ID;
char id_upd[BUFSIZE];
Message message_send_ID;
message_send_ID.ID = my_ID;
serialization(ID_UPDATE, message_send_ID, id_upd);
pthread_t message_send_thread_ID;
pthread_create(&message_send_thread_ID, NULL , tcp_send, (void*)id_upd);
break;
case NETCHECK:
puts("NETCHECK");
master_checkin = 1;
char net_check[BUFSIZE];
Message message_send;
serialization(NETCHECK, message_send, net_check);
pthread_t message_send_thread;
pthread_create(&message_send_thread, NULL , tcp_send, (void*)net_check);
sleep(6);
master_checkin = 0;
sleep(5);
if(master_checkin == 0){
puts("Master disconnected\n");
connection = 0;
}
break;
}
}
int main( int argc, char** argv )
{
::setenv( "PYLON_ROOT", STRINGIZED( BASLER_PYLON_DIR ), 0 );
::setenv( "GENICAM_ROOT_V2_1", STRINGIZED( BASLER_PYLON_GENICAM_DIR ), 0 );
try
{
unsigned int id;
std::string address;
std::string setAttributes;
unsigned int discard;
boost::program_options::options_description description( "options" );
unsigned int packet_size;
unsigned int exposure;
unsigned int gain;
unsigned int offset_x;
unsigned int offset_y;
unsigned int width;
unsigned int height;
std::string frame_trigger;
std::string line_trigger;
unsigned int line_rate;
double timeout_seconds;
description.add_options()
( "help,h", "display help message" )
( "address", boost::program_options::value< std::string >( &address ), "camera ip address; default: connect to the first available camera" )
( "discard", "discard frames, if cannot keep up; same as --buffer=1" )
( "buffer", boost::program_options::value< unsigned int >( &discard )->default_value( 0 ), "maximum buffer size before discarding frames, default: unlimited" )
( "list-cameras", "output camera list and exit" )
( "fields,f", boost::program_options::value< std::string >( &options.fields )->default_value( "t,rows,cols,type" ), "header fields, possible values: t,rows,cols,type,size,counters" )
( "image-type", boost::program_options::value< std::string >( &options.type )->default_value( "3ub" ), "image type, e.g. '3ub'; also see --long-help for details" )
( "offset-x", boost::program_options::value< unsigned int >( &offset_x )->default_value( 0 ), "offset in pixels in the line" )
( "offset-y", boost::program_options::value< unsigned int >( &offset_y )->default_value( 0 ), "offset in lines in the frame" )
( "width", boost::program_options::value< unsigned int >( &width )->default_value( std::numeric_limits< unsigned int >::max() ), "line width in pixels; default: max" )
( "height", boost::program_options::value< unsigned int >( &height )->default_value( std::numeric_limits< unsigned int >::max() ), "number of lines in frame (in chunk mode always 1); default: max" )
( "frame-trigger", boost::program_options::value< std::string >( &frame_trigger ), "'line1', 'line2', 'line3', 'encoder'" ) //; if absent while --line-trigger present, same as --line-trigger" )
( "line-trigger", boost::program_options::value< std::string >( &line_trigger ), "'line1', 'line2', 'line3', 'encoder'" )
( "line-rate", boost::program_options::value< unsigned int >( &line_rate ), "line aquisition rate" )
( "encoder-ticks", boost::program_options::value< unsigned int >( &encoder_ticks ), "number of encoder ticks until the counter resets (reused for line number in frame in chunk mode)" )
( "header-only", "output header only" )
( "no-header", "output image data only" )
( "packet-size", boost::program_options::value< unsigned int >( &packet_size ), "mtu size on camera side, should be not greater than your lan and network interface set to" )
( "exposure", boost::program_options::value< unsigned int >( &exposure )->default_value( 100 ), "exposure" )
( "gain", boost::program_options::value< unsigned int >( &gain )->default_value( 100 ), "gain" )
( "timeout", boost::program_options::value< double >( &timeout_seconds )->default_value( 3.0 ), " frame acquisition timeout" )
( "test-colour", "output colour test image" )
( "verbose,v", "be more verbose" );
boost::program_options::variables_map vm;
boost::program_options::store( boost::program_options::parse_command_line( argc, argv, description), vm );
boost::program_options::parsed_options parsed = boost::program_options::command_line_parser(argc, argv).options( description ).allow_unregistered().run();
boost::program_options::notify( vm );
if ( vm.count( "help" ) || vm.count( "long-help" ) )
{
std::cerr << "acquire images from a basler camera (for now gige only)" << std::endl;
std::cerr << "output to stdout as serialized cv::Mat" << std::endl;
std::cerr << std::endl;
std::cerr << "usage: basler-cat [<options>] [<filters>]" << std::endl;
std::cerr << std::endl;
std::cerr << description << std::endl;
if( vm.count( "long-help" ) )
{
std::cerr << std::endl;
std::cerr << snark::cv_mat::filters::usage() << std::endl;
std::cerr << std::endl;
std::cerr << snark::cv_mat::serialization::options::type_usage() << std::endl;
}
std::cerr << std::endl;
std::cerr << "note: there is a glitch or a subtle feature in basler line camera:" << std::endl;
std::cerr << " - power-cycle camera" << std::endl;
std::cerr << " - view colour images: it works" << std::endl;
std::cerr << " - view grey-scale images: it works" << std::endl;
std::cerr << " - view colour images: it still displays grey-scale" << std::endl;
std::cerr << " even in their native viewer you need to set colour image" << std::endl;
std::cerr << " repeatedly and with pure luck it works, but we have not" << std::endl;
std::cerr << " managed to do it in software; the remedy: power-cycle the camera" << std::endl;
std::cerr << std::endl;
return 1;
}
verbose = vm.count( "verbose" );
if( verbose )
{
std::cerr << "basler-cat: PYLON_ROOT=" << ::getenv( "PYLON_ROOT" ) << std::endl;
std::cerr << "basler-cat: GENICAM_ROOT_V2_1=" << ::getenv( "GENICAM_ROOT_V2_1" ) << std::endl;
std::cerr << "basler-cat: initializing camera..." << std::endl;
}
Pylon::PylonAutoInitTerm auto_init_term;
Pylon::CTlFactory& factory = Pylon::CTlFactory::GetInstance();
Pylon::ITransportLayer* transport_layer( Pylon::CTlFactory::GetInstance().CreateTl( Pylon::CBaslerGigECamera::DeviceClass() ) );
if( !transport_layer )
{
std::cerr << "basler-cat: failed to create transport layer" << std::endl;
std::cerr << " most likely PYLON_ROOT and GENICAM_ROOT_V2_1 environment variables not set" << std::endl;
std::cerr << " point them to your pylon installation, e.g:" << std::endl;
std::cerr << " export PYLON_ROOT=/opt/pylon" << std::endl;
std::cerr << " export GENICAM_ROOT_V2_1=/opt/pylon/genicam" << std::endl;
return 1;
}
if( vm.count( "list-cameras" ) )
{
Pylon::DeviceInfoList_t devices;
factory.EnumerateDevices( devices );
for( unsigned int i = 0; i < devices.size(); ++i ) { std::cerr << devices[i].GetFullName() << std::endl; }
return 0;
}
timeout = timeout_seconds * 1000.0;
std::string filters = comma::join( boost::program_options::collect_unrecognized( parsed.options, boost::program_options::include_positional ), ';' );
options.header_only = vm.count( "header-only" );
options.no_header = vm.count( "no-header" );
csv = comma::csv::options( argc, argv );
bool chunk_mode = csv.has_field( "counters" ) // quick and dirty
|| csv.has_field( "adjusted-t" )
|| csv.has_field( "line" )
|| csv.has_field( "line-count" )
|| csv.has_field( "ticks" )
|| csv.has_field( "counters/adjusted-t" )
|| csv.has_field( "counters/line" )
|| csv.has_field( "counters/line-count" )
|| csv.has_field( "counters/ticks" );
if( chunk_mode )
{
if( vm.count( "encoder-ticks" ) == 0 ) { std::cerr << "basler-cat: chunk mode, please specify --encoder-ticks" << std::endl; return 1; }
if( !filters.empty() ) { std::cerr << "basler-cat: chunk mode, cannot handle filters; use: basler-cat | cv-cat <filters> instead" << std::endl; return 1; }
if( height != 1 && height != std::numeric_limits< unsigned int >::max() ) { std::cerr << "basler-cat: only --height=1 implemented in chunk mode" << std::endl; return 1; }
height = 1;
std::vector< std::string > v = comma::split( csv.fields, ',' );
std::string format;
for( unsigned int i = 0; i < v.size(); ++i )
{
if( v[i] == "t" ) { v[i] = "header/" + v[i]; format += "t"; }
else if( v[i] == "rows" || v[i] == "cols" || v[i] == "size" || v[i] == "type" ) { v[i] = "header/" + v[i]; format += "ui"; }
else if( v[i] == "adjusted-t" ) { v[i] = "counters/" + v[i]; format += "t"; }
else if( v[i] == "line-count" || v[i] == "ticks" ) { v[i] = "counters/" + v[i]; format += "ul"; }
else if( v[i] == "line" ) { v[i] = "counters/" + v[i]; format += "ui"; }
else { std::cerr << "basler-cat: expected field, got '" << v[i] << "'" << std::endl; return 1; }
}
csv.fields = comma::join( v, ',' );
csv.full_xpath = true;
csv.format( format );
}
if( !vm.count( "buffer" ) && vm.count( "discard" ) ) { discard = 1; }
Pylon::CBaslerGigECamera camera;
if( vm.count( "address" ) )
{
Pylon::CBaslerGigEDeviceInfo info;
info.SetIpAddress( address.c_str() );
camera.Attach( factory.CreateDevice( info ) );
}
else
{
Pylon::DeviceInfoList_t devices;
factory.EnumerateDevices( devices );
if( devices.empty() ) { std::cerr << "basler-cat: no camera found" << std::endl; return 1; }
std::cerr << "basler-cat: will connect to the first of " << devices.size() << " found device(s):" << std::endl;
for( unsigned int i = 0; i < devices.size(); ++i ) { std::cerr << " " << devices[i].GetFullName() << std::endl; }
camera.Attach( transport_layer->CreateDevice( devices[0] ) );
}
if( verbose ) { std::cerr << "basler-cat: initialized camera" << std::endl; }
if( verbose ) { std::cerr << "basler-cat: opening camera " << camera.GetDevice()->GetDeviceInfo().GetFullName() << "..." << std::endl; }
camera.Open();
if( verbose ) { std::cerr << "basler-cat: opened camera " << camera.GetDevice()->GetDeviceInfo().GetFullName() << std::endl; }
Pylon::CBaslerGigECamera::StreamGrabber_t grabber( camera.GetStreamGrabber( 0 ) );
grabber.Open();
unsigned int channels;
switch( options.get_header().type ) // quick and dirty
{
case CV_8UC1:
channels = set_pixel_format_( camera, Basler_GigECamera::PixelFormat_Mono8 );
break;
case CV_8UC3:
channels = set_pixel_format_( camera, Basler_GigECamera::PixelFormat_RGB8Packed );
break;
default:
std::cerr << "basler-cat: type \"" << options.type << "\" not implemented or not supported by camera" << std::endl;
return 1;
}
unsigned int max_width = camera.Width.GetMax();
if( offset_x >= max_width ) { std::cerr << "basler-cat: expected --offset-x less than " << max_width << ", got " << offset_x << std::endl; return 1; }
camera.OffsetX.SetValue( offset_x );
width = ( ( unsigned long long )( offset_x ) + width ) < max_width ? width : max_width - offset_x;
camera.Width.SetValue( width );
unsigned int max_height = camera.Height.GetMax();
//if( height < 512 ) { std::cerr << "basler-cat: expected height greater than 512, got " << height << std::endl; return 1; }
// todo: is the colour line 2098 * 3 or ( 2098 / 3 ) * 3 ?
//offset_y *= channels;
//height *= channels;
if( offset_y >= max_height ) { std::cerr << "basler-cat: expected --offset-y less than " << max_height << ", got " << offset_y << std::endl; return 1; }
camera.OffsetY.SetValue( offset_y );
height = ( ( unsigned long long )( offset_y ) + height ) < max_height ? height : ( max_height - offset_y );
camera.Height.SetValue( height );
if( verbose ) { std::cerr << "basler-cat: set width,height to " << width << "," << height << std::endl; }
if( vm.count( "packet-size" ) ) { camera.GevSCPSPacketSize.SetValue( packet_size ); }
// todo: giving up... the commented code throws, but failure to stop acquisition, if active
// seems to lead to the following scenario:
// - power-cycle camera
// - view colour images: it works
// - view grey-scale images: it works
// - view colour images: it still displays grey-scale
//if( verbose ) { std::cerr << "basler-cat: getting aquisition status... (frigging voodoo...)" << std::endl; }
//GenApi::IEnumEntry* acquisition_status = camera.AcquisitionStatusSelector.GetEntry( Basler_GigECamera::AcquisitionStatusSelector_AcquisitionActive );
//if( acquisition_status && GenApi::IsAvailable( acquisition_status ) && camera.AcquisitionStatus() )
//{
// if( verbose ) { std::cerr << "basler-cat: stopping aquisition..." << std::endl; }
// camera.AcquisitionStop.Execute();
// if( verbose ) { std::cerr << "basler-cat: aquisition stopped" << std::endl; }
//}
// todo: a hack for now
GenApi::IEnumEntry* acquisitionStart = camera.TriggerSelector.GetEntry( Basler_GigECamera::TriggerSelector_AcquisitionStart );
if( acquisitionStart && GenApi::IsAvailable( acquisitionStart ) )
{
camera.TriggerSelector.SetValue( Basler_GigECamera::TriggerSelector_AcquisitionStart );
camera.TriggerMode.SetValue( frame_trigger.empty() ? Basler_GigECamera::TriggerMode_Off : Basler_GigECamera::TriggerMode_On );
}
GenApi::IEnumEntry* frameStart = camera.TriggerSelector.GetEntry( Basler_GigECamera::TriggerSelector_FrameStart );
if( frameStart && GenApi::IsAvailable( frameStart ) )
{
//if( frame_trigger.empty() ) { frame_trigger = line_trigger; }
if( frame_trigger.empty() )
{
camera.TriggerSelector.SetValue( Basler_GigECamera::TriggerSelector_FrameStart );
camera.TriggerMode.SetValue( Basler_GigECamera::TriggerMode_Off );
}
else
{
camera.TriggerSelector.SetValue( Basler_GigECamera::TriggerSelector_FrameStart );
camera.TriggerMode.SetValue( Basler_GigECamera::TriggerMode_On );
Basler_GigECamera::TriggerSourceEnums t;
if( frame_trigger == "line1" ) { camera.TriggerSource.SetValue( Basler_GigECamera::TriggerSource_Line1 ); }
if( frame_trigger == "line2" ) { camera.TriggerSource.SetValue( Basler_GigECamera::TriggerSource_Line2 ); }
if( frame_trigger == "line3" ) { camera.TriggerSource.SetValue( Basler_GigECamera::TriggerSource_Line3 ); }
else if( frame_trigger == "encoder" ) { camera.TriggerSource.SetValue( Basler_GigECamera::TriggerSource_ShaftEncoderModuleOut ); }
else { std::cerr << "basler-cat: frame trigger '" << frame_trigger << "' not implemented or invalid" << std::endl; return 1; }
camera.TriggerActivation.SetValue( Basler_GigECamera::TriggerActivation_RisingEdge );
camera.TriggerSelector.SetValue( Basler_GigECamera::TriggerSelector_LineStart );
camera.TriggerMode.SetValue( Basler_GigECamera::TriggerMode_On );
camera.TriggerActivation.SetValue( Basler_GigECamera::TriggerActivation_RisingEdge );
if( frame_trigger == "encoder" )
{
// todo: make configurable
camera.ShaftEncoderModuleLineSelector.SetValue( Basler_GigECamera::ShaftEncoderModuleLineSelector_PhaseA );
camera.ShaftEncoderModuleLineSource.SetValue( Basler_GigECamera::ShaftEncoderModuleLineSource_Line1 );
camera.ShaftEncoderModuleLineSelector.SetValue( Basler_GigECamera::ShaftEncoderModuleLineSelector_PhaseB );
camera.ShaftEncoderModuleLineSource.SetValue( Basler_GigECamera::ShaftEncoderModuleLineSource_Line2 );
camera.ShaftEncoderModuleCounterMode.SetValue( Basler_GigECamera::ShaftEncoderModuleCounterMode_FollowDirection );
camera.ShaftEncoderModuleMode.SetValue( Basler_GigECamera::ShaftEncoderModuleMode_ForwardOnly );
camera.ShaftEncoderModuleCounterMax.SetValue( encoder_ticks - 1 );
/// @todo compensate for mechanical jitter, if needed
/// see Runner_Users_manual.pdf, 8.3, Case 2
camera.ShaftEncoderModuleReverseCounterMax.SetValue( 0 );
camera.ShaftEncoderModuleCounterReset.Execute();
camera.ShaftEncoderModuleReverseCounterReset.Execute();
}
}
}
GenApi::IEnumEntry* lineStart = camera.TriggerSelector.GetEntry( Basler_GigECamera::TriggerSelector_LineStart );
if( lineStart && GenApi::IsAvailable( lineStart ) )
{
if( line_trigger.empty() )
{
camera.TriggerSelector.SetValue( Basler_GigECamera::TriggerSelector_LineStart );
camera.TriggerMode.SetValue( Basler_GigECamera::TriggerMode_Off );
}
else
{
camera.TriggerSelector.SetValue( Basler_GigECamera::TriggerSelector_LineStart );
camera.TriggerMode.SetValue( Basler_GigECamera::TriggerMode_On );
Basler_GigECamera::TriggerSourceEnums t;
if( line_trigger == "line1" ) { camera.TriggerSource.SetValue( Basler_GigECamera::TriggerSource_Line1 ); }
else if( line_trigger == "line2" ) { camera.TriggerSource.SetValue( Basler_GigECamera::TriggerSource_Line2 ); }
else if( line_trigger == "line3" ) { camera.TriggerSource.SetValue( Basler_GigECamera::TriggerSource_Line3 ); }
else if( line_trigger == "encoder" ) { camera.TriggerSource.SetValue( Basler_GigECamera::TriggerSource_ShaftEncoderModuleOut ); }
else { std::cerr << "basler-cat: line trigger '" << line_trigger << "' not implemented or invalid" << std::endl; return 1; }
camera.TriggerActivation.SetValue( Basler_GigECamera::TriggerActivation_RisingEdge );
camera.TriggerSelector.SetValue( Basler_GigECamera::TriggerSelector_LineStart );
camera.TriggerMode.SetValue( Basler_GigECamera::TriggerMode_On );
camera.TriggerActivation.SetValue( Basler_GigECamera::TriggerActivation_RisingEdge );
}
}
if( chunk_mode )
{
std::cerr << "basler-cat: setting chunk mode..." << std::endl;
if( !GenApi::IsWritable( camera.ChunkModeActive ) ) { std::cerr << "basler-cat: camera does not support chunk features" << std::endl; camera.Close(); return 1; }
camera.ChunkModeActive.SetValue( true );
camera.ChunkSelector.SetValue( Basler_GigECameraParams::ChunkSelector_Framecounter );
camera.ChunkEnable.SetValue( true );
camera.ChunkSelector.SetValue( Basler_GigECameraParams::ChunkSelector_Timestamp );
camera.ChunkEnable.SetValue( true );
camera.ChunkSelector.SetValue( Basler_GigECameraParams::ChunkSelector_LineTriggerIgnoredCounter );
camera.ChunkEnable.SetValue( true );
camera.ChunkSelector.SetValue( Basler_GigECameraParams::ChunkSelector_FrameTriggerIgnoredCounter );
camera.ChunkEnable.SetValue( true );
camera.ChunkSelector.SetValue( Basler_GigECameraParams::ChunkSelector_LineTriggerEndToEndCounter );
camera.ChunkEnable.SetValue( true );
camera.ChunkSelector.SetValue( Basler_GigECameraParams::ChunkSelector_FrameTriggerCounter );
camera.ChunkEnable.SetValue( true );
camera.ChunkSelector.SetValue( Basler_GigECameraParams::ChunkSelector_FramesPerTriggerCounter );
camera.ChunkEnable.SetValue( true );
parser = camera.CreateChunkParser();
if( !parser ) { std::cerr << "basler-cat: failed to create chunk parser" << std::endl; camera.Close(); return 1; }
std::cerr << "basler-cat: set chunk mode" << std::endl;
}
camera.ExposureMode.SetValue( Basler_GigECamera::ExposureMode_Timed );
if( vm.count( "exposure" ) ) { camera.ExposureTimeRaw.SetValue( exposure ); } // todo? auto exposure (see ExposureAutoEnums)
if( vm.count( "gain" ) )
{
camera.GainSelector.SetValue( Basler_GigECamera::GainSelector_All );
camera.GainRaw.SetValue( gain );
if( channels == 3 ) // todo: make configurable; also is not setting all not enough?
{
camera.GainSelector.SetValue( Basler_GigECamera::GainSelector_Red );
camera.GainRaw.SetValue( gain );
camera.GainSelector.SetValue( Basler_GigECamera::GainSelector_Green );
camera.GainRaw.SetValue( gain );
camera.GainSelector.SetValue( Basler_GigECamera::GainSelector_Blue );
camera.GainRaw.SetValue( gain );
}
}
if( vm.count( "line-rate" ) ) { camera.AcquisitionLineRateAbs.SetValue( line_rate ); }
if( vm.count( "test-colour" ) ) { camera.TestImageSelector.SetValue( Basler_GigECamera::TestImageSelector_Testimage6 ); }
else { camera.TestImageSelector.SetValue( Basler_GigECamera::TestImageSelector_Off ); }
unsigned int payload_size = camera.PayloadSize.GetValue();
if( verbose )
{
std::cerr << "basler-cat: camera mtu size: " << camera.GevSCPSPacketSize.GetValue() << std::endl;
std::cerr << "basler-cat: exposure: " << camera.ExposureTimeRaw.GetValue() << std::endl;
std::cerr << "basler-cat: payload size: " << payload_size << std::endl;
}
std::vector< std::vector< char > > buffers( 2 ); // todo? make number of buffers configurable
for( std::size_t i = 0; i < buffers.size(); ++i ) { buffers[i].resize( payload_size ); }
grabber.MaxBufferSize.SetValue( buffers[0].size() );
grabber.SocketBufferSize.SetValue( 127 );
if( verbose )
{
std::cerr << "basler-cat: socket buffer size: " << grabber.SocketBufferSize.GetValue() << std::endl;
std::cerr << "basler-cat: max buffer size: " << grabber.MaxBufferSize.GetValue() << std::endl;
}
grabber.MaxNumBuffer.SetValue( buffers.size() ); // todo: use --buffer value for number of buffered images
grabber.PrepareGrab(); // image size now must not be changed until FinishGrab() is called.
std::vector< Pylon::StreamBufferHandle > buffer_handles( buffers.size() );
for( std::size_t i = 0; i < buffers.size(); ++i )
{
buffer_handles[i] = grabber.RegisterBuffer( &buffers[i][0], buffers[i].size() );
grabber.QueueBuffer( buffer_handles[i], NULL );
}
if( chunk_mode )
{
snark::tbb::bursty_reader< ChunkPair > read( boost::bind( &capture_< ChunkPair >, boost::ref( camera ), boost::ref( grabber ) ), discard );
tbb::filter_t< ChunkPair, void > write( tbb::filter::serial_in_order, boost::bind( &write_, _1 ) );
snark::tbb::bursty_pipeline< ChunkPair > pipeline;
camera.AcquisitionMode.SetValue( Basler_GigECamera::AcquisitionMode_Continuous );
camera.AcquisitionStart.Execute(); // continuous acquisition mode
if( verbose ) { std::cerr << "basler-cat: running in chunk mode..." << std::endl; }
pipeline.run( read, write );
if( verbose ) { std::cerr << "basler-cat: shutting down..." << std::endl; }
camera.AcquisitionStop();
camera.DestroyChunkParser( parser );
}
else
{
snark::cv_mat::serialization serialization( options );
snark::tbb::bursty_reader< Pair > reader( boost::bind( &capture_< Pair >, boost::ref( camera ), boost::ref( grabber ) ), discard );
snark::imaging::applications::pipeline pipeline( serialization, filters, reader );
camera.AcquisitionMode.SetValue( Basler_GigECamera::AcquisitionMode_Continuous );
camera.AcquisitionStart.Execute(); // continuous acquisition mode
if( verbose ) { std::cerr << "basler-cat: running..." << std::endl; }
pipeline.run();
if( verbose ) { std::cerr << "basler-cat: shutting down..." << std::endl; }
camera.AcquisitionStop();
}
if( verbose ) { std::cerr << "basler-cat: acquisition stopped" << std::endl; }
is_shutdown = true;
while( !done ) { boost::thread::sleep( boost::posix_time::microsec_clock::universal_time() + boost::posix_time::milliseconds( 100 ) ); }
grabber.FinishGrab();
Pylon::GrabResult result;
while( grabber.RetrieveResult( result ) ); // get all buffers back
for( std::size_t i = 0; i < buffers.size(); ++i ) { grabber.DeregisterBuffer( buffer_handles[i] ); }
grabber.Close();
camera.Close();
if( verbose ) { std::cerr << "basler-cat: done" << std::endl; }
return 0;
}
catch( std::exception& ex ) { std::cerr << "basler-cat: " << ex.what() << std::endl; }
catch( ... ) { std::cerr << "basler-cat: unknown exception" << std::endl; }
return 1;
}
void CotMapCtrl::LoadGWF(LPCTSTR filename)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
//打开工程文件
CFile file;
if(!file.Open(filename,CFile::modeRead))
{
return;
}
//关闭之前的map
if(m_pGeomap)
{
m_pGeomap.reset();
}
CString PrjPath =filename;
CString basePath =PrjPath.Left(PrjPath.ReverseFind(_T('\\'))+1);
_bstr_t strPath =basePath;
//设置参考路径
SYSTEM::CRelativePath::SetBasePath(strPath);
CArchive ar(&file,CArchive::load);
unsigned long Size;
ar >> Size;
BYTE * pStart = new BYTE[Size];
ar.Read( pStart , Size );
SYSTEM::CBinArchive bin( pStart , Size );
bin.SetReadState();
serialization(bin,SERIEALIZE_MAP);
ar.Close ();
file.Close ();
//读取图元
CString strELFPath = filename;
int iResult = strELFPath.Replace( _T("GWF"), _T("ELF"));
if ( iResult == 1 && _waccess( strELFPath, 0) == 0 )
{
CFile fileElF(strELFPath,CFile::modeRead);
CArchive arELF(&fileElF,CArchive::load);
arELF >> Size;
BYTE * pbuffer = new BYTE[Size];
arELF.Read( pbuffer , Size );
SYSTEM::CBinArchive ebin( pbuffer , Size );
ebin.SetReadState();
serialization(ebin,SERIEALIZE_MAPELEMENT);
arELF.Close ();
fileElF.Close ();
}
void *master_connection_handler(void *socket_desc){
int client_id = clients-1;
int sock = *(int*)socket_desc;
int read_size;
char client_message[BUFSIZE], *message;
sleep(1);
client_message[0] = (clients-1)+'0';
write(sock , client_message , strlen(client_message)); //Give client ID
bzero(client_message,BUFSIZE);
//Set up timed socket
struct timeval tv;
tv.tv_sec = 11;
tv.tv_usec = 0;
setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO,(char *)&tv,sizeof(tv));
while( (read_size = recv(sock , client_message , BUFSIZE , 0)) > 0 ){
Message message_send,message_receive;
message_receive = deserialization(client_message);
switch(message_receive.type){
case BUTTON_CHECK:
if(add_to_queue(message_receive.button.type, message_receive.button.floor)){
char server_message[BUFSIZE];
for(int i = 0;i<6;i++){
message_send.orders[i][0] = queue[i][0];
message_send.orders[i][1] = queue[i][1];
}
message_send.ID = cost_function(message_receive.button.type, message_receive.button.floor);
message_send.elevator.new_floor_order=message_receive.button.floor;
pthread_t order_counter_thread;
char order_and_ID[2];
order_and_ID[1] = message_send.ID;
//Starts counter on each order
if(message_receive.button.type==BUTTON_CALL_UP){
queue[message_receive.button.floor][1] = message_send.ID;
queue[message_receive.button.floor][0] = 1;
message_send.orders[message_receive.button.floor][1] = message_send.ID;
order_and_ID[0] = message_receive.button.floor;
pthread_create(&order_counter_thread, NULL, order_counter, (void*)order_and_ID);
}
else{
queue[message_receive.button.floor+2][1] = message_send.ID;
queue[message_receive.button.floor+2][0] = 1;
message_send.orders[message_receive.button.floor+2][1] = message_send.ID;
order_and_ID[0] = message_receive.button.floor+2;
pthread_create(&order_counter_thread, NULL, order_counter, (void*)order_and_ID);
}
serialization(ELEV_ORDER, message_send, server_message);
for(int i = 0;i<clients;i++){
write(client_sockets[i], server_message, strlen(server_message));
}
}
break;
case ELEV_UPDATE: //Updates elevator location
elev_client[client_id].floor_current = message_receive.elevator.floor_current;
elev_client[client_id].direction = message_receive.elevator.direction;
break;
case ORDER_UPDATE: //Clears orders that are done and sets lamps
elev_client[client_id].floor_current = message_receive.elevator.floor_current;
elev_client[client_id].direction = message_receive.elevator.direction;
for(int i = 0;i<6;i++){
queue[i][0] &= message_receive.orders[i][0];
if(!(queue[i][0]&&message_receive.orders[i][0]))
queue[i][1] = -1;
}
puts("\nNew queue");
for(int i = 0;i<6;i++){
printf("Order: %d \t ID: %d\n",queue[i][0],queue[i][1]);
}
message_send.ID = -1;
for(int i = 0;i<6;i++){
message_send.orders[i][0] = queue[i][0];
message_send.orders[i][1] = queue[i][1];
}
char server_message[BUFSIZE];
serialization(ELEV_ORDER, message_send, server_message);
for(int i = 0;i<clients;i++){
write(client_sockets[i], server_message, strlen(server_message));
}
break;
case NETCHECK:
break;
case ID_UPDATE:
client_id = message_receive.ID;
break;
}
bzero(client_message,BUFSIZE);
}
if(read_size == 0){
puts("Client disconnected, terminal exit");
clients--;
fflush(stdout);
printf("#Clients: %d\n",clients);
if(client_id == 0){
system("gnome-terminal -x ./elevator 0");
}
else{
if((clients+1)==2 && client_id == 1){//Client 1 disconnected, client 2 will now be client 1
elev_client[1].floor_current = elev_client[2].floor_current;
Message message_send;
message_send.type = ID_UPDATE;
message_send.ID = client_id;
client_sockets[1] = client_sockets[2];
char server_message[BUFSIZE];
serialization(ID_UPDATE, message_send, server_message);
write(client_sockets[1], server_message, strlen(server_message));
}
}
sleep(1);
reallocate_orders(clients);
Message message_send;
char server_message[BUFSIZE];
for(int i = 0;i<6;i++){
message_send.orders[i][0] = queue[i][0];
message_send.orders[i][1] = queue[i][1];
}
serialization(ORDER_UPDATE, message_send, server_message);
for(int i = 0;i<clients;i++){
write(client_sockets[i], server_message, strlen(server_message));
}
}
else if(read_size == -1){
clients--;
perror("Network connection lost");
printf("Client id: %d", client_id);
printf("#Clients: %d\n",clients);
if((clients+1)==2 && client_id == 1){//Client 1 disconnected, client 2 will now be client 1
elev_client[1].floor_current = elev_client[2].floor_current;
Message message_send;
message_send.type = ID_UPDATE;
message_send.ID = client_id;
client_sockets[1] = client_sockets[2];
char server_message[BUFSIZE];
serialization(ID_UPDATE, message_send, server_message);
write(client_sockets[1], server_message, strlen(server_message));
}
sleep(1);
reallocate_orders(clients);
Message message_send;
char server_message[BUFSIZE];
for(int i = 0;i<6;i++){
message_send.orders[i][0] = queue[i][0];
message_send.orders[i][1] = queue[i][1];
}
serialization(ORDER_UPDATE, message_send, server_message);
for(int i = 0;i<clients;i++){
write(client_sockets[i], server_message, strlen(server_message));
}
}
//Free the socket pointer
free(socket_desc);
return 0;
}
int main(int argc, char * argv[])
{
if (argc != 2) {
std::cerr << "Usage: " << argv[0] << " GlobalManagerIP" << std::endl;
exit(-1);
}
//*
// before we start, estimate overhead related to serialization and de-serialization of parameters
osaTimeServer timeServer;
std::stringstream serializationStream;
cmnSerializer serialization(serializationStream);
cmnDeSerializer deSerialization(serializationStream);
unsigned int index;
prmPositionCartesianGet parameter;
cmnGenericObject * generated;
timeServer.SetTimeOrigin();
for (index = 0; index < confNumberOfSamples; index++) {
serialization.Serialize(parameter);
generated = deSerialization.DeSerialize();
if (generated->Services() != parameter.Services()) {
std::cout << "Serialization test failed!" << std::endl;
exit(0);
}
// delete generated object created by de-serialization
delete generated;
}
double elapsedTime = timeServer.GetRelativeTime();
std::cout << std::endl << std::endl
<< "Serialization, dynamic creation and deserialization time for "
<< confNumberOfSamples << " samples of " << parameter.Services()->GetName()
<< ": " << cmnInternalTo_ms(elapsedTime) << " (ms)" << std::endl
<< "Per sample: " << cmnInternalTo_ms(elapsedTime / confNumberOfSamples) << " (ms)" << std::endl
<< std::endl << std::endl;
//*/
// networking part
std::string globalTaskManagerIP(argv[1]);
// Log configuration
cmnLogger::SetMask(CMN_LOG_ALLOW_ERRORS_AND_WARNINGS);
cmnLogger::SetMaskFunction(CMN_LOG_ALLOW_ERRORS_AND_WARNINGS);
// create our server task
clientTask * client = new clientTask("Client", confClientPeriod);
// Get the TaskManager instance and set operation mode
mtsTaskManager * taskManager = mtsTaskManager::GetInstance();
taskManager->AddComponent(client);
// Connect the tasks across networks
taskManager->Connect("Client", "Required", "Server", "Provided");
// create the tasks, i.e. find the commands
taskManager->CreateAll();
// start the periodic Run
taskManager->StartAll();
// run while the benchmarks are not over
while (!(client->IsBenchmarkCompleted())) {
osaSleep(10.0 * cmn_ms);
}
// cleanup
taskManager->Cleanup();
taskManager->KillAll();
// To prevent crash due to CMN_LOG_CLASS (cmnLODOutputMultiplexer).
osaSleep(0.5 * cmn_s);
return 0;
}
