/** * Sends the picture currently in the pixbuf over serial */ int send_picture_msg(lua_State *_l) { uint32_t x, y; uint32_t size_x, size_y; // only send if we're in debug mode if (debug_on) { init_packet(); // First the header // first the ID we have to put it in two bytes // big endian put_slip_char(get_msg_id_most_repr(PPM_MSG_ID)); put_slip_char(get_msg_id_least_repr(PPM_MSG_ID)); // now the param count. 1 bytes put_slip_char(1); cc3_pixbuf_rewind(); // just in case uint8_t *row = cc3_malloc_rows(1); // now parameters size_x = cc3_g_pixbuf_frame.width; size_y = cc3_g_pixbuf_frame.height; char* head = malloc(20); sprintf(head,"P6\n%d %d\n255\n",size_x,size_y ); uint32_t size = strlen(head)+size_x*size_y*3; // size is 3 bytes, so we first get // rid of most representative byte put_slip_char(get_size_most_repr(size)); put_slip_char(get_size_middle_repr(size)); put_slip_char(get_size_least_repr(size)); put_slip_string(head); free(head); bool led_on = false; for (y = 0; y < size_y; y++) { cc3_pixbuf_read_rows(row, 1); cc3_led_set_state(0, led_on=!led_on); for (x = 0; x < size_x * 3U; x++) { /* Sleep to prevent byte-loss. Seems a bit extreme, but I saw problems with even 1000 and 500 as intervals. */ if (x % 100 == 0) { cc3_timer_wait_ms (5); } put_slip_char(row[x]); } } cc3_led_set_state(0, false); free(row); finish_packet(); } return 0; }
/** * Make the led passed in as parameter blink for ms * milliseconds. * The LED will be turned OFF as the last step of this function */ void blink_led( uint8_t led, uint32_t ms ) { uint32_t INTERVAL = 40; uint_least32_t start_time = cc3_timer_get_current_ms (); bool led_on = true; cc3_led_set_state(led, led_on); do { led_on = !led_on; cc3_led_set_state(led, led_on); cc3_timer_wait_ms(INTERVAL); } while (cc3_timer_get_current_ms () < (start_time + ms)); cc3_led_set_state(led, false); }
int main(void) { cc3_color_info_pkt_t s_pkt; cc3_uart_init (0, CC3_UART_RATE_115200, CC3_UART_MODE_8N1, CC3_UART_BINMODE_TEXT); cc3_camera_init (); //cc3_camera_set_colorspace(CC3_COLORSPACE_YCRCB); cc3_camera_set_resolution(CC3_CAMERA_RESOLUTION_LOW); //cc3_pixbuf_frame_set_subsample(CC3_SUBSAMPLE_NEAREST, 2, 2); cc3_camera_set_auto_exposure (true); cc3_camera_set_auto_white_balance (true); cc3_led_set_state (0, false); printf ("Waiting for image to stabilize\n"); cc3_timer_wait_ms (2000); cc3_led_set_state (0, true); cc3_camera_set_auto_exposure (false); cc3_camera_set_auto_white_balance (false); while(true) { simple_get_mean(&s_pkt); printf( "min = [%d,%d,%d] mean = [%d,%d,%d] max = [%d,%d,%d] deviation = [%d,%d,%d]\n", s_pkt.min.channel[0], s_pkt.min.channel[1], s_pkt.min.channel[2], s_pkt.mean.channel[0], s_pkt.mean.channel[1], s_pkt.mean.channel[2], s_pkt.max.channel[0], s_pkt.max.channel[1], s_pkt.max.channel[2], s_pkt.deviation.channel[0], s_pkt.deviation.channel[1], s_pkt.deviation.channel[2] ); } }
int main(void) { int i; cc3_uart_init (0, CC3_UART_RATE_115200, CC3_UART_MODE_8N1, CC3_UART_BINMODE_TEXT); cc3_camera_init (); // ready camera cc3_camera_set_auto_exposure (true); cc3_camera_set_auto_white_balance (true); cc3_camera_set_resolution(CC3_CAMERA_RESOLUTION_HIGH); cc3_camera_set_colorspace(CC3_COLORSPACE_YCRCB); //cc3_camera_set_colorspace(CC3_COLORSPACE_RGB); cc3_timer_wait_ms(1000); // init cc3_led_set_state(0, false); cc3_led_set_state(2, true); i = 0; while(true) { printf("Ready to go... waiting the button\n"); while(!cc3_button_get_state()); printf("Go\n"); i++; if (i%2==0) { cc3_led_set_state (2, true); } else { cc3_led_set_state (2, false); } compute_frm(i); } return 0; }
void get_gps_data() { // gps buffer char* gps_buff = (char*)malloc(sizeof(char)*100); // scan for data from the gps scanf("%s",gps_buff); #ifdef LOG_GPS snprintf(log_str, 100, "\r\nGetting GPS Data: %s\r\n",gps_buff); write_log(); #endif // now try to parst the gps string if(parse_GPS(gps_buff)) { #ifdef LOG_GPS snprintf(log_str, 100, "Lat - %d\tLon - %d\tTime - %02d:%02d:%02d\r\n", (int)(gps->lat*1000000), (int)(gps->lon*1000000), gps->hour,gps->minute,gps->second); write_log(); #endif // turn on 'Good GPS LED' cc3_led_set_state (1, true); } else { #ifdef LOG_GPS snprintf(log_str, 100, "INVALID\r\n"); write_log(); #endif // turn off 'Good GPS LED' cc3_led_set_state (1, false); } free(gps_buff); }
void takePict() { #ifdef LOG snprintf(log_str, 100, "\r\nTaking Picture:\n\r"); write_log(); #endif // Take picture char filename[24]; snprintf(filename, 24, "c:/%d/img%.5d.jpg", gps->hour, picNum); // print file that you are going to write to stderr fprintf(stderr,"%s\r\n", filename); memory = fopen(filename, "w"); if(memory==NULL) { cc3_led_set_state(3, true); #ifdef LOG snprintf(log_str, 100, "Error: Can't open file\r\n" ); write_log(); #endif while(1); } capture_current_jpeg(memory); fclose(memory); if ( fclose (memory) == EOF) { perror ("fclose failed"); while(1); } picNum++; // save the picture number just in case the camera is turned // off it will start naming with that number memory = fopen("c:/picNum.txt", "w"); if (memory == NULL) { perror ("fopen failed"); while(1); } fprintf(memory, "%d", picNum); if ( fclose (memory) == EOF) { perror ("fclose failed"); while(1); } }
/** * Turns LED led on for ms milliseconds. LED led is turned off * after that. */ void turn_on_led_for( uint8_t led, uint32_t ms ) { cc3_led_set_state(led, true); cc3_timer_wait_ms(ms); cc3_led_set_state(led, false); }
/** * Wrapper of cc_3_led_set_state to turn off LED */ int turn_off_led(lua_State *_l) { uint8_t led = luaL_checkinteger(_l, 1); // make sure it's an integer luaL_argcheck(_l, (led == 0 || led == 1 || led == 2), 1, "LED must be either 0, 1 or 2."); cc3_led_set_state(led, false); return 0; // no return parameters }
bool initialize() { char* config_buff = (char*)malloc(sizeof(char)*100); // init some variables prevTime = 0; deltaTime = 0; deltaDist = 0; power_save = false; cam_focus_delay = 8000; // init parser structures for gps and config parse_init(); // turn on leds so we know it started working cc3_led_set_state (1, true); cc3_led_set_state (2, true); // configure uart for gps serial communication cc3_uart_init (0, CC3_UART_RATE_4800, CC3_UART_MODE_8N1, CC3_UART_BINMODE_BINARY); // init the camera and file system cc3_camera_init (); cc3_filesystem_init(); #ifdef LOG snprintf(log_str, 100, "**********\n\rNew Session\n\r"); write_log(); snprintf(log_str, 100, "\n\rReading config file\r\n"); write_log(); #endif // read config file from MMC memory = fopen ("c:/config.txt", "r"); if (memory == NULL) { perror ("fopen failed\r\n"); return false; } // get config file fscanf(memory, "%s", config_buff); if (fclose (memory) == EOF) { perror ("fclose failed\r\n"); return false; } // parse config file parse_Config(config_buff); // if the config is not good then quit if(!config->good) { #ifdef LOG snprintf(log_str, 100, "\n\rconfig.txt INVALID\r\n"); write_log(); #endif return false; } #ifdef LOG snprintf(log_str, 100, "\r\nConfig File:\n\rDelay(ms) - %d\tMin Dist(mm) - %d",(int)config->delay,(int)(config->min_dist*1000)); write_log(); if(config->halo) { snprintf(log_str, 100, "\tHalo - true\r\n"); write_log(); snprintf(log_str, 100, "\tHalo %s:\t Lat*1000000 - %d\tLon*1000000 - %d\tRange(mm) - %d\r\n", config->halo_info->name, (int)(config->halo_info->lat*1000000), (int)(config->halo_info->lon*1000000), (int)(config->halo_info->range*1000) ); write_log(); } else { snprintf(log_str, 100, "\tHalo - false\r\n"); write_log(); } #endif //configure camera cc3_camera_set_colorspace (CC3_COLORSPACE_RGB); cc3_camera_set_resolution (CC3_CAMERA_RESOLUTION_HIGH); cc3_camera_set_auto_white_balance (true); cc3_camera_set_auto_exposure (true); // init pixbuf with width and height and JPEG compression cc3_pixbuf_load(); init_jpeg(); // try to open picNum.txt if exist that will be the // picture number we will start with if not start at 0 #ifdef LOG snprintf(log_str, 100, "\n\rReading picNum file\r\n"); write_log(); #endif memory = fopen ("c:/picNum.txt", "r"); if (memory == NULL) { picNum = 0; } else { char* picNum_buff = (char*)malloc(sizeof(char)*100); fscanf(memory, "%s", picNum_buff); picNum = atoi(picNum_buff); free(picNum_buff); } if (fclose (memory) == EOF) { perror ("fclose failed\r\n"); return false; } #ifdef LOG snprintf(log_str, 100, "Starting picture numbering at: %d\r\n",picNum); write_log(); #endif // starts out awake with no gps signal cc3_led_set_state (1, false); cc3_led_set_state (2, true); cc3_timer_wait_ms(1000); free(config_buff); return true; }
int main(void) { int i; int result; FILE *f; bool light_on = true; cc3_uart_init (0, CC3_UART_RATE_115200, CC3_UART_MODE_8N1, CC3_UART_BINMODE_TEXT); cc3_camera_init (); // use MMC cc3_filesystem_init(); cc3_camera_set_resolution(CC3_CAMERA_RESOLUTION_HIGH); cc3_timer_wait_ms(1000); // init cc3_led_set_state(0, false); i = 0; while(!cc3_button_get_state()); while(true) { char filename[16]; // Check if files exist, if they do then skip over them do { snprintf(filename, 16, "c:/img%.5d.ppm", i); //snprintf(filename, 16, "img%.5d.ppm", i); f = fopen(filename, "r"); if (f != NULL) { printf( "%s already exists...\n",filename ); i++; result = fclose(f); if (result) { perror("first fclose failed"); } } } while(f != NULL); // print file that you are going to write to stderr fprintf(stderr,"%s ", filename); fflush(stderr); f = fopen(filename, "w"); if (f == NULL || i > 512) { if (f == NULL) { perror("crap"); } else { fprintf(stderr, "full\n"); } while (true) { cc3_led_set_state(0, true); cc3_led_set_state(2, true); cc3_timer_wait_ms(500); cc3_led_set_state(0, false); cc3_led_set_state(2, false); cc3_timer_wait_ms(500); } } if (light_on) { cc3_led_set_state (2, true); } else { cc3_led_set_state (2, false); } light_on = !light_on; capture_ppm(f); result = fclose(f); if (result) { perror("second fclose failed"); } fprintf(stderr, "\r\n"); i++; } return 0; }
int main (void) { cc3_histogram_pkt_t my_hist; cc3_color_info_pkt_t s_pkt; cc3_frame_diff_pkt_t fd_pkt; cc3_timer_wait_ms (500); cc3_gpio_set_mode (0, CC3_GPIO_MODE_SERVO); cc3_gpio_set_mode (1, CC3_GPIO_MODE_SERVO); cc3_gpio_set_mode (2, CC3_GPIO_MODE_SERVO); cc3_gpio_set_mode (3, CC3_GPIO_MODE_SERVO); // configure uarts cc3_uart_init (0, CC3_UART_RATE_115200, CC3_UART_MODE_8N1, CC3_UART_BINMODE_TEXT); cc3_uart_init (1, CC3_UART_RATE_38400,//CC3_UART_RATE_115200, CC3_UART_MODE_8N1, CC3_UART_BINMODE_BINARY); // Make it so that stdout and stdin are not buffered setvbuf (stdout, NULL, _IONBF, 0); setvbuf (stdin, NULL, _IONBF, 0); printf( "Opening UART1 file pointer\n" ); FILE *fp = cc3_uart_fopen(1, "r"); if (fp) { printf("Success"); int i = 0; while (1) { fprintf(fp, "i = %08d\n", i++); } } printf( "Calling camera init\n" ); cc3_camera_init (); cc3_camera_set_colorspace (CAM_COLOURS); cc3_camera_set_resolution (CAM_FORMAT); cc3_pixbuf_frame_set_coi (CC3_CHANNEL_ALL);//for full 'colour_info' //cc3_camera_set_colorspace (CC3_COLORSPACE_YCRCB);?All switches handled? //cc3_camera_set_resolution (CC3_CAMERA_RESOLUTION_HIGH);// 352, 288 //cc3_pixbuf_frame_set_subsample(CC3_SUBSAMPLE_RANDOM, 2, 2); printf( "Camera init done\n%d x %d\n", cc3_g_pixbuf_frame.raw_width, cc3_g_pixbuf_frame.raw_height ); // frame difference fd_pkt.coi = CC3_CHANNEL_ALL; fd_pkt.template_width = 16;//8; fd_pkt.template_height = 16;//8; fd_pkt.total_x = cc3_g_pixbuf_frame.width; fd_pkt.total_y = cc3_g_pixbuf_frame.height; fd_pkt.load_frame = 1; // load a new frame fd_pkt.previous_template = malloc (fd_pkt.template_width * fd_pkt.template_height * sizeof (uint32_t)); if (fd_pkt.previous_template == NULL) printf ("Malloc FD startup error!\r"); cc3_camera_set_auto_white_balance (true); cc3_camera_set_auto_exposure (true); // The LED test masks the stabilization delays (~2000ms) printf ("Waiting for image to stabilize\n"); led_test (); cc3_camera_set_auto_white_balance (false); cc3_camera_set_auto_exposure (false); // printf ("\nPush button on camera back to continue\n"); // while (!cc3_button_get_state ()) // ; cc3_led_set_state (0, true); cc3_pixbuf_load (); my_hist.channel = CC3_CHANNEL_ALL; my_hist.bins = 24; my_hist.hist = malloc (my_hist.bins * sizeof (uint32_t)); while (true) { printf ("<3 EE\n 0x%02X\n ", (unsigned int)cc3_timer_get_current_ms()); // Grab an image and take a frame difference of it cc3_pixbuf_load (); frame_diff (&fd_pkt); // Rewind and take a histogram of it cc3_pixbuf_rewind (); //get_histogram (&my_hist); // Rewind and get some stats cc3_pixbuf_rewind (); get_mean(&s_pkt); printf( "min = [%d,%d,%d] mean = [%d,%d,%d] max = [%d,%d,%d] deviation = [%d,%d,%d] ", s_pkt.min.channel[0],s_pkt.min.channel[1],s_pkt.min.channel[2], s_pkt.mean.channel[0],s_pkt.mean.channel[1],s_pkt.mean.channel[2], s_pkt.max.channel[0],s_pkt.max.channel[1],s_pkt.max.channel[2], s_pkt.deviation.channel[0],s_pkt.deviation.channel[1],s_pkt.deviation.channel[2] ); /* printf ("hist[%d] = ", my_hist.bins); for (uint32_t i = 0; i < my_hist.bins; i++) { printf ("%08X ", my_hist.hist[i]); // sample non-blocking serial routine if (!cc3_uart_has_data (1)) { cc3_gpio_set_servo_position (0, SERVO_MID); cc3_gpio_set_servo_position (1, SERVO_MID); } } */ printf ("\n"); cc3_timer_wait_ms(400); // if (cc3_button_get_state()) // break; } printf("\n\nAll done!\n"); return 0; }
void led_test (void) { for (int i = 0; i < 8; i++) { if (i & 1) { cc3_led_set_state(0, true); } else { cc3_led_set_state(0, false); } if (i & 2) { cc3_led_set_state(1, true); } else { cc3_led_set_state(1, false); } if (i & 4) { cc3_led_set_state(2, true); } else { cc3_led_set_state(2, false); } cc3_timer_wait_ms(200); } cc3_led_set_state (0, true); cc3_led_set_state (1, true); cc3_led_set_state (2, true); cc3_timer_wait_ms(400); cc3_led_set_state (0, false); cc3_led_set_state (1, false); cc3_led_set_state (2, false); cc3_timer_wait_ms(400); }
/* simple hello world, showing features and compiling*/ int main (void) { uint32_t start_time, end_time, val; char c; FILE *fp; cc3_image_t img; // init filesystem driver cc3_filesystem_init (); // configure uarts cc3_uart_init (0, CC3_UART_RATE_115200, CC3_UART_MODE_8N1, CC3_UART_BINMODE_TEXT); // Make it so that stdout and stdin are not buffered val = setvbuf (stdout, NULL, _IONBF, 0); val = setvbuf (stdin, NULL, _IONBF, 0); printf( "Calling camera init\n" ); cc3_camera_init (); printf( "Camera init done\n" ); cc3_camera_set_colorspace (CC3_COLORSPACE_RGB); cc3_camera_set_resolution (CC3_CAMERA_RESOLUTION_LOW); cc3_camera_set_auto_white_balance (true); cc3_camera_set_auto_exposure (true); printf ("Hello World...\n"); cc3_led_set_state (0, false); cc3_led_set_state (1, false); cc3_led_set_state (2, false); // sample wait command in ms cc3_timer_wait_ms (1000); cc3_led_set_state (0, true); // sample showing how to write to the MMC card printf ("Type y to test MMC card, type n if you do not have the card\n"); c = getchar (); if (c == 'y' || c == 'Y') { int result; printf ("\nMMC test...\n"); fp = fopen ("c:/test.txt", "w"); if (fp == NULL) { perror ("fopen failed"); } fprintf (fp, "This will be written to the MMC...\n"); result = fclose (fp); if (result == EOF) { perror ("fclose failed"); } printf ("A string was written to test.txt on the mmc card.\n"); } // sample showing how to read button printf ("push button on camera back to continue\n"); start_time = cc3_timer_get_current_ms (); while (!cc3_button_get_state ()); cc3_led_set_state (1, true); // sample showing how to use timer printf ("It took you %dms to press the button\n", cc3_timer_get_current_ms () - start_time); // setup an image structure cc3_pixbuf_load (); img.channels = 3; img.width = cc3_g_pixbuf_frame.width; img.height = 1; // image will hold just 1 row for scanline processing img.pix = cc3_malloc_rows (1); printf ("Now we will use image data...\n"); val = 0; /* * Track the brightest red spot on the image */ while (1) { int y; uint16_t my_x, my_y; uint8_t max_red; cc3_pixel_t my_pix; if (val & 0x1) cc3_led_set_state (0, true); else cc3_led_set_state (0, false); if (val & 0x2) cc3_led_set_state (1, true); else cc3_led_set_state (1, false); if (val & 0x3) cc3_led_set_state (2, true); else cc3_led_set_state (2, false); if (val & 0x4) cc3_led_set_state (3, true); else cc3_led_set_state (3, false); val++; // This tells the camera to grab a new frame into the fifo and reset // any internal location information. cc3_pixbuf_frame_set_coi(CC3_CHANNEL_ALL); cc3_pixbuf_load (); // red search! // *** slow method for red search start_time = cc3_timer_get_current_ms(); max_red = 0; my_x = 0; my_y = 0; y = 0; while (cc3_pixbuf_read_rows (img.pix, 1)) { // read a row into the image picture memory from the camera for (uint16_t x = 0; x < img.width; x++) { // get a pixel from the img row memory cc3_get_pixel (&img, x, 0, &my_pix); if (my_pix.channel[CC3_CHANNEL_RED] > max_red) { max_red = my_pix.channel[CC3_CHANNEL_RED]; my_x = x; my_y = y; } } y++; } end_time = cc3_timer_get_current_ms(); printf ("Found max red value %d at %d, %d\n", max_red, my_x, my_y); printf (" cc3_get_pixel version took %d ms to complete\n", end_time - start_time); // *** faster method for red search cc3_pixbuf_rewind(); // use exactly the same pixbuf contents start_time = cc3_timer_get_current_ms(); max_red = 0; my_x = 0; my_y = 0; y = 0; while (cc3_pixbuf_read_rows (img.pix, 1)) { // read a row into the image picture memory from the camera for (uint16_t x = 0; x < img.width * 3; x+=3) { uint8_t red = ((uint8_t *) img.pix)[x + CC3_CHANNEL_RED]; if (red > max_red) { max_red = red; my_x = x; my_y = y; } } y++; } my_x /= 3; // correct channel offset end_time = cc3_timer_get_current_ms(); printf ("Found max red value %d at %d, %d\n", max_red, my_x, my_y); printf (" faster version took %d ms to complete\n", end_time - start_time); // *** even faster method for red search cc3_pixbuf_rewind(); // use exactly the same pixbuf contents cc3_pixbuf_frame_set_coi(CC3_CHANNEL_RED); start_time = cc3_timer_get_current_ms(); max_red = 0; my_x = 0; my_y = 0; y = 0; while (cc3_pixbuf_read_rows (img.pix, 1)) { // read a row into the image picture memory from the camera for (uint16_t x = 0; x < img.width; x++) { uint8_t red = ((uint8_t *) img.pix)[x]; if (red > max_red) { max_red = red; my_x = x; my_y = y; } } y++; } end_time = cc3_timer_get_current_ms(); printf ("Found max red value %d at %d, %d\n", max_red, my_x, my_y); printf (" even faster version took %d ms to complete\n", end_time - start_time); printf("\n"); // sample non-blocking serial routine if (!cc3_uart_has_data (0)) break; } free (img.pix); // don't forget to free! printf ("You pressed %c to escape\n", fgetc (stdin)); // stdio actually works... printf ("Type in a number followed by return to test scanf: "); scanf ("%d", &val); printf ("You typed %d\n", val); printf ("Good work, now try something on your own...\n"); while (1); return 0; }