| /PIC Stuff/Cerebot_32MX7_LED_Cube/BTN.c |
|---|
| 19,11 → 19,15 |
| INTDisableInterrupts(); |
| CNCONSET = 0x8000; // Turn on change notice interrupt |
| #if defined CEREBOT_32MX7 |
| CNENSET = 0x80300; // Set interrupt on CN8/9/19 |
| #elif defined CEREBOT_MX7CK |
| CNENSET = 0x00300; // Set interrupt on CN8/9 |
| #endif |
| int tmp = BTN1_PORT; |
| tmp = BTN2_PORT; |
| tmp = BTN3_PORT; |
| IPC6SET = 0x50000; // Set priority level = 1, sub-priority level = 1 |
| IPC6SET = 0xD0000; // Set priority level = 3, sub-priority level = 1 |
| IFS1CLR = 0x1; // Clear interrupt flag |
| IEC1SET = 0x1; // Enable interrupt |
| 30,7 → 34,7 |
| INTEnableInterrupts(); |
| } |
| void __ISR(_CHANGE_NOTICE_VECTOR, ipl1) __CN_Interrupt_Handler(void) { |
| void __ISR(_CHANGE_NOTICE_VECTOR, ipl3) __CN_Interrupt_Handler(void) { |
| // Upon interrupt, debounce input and call saved function |
| if (BTN1_PORT == 1) { |
| Delay_MS(BTN_DEBOUNCE_MS); |
| 46,6 → 50,7 |
| (*btn_data_ptr->callback_function_2)(); |
| } |
| } |
| #ifdef CEREBOT_32MX7 |
| if (BTN3_PORT == 1) { |
| Delay_MS(BTN_DEBOUNCE_MS); |
| if (BTN3_PORT == 1) { |
| 53,5 → 58,6 |
| (*btn_data_ptr->callback_function_3)(); |
| } |
| } |
| #endif |
| IFS1CLR = 0x1; // Clear interrupt flag |
| } |
| /PIC Stuff/Cerebot_32MX7_LED_Cube/BTN.h |
|---|
| 1,15 → 1,21 |
| #ifndef BTN_H |
| #define BTN_H |
| // BTN1 = CN8, BTN2 = CN9, BTN3 = CN19 |
| // BTN1 = RG6, BTN2 = RG7, BTN3 = RD13 |
| // BTN1 = CN8, BTN2 = CN9, BTN3 = CN19 (32MX7 only) |
| // BTN1 = RG6, BTN2 = RG7, BTN3 = RD13 (32MX7 only) |
| // Note: Write to PORTx is effectively the same as write to LATx |
| #define BTN1_TRIS TRISGbits.TRISG6 |
| #define BTN1_PORT PORTGbits.RG6 |
| #define BTN2_TRIS TRISGbits.TRISG7 |
| #define BTN2_PORT PORTGbits.RG7 |
| #if defined CEREBOT_32MX7 |
| #define BTN3_TRIS TRISDbits.TRISD13 |
| #define BTN3_PORT PORTDbits.RD13 |
| #elif defined CEREBOT_MX7CK |
| #define BTN3_TRIS TRISAbits.TRISA0 |
| #define BTN3_PORT PORTAbits.RA0 |
| #endif |
| #define BTN_DEBOUNCE_MS 1 |
| /PIC Stuff/Cerebot_32MX7_LED_Cube/CUBE.c |
|---|
| 18,6 → 18,8 |
| cube_data_ptr = data; |
| cube_data_ptr->current_layer = 0; |
| cube_data_ptr->rotation_counter = 0; |
| cube_data_ptr->frame_state = IDLE; |
| cube_data_ptr->frame_escape = 0; |
| SFT_D = 0; |
| SFT_S = 0; |
| 62,6 → 64,10 |
| SPI1_Write(cube_data_ptr->GCS_WRITE[cube_data_ptr->current_layer], GCS_LAYER_SIZE, &Cube_GCS_Write_Callback); |
| } |
| //////////////////////// |
| // Callback functions // |
| //////////////////////// |
| void Cube_DCS_Write_Callback(void) { |
| // GSLAT must be >7ms after DCS write |
| Delay_MS(7); |
| 101,6 → 107,10 |
| ? 0 : cube_data_ptr->current_layer + 1; |
| } |
| //////////////////////////// |
| // Cube control functions // |
| //////////////////////////// |
| void Cube_Write_DCS(char BC) { |
| XBLNK = 0; |
| int i,j; |
| 431,6 → 441,9 |
| } |
| } |
| /////////////////////////////// |
| // Overlay control functions // |
| /////////////////////////////// |
| void Cube_Overlay_Clear(void) { |
| int i,j; |
| 662,6 → 675,9 |
| } |
| } |
| //////////////////////////// |
| // Text control functions // |
| //////////////////////////// |
| void Cube_Text_Init(char *string, char length, int R, int G, int B) { |
| // Ensure that the length of the string does not exceed the storage buffer |
| 715,4 → 731,73 |
| } else { |
| cube_data_ptr->string_line += 1; |
| } |
| } |
| ///////////////////////////////////////////// |
| // Functions for processing streaming data // |
| ///////////////////////////////////////////// |
| void Cube_Data_In(char c) { |
| // Reset upon receiving the start char |
| if (c == CUBE_START_CHAR) { |
| cube_data_ptr->frame_length = 0; |
| cube_data_ptr->frame_index = 0; |
| cube_data_ptr->frame_checksum = 0; |
| cube_data_ptr->frame_command = 0; |
| cube_data_ptr->frame_state = READ_LENGTH_MSB; |
| } else { |
| // If the input is the escape char, XOR the next char received |
| if (c == CUBE_ESCAPE_CHAR) { |
| cube_data_ptr->frame_escape = 1; |
| return; |
| } |
| // XOR the input char if needed |
| if (cube_data_ptr->frame_escape) { |
| c ^= CUBE_ESCAPE_XOR; |
| cube_data_ptr->frame_escape = 0; |
| } |
| // Process data |
| switch (cube_data_ptr->frame_state) { |
| case READ_LENGTH_MSB: // Save MSB of length |
| cube_data_ptr->frame_length |= (c << 8); |
| cube_data_ptr->frame_state = READ_LENGTH_LSB; |
| break; |
| case READ_LENGTH_LSB: // Save LSB of length |
| cube_data_ptr->frame_length |= c; |
| cube_data_ptr->frame_state = READ_COMMAND; |
| break; |
| case READ_COMMAND: // Store the command byte |
| cube_data_ptr->frame_checksum += c; |
| cube_data_ptr->frame_command = c; |
| cube_data_ptr->frame_state = READ_DATA; |
| break; |
| case READ_DATA: // Read the passed data into the buffer |
| cube_data_ptr->frame_checksum += c; |
| cube_data_ptr->frame_buffer[cube_data_ptr->frame_index] = c; |
| cube_data_ptr->frame_index++; |
| if (cube_data_ptr->frame_index == cube_data_ptr->frame_length) |
| cube_data_ptr->frame_state = READ_CHECKSUM; |
| break; |
| case READ_CHECKSUM: // Process frame if checksum is valid |
| if (0xFF - (cube_data_ptr->frame_checksum && 0xFF) == c) |
| Cube_Data_In_Process_Frame(); |
| cube_data_ptr->frame_state = IDLE; |
| break; |
| case IDLE: |
| default: |
| // Do nothing |
| break; |
| } |
| } |
| } |
| void Cube_Data_In_Process_Frame(void) { |
| char *frame = cube_data_ptr->frame_buffer; |
| switch (cube_data_ptr->frame_command) { |
| case CUBE_COMMAND_SET_PIXEL: |
| Cube_Set_Pixel(frame[0], frame[1], frame[2], frame[3], frame[4], frame[5]); |
| break; |
| default: |
| break; |
| } |
| } |
| /PIC Stuff/Cerebot_32MX7_LED_Cube/CUBE.h |
|---|
| 1,6 → 1,7 |
| #ifndef CUBE_H |
| #define CUBE_H |
| // Cube Parameters |
| #define CUBE_ROW_COUNT 8 |
| #define CUBE_COLUMN_COUNT 8 |
| #define CUBE_LAYER_COUNT 8 |
| 9,8 → 10,7 |
| #define GCS_REG_SIZE 36 |
| #define GCS_LAYER_SIZE (GCS_REG_SIZE*CUBE_ROW_COUNT) |
| #define CUBE_STRING_MAX_LENGTH 32 |
| // Color Definitions |
| #define RED 0x08F,0x000,0x000 |
| #define ORANGE 0x08F,0x020,0x000 |
| #define YELLOW 0x08F,0x08F,0x000 |
| 19,6 → 19,7 |
| #define BLUE 0x000,0x000,0x08F |
| #define PURPLE 0x08F,0x000,0x08F |
| // Control Pin Declarations |
| #define SFT_D_TRIS TRISBbits.TRISB15 |
| #define SFT_S_TRIS TRISDbits.TRISD5 |
| #define SFT_K_TRIS TRISDbits.TRISD4 |
| 35,7 → 36,30 |
| #define GSLAT PORTDbits.RD9 |
| #define XBLNK PORTDbits.RD2 |
| // String Overlay Buffer Size |
| #define CUBE_STRING_MAX_LENGTH 32 |
| // Data Streaming In Buffer Size |
| #define CUBE_FRAME_BUFFER_SIZE 128 |
| #define CUBE_START_CHAR 0x7E |
| #define CUBE_ESCAPE_CHAR 0x7D |
| #define CUBE_ESCAPE_XOR 0x20 |
| // Data Streaming In Command Set |
| #define CUBE_COMMAND_SET_PIXEL 0x10 // Layer, Row, Column, R, G, B <-- frame layout |
| typedef enum { |
| IDLE, |
| READ_LENGTH_MSB, |
| READ_LENGTH_LSB, |
| READ_COMMAND, |
| READ_DATA, |
| READ_CHECKSUM |
| } PROCESS_STATE; |
| typedef struct { |
| // Variables for base cube |
| unsigned char GCS[CUBE_LAYER_COUNT][GCS_LAYER_SIZE]; |
| unsigned char GCS_OVERLAY[CUBE_LAYER_COUNT][GCS_LAYER_SIZE]; |
| unsigned char GCS_WRITE[CUBE_LAYER_COUNT][GCS_LAYER_SIZE]; |
| 42,11 → 66,21 |
| unsigned char current_layer; |
| unsigned char rotation_counter; |
| // Variables for the scrolling text |
| unsigned char string[CUBE_STRING_MAX_LENGTH]; |
| unsigned char string_length; |
| unsigned char string_index; |
| unsigned char string_line; |
| int string_R, string_G, string_B; |
| // Variables for input frame data |
| PROCESS_STATE frame_state; |
| unsigned char frame_buffer[CUBE_FRAME_BUFFER_SIZE]; |
| int frame_checksum; |
| int frame_length; |
| int frame_index; |
| int frame_command; |
| int frame_escape; |
| } CUBE_DATA; |
| void Cube_Init(CUBE_DATA *data, char BC); |
| 67,6 → 101,7 |
| void Cube_Rotate_Shell(char shell, char direction); |
| void Cube_Rotate(char direction); |
| // Overlay control functions |
| void Cube_Overlay_Clear(void); |
| void Cube_Overlay_Set_Pixel(int layer, int row, int column, int R, int G, int B); |
| void Cube_Overlay_Get_Pixel(int layer, int row, int column, int* R, int* G, int* B); |
| 73,8 → 108,13 |
| void Cube_Overlay_Move_Pixel(int layer1, int row1, int column1, int layer2, int row2, int column2); |
| void Cube_Overlay_Rotate_Shell(char shell, char direction); |
| // Text control functions |
| void Cube_Text_Init(char *string, char length, int R, int G, int B); |
| void Cube_Text_Interrupt(void); |
| // Data stream in control functions |
| void Cube_Data_In(char c); |
| void Cube_Data_In_Process_Frame(void); |
| #endif /* CUBE_H */ |
| /PIC Stuff/Cerebot_32MX7_LED_Cube/SPI1.c |
|---|
| 5,14 → 5,11 |
| static SPI1_DATA *spi_data_ptr; |
| void SPI1_Init(SPI1_DATA *data) { |
| void SPI1_Init(SPI1_DATA *data, void (*rx_callback)(char)) { |
| spi_data_ptr = data; |
| spi_data_ptr->outBufferInd = 0; |
| spi_data_ptr->outBufferLen = 0; |
| #ifndef SPI1_WRITE_ONLY |
| spi_data_ptr->inBufferInd = 0; |
| spi_data_ptr->inBufferLen = 0; |
| #endif |
| spi_data_ptr->buffer_out_ind = 0; |
| spi_data_ptr->buffer_out_len = 0; |
| spi_data_ptr->rx_callback = rx_callback; |
| INTDisableInterrupts(); |
| 38,7 → 35,7 |
| IPC5SET = 0x19000000; // Set IPL=6, Subpriority 1 |
| SPI1BRG = 0x1; // Use FPB/4 clock frequency |
| SPI1STATCLR = 0x40; // Clear the Overflow |
| #ifndef SPI1_WRITE_ONLY |
| #ifndef SPI_WRITE_ONLY |
| IEC0SET = 0x01800000; // Enable RX and Error interrupts |
| #endif |
| // Enhanced buffer, SPI on, 8 bits transfer, SMP=1, Master mode |
| 48,45 → 45,20 |
| INTEnableInterrupts(); |
| } |
| #ifndef SPI1_WRITE_ONLY |
| int SPI1_Read_Buffer(unsigned char *array, unsigned int count) { |
| if (count > SPI1_BUFFER_SIZE) |
| return 0; |
| if (spi_data_ptr->inBufferLen == 0) |
| return 0; |
| int SPI1_Write(unsigned char *array, unsigned int count, void (*tx_callback)(void)) { |
| spi_data_ptr->tx_callback = tx_callback; |
| // Save previous interrupt state |
| int prev = IEC0 & 0x03800000; |
| // Temporarily disable interrupts |
| IEC0CLR = 0x03800000; |
| int ret = spi_data_ptr->inBufferLen; |
| int i; |
| for (i = 0; i < count; i++) { |
| array[i] = spi_data_ptr->inBuffer[i]; |
| } |
| // Reset buffer pointers |
| spi_data_ptr->inBufferInd = 0; |
| spi_data_ptr->inBufferLen = 0; |
| // Restore saved interrupt state |
| IEC0SET = prev; |
| // Return the number of valid bytes in the buffer |
| return ret; |
| } |
| #endif |
| int SPI1_Write(unsigned char *array, unsigned int count, void (*callback)(void)) { |
| spi_data_ptr->callback_function = callback; |
| if (count > SPI1_BUFFER_SIZE) |
| return 0; |
| if (spi_data_ptr->outBufferLen != 0) |
| if (spi_data_ptr->buffer_out_len != 0) |
| return 0; |
| spi_data_ptr->outBufferLen = count; |
| spi_data_ptr->outBufferInd = count-1; |
| // Put the data to send into the outbound buffer |
| spi_data_ptr->buffer_out_len = count; |
| spi_data_ptr->buffer_out_ind = count-1; |
| int i; |
| for (i = 0; i < count; i++) { |
| spi_data_ptr->outBuffer[i] = array[i]; |
| spi_data_ptr->buffer_out[i] = array[i]; |
| } |
| IEC0SET = 0x02000000; // Enable TX interrupt |
| return 1; |
| 93,7 → 65,7 |
| } |
| void __ISR(_SPI_1_VECTOR, ipl6) __SPI_1_Interrupt_Handler(void) { |
| #ifndef SPI1_WRITE_ONLY |
| #ifndef SPI_WRITE_ONLY |
| // Process SPI1 error flag |
| if (IFS0bits.SPI1EIF) { |
| // Clear the receive overflow bit if it is set |
| 108,17 → 80,11 |
| int i; |
| // Read the data received from the last transfer |
| int rxBufferCount = SPI1STATbits.RXBUFELM; |
| if (spi_data_ptr->inBufferLen + rxBufferCount < SPI1_BUFFER_SIZE) { |
| for (i = 0; i < rxBufferCount; i++) { |
| spi_data_ptr->inBuffer[spi_data_ptr->inBufferInd] = SPI1BUF; |
| spi_data_ptr->inBufferInd++; |
| spi_data_ptr->inBufferLen++; |
| } |
| } else { |
| // If buffer is full, discard data in enhanced buffer |
| for (i = 0; i < rxBufferCount; i++) { |
| int tmp = SPI1BUF; |
| } |
| for (i = 0; i < rxBufferCount; i++) { |
| char c = SPI1BUF; |
| // Call the RX callback function on the received data |
| if (spi_data_ptr->rx_callback != NULL) |
| (*spi_data_ptr->rx_callback)(c); |
| } |
| IFS0CLR = 0x01000000; // Clear the RX flag |
| } |
| 128,25 → 94,25 |
| if (IFS0bits.SPI1TXIF) { |
| int i; |
| // Disable the transmit interrupt if all data has been sent |
| if (spi_data_ptr->outBufferLen == 0) { |
| if (spi_data_ptr->buffer_out_len == 0) { |
| IEC0CLR=0x02000000; |
| if (spi_data_ptr->callback_function != NULL) |
| (*spi_data_ptr->callback_function)(); |
| if (spi_data_ptr->tx_callback != NULL) |
| (*spi_data_ptr->tx_callback)(); |
| } else { |
| // Start transmitting the data in the buffer |
| int txBufferFree = 16 - SPI1STATbits.TXBUFELM; |
| if (spi_data_ptr->outBufferLen > txBufferFree) { |
| if (spi_data_ptr->buffer_out_len > txBufferFree) { |
| for (i = 0; i < txBufferFree; i++) { |
| SPI1BUF = spi_data_ptr->outBuffer[spi_data_ptr->outBufferInd]; |
| spi_data_ptr->outBufferInd--; |
| SPI1BUF = spi_data_ptr->buffer_out[spi_data_ptr->buffer_out_ind]; |
| spi_data_ptr->buffer_out_ind--; |
| } |
| spi_data_ptr->outBufferLen -= txBufferFree; |
| spi_data_ptr->buffer_out_len -= txBufferFree; |
| } else { |
| for (i = 0; i < spi_data_ptr->outBufferLen; i++) { |
| SPI1BUF = spi_data_ptr->outBuffer[spi_data_ptr->outBufferInd]; |
| spi_data_ptr->outBufferInd--; |
| for (i = 0; i < spi_data_ptr->buffer_out_len; i++) { |
| SPI1BUF = spi_data_ptr->buffer_out[spi_data_ptr->buffer_out_ind]; |
| spi_data_ptr->buffer_out_ind--; |
| } |
| spi_data_ptr->outBufferLen = 0; |
| spi_data_ptr->buffer_out_len = 0; |
| } |
| } |
| IFS0CLR = 0x02000000; // Clear the TX flag |
| /PIC Stuff/Cerebot_32MX7_LED_Cube/SPI1.h |
|---|
| 3,27 → 3,20 |
| #define SPI1_BUFFER_SIZE 300 |
| // Flag for selecting write-only on SPI1 |
| #define SPI1_WRITE_ONLY |
| #define SPI_WRITE_ONLY |
| typedef struct { |
| char outBuffer[SPI1_BUFFER_SIZE]; |
| int outBufferInd; |
| int outBufferLen; |
| #ifndef SPI1_WRITE_ONLY |
| char inBuffer[SPI1_BUFFER_SIZE]; |
| int inBufferInd; |
| int inBufferLen; |
| #endif |
| void (*callback_function)(void); |
| char buffer_out[SPI1_BUFFER_SIZE]; |
| int buffer_out_ind; |
| int buffer_out_len; |
| void (*tx_callback)(void); |
| void (*rx_callback)(char); |
| } SPI1_DATA; |
| void SPI1_Init(SPI1_DATA *data); |
| void SPI1_Init(SPI1_DATA *data, void (*rx_callback)(char)); |
| // Note: SPI1_Write() writes MSB -> LSB! |
| int SPI1_Write(unsigned char *array, unsigned int count, void (*callback)(void)); |
| #ifndef SPI1_WRITE_ONLY |
| int SPI1_Read_Buffer(unsigned char *array, unsigned int count); |
| #endif |
| int SPI1_Write(unsigned char *array, unsigned int count, void (*tx_callback)(void)); |
| #endif /* SPI1_H */ |
| /PIC Stuff/Cerebot_32MX7_LED_Cube/UART1.c |
|---|
| 0,0 → 1,95 |
| #include <xc.h> |
| #include <plib.h> |
| #include "defines.h" |
| #include "UART1.h" |
| static UART1_DATA *uart_data_ptr; |
| void UART1_Init(UART1_DATA *data, void (*rx_callback)(char)) { |
| uart_data_ptr = data; |
| uart_data_ptr->rx_callback = rx_callback; |
| uart_data_ptr->buffer_out_len = 0; |
| uart_data_ptr->buffer_out_ind = 0; |
| INTDisableInterrupts(); |
| IEC0CLR = 0x1C000000; // Disable all UART1 interrupts |
| IFS0CLR = 0x1C000000; // Clear any existing events |
| IPC6SET = 0x00000009; // Set Priority = 2, Subpriority = 1 |
| U1MODE = 0x00008000; // UART enabled, BRGH = 0 |
| U1STA = 0x00009400; // TX interrupt on buffer empty, RX interrupt on buffer not empty |
| U1BRG = 19; // Set baud rate to 256000 @ 80MHz |
| IEC0SET = 0x0C000000; // Enable the RX and Error interrupts |
| INTEnableInterrupts(); |
| TRISDbits.TRISD14 = 0; |
| PORTDbits.RD14 = 0; |
| } |
| int UART1_Write(char *string, int length) { |
| if (length > UART1_BUFFER_SIZE) |
| return 0; |
| if (uart_data_ptr->buffer_out_len != 0) |
| return 0; |
| // Put the data to send into the outbound buffer |
| uart_data_ptr->buffer_out_len = length; |
| uart_data_ptr->buffer_out_ind = 0; |
| int i; |
| for (i = 0; i < length; i++) { |
| uart_data_ptr->buffer_out[i] = string[i]; |
| } |
| IEC0SET = 0x10000000; // Enable TX interrupt |
| return 1; |
| } |
| void __ISR(_UART_1_VECTOR, ipl2) __UART_1_Interrupt_Handler(void) { |
| PORTDbits.RD14 = 1; |
| // Process UART1 error flag |
| if (IFS0bits.U1EIF) { |
| if (U1STAbits.PERR) { // Process parity error |
| } |
| if (U1STAbits.FERR) { // Process frame error |
| } |
| if (U1STAbits.OERR) { // Process receive buffer overrun error |
| U1STAbits.OERR = 0; // Clear the overrun error if set |
| } |
| IFS0CLR = 0x04000000; // Clear the error flag |
| } |
| // Process UART1 recieve flag |
| if (IFS0bits.U1RXIF) { |
| // Read the data received from the last transfer |
| while (U1STAbits.URXDA) { |
| char c = U1RXREG; |
| // Call the RX callback function on each received data |
| if (uart_data_ptr->rx_callback != NULL) { |
| (*uart_data_ptr->rx_callback)(c); |
| } |
| } |
| IFS0CLR = 0x08000000; // Clear the recieve flag |
| } |
| // Process UART1 transmit flag |
| if (IFS0bits.U1TXIF) { |
| // Disable the transmit interrupt if all data has been sent |
| if (uart_data_ptr->buffer_out_ind == uart_data_ptr->buffer_out_len) { |
| IEC0CLR = 0x10000000; |
| uart_data_ptr->buffer_out_len = 0; |
| } else { |
| // Start filling the transmit buffer |
| while (!U1STAbits.UTXBF) { |
| U1TXREG = uart_data_ptr->buffer_out[uart_data_ptr->buffer_out_ind]; |
| uart_data_ptr->buffer_out_ind++; |
| if (uart_data_ptr->buffer_out_ind == uart_data_ptr->buffer_out_len) |
| break; |
| } |
| } |
| IFS0CLR = 0x10000000; // Clear the transmit flag |
| } |
| PORTDbits.RD14 = 0; |
| } |
| /PIC Stuff/Cerebot_32MX7_LED_Cube/UART1.h |
|---|
| 0,0 → 1,17 |
| #ifndef UART1_H |
| #define UART1_H |
| #define UART1_BUFFER_SIZE 128 |
| typedef struct { |
| void (*rx_callback)(char c); |
| char buffer_out[UART1_BUFFER_SIZE]; |
| int buffer_out_ind; |
| int buffer_out_len; |
| } UART1_DATA; |
| void UART1_Init(UART1_DATA *data, void (*rx_callback)(char)); |
| int UART1_Write(char *string, int length); |
| #endif /* UART1_H */ |
| /PIC Stuff/Cerebot_32MX7_LED_Cube/defines.h |
|---|
| 1,5 → 1,9 |
| // PIC32MX795F512L |
| // Uncomment ONE of the following: |
| //#define CEREBOT_32MX7 |
| #define CEREBOT_MX7CK |
| // Power supply must be 5V for proper operation of the board! |
| #define CPU_CLOCK_HZ 80000000UL |
| 65,7 → 69,7 |
| JE-02 SCL3/SDO3/U1TX/RF8 RF08 |
| JE-03 SDA3/SDI3/U1RX/RF2 RF02 |
| JE-04 AETXD1/SCK3/U4TX/U1RTS/CN21/RD15 RD15 |
| JE-07 TRCLK/RA6 RA06 |
| JE-07 TRCLK/RA6 RA06 on 32MX7 or INT1/RF8 on MX7CK |
| JE-08 TRD3/RA7 RA07 |
| JE-09 Vref-/CVref-/AERXD2/PMA7/RA9 RA09 |
| JE-10 Vref+/CVref+/AERXD3/PMA6/RA10 RA10 |
| 74,7 → 78,7 |
| JF-02 SCL5/SDO4/U2TX/PMA8/CN18/RF5 RF05 |
| JF-03 SDA5/SDI4/U2RX/PMA9/CN17/RF4 RF04 |
| JF-04 AC1TX/SCK4/U5TX/U2RTS/RF13 RF13 shared with CAN1 Transceiver (JP-2) |
| JF-07 TMS/RA0 RA00 |
| JF-07 TMS/RA0 RA00 on 32MX7 or INT2/RF9 on MX7CK |
| JF-08 TCK/RA1 RA01 |
| JF-09 TDI/RA4 RA04 |
| JF-10 TDO/RA5 RA05 |
| 117,10 → 121,17 |
| // <editor-fold defaultstate="collapsed" desc="Connectors"> |
| /* |
| J7 - I2C port #2 daisy chain connector |
| * This connector provides access to the I2C signals, power and ground for I2C port #2. |
| J8 - I2C port #1 daisy chain connector |
| * This connector provides access to the I2C signals, power and ground for I2C port #1. |
| J1 - Serial USB Misc Connections (MX7CK only) |
| * This header contains other FTDI UART function pins (CTS, DSR, DCD, RI) |
| J2 - Serial USB Connector (MX7CK only) |
| * This connector is connected to UART1 or PMOD JE |
| J7 - I2C port daisy chain connector |
| * On the Cerebot 32MX7, this connector provides access to the I2C signals, power and ground for I2C2. |
| * On the Cerebot MX7CK, this connector provides access to the I2C signals, power and ground for I2C1 + INT3/4. |
| J8 - I2C port daisy chain connector |
| * On the Cerebot 32MX7, this connector provides access to the I2C signals, power and ground for I2C1. |
| * On the Cerebot MX7CK, this connector provides access to the I2C signals, power and ground for I2C2. |
| EEPROM is changed to this port on the MX7CK |
| J9 - CAN #1 Connector |
| * This connector is used to access the signals for CAN #1. |
| J10 - CAN #2 Connector |
| 161,10 → 172,6 |
| // <editor-fold defaultstate="collapsed" desc="Jumpers"> |
| /* |
| J20 - USB Host Connector |
| * This is a standard sized USB type A connector. This connector is used to |
| connect USB devices to the board when using the PIC32MX795 microcontroller |
| to implement an embedded USB host. |
| JP1 & JP2 - CAN or Pmod Select |
| * These jumpers select microcontroller signals RF12 and RF13 for use with CAN |
| #1 or Pmod connector JF. Place these jumpers in the CAN position to use CAN |
| 191,11 → 198,14 |
| Insert the shorting block to connect the board 5V0 supply to pins 9 & 10 of |
| CAN #1 connector. Remove the shorting block to disconnect the 5V0 supply. |
| JP9 - Do Not Use |
| JP10 - USB host power select |
| JP10 - USB Host Power Select |
| * This jumper is used to select which host connector is powered when host power |
| is enabled. Place the shorting block in the ?MICRO? position to supply power |
| to the USB micro-AB OTG Connector, J19. Place the shorting block in the ?A? |
| position to supply power to the USB type A Host Connector, J20. |
| JP11 - Programmer Serial Select (MX7CK only) |
| * Remove the jumper to disconnect the USB serial converter's connection to the |
| MCLR pin. Disconnecting this when using the built in debugger is recommended. |
| JP17 - Do Not Use |
| */ |
| // </editor-fold> |
| /PIC Stuff/Cerebot_32MX7_LED_Cube/main.c |
|---|
| 39,6 → 39,7 |
| #include <plib.h> |
| #include <stdlib.h> |
| #include "defines.h" |
| #include "UART1.h" |
| #include "SPI1.h" |
| #include "TIMER4.h" |
| #include "TIMER5.h" |
| 86,15 → 87,19 |
| // Set all analog I/O pins to digital |
| AD1PCFGSET = 0xFFFF; |
| // Initialize peripherals |
| // Initialize the SPI1 module |
| SPI1_DATA spi_data; |
| SPI1_Init(&spi_data); |
| SPI1_Init(&spi_data, NULL); |
| // Initializs the PWM output to 20MHz |
| // Initialize the UART1 module |
| UART1_DATA uart_data; |
| UART1_Init(&uart_data, &Cube_Data_In); |
| // Initializs the PWM2 output to 20MHz |
| PWM2_Init(); |
| PWM2_Start(); |
| // Initialize the cube |
| // Initialize the cube variables |
| CUBE_DATA cube_data; |
| Cube_Init(&cube_data, 0x40); |
| 121,6 → 126,9 |
| // Cube_Set_All(BLUE); |
| // Delay_MS(6000); |
| char start_text[] = "uC Started"; |
| UART1_Write(start_text, 10); |
| // Set the overlay text |
| char text_string[] = "Welcome to the CCM Lab "; |
| Cube_Text_Init(text_string, 26, 0xFF, 0xFF, 0xFF); |
| /PIC Stuff/Cerebot_32MX7_LED_Cube/nbproject/Makefile-default.mk |
|---|
| 45,11 → 45,11 |
| DISTDIR=dist/${CND_CONF}/${IMAGE_TYPE} |
| # Object Files Quoted if spaced |
| OBJECTFILES_QUOTED_IF_SPACED=${OBJECTDIR}/main.o ${OBJECTDIR}/SPI1.o ${OBJECTDIR}/TIMER5.o ${OBJECTDIR}/CUBE.o ${OBJECTDIR}/PWM2.o ${OBJECTDIR}/BTN.o ${OBJECTDIR}/TIMER4.o |
| POSSIBLE_DEPFILES=${OBJECTDIR}/main.o.d ${OBJECTDIR}/SPI1.o.d ${OBJECTDIR}/TIMER5.o.d ${OBJECTDIR}/CUBE.o.d ${OBJECTDIR}/PWM2.o.d ${OBJECTDIR}/BTN.o.d ${OBJECTDIR}/TIMER4.o.d |
| OBJECTFILES_QUOTED_IF_SPACED=${OBJECTDIR}/main.o ${OBJECTDIR}/SPI1.o ${OBJECTDIR}/TIMER5.o ${OBJECTDIR}/CUBE.o ${OBJECTDIR}/PWM2.o ${OBJECTDIR}/BTN.o ${OBJECTDIR}/TIMER4.o ${OBJECTDIR}/UART1.o |
| POSSIBLE_DEPFILES=${OBJECTDIR}/main.o.d ${OBJECTDIR}/SPI1.o.d ${OBJECTDIR}/TIMER5.o.d ${OBJECTDIR}/CUBE.o.d ${OBJECTDIR}/PWM2.o.d ${OBJECTDIR}/BTN.o.d ${OBJECTDIR}/TIMER4.o.d ${OBJECTDIR}/UART1.o.d |
| # Object Files |
| OBJECTFILES=${OBJECTDIR}/main.o ${OBJECTDIR}/SPI1.o ${OBJECTDIR}/TIMER5.o ${OBJECTDIR}/CUBE.o ${OBJECTDIR}/PWM2.o ${OBJECTDIR}/BTN.o ${OBJECTDIR}/TIMER4.o |
| OBJECTFILES=${OBJECTDIR}/main.o ${OBJECTDIR}/SPI1.o ${OBJECTDIR}/TIMER5.o ${OBJECTDIR}/CUBE.o ${OBJECTDIR}/PWM2.o ${OBJECTDIR}/BTN.o ${OBJECTDIR}/TIMER4.o ${OBJECTDIR}/UART1.o |
| CFLAGS= |
| 120,6 → 120,11 |
| @${RM} ${OBJECTDIR}/TIMER4.o.d |
| @${FIXDEPS} "${OBJECTDIR}/TIMER4.o.d" $(SILENT) -rsi ${MP_CC_DIR}../ -c ${MP_CC} $(MP_EXTRA_CC_PRE) -g -D__DEBUG -D__MPLAB_DEBUGGER_PK3=1 -fframe-base-loclist -x c -c -mprocessor=$(MP_PROCESSOR_OPTION) -O1 -funroll-loops -MMD -MF "${OBJECTDIR}/TIMER4.o.d" -o ${OBJECTDIR}/TIMER4.o TIMER4.c |
| ${OBJECTDIR}/UART1.o: UART1.c nbproject/Makefile-${CND_CONF}.mk |
| @${MKDIR} ${OBJECTDIR} |
| @${RM} ${OBJECTDIR}/UART1.o.d |
| @${FIXDEPS} "${OBJECTDIR}/UART1.o.d" $(SILENT) -rsi ${MP_CC_DIR}../ -c ${MP_CC} $(MP_EXTRA_CC_PRE) -g -D__DEBUG -D__MPLAB_DEBUGGER_PK3=1 -fframe-base-loclist -x c -c -mprocessor=$(MP_PROCESSOR_OPTION) -O1 -funroll-loops -MMD -MF "${OBJECTDIR}/UART1.o.d" -o ${OBJECTDIR}/UART1.o UART1.c |
| else |
| ${OBJECTDIR}/main.o: main.c nbproject/Makefile-${CND_CONF}.mk |
| @${MKDIR} ${OBJECTDIR} |
| 156,6 → 161,11 |
| @${RM} ${OBJECTDIR}/TIMER4.o.d |
| @${FIXDEPS} "${OBJECTDIR}/TIMER4.o.d" $(SILENT) -rsi ${MP_CC_DIR}../ -c ${MP_CC} $(MP_EXTRA_CC_PRE) -g -x c -c -mprocessor=$(MP_PROCESSOR_OPTION) -O1 -funroll-loops -MMD -MF "${OBJECTDIR}/TIMER4.o.d" -o ${OBJECTDIR}/TIMER4.o TIMER4.c |
| ${OBJECTDIR}/UART1.o: UART1.c nbproject/Makefile-${CND_CONF}.mk |
| @${MKDIR} ${OBJECTDIR} |
| @${RM} ${OBJECTDIR}/UART1.o.d |
| @${FIXDEPS} "${OBJECTDIR}/UART1.o.d" $(SILENT) -rsi ${MP_CC_DIR}../ -c ${MP_CC} $(MP_EXTRA_CC_PRE) -g -x c -c -mprocessor=$(MP_PROCESSOR_OPTION) -O1 -funroll-loops -MMD -MF "${OBJECTDIR}/UART1.o.d" -o ${OBJECTDIR}/UART1.o UART1.c |
| endif |
| # ------------------------------------------------------------------------------------ |
| /PIC Stuff/Cerebot_32MX7_LED_Cube/nbproject/Makefile-genesis.properties |
|---|
| 1,5 → 1,5 |
| # |
| #Sun Jul 07 22:44:27 EDT 2013 |
| #Wed Aug 07 15:16:19 EDT 2013 |
| default.com-microchip-mplab-nbide-toolchainXC32-XC32LanguageToolchain.md5=6b4fa04caf3910c7c3a4666b1aea8c5c |
| default.languagetoolchain.dir=C\:\\Program Files (x86)\\Microchip\\xc32\\v1.20\\bin |
| com-microchip-mplab-nbide-embedded-makeproject-MakeProject.md5=415494acd195d89b2f6d7a36797a5ab4 |
| /PIC Stuff/Cerebot_32MX7_LED_Cube/nbproject/configurations.xml |
|---|
| 12,6 → 12,7 |
| <itemPath>PWM2.h</itemPath> |
| <itemPath>TIMER4.h</itemPath> |
| <itemPath>glcdfont.h</itemPath> |
| <itemPath>UART1.h</itemPath> |
| </logicalFolder> |
| <logicalFolder name="LinkerScript" |
| displayName="Linker Files" |
| 27,6 → 28,7 |
| <itemPath>PWM2.c</itemPath> |
| <itemPath>BTN.c</itemPath> |
| <itemPath>TIMER4.c</itemPath> |
| <itemPath>UART1.c</itemPath> |
| </logicalFolder> |
| <logicalFolder name="ExternalFiles" |
| displayName="Important Files" |
| /PIC Stuff/Cerebot_32MX7_LED_Cube/nbproject/private/configurations.xml |
|---|
| 4,7 → 4,7 |
| <defaultConf>0</defaultConf> |
| <confs> |
| <conf name="default" type="2"> |
| <platformToolSN>:=MPLABCommUSB:=04D8:=8108:=0002:=Digilent:=Cerebot 32MX7:=D370400:=x:=en</platformToolSN> |
| <platformToolSN>:=MPLABCommUSB:=04D8:=8108:=0002:=Digilent:=CerebotMX7CK:=D459520:=x:=en</platformToolSN> |
| <languageToolchainDir>C:\Program Files (x86)\Microchip\xc32\v1.20\bin</languageToolchainDir> |
| <mdbdebugger version="1"> |
| <placeholder1>place holder 1</placeholder1> |