/ - Diff - Colony - Robotics Club

     #include "gtk_gui.h"
     /**
      * @file main.c
      * @author Colony Project
      * @brief Initializes the program.
+     *
      * Contains only the main function, which
      * initializes the program.
      **/
     #include <stdlib.h>
     #include <stdio.h>
     #include <unistd.h>
     #include <stdlib.h>
     #include <signal.h>
     #include <sys/wait.h>
     #include <robot_shared.h>
     #include <sys/ipc.h>
     #include <sys/types.h>
     #include <sys/shm.h>
     #include <errno.h>
     int create_robot(char *execname, int id, SimulatorRobot* sim_memory)
+    {
       /* do shared memory stuff here */
       // key_t key = IPC_PRIVATE;
       /*Memory accessible only to children and gives them read/write priveledge*/
       //  sim_memory->robotSharedMemoryID = shmget(key, sizeof(RobotShared), IPC_CREAT | 0666);
       /*  if(sim_memory->robotSharedMemoryID < 0)
+      {
     	  printf("error getting shared memory\n");
     	  return -1;
+      }
     #include "gtk_gui.h"
     #include "robot.h"
       sim_memory->robotState = shmat(sim_memory->robotSharedMemoryID, NULL, 0);
       if(!(sim_memory->robotState))
+      {
     	printf("error attaching parent process\n");
     	return -1;
+      }
       */
       /*Init robot structure here*/
       /*  sim_memory->robotState->motor1 = 0;
           sim_memory->robotState->motor2 = 0;*/
       int pid;
       if((pid = fork())<0){
         printf("error with fork!\n");
         return -1;
+      }
       char var[21];
       char *envp[] = {var, NULL};
       if(!pid){
         /* restore default sigchld handler */
         signal(SIGCHLD, SIG_DFL);
         sprintf(var, "memory_id=%d", 1);//sim_memory->robotSharedMemoryID);
         execve(execname, NULL, envp);  //TODO: keep the other env. stuff around
         printf ("error! exec failed\n");
         exit(-1);
+      }
       return pid;
+    }
     int free_robot(SimulatorRobot sim)
     int main(int argc, char** argv)
+    {
       return 0;/*
      	shmdt(sim.robotState);
     	return shmctl(sim.robotSharedMemoryID, IPC_RMID, NULL); */
+    }
     	if (robots_initialize())
     		return -1;
     void *sig_chld_handler(int sig)
+    {
       pid_t pid;
       int cstat;
     	if(argc<=1){
     		printf("Usage: simulator <robot execetuable>\n");
     		exit(-1);
+    	}
     	robot_create(argv[1]);
       printf("SIGCHLD: parent waiting\n");
     	printf("returned to parent\n");
       pid = waitpid(0, &cstat, WUNTRACED);
     	gtk_gui_run(argc, argv);
       printf("got %d from %d\n", cstat, pid);
       kill(pid, SIGCONT);
       return NULL;
     	return 0;
+    }
     int main(int argc, char** argv)
+    {
       signal(SIGCHLD, sig_chld_handler);
       //SimulatorRobot sim;
       if(argc<=1){
         printf("Usage: simulator <robot execetuable>\n");
         exit(-1);
+      }
       create_robot(argv[1], 0, NULL/*&sim*/);
       printf("returned to parent\n");
       int x;
       /*  for(x = 0; x <10000; x++)
           printf("motor 1: %d\n", x);*/
       gtk_gui_run(argc, argv);
       printf("parent exiting.\n");
       return 0;
+    }

     /**
      * @file robot.c
      * @author Colony Project
      * @brief Simulator Robot Management
+     *
      * Contains implementations of functions managing robots
      * in the simulator, including process control and memory
      * management.
      **/
     #include <stdlib.h>
     #include <stdio.h>
     #include <string.h>
     #include <unistd.h>
     #include <signal.h>
     #include <sys/wait.h>
     #include <robot_shared.h>
     #include <sys/ipc.h>
     #include <sys/types.h>
     #include <sys/shm.h>
     #include <errno.h>
     #include "robot.h"
     void sig_chld_handler(int sig);
     // global variables
     int first_available_id = 0;
     // an expanding array of robots
     Robot* robots = NULL;
     int robots_size = 0;
     int robots_initialize(void)
+    {
     	if (signal(SIGCHLD, sig_chld_handler) == SIG_ERR)
     		return -1;
     	robots_size = 10;
     	robots = (Robot*)malloc(sizeof(Robot) * robots_size);
     	if (!robots)
     		return -1;
     	memset(robots, 0, sizeof(Robot) * robots_size);
     	return 0;
+    }
     /**
      * Creates a new robot. Returns its id on
      * success, or a negative integer on failure.
      **/
     int robot_create(char *execname)
+    {
     	int pid;
     	int id = first_available_id;
     	Robot* r = &robots[id];
     	// do shared memory stuff here
     	key_t key = IPC_PRIVATE;
     	//Memory accessible only to children with r/w privileges
     	r->sharedMemID = shmget(key, sizeof(RobotShared), IPC_CREAT | 0666);
     	if(r->sharedMemID < 0)
+    	{
     		fprintf(stderr, "Failed to get shared memory.\n");
     		return -1;
+    	}
     	r->shared = (RobotShared*)shmat(r->sharedMemID, NULL, 0);
     	if(!(r->shared))
+    	{
     		// TODO: do we have to free the shared memory?
     		fprintf(stderr, "Error attaching memory to parent.\n");
     		return -1;
+    	}
     	// Initialize robot structure here
     	r->shared->motor1 = 0;
     	r->shared->motor2 = 0;
     	r->id = id;
     	if((pid = fork()) < 0)
+    	{
     		// TODO: do we have to free the shared memory?
     		r->id = 0;
     		fprintf(stderr, "Failed to fork robot process.\n");
     		return -1;
+    	}
     	if(!pid)
+    	{
     		char var[21];
     		char *envp[] = {var, NULL};
     		/* restore default sigchld handler */
     		signal(SIGCHLD, SIG_DFL);
     		sprintf(var, "memory_id=%d", r->sharedMemID);
     		//TODO: keep the other env. stuff around
     		execve(execname, NULL, envp);
     		fprintf(stderr, "exec failed to run child process.\n");
     		exit(-1);
+    	}
     	else
+    	{
     		r->pid = pid;
     		do {
     			first_available_id++;
     		} while (first_available_id < robots_size &&
     				robots[first_available_id].id != 0);
     		// resize the array if necessary
     		if (first_available_id >= robots_size)
+    		{
     			robots_size *= 2;
     			robots = realloc(robots, sizeof(Robot) * robots_size);
     			if (!robots)
+    			{
     				fprintf(stderr, "Out of memory.\n");
     				return -1;
+    			}
+    		}
+    	}
     	return id;
+    }
     /**
      * Frees all resources associated with a robot, including
      * killing its process if necessary.
+     *
      * @return zero on success, nonzero on failure
      **/
     int robot_destroy(int id)
+    {
     	Robot* r;
     	if (id < 0 || id >= robots_size)
     		return -1;
     	r = &robots[id];
     	if (r->id == 0)
     		return -1;
     	if (!shmdt(r->shared))
+    	{
     		fprintf(stderr, "Failed to free shared memory.\n");
     		return -1;
+    	}
     	if (!shmctl(r->sharedMemID, IPC_RMID, NULL))
+    	{
     		fprintf(stderr, "Failed to free shared memory.\n");
     		return -1;
+    	}
     	memset(r, 0, sizeof(Robot));
     	if (id < first_available_id)
     		first_available_id = 0;
     	return 0;
+    }
     void sig_chld_handler(int sig)
+    {
     	pid_t pid;
     	int cstat;
     	printf("SIGCHLD: parent waiting\n");
     	pid = waitpid(0, &cstat, WUNTRACED);
     	printf("got %d from %d\n", cstat, pid);
     	kill(pid, SIGCONT);
+    }

     /**
      * @file robot.h
      * @author Colony Project
+     *
      * @brief Manages simulated robots.
+     *
      * Contains structures and function prototypes used
      * for managing robots in the simulator.
      **/
     #ifndef __ROBOT_H__
     #define __ROBOT_H__
     #include "robot_shared.h"
     typedef struct PoseType
+    {
     	int x,y; /* position of robot in environment */
     	int theta; /* orientation of robot in environment */
     } Pose;
     typedef struct RobotType
+    {
     	// the id is 0 if the robot hasn't been created
     	int id;
     	int pid;
     	int sharedMemID; /* id for shared memory object */
     	Pose pose; /* position in environment */
     	RobotShared* shared;
     	/* add other sensors, etc here */
     } Robot;
     int robots_initialize(void);
     int robot_create(char *execname);
     int robot_destroy(int id);
     #endif

branches/simulator/projects/simulator/simulator/Makefile
1	1	# Add new files here
2	2	COMMON_SRCS :=
3		CORE_SRCS := main.c
	3	CORE_SRCS := main.c robot.c
4	4	GUI_SRCS := gtk_gui.c gtk_environment_view.c draw_funcs.c
5	5
6	6	CORE_DIR := core

     /* shared structs for simulator */
     /**
      * @file robot_shared.h
      * @author Colony Project
+     *
      * @brief Shared simulator structures.
+     *
      * This file is for structures that are used by
      * both the simulator and the simulator library which
      * is linked to by robot programs.
      **/
     #ifndef __ROBOT_SHARED_H
     #define __ROBOT_SHARED_H
     typedef struct PositionType
+    {
       int x,y; /* position of robot in environment */
       int theta; /* orientation of robot in environment */
     } Position;
     /* rangefinders are 1-5, so write convert function for this */
     typedef struct RangeFinderType
+    {
       short d[5];
     	short d[5];
     } RangeFinder;
     /* this is what is in the robot shared memory */
-...
+    {
     	short motor1; /* motor1 value */
     	short motor2; /* motor2 value */
       RangeFinder ranges; /* rangefinders */
       /* add other sensors, etc here */
     	RangeFinder ranges; /* rangefinders */
     	/* add other sensors, etc here */
     } RobotShared;
     #endif
     typedef struct SimulatorRobotType
+    {
       int robotSharedMemoryID; /* id for shared memory object */
       RobotShared* robotState;/*Pointer to shared state*/
       Position pos; /* position in environment */
     	short motor1; /* motor1 value */
     	short motor2; /* motor2 value */
       RangeFinder ranges; /* rangefinders */
       /* add other sensors, etc here */
     } SimulatorRobot;
     #endif

Project

General

Profile

Colony

Revision 988