int main (int argc, char **argv){
char *host = HOSTIP;
int port = DEFAULTPORT;
if (argc >= 2) { host = argv[1]; }
if (argc >= 3) { port = atoi(argv[2]); }
init_vision(host, port);
//init_facedetect();
while(1){
//proc_vision();
proc_jpg_vision();
//detect_and_draw();
/**** 処理結果(euslispのクライアントが受け取る情報)
を取得して標準エラーに出力 ****/
char result[8024];
int n;
write(client_sock, "result\n", 64);
n = recv(client_sock, result, 8024, 0);
result[n] = '\0';
fprintf(stderr, "result is %s", result);
/**** 処理結果を取得(ここまで) ****/
//if( (cvWaitKey(30) & 255) == 27 ) {
//break;
//}
}
return 0;
}
void robot_class::TestInit() {
std::printf("test init\n");
stop_vision();
driveTrain->SetSafetyEnabled(false);
driveTrain->TankDrive(0.0f,0.0f);
LEDring.Set(Relay::kForward);
init_vision();
std::printf("good\n");
std::printf("engine: %p\n",engine);
engine->startContinuous();
}
void robot_class::AutonomousInit() {
stop_vision();
driveTrain->SetSafetyEnabled(false);
unsigned int choice = 0;
if(autoSwitch.Get())//determining pot angles
choice = 1;
std::printf("switch: %d\n",autoSwitch.Get());
AUTO_ANGLE = AUTO_ANGLES[choice];/*choices are at the top*/
shooter -> setAngle(AUTO_ANGLE); /*and deterined by autoSwitch*/
shooter -> wheelForward = true;
shooter -> setSpeed(AUTO_SPEED);
init_vision();
}
/* #########################################################################
Main
######################################################################### */
int main(int argc, char *argv[])
{
struct sockaddr_in addr;
int on = 1, disable_control_port = 0;
pthread_t client, cam, cntrl, mind, uart_control;
char *dev = "/dev/video0";
int fps = 5, daemon = 0;
cd.width = 640;
cd.height = 480;
cdata = &cd;
cd.control_port = htons(8081);
cd.stream_port = htons(8080);
while (1) {
int option_index = 0, c = 0;
static struct option long_options[] = \
{
{"h", no_argument, 0, 0},
{"help", no_argument, 0, 0},
{"d", required_argument, 0, 0},
{"device", required_argument, 0, 0},
{"r", required_argument, 0, 0},
{"resolution", required_argument, 0, 0},
{"f", required_argument, 0, 0},
{"fps", required_argument, 0, 0},
{"p", required_argument, 0, 0},
{"port", required_argument, 0, 0},
{"v", no_argument, 0, 0},
{"version", no_argument, 0, 0},
{"b", no_argument, 0, 0},
{"background", no_argument, 0, 0},
{"c", required_argument, 0, 0},
{"control_port", required_argument, 0, 0},
{"disable_control", no_argument, 0, 0},
{"C", no_argument, 0, 0},
{"calibrate", no_argument, 0, 0},
{0, 0, 0, 0}
};
c = getopt_long_only(argc, argv, "", long_options, &option_index);
/* no more options to parse */
if (c == -1) break;
/* unrecognized option */
if (c == '?') {
help(argv[0]);
return 0;
}
switch (option_index) {
/* h, help */
case 0:
case 1:
help(argv[0]);
return 0;
break;
/* d, device */
case 2:
case 3:
dev = strdup(optarg);
break;
/* r, resolution */
case 4:
case 5:
if (strcmp("960x720", optarg) == 0) {
cd.width = 960;
cd.height = 720;
} else if (strcmp("640x480", optarg) == 0) {
cd.width = 640;
cd.height = 480;
} else if (strcmp("320x240", optarg) == 0) {
cd.width = 320;
cd.height = 240;
} else if (strcmp("160x120", optarg) == 0) {
cd.width = 160;
cd.height = 120;
} else {
fprintf(stderr, "ignoring unsupported resolution\n");
}
break;
/* f, fps */
case 6:
case 7:
fps = atoi(optarg);
break;
/* p, port */
case 8:
case 9:
cd.stream_port = htons(atoi(optarg));
break;
/* v, version */
case 10:
case 11:
printf("UVC Streamer Version: %s\n" \
"Compilation Date....: %s\n" \
"Compilation Time....: %s\n", SOURCE_VERSION, __DATE__, __TIME__);
return 0;
break;
/* v, version */
case 12:
case 13:
daemon = 1;
break;
/* c, control_port */
case 14:
case 15:
cd.control_port = htons(atoi(optarg));
break;
/* disable_control */
case 16:
disable_control_port = 1;
break;
case 17:
case 18:
disable_control_port = 1;
break;
default:
help(argv[0]);
return 0;
}
}
/* ignore SIGPIPE (send if transmitting to closed sockets) */
signal(SIGPIPE, SIG_IGN);
if (signal(SIGINT, signal_handler) == SIG_ERR) {
fprintf(stderr, "could not register signal handler\n");
exit(1);
}
/* fork to the background */
if (daemon) {
daemon_mode();
}
/* allocate webcam datastructure */
cd.videoIn = (struct vdIn *) calloc(1, sizeof(struct vdIn));
fprintf(stderr, "Using V4L2 device.....: %s\n", dev);
fprintf(stderr, "Resolution............: %i x %i\n", cdata->width, cdata->height);
fprintf(stderr, "frames per second.....: %i\n", fps);
fprintf(stderr, "TCP port..............: %i\n", ntohs(cd.stream_port));
if (disable_control_port == 1) {
fprintf(stderr, "motor control server..: disabled\n");
} else {
fprintf(stderr, "motor control TCP port: %i\n", ntohs(cd.control_port));
}
/* open video device and prepare data structure */
cd.video_dev = init_videoIn(cd.videoIn, dev, cd.width, cd.height, fps, V4L2_PIX_FMT_MJPEG, 1);
if (cd.video_dev < 0) {
fprintf(stderr, "init_VideoIn failed\n");
exit(1);
}
/* open socket for server */
sd = socket(PF_INET, SOCK_STREAM, 0);
if (sd < 0) {
fprintf(stderr, "socket failed\n");
exit(1);
}
/* ignore "socket already in use" errors */
if (setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0) {
perror("setsockopt(SO_REUSEADDR) failed");
exit(1);
}
/* configure server address to listen to all local IPs */
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = cd.stream_port;
addr.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind(sd, (struct sockaddr*) &addr, sizeof(addr)) != 0) {
fprintf(stderr, "bind failed\n");
perror("Bind");
exit(1);
}
/* start listening on socket */
if (listen(sd, 10) != 0) {
fprintf(stderr, "listen failed\n");
exit(1);
}
/* start to read the camera, push picture buffers into global buffer */
cd.videoIn->tmpbuffer = (unsigned char *) calloc(1, (size_t) cd.videoIn->framesizeIn);
g_buf = (unsigned char *) calloc(1, (size_t) cd.videoIn->framesizeIn);
vision_control_init(); //must be first to call;
pthread_create(&cam, 0, cam_thread, NULL);
pthread_detach(cam);
pthread_create(&mind, 0, mind_thread, NULL);
pthread_detach(mind);
init_vision();
init_controller();
pthread_create(&uart_control, 0, &uart_control_read, NULL);
pthread_detach(uart_control);
/* start control server */
if (disable_control_port == 0) {
pthread_create(&cntrl, NULL, &uvcstream_control, cdata);
pthread_detach(cntrl);
}
/* create a child for every client that connects */
while (1) {
int *pfd = (int *) calloc(1, sizeof(int));
*pfd = accept(sd, 0, 0);
pthread_create(&client, NULL, &client_thread, pfd);
pthread_detach(client);
}
return 0;
}