screen_tracking.c File Reference

#include "screen_tracking.h"
#include "pixy_control.h"
#include "button.h"
#include "checkbox.h"
#include "tft.h"
#include "touch.h"
#include "pixy.h"
#include "system.h"
#include "pixy_frame.h"

Include dependency graph for screen_tracking.c:

Go to the source code of this file.

Data Structures
struct	TRACKING_CONFIG_STRUCT

Macros
#define	FRAME_START_X   1
#define	FRAME_START_Y   41
#define	FRAME_WIDTH   318
#define	FRAME_HEIGHT   198
#define	FRAME_END_X   FRAME_START_X +FRAME_WIDTH-1
#define	FRAME_END_Y   FRAME_START_Y +FRAME_HEIGHT-1
#define	BLOCK_BUFFER_SIZE   5

Typedefs
typedef void(*	TRACKING_VOID_CALLBACK) (void *tracking_config)
typedef void(*	TRACKING_BLOCK_CALLBACK) (void *tracking_config, struct Block *blocks, int num_blocks)

Enumerations
enum	{   detecting, init, tracking, preselecting,   abortselecting, selecting, selected, error }

Functions
static void	b_back_cb (void *button)
static void	c_frame_toggle_cb (void *checkbox, bool checked)
static void	b_select_cb (void *button)
static void	touchCB (void *touchArea, TOUCH_ACTION triggeredAction)
void	tracking_our_start (void *tracking_config)
void	tracking_our_stop (void *tracking_config)
void	tracking_our_update (void *tracking_config, struct Block *blocks, int num_blocks)
void	tracking_reference_start (void *tracking_config)
void	tracking_reference_stop (void *tracking_config)
void	tracking_reference_update (void *tracking_config, struct Block *blocks, int num_blocks)
void	tracking_set_mode (enum Tracking_Implementation impl)
static void	enter (void *screen)
static void	leave (void *screen)
static void	update (void *screen)
SCREEN_STRUCT *	get_screen_tracking ()

Variables
static BUTTON_STRUCT	b_back
static BUTTON_STRUCT	b_select
static CHECKBOX_STRUCT	c_frame_toggle
static TOUCH_AREA_STRUCT	a_area
static volatile bool	frame_visible = false
static enum { ... }	state
static POINT_STRUCT	point1
static POINT_STRUCT	point2
static bool	point1_valid
static int16_t	servo_x = 0
static int16_t	servo_y = 0
static TRACKING_CONFIG_STRUCT	tracking_our
static TRACKING_CONFIG_STRUCT	tracking_reference
static TRACKING_CONFIG_STRUCT *	tracking_current
static SCREEN_STRUCT	screen

Macro Definition Documentation

#define BLOCK_BUFFER_SIZE   5

#define FRAME_END_X   FRAME_START_X +FRAME_WIDTH-1

Definition at line 70 of file screen_tracking.c.

#define FRAME_END_Y   FRAME_START_Y +FRAME_HEIGHT-1

Definition at line 71 of file screen_tracking.c.

#define FRAME_HEIGHT   198

Definition at line 69 of file screen_tracking.c.

#define FRAME_START_X   1

Definition at line 66 of file screen_tracking.c.

#define FRAME_START_Y   41

Definition at line 67 of file screen_tracking.c.

#define FRAME_WIDTH   318

Definition at line 68 of file screen_tracking.c.

Typedef Documentation

typedef void(* TRACKING_BLOCK_CALLBACK) (void *tracking_config, struct Block *blocks, int num_blocks)

Definition at line 100 of file screen_tracking.c.

typedef void(* TRACKING_VOID_CALLBACK) (void *tracking_config)

Definition at line 98 of file screen_tracking.c.

Enumeration Type Documentation

anonymous enum

Enumerator
detecting
init
tracking
preselecting
abortselecting
selecting
selected
error

Definition at line 48 of file screen_tracking.c.

{detecting, init, tracking, preselecting, abortselecting, selecting, selected, error} state; //Current state of the screen state machine

Function Documentation

static void b_back_cb ( void *  button )

static

Definition at line 36 of file screen_tracking.c.

{
    gui_screen_back(); //navigate back to the previous screen
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void b_select_cb ( void *  button )

static

Definition at line 55 of file screen_tracking.c.

{
    if (state == selecting) { //we're currently selecting a color region
        state = abortselecting; //Abort selecting!!
    } else if (state == tracking) { //we're currently watching the tracking
        state = preselecting; //start selecting
    }
}

Here is the caller graph for this function:

static void c_frame_toggle_cb ( void *  checkbox, bool  checked  )

static

Definition at line 42 of file screen_tracking.c.

{
    frame_visible = checked; //Set the visibility of the frame to the checked state of the checkbox
    //Frame will be drawn in the main loop below
}

Here is the caller graph for this function:

static void enter ( void *  screen )

static

Definition at line 229 of file screen_tracking.c.

{
    tft_clear(WHITE);

    //"Back" button
    b_back.base.x1 = 5; //Start X of Button
    b_back.base.y1 = 5; //Start Y of Button
    b_back.base.x2 = AUTO; //Auto Calculate X2 with String Width
    b_back.base.y2 = AUTO; //Auto Calculate Y2 with String Height
    b_back.txtcolor = WHITE; //Set foreground color
    b_back.bgcolor = HEX(0xAE1010); //Set background color (Don't take 255 or 0 on at least one channel, to make shadows possible)
    b_back.font = 0; //Select Font
    b_back.text = "Back"; //Set Text (For formatted strings take sprintf)
    b_back.callback = b_back_cb; //Call b_back_cb as Callback
    gui_button_add(&b_back); //Register Button (and run the callback from now on)


    //"Select color" button
    b_select.base.x1 = 150;
    b_select.base.y1 = 5;
    b_select.base.x2 = AUTO;
    b_select.base.y2 = AUTO;
    b_select.txtcolor = WHITE;
    b_select.bgcolor = HEX(0xAE1010);
    b_select.font = 0;
    b_select.text = "Select Color";
    b_select.callback = b_select_cb;
    gui_button_add(&b_select);

    //"Frame visible" checkbox
    c_frame_toggle.base.x1 = 50;
    c_frame_toggle.base.x2 = 50 + 16;
    c_frame_toggle.base.y1 = 5;
    c_frame_toggle.base.y2 = 5 + 16;
    c_frame_toggle.checked = frame_visible;
    c_frame_toggle.fgcolor = CHECKBOX_WIN_FG_COLOR;
    c_frame_toggle.callback = c_frame_toggle_cb;
    gui_checkbox_add(&c_frame_toggle);
    tft_print_line(73, 8, BLACK, TRANSPARENT, 0, "Show Video");


    //Area to select a "color region"
    a_area.hookedActions =  PEN_DOWN | PEN_UP;
    a_area.x1 = FRAME_START_X;
    a_area.y1 = FRAME_START_Y;
    a_area.x2 = FRAME_END_X;
    a_area.y2 = FRAME_END_Y;
    a_area.callback = touchCB;
    //Do not register it here, we do that later

    if (tracking_current == NULL) {
        state = error;
    } else {
        state = detecting; //Start with the detecting state
    }
}

Here is the call graph for this function:

static void leave ( void *  screen )

static

Definition at line 287 of file screen_tracking.c.

{
    //Remove buttons and checkbox
    gui_button_remove(&b_back);
    gui_button_remove(&b_select);
    gui_checkbox_remove(&c_frame_toggle);

    if (state == selecting) { //the user left the screen in the "selecting" phase
        touch_unregister_area(&a_area); //remove the touch area
    }

    if (state == tracking) { //the user left the screen in the "tracking" phase
        tracking_current->stop(tracking_current); //stop tracking
        pixy_led_set_RGB(0, 0, 0);
    }
}

Here is the call graph for this function:

static void touchCB ( void *  touchArea, TOUCH_ACTION  triggeredAction  )

static

Definition at line 75 of file screen_tracking.c.

{
    POINT_STRUCT p = touch_get_last_point();

    switch (triggeredAction) {
    case PEN_DOWN: //The user just put down the pen
        point1.x = p.x - FRAME_START_X; //Calculate x-Coordinate relative to frame start
        point1.y = p.y - FRAME_START_Y; //Calculate y-Coordinate relative to frame start
        point1_valid = true; //The point1 is now valid
        break;

    case PEN_UP: //The user took the pen away
        if (point1_valid) { //only execute if point1 is valid
            point2.x = p.x - FRAME_START_X; //Calculate x-Coordinate relative to frame start
            point2.y = p.y - FRAME_START_Y; //Calculate y-Coordinate relative to frame start
            state = selected;
        }

        break;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void tracking_our_start

(

void *

tracking_config

)

Definition at line 114 of file screen_tracking.c.

{
    //Activate pixy's data send program
    int32_t response;
    int return_value;

    servo_x = servo_y = 500;                // set a default value of 500
    pixy_rcs_set_position(0, servo_x);      // set default
    pixy_rcs_set_position(1, servo_y);      // set default

    return_value = pixy_command("runprog", INT8(0), END_OUT_ARGS,  &response, END_IN_ARGS);
}

Here is the call graph for this function:

void tracking_our_stop

(

void *

tracking_config

)

Definition at line 128 of file screen_tracking.c.

{
    //Stop pixy's data send programm
    int32_t response;
    int return_value;
    return_value = pixy_command("stop", END_OUT_ARGS,  &response, END_IN_ARGS);
}

Here is the call graph for this function:

void tracking_our_update	(	void *	tracking_config,
		struct Block *	blocks,
		int	num_blocks
	)

Definition at line 137 of file screen_tracking.c.

{

    if (num_blocks <= 0) {                  // Check if there are blocks available
        return;                             // When there are none, do nothing
    }

    uint16_t x = blocks[0].x;               // Get x coordinate of the biggest object
    uint16_t y = blocks[0].y;               // Get y coordinate of the biggest object

    int16_t xset = 0;
    int16_t yset = 0;

    xset = (servo_x + pixy_PID_X((FRAME_WIDTH / 2), x));    // calculate the PID output for x
    yset = (servo_y - pixy_PID_Y((FRAME_HEIGHT / 2), y));   // calculate the PID output for y

    xset = (xset < 0) ? 0 : xset;           // x lower boundary check
    xset = (xset > 1000) ? 1000 : xset;     // x upper boundary check

    yset = (yset < 0) ? 0 : yset;           // y lower boundary check
    yset = (yset > 1000) ? 1000 : yset;     // y upper boundary check

    servo_x = xset;                         // update the global, static variable for x
    servo_y = yset;                         // update the global, statuc variable for y

    pixy_rcs_set_position(0, servo_x);      // set the new x position
    pixy_rcs_set_position(1, servo_y);      // set the new y position
}

Here is the call graph for this function:

void tracking_reference_start

(

void *

tracking_config

)

Definition at line 176 of file screen_tracking.c.

{
    //Run reference tracking
    int32_t response;
    int return_value;
    return_value = pixy_command("runprog", INT8(2), END_OUT_ARGS,  &response, END_IN_ARGS);
}

Here is the call graph for this function:

void tracking_reference_stop

(

void *

tracking_config

)

Definition at line 185 of file screen_tracking.c.

{
    //Stop reference tracking
    int32_t response;
    int return_value;
    return_value = pixy_command("stop", END_OUT_ARGS,  &response, END_IN_ARGS);
}

Here is the call graph for this function:

void tracking_reference_update	(	void *	tracking_config,
		struct Block *	blocks,
		int	num_blocks
	)

Definition at line 194 of file screen_tracking.c.

{
    //Nothing to do here. Pixy does it all.
}

static void update ( void *  screen )

static

Definition at line 306 of file screen_tracking.c.

{
    switch (state) {
    case detecting: //Detecting State: Where we try to connect to the pixy
        if (pixy_init() == 0) { //Pixy connection ok
            state = init; //Go to next state
        }

        break;

    case init: //Init State: Where we start the tracking
        tracking_current->start(tracking_current);
        state = tracking;
        break;

    case tracking: //Tracking state: Where we render the frame and the tracked objects
        pixy_service(); //Receive events (e.g. block-data) from pixy

        if (pixy_blocks_are_new()) { //There are new blocks available
            if (frame_visible) { //If the user want's us to draw the video data
                pixy_render_full_frame(FRAME_START_X, FRAME_START_Y);
            } else { //the user want's a colored background
                tft_fill_rectangle(FRAME_START_X, FRAME_START_Y, FRAME_END_X, FRAME_END_Y, RGB(200, 200, 200));
            }

#define BLOCK_BUFFER_SIZE 5 //The maximum amount of blocks that we want to receive
            struct Block blocks[BLOCK_BUFFER_SIZE]; //Storage to receive blocks from pixy
            int blocks_received = pixy_get_blocks(BLOCK_BUFFER_SIZE, blocks); //Try to receive up to BLOCK_BUFFER_SIZE Blocks from pixy

            if (blocks_received >= 0) { //block receiving ok
                tracking_current->update(tracking_current, blocks, blocks_received); //apply tracking

                //Draw blocks
                for (int i = 0; i < blocks_received; i++) { //for each received block
                    struct Block* block = &(blocks[i]);
                    //block.x and block.y are the center coordinates of the object relative to the camera origin.
                    uint16_t x = block->x - 1 + FRAME_START_X - block->width / 2; //Calculate x-Coordinate on the display
                    uint16_t y = block->y - 1 + FRAME_START_Y - block->height / 2; //Calculate y-Coordinate on the display
                    tft_draw_rectangle(x, y, x + block->width - 1, y + block->height - 1, WHITE); //Draw a white rectangle
                }
            }
        }

        break;

    case preselecting: { //Pre-Selecting State: Where we set up the color region selection
        tracking_current->stop(tracking_current); //Stop tracking

        pixy_render_full_frame(FRAME_START_X, FRAME_START_Y); //Render one frame

        touch_register_area(&a_area); //Register touch area and receive events from now on
        point1_valid = false; //we start with an invalid point1

        b_select.text = "Abort"; //Change the button text to "Abort"
        gui_button_redraw(&b_select); //redraw button

        state = selecting; //The user can now select a region
    }
    break;

    case selected: { //Selected State: Where we send the users selection to pixy
        //Ensure that (x1,y1) represent the top-left point and (x2,y2) the bottom-right.
        unsigned int tmp;

        if (point1.x > point2.x) {
            tmp = point1.x;
            point1.x = point2.x;
            point2.x = tmp;
        }

        if (point1.y > point2.y) {
            tmp = point1.y;
            point1.y = point2.y;
            point2.y = tmp;
        }

        //Send pixy the selected region
        pixy_cc_set_region(1, point1.x, point1.y, point2.x - point1.x, point2.y - point1.y);
    }

    //no break here: We want the following code to be executed as well

    case abortselecting: { //Abort-Selecting State: Where we deinitialize the stuff we used for region selection
        touch_unregister_area(&a_area); //Remove the touch area. We'll no longer receive touch events

        b_select.text = "Select Color"; //Change the button text back to "Select Color"
        gui_button_redraw(&b_select); //redraw button

        tracking_current->start(tracking_current); //Start tracking again
        state = tracking;
    }
    break;

    case selecting: //Selecting State: Where we wait on the user to select a color region
        pixy_service(); //receive pixy events
        //wait on user to select the image area
        break;

    case error: //Error State: Where we show an error message and leave the user no other choice than to click the backbutton
        //wait on user to click the back button
        break;
    }
}

Here is the call graph for this function:

Variable Documentation

TOUCH_AREA_STRUCT a_area

static

Definition at line 33 of file screen_tracking.c.

BUTTON_STRUCT b_back

static

Definition at line 30 of file screen_tracking.c.

BUTTON_STRUCT b_select

static

Definition at line 31 of file screen_tracking.c.

CHECKBOX_STRUCT c_frame_toggle

static

Definition at line 32 of file screen_tracking.c.

volatile bool frame_visible = false

static

Definition at line 41 of file screen_tracking.c.

POINT_STRUCT point1

static

Definition at line 50 of file screen_tracking.c.

bool point1_valid

static

Definition at line 52 of file screen_tracking.c.

POINT_STRUCT point2

static

Definition at line 51 of file screen_tracking.c.

SCREEN_STRUCT screen

static

Initial value:

= {
    enter,
    leave,
    update
}

Definition at line 411 of file screen_tracking.c.

int16_t servo_x = 0

static

Definition at line 110 of file screen_tracking.c.

int16_t servo_y = 0

static

Definition at line 111 of file screen_tracking.c.

enum { ... } state

TRACKING_CONFIG_STRUCT* tracking_current

static

Definition at line 207 of file screen_tracking.c.

TRACKING_CONFIG_STRUCT tracking_our

static

Initial value:

= {
    tracking_our_start,
    tracking_our_stop,
    tracking_our_update
}

Definition at line 167 of file screen_tracking.c.

TRACKING_CONFIG_STRUCT tracking_reference

static

Initial value:

= {
    tracking_reference_start,
    tracking_reference_stop,
    tracking_reference_update
}

Definition at line 200 of file screen_tracking.c.