/ - Diff - Colony - Robotics Club

     #include "logger.h"
     #include "robot.h"
     #include <stdio.h>
     int setLogFile(char *name)
+    {
     	file = fopen(name, "a+");
     	if(file == 0)
     		return -1;
     	return 0;
+    }
     void commit(Robot* robot, int index, int timeStep)
+    {
     	if(!file)
+    	{
     		return;
+    	}
     	if(fwrite(&timeStep, sizeof(int), 1, file) < 1)
+    	{
     		printf("Logging Error\n");
     		return;
+    	}
     	if(fwrite(&index, sizeof(int), 1, file) < 1)
+    	{
     		printf("Logging Error\n");
     		return;
+    	}
     	if(fwrite(robot, sizeof(Robot), 1, file) < 1)
+    	{
     		printf("Logging Error\n");
     		return;
+    	}
+    }
     int getStep()
+    {
     	int toReturn;
     	if(!file)
+    	{
     		return 0;
+    	}
     	if(fread(&toReturn, sizeof(int), 1, file) < 1)
+    	{
     		printf("Logging Error\n");
     		return -1;
+    	}
     	return toReturn;
+    }
     int getLog(Robot* robot)
+    {
     	if(!file)
+    	{
     		return 0;
+    	}
     	if(fread(robot, sizeof(Robot), 1, file) < 1)
+    	{
     		printf("Logging Error\n");
     		return -1;
+    	}
     	return 0;
+    }

branches/simulator/projects/simulator/simulator/core/player.h
	1	#ifndef PLAYER_H
	2	#define PLAYER_H
	3
	4	int playLog(int argc, char ** argv);
	5
	6	#endif

     #include <gtk/gtk.h>
     #include <glib.h>
     #include <signal.h>
     #include <unistd.h>
     #include "gtk_gui.h"
     #include "robot.h"
     #include "world.h"
     #include "logger.h"
     #include "player.h"
     extern char *optarg;
     extern int optind, optopt;
     int main(int argc, char** argv)
+    {
     	if (robots_initialize())
     		return -1;
     	if(argc<=1){
     	if(argc - optind < 0){
     		printf("Usage: simulator <robot execetuable>\n");
     		exit(-1);
+    	}
     	int c;
         char worldLoadedFlag = 0;
     	while((c = getopt(argc, argv, ":l:p:w:")) != -1)
+    	{
     		switch(c)
+    		{
     			case 'l':
     				setLogFile(optarg);
     				break;
     			case 'p':
     				setLogFile(optarg);
     				playLog(argc, argv);
     				return 0;
     				break;
     			case 'w':
     				load_world(optarg, 100);
     				worldLoadedFlag = 1;
     				break;
     			case ':':
     				fprintf(stderr, "Argument requires file name\n");
     				break;
     			case '?':
     				fprintf(stderr, "Unknown argument\n");
     				break;
+    		}
+    	}
     	load_world("../test/world.txt", 100);
     	if(!worldLoadedFlag)
     		load_world("../test/world.txt", 100);
     	robot_create(argv[1]);
     	robot_create(argv[1]);
     	robot_create(argv[1]);
     	robot_create(argv[1]);
     	robot_create(argv[1]);
     	robot_create(argv[1]);
     	robot_create(argv[1]);
     	robot_create(argv[1]);
     	robot_create(argv[1]);
     	robot_create(argv[1]);
     	robot_create(argv[1]);
     	robot_create(argv[1]);
     	robot_create(argv[1]);
     	robot_create(argv[1]);
     	robot_create(argv[1]);
     	robot_create(argv[1]);
     	robot_create(argv[1]);
     	robot_create(argv[1]);
     	robot_create(argv[1]);
     	robot_create(argv[1]);
     	robot_create(argv[optind]);
     	robot_create(argv[optind]);
     	robot_create(argv[optind]);
     	robot_create(argv[optind]);
     	robot_create(argv[optind]);
     	robot_create(argv[optind]);
     	robot_create(argv[optind]);
     	robot_create(argv[optind]);
     	robot_create(argv[optind]);
     	robot_create(argv[optind]);
     	robot_create(argv[optind]);
     	robot_create(argv[optind]);
     	robot_create(argv[optind]);
     	robot_create(argv[optind]);
     	robot_create(argv[optind]);
     	robot_create(argv[optind]);
     	robot_create(argv[optind]);
     	robot_create(argv[optind]);
     	robot_create(argv[optind]);
     	robot_create(argv[optind]);
     	sigset_t set;

     #ifndef LOGGER_H
     #define LOGGER_H
     #include "robot.h"
     #include <stdio.h>
     #define CREATE_STEP -2
     FILE* file;
     int setLogFile( char *name);
     void commit(Robot* robot,int index, int timeStep);
     int getStep();
     int getLog(Robot* robot);
     #endif

     #include <errno.h>
     #include <pthread.h>
     #include <err.h>
     #include <unistd.h>
     #include "gtk_gui.h"
-...
     #include "motion.h"
     #include "rangefinders.h"
     #include "world.h"
     #include "logger.h"
     #include "gtk_gui.h"
     void sig_chld_handler(int sig);
     void robot_update(int i);
-...
     int robots_size = 0;
     int num_robots = 0;
     int iterator_pos = 0;
     int iterator_pos = 0;
     int timeStep = 0;
     // signalled when all robots have run for a bit
     pthread_mutex_t all_finished_mutex;
     pthread_cond_t all_finished_cond;
-...
      **/
     int robot_create(char *execname)
+    {
       int pid,i;
       	int pid,i;
     	int id = first_available_id;
     	Robot* r = &robots[id];
     	// do shared memory stuff here
-...
     	r->shared->motor2 = 0;
     	r->id = id;
     	if((pid = fork()) < 0)
     	if(execname != NULL)
+    	{
     		//Free Shared Memory Region
     		if (!shmdt(r->shared))
     			fprintf(stderr, "Failed to free shared memory.\n");
     		if (!shmctl(r->sharedMemID, IPC_RMID, NULL))
     			fprintf(stderr, "Failed to free shared memory.\n");
     		if((pid = fork()) < 0)
+    		{
     			//Free Shared Memory Region
     			if (!shmdt(r->shared))
     				fprintf(stderr, "Failed to free shared memory.\n");
     			if (!shmctl(r->sharedMemID, IPC_RMID, NULL))
     				fprintf(stderr, "Failed to free shared memory.\n");
     		r->id = -1;
     		fprintf(stderr, "Failed to fork robot process.\n");
     		return -1;
     			r->id = -1;
     			fprintf(stderr, "Failed to fork robot process.\n");
     			return -1;
+    		}
+    	}
     	if(!pid)
     	if(!pid && execname)
+    	{
     	  char var[21];
     	  /* restore default sigchld handler */
-...
     			  robots[i].id = -1;
+    		}
+    	}
     	//Log creation
     	if(execname != NULL)
+    	{
     		//printf("commiting %d\n", num_robots);
     		commit(r, num_robots, CREATE_STEP);
+    	}
     	num_robots++;
     	num_robots++;
     	return id;
+    }
-...
     	if (id < first_available_id)
     		first_available_id = 0;
     	return 0;
+    }
     void robot_destroy_all()
+    {
     	int i;
     	for(i = 0; i < num_robots; i++)
     		robot_destroy(i);
+    }
     void robot_iterator_reset(void)
+    {
-...
     		if(ret)
     		  fprintf(stderr, "hmmm, error unlocking. errno: %d", errno);
     		timeStep++;
     		for (i = 0; i < robots_size; i++)
     			if (robots[i].id != -1)
+    			{
     				robot_update(i);
     				printf("commit %d\n", i);
     				commit(&robots[i],i,timeStep);
+    			}
     		for (i = 0; i < robots_size; i++)
+    		{
     			if (robots[i].id == -1)
-...
+    	}
+    }
     void* logger_step_loop(void* arg)
+    {
     	printf("going into logger\n");
     	int timeStep;
     	int index;
     	int prevStep = -1;
     	if(fread(&timeStep, sizeof(int), 1, file) < 1)
+    	{
     		robot_destroy_all();
     		fprintf(stderr, "problem reading timestep\n");
     	    return (void*)-1;
+    	}
     	 while(1){
     		prevStep = timeStep;
     		do
+    	   	{
     			if(fread(&index, sizeof(int), 1, file) < 1)
+    			{
     				robot_destroy_all();
     			 	return (void*) -1;
+    			}
                 //Update the robot
     			if(timeStep == CREATE_STEP)
+    			{
     			    robot_create(NULL);
+    			}
     			if(getLog(&robots[index]) < 0)
+    			{
     				robot_destroy_all();
     				 return (void*) -1;
+    			}
     			//Read in next logfile and check number
     		   	if(fread(&timeStep, sizeof(int), 1, file) < 1)
+    			{
     				robot_destroy_all();
     				return (void*)-1;
+    			}
                	if (prevStep < 0)
     			   	prevStep = timeStep;
     	   	}while(timeStep == prevStep || timeStep == CREATE_STEP);
     		gui_refresh();
     		usleep(100);
+    	}
+    }
     void robot_update(int i)
+    {
     	Robot* r = &(robots[i]);

branches/simulator/projects/simulator/simulator/core/robot.h
39	39	Robot* robot_iterator_next(void);
40	40
41	41	void* robot_event_loop(void* arg);
	42	void* logger_step_loop(void* arg);
42	43
43	44	#endif
44	45

     #include <stdlib.h>
     #include <stdio.h>
     #include <gtk/gtk.h>
     #include <glib.h>
     #include "gtk_gui.h"
     #include "robot.h"
     #include "world.h"
     #include "logger.h"
     int playLog(int argc, char** argv)
+    {
     	load_world("../test/world.txt", 100);
     	g_thread_init(NULL);
     	gdk_threads_init();
     	printf("g thread create\n");
     	g_thread_create(logger_step_loop, NULL, TRUE, NULL);
     	printf("run\n");
     	gtk_gui_run(argc, argv);
     	return 0;
+    }

     # Add new files here
     COMMON_SRCS :=
     CORE_SRCS := main.c robot.c motion.c world.c rangefinders.c
     CORE_SRCS := main.c robot.c motion.c world.c logger.c player.c rangefinders.c
     GUI_SRCS := gtk_gui.c gtk_environment_view.c
     CORE_DIR := core

Project

General

Profile

Colony

Revision 1068