Subversion Repositories Code-Repo

Rev

Rev 276 | Go to most recent revision | Blame | Last modification | View Log | RSS feed 

// <editor-fold defaultstate="collapsed" desc="Configuration Bits">
/* ------------------------------------------------------------ */
/* PIC32 Configuration Settings */
/* ------------------------------------------------------------ */
/* Oscillator Settings */
#pragma config FNOSC     = PRIPLL   // Oscillator Selection Bits
#pragma config POSCMOD   = EC       // Primary Oscillator Configuration
#pragma config FPLLIDIV  = DIV_2    // PLL Input Divider
#pragma config FPLLMUL   = MUL_20   // PLL Multiplier
#pragma config FPLLODIV  = DIV_1    // PLL Output Divider
#pragma config FPBDIV    = DIV_1    // Peripheral Clock Divisor (timers/UART/SPI/I2C)
#pragma config FSOSCEN   = OFF      // Secondary Oscillator Enable
/* Clock Control Settings */
#pragma config IESO      = OFF      // Internal/External Clock Switch Over
#pragma config FCKSM     = CSDCMD   // Clock Switching and Monitor Selection
#pragma config OSCIOFNC  = OFF      // CLKO Output Signal Active on the OSCO Pin
/* USB Settings */
#pragma config UPLLEN    = ON       // USB PLL Enable
#pragma config UPLLIDIV  = DIV_2    // USB PLL Input Divider
#pragma config FVBUSONIO = OFF      // USB VBUS ON Selection
#pragma config FUSBIDIO  = OFF      // USB USID Selection
/* Other Peripheral Device Settings */
#pragma config FWDTEN    = OFF      // Watchdog Timer Enable
#pragma config WDTPS     = PS1048576    // Watchdog Timer Postscaler (1048.576s)
#pragma config FSRSSEL   = PRIORITY_7   // SRS Interrupt Priority
#pragma config FCANIO    = OFF      // CAN I/O Pin Select (default/alternate)
#pragma config FETHIO    = ON       // Ethernet I/O Pin Select (default/alternate)
#pragma config FMIIEN    = OFF      // Ethernet MII/RMII select (OFF=RMII)
/* Code Protection Settings */
#pragma config CP        = OFF      // Code Protect
#pragma config BWP       = OFF      // Boot Flash Write Protect
#pragma config PWP       = OFF      // Program Flash Write Protect
/* Debug Settings */
#pragma config ICESEL = ICS_PGx1    // ICE/ICD Comm Channel Select (on-board debugger)
/* ------------------------------------------------------------ */
// </editor-fold>

#include "defines.h"
#include "UART1.h"
#include "SPI1.h"
#include "SPI4.h"
#include "I2C1.h"
#include "ETHERNET.h"
#include "TIMER4.h"
#include "TIMER5.h"
#include "CUBE.h"
#include "BTN.h"
#include "ANIMATIONS.h"
#include "CONTROLLERS.h"
#include "SNAKE.h"
#include "TRON.h"

void BTN1_Interrupt(void);
void BTN2_Interrupt(void);
void BTN3_Interrupt(void);

void Delay_MS(uint32_t delay_ms) {
    // Delays the CPU for the given amount of time.
    // Note: Watch out for integer overflow! (max delay_ms = 107374) ??
    uint32_t delay = delay_ms * MS_TO_CT_TICKS;
    uint32_t startTime = ReadCoreTimer();
    while ((uint32_t)(ReadCoreTimer() - startTime) < delay) {};
}

void Delay_US(uint32_t delay_us) {
    // Delays the CPU for the given amount of time.
    // Note: Watch out for integer overflow!
    uint32_t delay = delay_us * US_TO_CT_TICKS;
    uint32_t startTime = ReadCoreTimer();
    while ((uint32_t)(ReadCoreTimer() - startTime) < delay) {};
}

uint8_t Get_Reset_Condition(void) {
    uint8_t ret = 0;
    if (RCONbits.POR && RCONbits.BOR)
        ret = RESET_POR;
    else if (RCONbits.BOR)
        ret = RESET_BOR;
    else if (RCONbits.EXTR)
        ret = RESET_PIN;
    else if (RCONbits.SWR)
        ret = RESET_SWR;
    else if (RCONbits.CMR)
        ret = RESET_CFG;
    else if (RCONbits.WDTO)
        ret = RESET_WDT;
    // Clear the RCON register
    RCON = 0x0;
    return ret;
}

// Initialize a persistent operational state machine
volatile static uint8_t op_state __attribute__((persistent));

uint8_t Get_Board_State(void) {
    return op_state;
}

void Reset_Board(uint8_t next_state) {
    op_state = next_state;
    
    // Executes a software reset
    INTDisableInterrupts();
    SYSKEY = 0x00000000; // Write invalid key to force lock
    SYSKEY = 0xAA996655; // Write key1 to SYSKEY
    SYSKEY = 0x556699AA; // Write key2 to SYSKEY
    /* OSCCON is now unlocked */
    // Set SWRST bit to arm reset
    RSWRSTSET = 1;
    // Read RSWRST register to trigger reset
    uint32_t dummy;
    dummy = RSWRST;
    // Prevent any unwanted code execution until reset occurs
    while(1);
}

void Test_Callback(uint8_t controller, CTRL_BTN_STATUS value) {
    LED1_LAT = 0;
    LED2_LAT = 0;
    LED3_LAT = 0;
    LED4_LAT = 0;
    if (value.BTN_R_N)
        LED1_LAT = 1;
    if (value.BTN_R_E)
        LED2_LAT = 1;
    if (value.BTN_R_S)
        LED3_LAT = 1;
    if (value.BTN_R_W)
        LED4_LAT = 1;
}

void main() {
    // WARNING!! THIS BOARD WILL RESET EVERY 1048.576s DUE TO THE WDT!!

    /* -------------------- BEGIN INITIALIZATION --------------------- */
    
    // Configure the target for maximum performance at 80 MHz.
    // Note: This overrides the peripheral clock to 80Mhz regardless of config
    SYSTEMConfigPerformance(CPU_CLOCK_HZ);

    // Configure the interrupts for multiple vectors
    INTConfigureSystem(INT_SYSTEM_CONFIG_MULT_VECTOR);

    // Set all analog I/O pins to digital
    AD1PCFGSET = 0xFFFF;

    // Enable the watchdog timer with windowed mode disabled
    // WDT prescaler set to 1048576 (1048.576s) (see config bits)
//    WDTCON = 0x00008000;
    WDTCON = 0x00000000;

    // Configure onboard LEDs
    LED1_TRIS = 0;
    LED2_TRIS = 0;
    LED3_TRIS = 0;
    LED4_TRIS = 0;
    LED1_LAT = 0;
    LED2_LAT = 0;
    LED3_LAT = 0;
    LED4_LAT = 0;

    // Determine what to do at this point. We either choose to idle (on POR)
    // or go into a mode specified prior to the software reset event
    uint8_t last_reset = Get_Reset_Condition();
    if (last_reset == RESET_POR || last_reset == RESET_BOR ||
            last_reset == RESET_PIN || last_reset == RESET_WDT ||
            last_reset == RESET_CFG) {
        op_state = BOARD_MODE_IDLE;
    }

    // Initialize the SPI1 module
    SPI1_DATA spi_1_data;
    SPI1_Init(&spi_1_data, NULL);

    // Initialize the SPI4 module
//    SPI4_DATA spi_4_data;
//    SPI4_Init(&spi_4_data);

    // Initialize the I2C1 module
    I2C1_DATA i2c_1_data;
    I2C1_Init(&i2c_1_data, I2C1_400KHZ, 0x20);

//    // Initialize the UART1 module
//    UART1_DATA uart_data;
//    UART1_Init(&uart_data, &Cube_Data_In);

    // Initializs the PWM2 output to 20MHz
    PWM2_Init();

    // Initialize the cube variables
    CUBE_DATA cube_data;
    Cube_Init(&cube_data, 0x40);

    // Start the cube update layer interrupt
    // 2084 = 60Hz, 500 = 250Hz, 250 = 500Hz
    TIMER5_DATA timer_5_data;
    TIMER5_Init(&timer_5_data, &Cube_Timer_Interrupt, 500);

    // Initialize timer for controller polling and overlay rotation interrupt
    TIMER4_DATA timer_4_data;
    TIMER4_Init(&timer_4_data, NULL, NULL, 0);

    // Process button inputs
    BTN_DATA btn_data;
    BTN_Init(&btn_data, &BTN1_Interrupt, &BTN2_Interrupt, NULL);

    // Initialize controllers
    CONTROLLER_DATA ctrl_data;
    Controller_Init(&ctrl_data, NULL);

    // Initialize the Ethernet module
    if (op_state == BOARD_MODE_ETHERNET) {
        LED1_LAT = 1;
        ETH_DATA eth_data;
        ETH_Init(&eth_data, NULL, &Cube_Ethernet_Frame_In);
    }
    
    SNAKE_DATA snake_data;
    TRON_DATA tron_data;

    PWM2_Start();
    
    /* -------------------- END OF INITIALIZATION -------------------- */
    /* ------------------------ BEGIN DISPLAY ------------------------ */

    // Figure out what to do at this point (depending on current state)
    switch (op_state) {
        case BOARD_MODE_IDLE:
            TIMER5_Start(); // Use the default refresh rate (250Hz)
            Idle_Animation_Sequence();
            break;
        case BOARD_MODE_SNAKE:
            // Change refresh rate to ~60Hz
            TIMER5_Init(NULL, &Cube_Timer_Interrupt, 2000);
            TIMER5_Start();
            // Poll the controllers at 1kHz
            Controller_Init(NULL, &Snake_Update_Direction);
            TIMER4_Init(NULL, &Controller_Update, NULL, 0);
            // Initialize and start the game
            Snake_Init(&snake_data);
            Snake_Main();
            break;
        case BOARD_MODE_TRON:
            // Change refresh rate to ~60Hz
            TIMER5_Init(NULL, &Cube_Timer_Interrupt, 2000);
            TIMER5_Start();
            // Poll the controllers at 1kHz
            Controller_Init(NULL, &Tron_Update_Direction);
            TIMER4_Init(NULL, &Controller_Update, NULL, 0);
            // Initialize and start the game
            Tron_Init(&tron_data);
            Tron_Main();
            break;
        case BOARD_MODE_ETHERNET:
            TIMER4_Stop();
            TIMER5_Start();
            LED2_LAT = 1;
            while(1);
            break;
    }

}

void Idle_Animation_Sequence(void) {

//    Cube_Set_All(RED);
//    Delay_MS(2000);
//    Cube_Set_All(GREEN);
//    Delay_MS(2000);
//    Cube_Set_All(BLUE);
//    Delay_MS(2000);
//    Animation_Pseudo_Random_Colors(200);
//    Animation_Pseudo_Random_Colors(200);
//    Animation_Pseudo_Random_Colors(200);
//    Animation_Pseudo_Random_Colors(200);
//    Animation_Pseudo_Random_Colors(200);
//    Animation_Pseudo_Random_Colors(200);
    
    uint8_t connected, i;
    connected = Controller_Get_Connected();
    for (i = 0; i < connected; i++) {
        Controller_Set_Idle(i);
    }

    // Start the scrolling text
    TIMER4_Stop();
    TIMER4_Init(NULL, NULL, &Cube_Text_Interrupt, 100);
//    TIMER4_Start();

//    int8_t start_text[] = "Cube Initialized\r\n";
//    UART1_Write(start_text, 18);

    // Set the overlay text
    uint8_t text_string[] = "Welcome to the CCM Lab     ";
    Cube_Text_Init(text_string, 27, 0xFF, 0xFF, 0xFF);
//    TIMER4_Start();

    // Loop through some preset animations
    while(1) {

        Animation_Sawtooth(100);
        Animation_Sawtooth(100);
        Animation_Sawtooth(100);
        Animation_Sphere(100);
        Animation_Sphere(100);
        Animation_Sphere(100);
        Animation_Sphere(100);
        Animation_Wave1(100);
        Animation_Wave1(100);
        Animation_Wave1(100);
        Animation_Wave1(100);
        Animation_Wave2(100);
        Animation_Wave2(100);
        Animation_Wave2(100);
        Animation_Wave2(100);
//        Animation_Solid_Colors(300);
//        Animation_Layer_Alternate(300);
//        Animation_Pixel_Alternate(200);
//        Animation_Full_Color_Sweep(1000);
//        Animation_Row_Column_Sweep(40);
        Animation_Row_Column_Sweep(40);
        Animation_Cube_In_Cube(300);
        Animation_Cube_In_Cube(300);
        Animation_Cube_In_Cube(300);
        Animation_Double_Rotation(30);
        Animation_Double_Rotation(30);
        Animation_Double_Rotation(30);
        Animation_Double_Rotation(30);
        Animation_Pseudo_Random_Colors(300);
        Animation_Pseudo_Random_Colors(300);
        Animation_Pseudo_Random_Colors(300);
        Animation_Pseudo_Random_Colors(300);
        Animation_Pseudo_Random_Colors(300);
        Animation_Pseudo_Random_Colors(300);
        Animation_Pseudo_Random_Colors(300);
        Animation_Pseudo_Random_Colors(300);
        Animation_Pseudo_Random_Colors(300);
        Animation_Pseudo_Random_Colors(300);
//        Animation_Random_Colors(300);

//        ClearWDT(); // Clear the WDT if we dont want the board to reset
    }
}

// Function call on button 1 press to change cube operation
void BTN1_Interrupt(void) {
    switch (op_state) {
        case BOARD_MODE_IDLE:
            Reset_Board(BOARD_MODE_SNAKE);
            break;
        case BOARD_MODE_SNAKE:
            Reset_Board(BOARD_MODE_TRON);
            break;
        case BOARD_MODE_TRON:
            Reset_Board(BOARD_MODE_ETHERNET);
            break;
        case BOARD_MODE_ETHERNET:
            Reset_Board(BOARD_MODE_IDLE);
            break;
    }

    // Code to change refresh rate on button press
//    static uint8_t state;
//    state = (state == 4) ? 0 : state + 1;
//    TIMER5_Stop();
//    switch (state) {
//        case 0:
//            TIMER5_Init(NULL, &Cube_Timer_Interrupt, 500); // 250Hz
//            break;
//        case 1:
//            TIMER5_Init(NULL, &Cube_Timer_Interrupt, 2083); // 60Hz
//            break;
//        case 2:
//            TIMER5_Init(NULL, &Cube_Timer_Interrupt, 4166); // 30Hz
//            break;
//        case 3:
//            TIMER5_Init(NULL, &Cube_Timer_Interrupt, 12498); // 10Hz
//            break;
//        case 4:
//            TIMER5_Init(NULL, &Cube_Timer_Interrupt, 24996); // 5Hz
//            break;
//    }
//    TIMER5_Start();
}

// Function call on button 2 press to change brightness
void BTN2_Interrupt(void) {
    static uint8_t state = 6;
    state = (state == 6) ? 0 : state + 1;
    TIMER5_Stop();
    Delay_MS(1); // Need to wait for all SPI writes to complete
    uint8_t BC;
    switch (state) {
        case 0:
            BC = 0x01;
            break;
        case 1:
            BC = 0x08;
            break;
        case 2:
            BC = 0x10;
            break;
        case 3:
            BC = 0x20;
            break;
        case 4:
            BC = 0x40;
            break;
        case 5:
            BC = 0x80;
            break;
        case 6:
            BC = 0xFF;
            break;
    }
    Cube_Write_DCS(BC);
    TIMER5_Start();
}

//// Function call on button 3 press to change text scroll speed
//void BTN3_Interrupt(void)  {
//    static uint8_t state;
//    state = (state == 4) ? 0 : state + 1;
//    TIMER4_Stop();
//    switch (state) {
//        case 0:
//            TIMER4_Init(NULL, &Cube_Text_Interrupt, 209712);
//            break;
//        case 1:
//            TIMER4_Init(NULL, &Cube_Text_Interrupt, 180000);
//            break;
//        case 2:
//            TIMER4_Init(NULL, &Cube_Text_Interrupt, 150000);
//            break;
//        case 3:
//            TIMER4_Init(NULL, &Cube_Text_Interrupt, 120000);
//            break;
//        case 4:
//            TIMER4_Init(NULL, &Cube_Text_Interrupt, 90000);
//            break;
//    }
//    TIMER4_Start();
//}