Subversion Repositories Code-Repo

Rev

Rev 274 | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 274 Rev 276
Line 2... Line 2...
2 
#include "CONTROLLERS.h"
 2 
#include "CONTROLLERS.h"
3 
#include "I2C1.h"
 3 
#include "I2C1.h"
4 
 
 4 
 
5 
static CONTROLLER_DATA *ctrl_data_p;
 5 
static CONTROLLER_DATA *ctrl_data_p;
6 
 
 6 
 
7 
void Controller_Init(CONTROLLER_DATA *data) {
 7 
void Controller_Init(CONTROLLER_DATA *data,
- 
 
 8 
        void (*change_callback)(uint8_t controller, CTRL_BTN_STATUS values)) {
- 
 
 9 
 
- 
 
 10 
    if (data != NULL)
8 
    ctrl_data_p = data;
 11 
        ctrl_data_p = data;
- 
 
 12 
    ctrl_data_p->change_callback = change_callback;
9 
 
 13 
 
10 
    // Variable initialization
 14 
    // Variable initialization
11 
    int i;
 15 
    int i, j;
12 
    for (i = 0; i < CONTROLLER_MAX_COUNT; i++) {
 16 
    for (i = 0; i < CONTROLLER_MAX_COUNT; i++) {
13 
        ctrl_data_p->connected_controllers[i] = 0x0;
 17 
        ctrl_data_p->connected_controllers[i] = 0x0;
14 
        ctrl_data_p->led_status[i][0] = 0x0;
 18 
        ctrl_data_p->led_status[i].w[i] = 0x0;
15 
        ctrl_data_p->led_status[i][1] = 0x0;
 19 
        ctrl_data_p->btn_prev[i].w = 0x0;
16 
        ctrl_data_p->btn_prev[i] = 0x0;
 20 
        ctrl_data_p->btn_curr[i].w = 0x0;
- 
 
 21 
        for (j = 0; j < 16; j++) {
17 
        ctrl_data_p->btn_last[i] = 0x0;
 22 
            ctrl_data_p->led_status[i].w[j] = 0x0;
- 
 
 23 
        }
18 
    }
 24 
    }
19 
 
 25 
 
20 
    ctrl_data_p->connected_count = 0x0;
 26 
    ctrl_data_p->connected_count = 0x0;
21 
 
 27 
 
22 
    // Poll to see which controllers are connected
 28 
    // Poll to see which controllers are connected
23 
    Controller_Poll_Connected();
 29 
    Controller_Poll_Connected();
24 
}
 30 
}
25 
 
 31 
 
26 
void Controller_Poll_Connected(void) {
 32 
void Controller_Poll_Connected(void) {
27 
    uint8_t buffer[2] = {CONTROLLER_CMD_RESET};
 33 
    uint8_t buffer[2];
28 
    uint8_t result, length, i;
 34 
    uint8_t result, i;
29 
    uint8_t address = CONTROLLER_PREFIX_ADDRESS + CONTROLLER_START_ADDRESS;
 35 
    uint8_t address = CONTROLLER_PREFIX_ADDRESS + CONTROLLER_START_ADDRESS;
30 
 
 36 
 
31 
    // Attempt to contact each controller to see if its connected
 37 
    // Attempt to contact each controller to see if its connected
32 
    for (i = 0; i < CONTROLLER_MAX_COUNT; i++) {
 38 
    for (i = 0; i < CONTROLLER_MAX_COUNT; i++) {
33 
//        I2C1_Master_Send(address + i, buffer, 1);
 - 
 
34 
//        do {
 - 
 
35 
//            result = I2C1_Get_Status();
 - 
 
36 
//        } while (!result);
 - 
 
37 
//        if (result == I2C1_SEND_OK) {
 - 
 
38 
//            // If a controller is connected, save its address
 - 
 
39 
//            ctrl_data_p->connected_controllers[ctrl_data_p->connected_count]
 - 
 
40 
//                    = address + i;
 - 
 
41 
//            ctrl_data_p->connected_count++;
 - 
 
42 
//        }
 - 
 
43 
        I2C1_Master_Restart(address + i, CONTROLLER_CMD_READ, 1);
 39 
        I2C1_Master_Restart(address + i, CONTROLLER_CMD_READ, 1);
44 
        do {
 40 
        do {
45 
            result = I2C1_Get_Status();
 41 
            result = I2C1_Get_Status();
46 
        } while (!result);
 42 
        } while (!result);
47 
        if (result == I2C1_RECV_OK) {
 43 
        if (result == I2C1_RECV_OK) {
48 
            length = I2C1_Read_Buffer(buffer);
 44 
            uint8_t length = I2C1_Read_Buffer(buffer);
49 
            // If a controller is connected, save its address
 45 
            // If a controller is connected, save its address
50 
            ctrl_data_p->connected_controllers[ctrl_data_p->connected_count]
 46 
            ctrl_data_p->connected_controllers[ctrl_data_p->connected_count] = address + i;
51 
                    = address + i;
 - 
 
52 
            ctrl_data_p->connected_count++;
 47 
            ctrl_data_p->connected_count++;
53 
        }
 48 
        }
- 
 
 49 
 
- 
 
 50 
        // A small delay is needed between polls
- 
 
 51 
        Delay_MS(1);
54 
    }
 52 
    }
- 
 
 53 
 
- 
 
 54 
    // Show the number of controllers connected
- 
 
 55 
    if (ctrl_data_p->connected_count & 0x1)
- 
 
 56 
        LED1_LAT = 1;
- 
 
 57 
    if (ctrl_data_p->connected_count & 0x2)
- 
 
 58 
        LED2_LAT = 1;
- 
 
 59 
    if (ctrl_data_p->connected_count & 0x4)
- 
 
 60 
        LED3_LAT = 1;
- 
 
 61 
    if (ctrl_data_p->connected_count & 0x8)
- 
 
 62 
        LED4_LAT = 1;
55 
}
 63 
}
56 
 
 64 
 
57 
void Controller_Update(void) {
 65 
void Controller_Update(void) {
58 
    /*
 - 
 
59 
    uint8_t buffer[2];
 66 
    uint8_t buffer[2];
60 
    uint8_t result, length;
 67 
    uint8_t result, length, i, j;
- 
 
 68 
    CTRL_BTN_STATUS btn_change;
- 
 
 69
- 
 
 70 
    for (i = 0; i < ctrl_data_p->connected_count; i++) {
- 
 
 71 
        // Store the last read values
61 
    uint8_t ctrl_1_btn = 0, ctrl_2_btn = 0;
 72 
        ctrl_data_p->btn_prev[i] = ctrl_data_p->btn_curr[i];
62 
 
 73 
 
63 
    // Read button values from controllers
 74 
        // Read in the button values for each controller
64 
    I2C1_Master_Restart(CONTROLLER_1_ADDRESS, CONTROLLER_READ, 1);
 75 
        I2C1_Master_Restart(ctrl_data_p->connected_controllers[i], CONTROLLER_CMD_READ, 1);
65 
    do {
 76 
        do {
66 
        result = I2C1_Get_Status();
 77 
            result = I2C1_Get_Status();
67 
    } while (!result);
 78 
        } while (!result);
68 
    if (result == I2C1_RECV_OK) {
 - 
 
69 
        // Indicate that controller 1 is connected
 79 
        // Save the read values
70 
        LED1_LAT = 1;
 - 
 
71 
        ctrl_data_p->ctrl_1_connected = 1;
 - 
 
72 
        length = I2C1_Read_Buffer(buffer);
 80 
        length = I2C1_Read_Buffer(buffer);
73 
        buffer[0] = ~buffer[0];
 81 
        ctrl_data_p->btn_curr[i].w = buffer[0];
- 
 
 82 
 
74 
        // Button change detected
 83 
        // Determine if a change was made between the current and previous values
75 
        if (ctrl_data_p->ctrl_1_buttons_prev != buffer[0]) {
 84 
        if (ctrl_data_p->btn_curr[i].w != ctrl_data_p->btn_prev[i].w) {
76 
            // Check if a button has been pressed since startup
 85 
            // Determine if a button was pressed (unpressed->pressed)
- 
 
 86 
            btn_change.w = ctrl_data_p->btn_prev[i].w ^ ctrl_data_p->btn_curr[i].w;
- 
 
 87 
            btn_change.w &= ctrl_data_p->btn_curr[i].w;
- 
 
 88 
 
- 
 
 89 
            // If a button was pressed, call the saved callback
- 
 
 90 
            if (btn_change.w) {
77 
            if (!ctrl_data_p->ctrl_1_active) {
 91 
                if (ctrl_data_p->change_callback != NULL) {
78 
                ctrl_data_p->ctrl_1_active = 1;
 92 
                    ctrl_data_p->change_callback(i, btn_change);
- 
 
 93 
                }
79 
            }
 94 
            }
80 
            // Figure out which button has changed
 - 
 
81 
            ctrl_1_btn = ctrl_data_p->ctrl_1_buttons_prev ^ buffer[0];
 - 
 
82 
            // Save the button if it went from unpressed -> pressed
 - 
 
83 
            ctrl_1_btn &= buffer[0];
 - 
 
84 
        }
 95 
        }
85 
        ctrl_data_p->ctrl_1_buttons_prev = buffer[0];
 - 
 
86 
    } else {
 - 
 
87 
        LED1_LAT = 0;
 - 
 
88 
        ctrl_data_p->ctrl_1_connected = 0;
 - 
 
89 
        ctrl_data_p->ctrl_1_active = 0;
 - 
 
90 
    }
 96 
    }
- 
 
 97 
}
91 
 
 98 
 
- 
 
 99 
void Controller_Set_Left_Leds(uint8_t controller, uint8_t value) {
- 
 
 100 
    uint8_t result, i;
- 
 
 101 
    uint8_t buffer[18];
- 
 
 102 
 
- 
 
 103 
    for (i = 0; i < 4; i++) {
- 
 
 104 
        if (value & (0x01 << i))
- 
 
 105 
            ctrl_data_p->led_status[controller].w[i+12] = CONTROLLER_BRIGHTNESS_HIGH;
- 
 
 106 
        else
- 
 
 107 
            ctrl_data_p->led_status[controller].w[i+12] = 0x00;
- 
 
 108 
    }
- 
 
 109 
 
- 
 
 110 
    // Write the LED value to the controller
- 
 
 111 
    buffer[0] = CONTROLLER_CMD_WRITE;
- 
 
 112 
    for (i = 0; i < 16; i++)
- 
 
 113 
        buffer[i+1] = ctrl_data_p->led_status[controller].w[i];
92 
    I2C1_Master_Restart(CONTROLLER_2_ADDRESS, CONTROLLER_READ, 1);
 114 
    I2C1_Master_Send(ctrl_data_p->connected_controllers[controller], buffer, 17);
93 
    do {
 115 
    do {
94 
        result = I2C1_Get_Status();
 116 
        result = I2C1_Get_Status();
95 
    } while (!result);
 117 
    } while (!result);
96 
    if (result == I2C1_RECV_OK) {
 - 
 
97 
        // Indicate that controller 2 is connected
 - 
 
98 
        LED2_LAT = 1;
 - 
 
99 
        ctrl_data_p->ctrl_2_connected = 1;
 - 
 
100 
        length = I2C1_Read_Buffer(buffer);
 - 
 
101 
        buffer[0] = ~buffer[0];
 - 
 
102 
        // Button change detected
 - 
 
103 
        if (ctrl_data_p->ctrl_2_buttons_prev != buffer[0]) {
 - 
 
104 
            // Check if a button has been pressed since startup
 - 
 
105 
            if (!ctrl_data_p->ctrl_2_active) {
 - 
 
106 
                ctrl_data_p->ctrl_2_active = 1;
 - 
 
107 
            }
 - 
 
108 
            // Figure out which button has changed
 - 
 
109 
            ctrl_2_btn = ctrl_data_p->ctrl_2_buttons_prev ^ buffer[0];
 - 
 
110 
            // Save the button if it went from unpressed -> pressed
 - 
 
111 
            ctrl_2_btn &= buffer[0];
 - 
 
112 
        }
 - 
 
113 
        ctrl_data_p->ctrl_2_buttons_prev = buffer[0];
 - 
 
114 
    } else {
 - 
 
115 
        LED2_LAT = 0;
 - 
 
116 
        ctrl_data_p->ctrl_2_connected = 0;
 - 
 
117 
        ctrl_data_p->ctrl_2_active = 0;
 - 
 
118 
    }
 - 
 
119 
 
 118 
 
120 
    // Write LED values to controllers
 - 
 
121 
    if (ctrl_data_p->ctrl_1_connected) {
 - 
 
122 
        buffer[0] = CONTROLLER_WRITE;
 - 
 
123 
        buffer[1] = ctrl_data_p->ctrl_1_leds;
 - 
 
124 
        I2C1_Master_Send(CONTROLLER_1_ADDRESS, buffer, 2);
 - 
 
125 
        do {
 119 
    Delay_MS(1);
126 
            result = I2C1_Get_Status();
 - 
 
127 
        } while (!result);
 - 
 
128 
    }
 120 
}
129 
 
 121 
 
- 
 
 122 
void Controller_Set_Middle_Leds(uint8_t controller, uint8_t value) {
- 
 
 123 
    uint8_t result, i;
- 
 
 124 
    uint8_t buffer[18];
- 
 
 125 
 
- 
 
 126 
    for (i = 0; i < 8; i++) {
- 
 
 127 
        if (value & (0x01 << i))
- 
 
 128 
            ctrl_data_p->led_status[controller].w[i] = CONTROLLER_BRIGHTNESS_HIGH;
- 
 
 129 
        else
130 
    if (ctrl_data_p->ctrl_2_connected) {
 130 
            ctrl_data_p->led_status[controller].w[i] = 0x00;
- 
 
 131 
    }
- 
 
 132 
 
- 
 
 133 
    // Write the LED value to the controller
131 
        buffer[0] = CONTROLLER_WRITE;
 134 
    buffer[0] = CONTROLLER_CMD_WRITE;
- 
 
 135 
    for (i = 0; i < 16; i++)
132 
        buffer[1] = ctrl_data_p->ctrl_2_leds;
 136 
        buffer[i+1] = ctrl_data_p->led_status[controller].w[i];
133 
        I2C1_Master_Send(CONTROLLER_2_ADDRESS, buffer, 2);
 137 
    I2C1_Master_Send(ctrl_data_p->connected_controllers[controller], buffer, 17);
134 
        do {
 138 
    do {
135 
            result = I2C1_Get_Status();
 139 
        result = I2C1_Get_Status();
136 
        } while (!result);
 140 
    } while (!result);
137 
    }
 - 
 
138 
 
 141 
 
139 
    // If board is in an idle state and a controller is connected, switch modes
 - 
 
140 
    if (Get_Board_State() == BOARD_MODE_IDLE) {
 - 
 
141 
        // If both controllers are active, go into game TRON mode
 - 
 
142 
        if (ctrl_data_p->ctrl_1_active && ctrl_data_p->ctrl_2_active) {
 - 
 
143 
            Reset_Board(BOARD_MODE_TRON);
 - 
 
144 
        }
 142 
    Delay_MS(1);
145 
        // Otherwise if only one controller is active, go into game SNAKE mode
 - 
 
146 
        if (ctrl_data_p->ctrl_1_active || ctrl_data_p->ctrl_2_active) {
 - 
 
147 
            Reset_Board(BOARD_MODE_SNAKE);
 - 
 
148 
        }
 - 
 
149 
    }
 - 
 
150 
    if (Get_Board_State() == BOARD_MODE_SNAKE) {
 - 
 
151 
        // If both controllers are active, go into game TRON mode
 - 
 
152 
        if (ctrl_data_p->ctrl_1_active && ctrl_data_p->ctrl_2_active) {
 - 
 
153 
            Reset_Board(BOARD_MODE_TRON);
 - 
 
154 
        }
 - 
 
155 
    }
 143 
}
156 
 
 144 
 
157 
    // Call the callback function if any buttons have changed
 145 
void Controller_Set_Right_Leds(uint8_t controller, uint8_t value) {
- 
 
 146 
    uint8_t result, i;
- 
 
 147 
    uint8_t buffer[18];
- 
 
 148 
 
158 
    if (ctrl_data_p->btn_change_callback != NULL) {
 149 
    for (i = 0; i < 4; i++) {
159 
        if (ctrl_1_btn || ctrl_2_btn) {
 150 
        if (value & (0x01 << i))
160 
            (*ctrl_data_p->btn_change_callback)(ctrl_1_btn, ctrl_2_btn);
 151 
            ctrl_data_p->led_status[controller].w[i+8] = CONTROLLER_BRIGHTNESS_HIGH;
161 
        }
 152 
        else
- 
 
 153 
            ctrl_data_p->led_status[controller].w[i+8] = 0x00;
162 
    }
 154 
    }
- 
 
 155 
 
- 
 
 156 
    // Write the LED value to the controller
- 
 
 157 
    buffer[0] = CONTROLLER_CMD_WRITE;
- 
 
 158 
    for (i = 0; i < 16; i++)
- 
 
 159 
        buffer[i+1] = ctrl_data_p->led_status[controller].w[i];
- 
 
 160 
    I2C1_Master_Send(ctrl_data_p->connected_controllers[controller], buffer, 17);
163 
    */
 161 
    do {
- 
 
 162 
        result = I2C1_Get_Status();
- 
 
 163 
    } while (!result);
- 
 
 164 
 
- 
 
 165 
    Delay_MS(1);
- 
 
 166 
}
- 
 
 167 
 
- 
 
 168 
uint8_t Controller_Get_Connected(void) {
- 
 
 169 
    return ctrl_data_p->connected_count;
164 
}
 170 
}
165 
 
 171 
 
166 
void Controller_Set_Leds(uint8_t controller, uint16_t value) {
 172 
void Controller_Set_Active(uint8_t controller) {
- 
 
 173 
    uint8_t buffer[2];
- 
 
 174 
    uint8_t result;
- 
 
 175 
 
167 
//    ctrl_data_p->ctrl_1_leds = ctrl_1;
 176 
    buffer[0] = CONTROLLER_CMD_ACTIVE;
- 
 
 177 
    I2C1_Master_Send(ctrl_data_p->connected_controllers[controller], buffer, 1);
- 
 
 178 
    do {
168 
//    ctrl_data_p->ctrl_2_leds = ctrl_2;
 179 
        result = I2C1_Get_Status();
- 
 
 180 
    } while (!result);
- 
 
 181 
 
- 
 
 182 
    Delay_MS(1);
169 
}
 183 
}
170 
 
 184 
 
171 
uint8_t Controller_Query(uint8_t controller) {
 185 
void Controller_Set_Idle(uint8_t controller) {
172 
//    // Returns the active status of attached controllers
 186 
    uint8_t buffer[2];
173 
//    if (ctrl_data_p->ctrl_1_active && ctrl_data_p->ctrl_2_active)
 - 
 
174 
//        return 0x3;
 187 
    uint8_t result;
- 
 
 188 
 
- 
 
 189 
    buffer[0] = CONTROLLER_CMD_RESET;
175 
//    else if (ctrl_data_p->ctrl_1_active)
 190 
    I2C1_Master_Send(ctrl_data_p->connected_controllers[controller], buffer, 1);
176 
//        return 0x1;
 191 
    do {
177 
//    else if (ctrl_data_p->ctrl_2_active)
 192 
        result = I2C1_Get_Status();
178 
//        return 0x2;
 193 
    } while (!result);
- 
 
 194 
 
179 
//    return 0;
 195 
    Delay_MS(1);
180 
}
 196 
}
181 

            197