// // Version 1.2 03/03/09 BPS : Fixed problem with boot_software_key_sec so it will work reliably with bootloader (forgot leading .) #include "GenericTypeDefs.h" #include "Compiler.h" #include "usb_config.h" //#include "USB/usb_device.h" #include "USB/usb.h" #include "USB/usb_function_cdc.h" #include "HardwareProfile.h" #include "D32.h" #define bitset(var,bitno) ((var) |= (1 << (bitno))) #define bitclr(var,bitno) ((var) &= ~(1 << (bitno))) #define bittst(var,bitno) (((var) & (1 << (bitno)))?1:0) #define bitinvert(var,bitno) ((var) ^ (1 << (bitno))) #define kTX_BUF_SIZE (64) // In bytes #define kRX_BUF_SIZE (64) // In bytes #define kUSART_TX_BUF_SIZE (64) // In bytes #define kUSART_RX_BUF_SIZE (64) // In bytes #define kMAX_PORTS (7) // Enum for extract_num() function parameter typedef enum { kCHAR ,kUCHAR ,kINT ,kUINT ,kASCII_CHAR ,kUCASE_ASCII_CHAR } ExtractType; typedef enum { kEXTRACT_OK = 0 ,kEXTRACT_PARAMETER_OUTSIDE_LIMIT ,kEXTRACT_COMMA_MISSING ,kEXTRACT_MISSING_PARAMETER ,kEXTRACT_INVALID_TYPE } ExtractReturnType; #define kREQUIRED FALSE #define kOPTIONAL TRUE #define advance_RX_buf_out() \ { \ g_RX_buf_out++; \ if (kRX_BUF_SIZE == g_RX_buf_out) \ { \ g_RX_buf_out = 0; \ } \ } #define kISR_FIFO_A_DEPTH 3 #define kISR_FIFO_D_DEPTH 3 #define kCR 0x0D #define kLF 0x0A #define kBS 0x08 // defines for the error_byte byte - each bit has a meaning #define kERROR_BYTE_TX_BUF_OVERRUN 2 #define kERROR_BYTE_RX_BUFFER_OVERRUN 3 #define kERROR_BYTE_MISSING_PARAMETER 4 #define kERROR_BYTE_PRINTED_ERROR 5 // We've already printed out an error #define kERROR_BYTE_PARAMETER_OUTSIDE_LIMIT 6 #define kERROR_BYTE_EXTRA_CHARACTERS 7 #define kERROR_BYTE_UNKNOWN_COMMAND 8 // Part of command parser, not error handler // Let compile time pre-processor calculate the CORE_TICK_PERIOD #define SYS_FREQ (80000000L) #define TOGGLES_PER_SEC 1000 #define CORE_TICK_RATE (SYS_FREQ/2/TOGGLES_PER_SEC) static char USB_In_Buffer[64]; // Local variables for this file (statics) static WORD old_swUser; static WORD old_swProgram; // This byte has each of its bits used as a seperate error flag static BYTE error_byte; // ROM strings const char st_OK[] = {"OK\r\n"}; const char st_LFCR[] = {"\r\n"}; const char st_version[] = {"UBW32 Version 1.2"}; const char ErrorStrings[8][40] = { "!0 \r\n", // Unused as of yet "!1 \r\n", // Unused as of yet "!2 Err: TX Buffer overrun\r\n", // kERROR_BYTE_TX_BUF_OVERRUN "!3 Err: RX Buffer overrun\r\n", // kERROR_BYTE_RX_BUFFER_OVERRUN "!4 Err: Missing parameter(s)\r\n", // kERROR_BYTE_MISSING_PARAMETER "", // kERROR_BYTE_PRINTED_ERROR (something already printed) "!6 Err: Invalid paramter value\r\n", // kERROR_BYTE_PARAMETER_OUTSIDE_LIMIT "!7 Err: Extra parmater\r\n" // kERROR_BYTE_EXTRA_CHARACTERS }; // USB Transmit buffer for packets (back to PC) unsigned char g_TX_buf[kTX_BUF_SIZE]; // USB Receiving buffer for commands as they come from PC unsigned char g_RX_buf[kRX_BUF_SIZE]; // USART Receiving buffer for data coming from the USART unsigned char g_USART_RX_buf[kUSART_RX_BUF_SIZE]; // USART Transmit buffer for data going to the USART unsigned char g_USART_TX_buf[kUSART_TX_BUF_SIZE]; // Pointers to USB transmit (back to PC) buffer unsigned char g_TX_buf_in; unsigned char g_TX_buf_out; unsigned char g_TX_buf_length; // Pointers to USB receive (from PC) buffer unsigned char g_RX_buf_in; unsigned char g_RX_buf_out; // In and out pointers to our USART input buffer unsigned char g_USART_RX_buf_in; unsigned char g_USART_RX_buf_out; // In and out pointers to our USART output buffer unsigned char g_USART_TX_buf_in; unsigned char g_USART_TX_buf_out; // Normally set to TRUE. Able to set FALSE to not send "OK" message after packet recepetion BOOL g_ack_enable; // Normally set to TRUE. Set to false to disable echoing of all data sent to UBW BOOL g_echo_enable; // Used in T1 command to time the LEDs. In ms. volatile unsigned int T1_timer; volatile unsigned int * const ROM LATPtr[kMAX_PORTS] = { &LATA, &LATB, &LATC, &LATD, &LATE, &LATF, &LATG }; volatile unsigned int * const ROM PORTPtr[kMAX_PORTS] = { &PORTA, &PORTB, &PORTC, &PORTD, &PORTE, &PORTF, &PORTG }; volatile unsigned int * const ROM TRISPtr[kMAX_PORTS] = { &TRISA, &TRISB, &TRISC, &TRISD, &TRISE, &TRISF, &TRISG }; volatile unsigned int * const ROM ODCPtr[kMAX_PORTS] = { &ODCA, &ODCB, &ODCC, &ODCD, &ODCE, &ODCF, &ODCG }; unsigned int __attribute__((section(".boot_software_key_sec,\"aw\",@nobits#"))) SoftwareKey; /** P R I V A T E P R O T O T Y P E S ***************************************/ void parse_packet (void); // Take a full packet and dispatch it to the right function ExtractReturnType extract_number( ExtractType Type, void * ReturnValue, unsigned char Required ); // Pull a number paramter out of the packet signed char extract_digit (signed long * acc, unsigned char digits); // Pull a character out of the packet void PrintErrors (void); // Prints out any errors in error_byte void parse_R_packet (void); // R for resetting UBW void parse_BL_packet (void); // BL for entering into bootloader void parse_C_packet (void); // C for configuring I/O and analog pins void parse_CX_packet (void); // CX For configuring serial port void parse_O_packet (void); // O for output digital to pins void parse_I_packet (void); // I for input digital from pins void parse_V_packet (void); // V for printing version void parse_A_packet (void); // A for requesting analog inputs void parse_T_packet (void); // T for setting up timed I/O (digital or analog) void parse_PI_packet (void); // PI for reading a single pin void parse_PO_packet (void); // PO for setting a single pin state void parse_PD_packet (void); // PD for setting a pin's direction void parse_MR_packet (void); // MR for Memory Read void parse_MW_packet (void); // MW for Memory Write void parse_TX_packet (void); // TX for transmitting serial void parse_RX_packet (void); // RX for receiving serial void parse_RC_packet (void); // RC is for outputing RC servo pulses void parse_BO_packet (void); // BO sends data to fast parallel output void parse_BC_packet (void); // BC configures fast parallel outputs void parse_BS_packet (void); // BS sends binary data to fast parallel output void parse_CU_packet (void); // CU configures UBW (system wide parameters) void parse_SS_packet (void); // SS Send SPI void parse_RS_packet (void); // RS Receive SPI void parse_CS_packet (void); // CS Configure SPI void parse_SI_packet (void); // SI Send I2C void parse_RI_packet (void); // RI Receive I2C void parse_CI_packet (void); // CI Configure I2C void parse_TP_packet (void); // TP Toggle Pin void parse_SL_packet (void); // SL Set Latch void parse_TO_packet (void); // TO porT Output void parse_TI_packet (void); // TI porT Input void parse_PW_packet (void); // PW PWm on any pin void parse_SC_packet (void); // SC Serial Configure (serial shift) void parse_SO_packet (void); // SO Serial Output (serial shift) void parse_EC_packet (void); // EC stEpper Configure void parse_ES_packet (void); // SS stEpper Step void parse_T1_packet (void); // T1 for Test number 1 (cycle all I/Os) void StartWrite(void); // Sets up write enable in hardware for EEPROM unsigned char ReadEE(unsigned char Address); // Reads a byte of EEPROM void WriteEE(unsigned char Address, unsigned char Data); // Writes a byte of EEPROM void check_and_send_TX_data (void); // See if there is any data to send to PC, and if so, do it void PrintAck (void); // Print "OK" after packet is parsed void _mon_putc (char c); // Our USB based stream character printer unsigned char CheckLatchingInput (unsigned char PortIndex, unsigned char LatchingClearMask); // Handles the latching of inputs typedef struct { unsigned char Name1; unsigned char Name2; void (*CommandPtr)(void); } CommandListType; const CommandListType CommandList[] = { {'R',0x00, &parse_R_packet}, {'C',0x00, &parse_C_packet}, // {'C','X', &parse_CX_packet}, {'O',0x00, &parse_O_packet}, {'I',0x00, &parse_I_packet}, {'V',0x00, &parse_V_packet}, // {'A',0x00, &parse_A_packet}, // {'T',0x00, &parse_T_packet}, {'P','I', &parse_PI_packet}, {'P','O', &parse_PO_packet}, {'P','D', &parse_PD_packet}, // {'M','R', &parse_MR_packet}, // {'M','W', &parse_MW_packet}, // {'T','X', &parse_TX_packet}, // {'R','X', &parse_RX_packet}, // {'R','C', &parse_RC_packet}, // {'B','O', &parse_BO_packet}, // {'B','C', &parse_BC_packet}, // {'B','S', &parse_BS_packet}, {'C','U', &parse_CU_packet}, // {'S','S', &parse_SS_packet}, // {'R','S', &parse_RS_packet}, // {'C','I', &parse_CS_packet}, // {'S','I', &parse_SI_packet}, // {'R','I', &parse_RI_packet}, // {'C','I', &parse_CI_packet}, // {'T','P', &parse_TP_packet}, // {'S','L', &parse_SL_packet}, {'T','O', &parse_TO_packet}, {'T','I', &parse_TI_packet}, // {'P','W', &parse_PW_packet}, // {'S','C', &parse_SC_packet}, // {'S','O', &parse_SO_packet}, // {'E','C', &parse_EC_packet}, // {'E','S', &parse_ES_packet}, {'B','L', &parse_BL_packet}, {'T','1', &parse_T1_packet}, {0x00,0x00, NULL} }; void __ISR(_CORE_TIMER_VECTOR, ipl2) CoreTimerHandler(void) { // clear the interrupt flag mCTClearIntFlag(); if (T1_timer) { T1_timer--; } // update the period UpdateCoreTimer(CORE_TICK_RATE); } /* Switch routines */ BOOL SwitchUserIsPressed(void) { if(swUser != old_swUser) { old_swUser = swUser; // Save new value if(swUser == 0) // If pressed return TRUE; // Was pressed }//end if return FALSE; // Was not pressed } BOOL SwitchProgramIsPressed(void) { if(swProgram != old_swProgram) { old_swProgram = swProgram; // Save new value if(swProgram == 0) // If pressed return TRUE; // Was pressed }//end if return FALSE; // Was not pressed } /** D E C L A R A T I O N S **************************************************/ /****************************************************************************** * Function: void UserInit(void) * * PreCondition: None * * Input: None * * Output: None * * Side Effects: None * * Overview: This routine should take care of all of the demo code * initialization that is required. * * Note: * *****************************************************************************/ void UserInit(void) { char i; // Loop through each I/O register, setting them all to digital inputs // and making none of them open drain and turning off all pullups and // setting all of the latches to zero. We have PORTA through PORTG on // this chip. That's 7 total. for (i = 0; i < 7; i++) { *LATPtr[i] = 0x0000; *TRISPtr[i] = 0xFFFF; *ODCPtr[i] = 0x0000; } //Initialize all of the LED pins mInitAllLEDs(); // Start off always using "OK" acknoledge. g_ack_enable = TRUE; // Start off always echoing all data sent to us g_echo_enable = TRUE; // Inialize USB TX and RX buffer management g_RX_buf_in = 0; g_RX_buf_out = 0; g_TX_buf_in = 0; g_TX_buf_out = 0; g_TX_buf_length = 0; // And the USART TX and RX buffer management g_USART_RX_buf_in = 0; g_USART_RX_buf_out = 0; g_USART_TX_buf_in = 0; g_USART_TX_buf_out = 0; // Open up the core timer at our 1ms rate OpenCoreTimer(CORE_TICK_RATE); // set up the core timer interrupt with a prioirty of 2 and zero sub-priority mConfigIntCoreTimer((CT_INT_ON | CT_INT_PRIOR_2 | CT_INT_SUB_PRIOR_0)); // enable multi-vector interrupts INTEnableSystemMultiVectoredInt(); }//end UserInit /******************************************************************** * Function: void ProcessIO(void) * * PreCondition: None * * Input: None * * Output: None * * Side Effects: None * * Overview: This function is a place holder for other user * routines. It is a mixture of both USB and * non-USB tasks. * * Note: None *******************************************************************/ void ProcessIO(void) { static BOOL in_cr = FALSE; static char last_fifo_size; unsigned char tst_char; unsigned char RXBufInTemp; BOOL got_full_packet = FALSE; cdc_rx_len = 0; BYTE numBytesRead; //Blink the LEDs according to the USB device status BlinkUSBStatus(); // User Application USB tasks if((USBDeviceState < CONFIGURED_STATE)||(USBSuspendControl==1)) return; // Pull in some new data if there is new data to pull in numBytesRead = getsUSBUSART(USB_In_Buffer,64); if(numBytesRead != 0) { // Copy data from USB buffer to our buffer for(cdc_rx_len = 0; cdc_rx_len < numBytesRead; cdc_rx_len++) { // Check to see if we are in a CR/LF situation tst_char = USB_In_Buffer[cdc_rx_len]; if (g_echo_enable) { _mon_putc(tst_char); if (kCR == tst_char) { _mon_putc(kLF); } if (kBS == tst_char) { _mon_putc(' '); _mon_putc(kBS); } } if ( !in_cr && ( kCR == tst_char || kLF == tst_char ) ) { in_cr = TRUE; g_RX_buf[g_RX_buf_in] = kCR; g_RX_buf_in++; // At this point, we know we have a full packet // of information from the PC to parse got_full_packet = TRUE; } else if ( tst_char != kCR && tst_char != kLF ) { in_cr = FALSE; if (kBS == tst_char) { // Check to see that we're not already at the beginning if (g_RX_buf_in != g_RX_buf_out) { // If we have backspace, then handle that here // Then decriment the input pointer if (g_RX_buf_in > 0) { g_RX_buf_in--; } else { g_RX_buf_in = kRX_BUF_SIZE - 1; } } continue; } else { // Only add a byte if it is not a CR or LF or BS g_RX_buf[g_RX_buf_in] = tst_char; g_RX_buf_in++; } } else { continue; } // Check for buffer wraparound if (kRX_BUF_SIZE == g_RX_buf_in) { g_RX_buf_in = 0; } // If we hit the out pointer, then this is bad. if (g_RX_buf_in == g_RX_buf_out) { bitset (error_byte, kERROR_BYTE_RX_BUFFER_OVERRUN); break; } // Now, if we've gotten a full command (user send ) then // go call the code that deals with that command, and then // keep parsing. (This allows multiple small commands per packet) if (got_full_packet) { parse_packet (); got_full_packet = FALSE; } PrintErrors (); } } PrintErrors(); // Go send any data that needs sending to PC check_and_send_TX_data (); CDCTxService(); } // This routine checks to see if any of the bits in error_byte // are set, and if so, prints out the corresponding error string. void PrintErrors (void) { unsigned char Bit; // Check for any errors logged in error_byte that need to be sent out if (error_byte) { for (Bit = 0; Bit < 8; Bit++) { if (bittst (error_byte, Bit)) { printf (ErrorStrings[Bit]); } } error_byte = 0; } } // This is our replacement for the standard putc routine // This enables printf() and all related functions to print to // the USB output (i.e. to the PC) buffer void _mon_putc (char c) { // Only add chars to USB buffer if it's configured! if((USBDeviceState < CONFIGURED_STATE)||(USBSuspendControl==1)) { return; } // We need to check to see if adding this character will // cause us to become overfull. // We want to sit and just process USB tasks if our buffer // is full. if (g_TX_buf_length >= (kTX_BUF_SIZE - 2)) { while (g_TX_buf_length > 0) { // In this case, we want to puase for a moment, send out these // characers to the PC over USB, and then clear out out buffer. check_and_send_TX_data(); } } // Copy the character into the output buffer g_TX_buf[g_TX_buf_in] = c; g_TX_buf_in++; g_TX_buf_length++; // Check for wrap around if (kTX_BUF_SIZE == g_TX_buf_in) { g_TX_buf_in = 0; } // Also check to see if we bumped up against our output pointer if (g_TX_buf_in == g_TX_buf_out) { bitset (error_byte, kERROR_BYTE_TX_BUF_OVERRUN); g_TX_buf_in = 0; g_TX_buf_out = 0; g_TX_buf_length = 0; } return; } // In this function, we check to see it is OK to transmit. If so // we see if there is any data to transmit to PC. If so, we schedule // it for sending. void check_and_send_TX_data (void) { char temp; unsigned char i; char TempBuf[64]; // Only send if there's something there to send if (g_TX_buf_length != 0) { // We're going to sit and spin and wait until // can transmit while (!mUSBUSARTIsTxTrfReady ()) { USBDeviceTasks(); CDCTxService(); } // Now copy over all of the FIFO bytes into our temp buffer for (i = 0; i < g_TX_buf_length; i++) { TempBuf[i] = g_TX_buf[g_TX_buf_out]; g_TX_buf_out++; if (g_TX_buf_out == kTX_BUF_SIZE) { g_TX_buf_out = 0; } } putUSBUSART (TempBuf, g_TX_buf_length); g_TX_buf_length = 0; g_TX_buf_out = g_TX_buf_in; USBDeviceTasks(); CDCTxService(); } } // Look at the new packet, see what command it is, and // route it appropriately. We come in knowing that // our packet is in g_RX_buf[], and that the beginning // of the packet is at g_RX_buf_out, and the end (CR) is at // g_RX_buf_in. Note that because of buffer wrapping, // g_RX_buf_in may be less than g_RX_buf_out. void parse_packet(void) { unsigned char CommandNumber = 0; unsigned char CmdName1 = 0; unsigned char CmdName2 = 0; // Always grab the first character (which is the first byte of the command) CmdName1 = toupper (g_RX_buf[g_RX_buf_out]); if (kCR == CmdName1) { goto parse_packet_end; } advance_RX_buf_out(); // Only grab second one if it is not a comma or CR if (g_RX_buf[g_RX_buf_out] != ',' && g_RX_buf[g_RX_buf_out] != kCR) { CmdName2 = toupper (g_RX_buf[g_RX_buf_out]); advance_RX_buf_out(); } // Now loop through the array of commands, trying to find // a match based upon the two (or one) first characters of the command while (CommandList[CommandNumber].CommandPtr != NULL && CommandNumber < 250) { // If the two name characters match, then call the command to do the work if ( (CmdName1 == CommandList[CommandNumber].Name1) && (CmdName2 == CommandList[CommandNumber].Name2) ) { CommandList[CommandNumber].CommandPtr(); goto parse_packet_end; } else { CommandNumber++; } } // If we get here then we did not find a match for our command characters if (0 == CmdName2) { // Send back 'unknown command' error printf ( (const char *)"!8 Err: Unknown command '%c:%2X'\r\n" ,CmdName1 ,CmdName1 ); } else { // Send back 'unknown command' error printf ( (const char *)"!8 Err: Unknown command '%c%c:%2X%2X'\r\n" ,CmdName1 ,CmdName2 ,CmdName1 ,CmdName2 ); } // Set the error bit so that other routines knew there was an error bitset (error_byte, kERROR_BYTE_PRINTED_ERROR); parse_packet_end: // Double check that our output pointer is now at the ending // If it is not, this indicates that there were extra characters that // the command parsing routine didn't eat. This would be an error and needs // to be reported. (Ignore for Reset command because FIFO pointers get cleared.) if ( (g_RX_buf[g_RX_buf_out] != kCR) && (0 == error_byte) && ( ('R' != CmdName1) || (0 != CmdName2) ) ) { bitset (error_byte, kERROR_BYTE_EXTRA_CHARACTERS); } // Clean up by skipping over any bytes we haven't eaten // This is safe since we parse each packet as we get a // (i.e. g_RX_buf_in doesn't move while we are in this routine) g_RX_buf_out = g_RX_buf_in; // Always try to print out an OK packet here. If there was an // error, nothing will print out. PrintAck(); } // Print out the positive acknoledgement that the packet was received // if we have acks turned on. void PrintAck(void) { if (g_ack_enable && !error_byte) { printf ((const char *)st_OK); } } // Return all I/Os to their default power-on values void parse_R_packet(void) { UserInit (); } // Restarts UBW32 with a software reset, which should launch bootloader // without user having to press PRG button void parse_BL_packet(void) { unsigned int dma_status; unsigned int int_status; // Kill USB so that we always re-enumerate when we hit the bootloader USBModuleDisable(); // Set the software key SoftwareKey = 0x12345678; // TEMP : For reset testing /* The following code illustrates a software Reset */ /* perform a system unlock sequence */ mSYSTEMUnlock(int_status, dma_status); /* set SWRST bit to arm reset */ RSWRSTSET = 1; /* read RSWRST register to trigger reset */ volatile int* p = &RSWRST; *p; /* prevent any unwanted code execution until reset occurs*/ while(1); } // CU is "Configure UBW32" and controls system-wide configruation values // "CU,," // // 1 {1|0} turns on or off the 'ack' ("OK" at end of packets) // 2 {1|0} turns on or off the echoing of all data sent to the UBW void parse_CU_packet(void) { unsigned char parameter_number; signed int parameter_value; extract_number (kUCHAR, (void*)¶meter_number, kREQUIRED); extract_number (kINT, (void*)¶meter_value, kREQUIRED); // Bail if we got a conversion error if (error_byte) { return; } switch (parameter_number) { case 1: if (0 == parameter_value || 1 == parameter_value) { g_ack_enable = parameter_value; } else { bitset (error_byte, kERROR_BYTE_PARAMETER_OUTSIDE_LIMIT); } break; case 2: if (0 == parameter_value || 1 == parameter_value) { g_echo_enable = parameter_value; } else { bitset (error_byte, kERROR_BYTE_PARAMETER_OUTSIDE_LIMIT); } break; default: bitset (error_byte, kERROR_BYTE_PARAMETER_OUTSIDE_LIMIT); } } // T1 command will do a 'Test #1', which sets all available pins on // UBW32 to be outputs, then turns each one on and off in turn, right // around the whole board. If you hook and LED up to every I/O pin, // you'll get to see them cycle. First // we go from A15 to D8, then back again. Proves // PIC32 part is soldered down, no opens or shorts. (Watch for missing // LEDs or multiple LEDs coming on at the same time.) // First parameter is ms/pin, second parameter is number of total cycles // FORMAT: T1,