Projects/AVRISP_Programmer/AVRISP_Programmer.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2009.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6       www.fourwalledcubicle.com
   7 */
   8
   9 /*
  10   Copyright 2009  Dean Camera (dean [at] fourwalledcubicle [dot] com)
  11   AVR ISP Programmer code Copyright 2009  Opendous Inc. (www.opendous.org)
  12   For more info and usage instructions for this firmware, visit:
  13   http://code.google.com/p/avropendous/wiki/AVR_ISP_Programmer
  14
  15   Note that this firmware is designed to work with AVRdude:
  16   http://savannah.nongnu.org/projects/avrdude
  17   But should work with other software that supports the AVR910 ISP
  18   programmer or STK200 hardware.
  19
  20   Permission to use, copy, modify, and distribute this software
  21   and its documentation for any purpose and without fee is hereby
  22   granted, provided that the above copyright notice appear in all
  23   copies and that both that the copyright notice and this
  24   permission notice and warranty disclaimer appear in supporting
  25   documentation, and that the name of the author not be used in
  26   advertising or publicity pertaining to distribution of the
  27   software without specific, written prior permission.
  28
  29   The author disclaim all warranties with regard to this
  30   software, including all implied warranties of merchantability
  31   and fitness.  In no event shall the author be liable for any
  32   special, indirect or consequential damages or any damages
  33   whatsoever resulting from loss of use, data or profits, whether
  34   in an action of contract, negligence or other tortious action,
  35   arising out of or in connection with the use or performance of
  36   this software.
  37 */
  38
  39 /*
  40     Usage:
  41      avrdude -vv -F -P COM7 -c avr910 -p t261
  42        Note -F flag which overrides signature check and enables programming
  43        of any "In-System Programmable via SPI Port" AVR MCU.  Part number,
  44        t261, should be set to your target device.
  45      avrdude -vv -F -P COM7 -c avr910 -p t261 -U flash:w:PROG.hex
  46        PROG.hex is the hex file to program your t261 AVR with
  47      avrdude -vv -F -P COM7 -b 115200 -c avr910 -p t261 -U flash:w:test.hex
  48        The -b 115200 sets the SPI clock to 62.5kHz from the default 125kHz and may
  49        work when the default programming speed fails.
  50      AVROSP.exe -dATtiny261 -cCOM7 -rf
  51        AVRosp is the Open Source AVR ISP Programming Software available from Atmel.com
  52
  53     Note: on Linux systems, COM7 should be replaced with someting like /dev/ttyACM0
  54           You can determine this value by running dmesg after plugging in the device
  55     Note: you must RESET the programmer after each use (AVRdude session).
  56
  57     Note: If you experience errors with older devices, try changing the DELAY defines
  58
  59     MISO, MOSI, and SCK are connected directly from the AVRopendous board
  60     to the pin of the same functionality on the target.  RESET pin on the target
  61     can be connected either to SS (PB0), or PC2.  Do not have any other pins
  62     connected - especially HWB pin, to avoid unintentional behaviour.
  63
  64     AVR910 functionality was overlayed on USBtoSerial  functionality.
  65     Keep this in mind when looking over the code.
  66     Default target speed is 125kHz and corresponds to 19200 baud, which
  67     is the default setting for AVRdude.
  68
  69     Changing "Baud-Rate" will change the SPI speed.  Defualt SPI clock speed
  70     is 8Mhz / 4 = 2MHz.  8Mhz is the device clock speed.  This is the setting at
  71     9600 baud.  The following is a table of baud-rate vs. SPI Speed that will result
  72          9600 = 2Mhz
  73          14400 = 1MHz
  74          19200 = 125kHz (AVRdude Default)
  75          38400 = 250kHz
  76          57600 = 500kHz
  77          115200 = 62.5kHz
  78
  79         Before running, you will need to install the INF file that
  80         is located in the project directory. This will enable
  81         Windows to use its inbuilt CDC drivers, negating the need
  82         for special Windows drivers for the device. To install,
  83         right-click the .INF file and choose the Install option.
  84 */
  85
  86 /*      TODO: - fix the requirement that a RESET must be performed after each session, which
  87             is only an issue under Windows.  Everything works fine under Linux
  88 */
  89
  90 #include "AVRISP_Programmer.h"
  91
  92 /* Project Tags, for reading out using the ButtLoad project */
  93 BUTTLOADTAG(ProjName,    "LUFA AVR910 ISP Programmer");
  94 BUTTLOADTAG(BuildTime,   __TIME__);
  95 BUTTLOADTAG(BuildDate,   __DATE__);
  96 BUTTLOADTAG(LUFAVersion, "LUFA V" LUFA_VERSION_STRING);
  97
  98
  99 #define RESETPORT       PORTB
 100 #define RESETPIN        PB0
 101 #define RESETPORT2      PORTC
 102 #define RESETPIN2       PC2
 103 #define CR_HEX          '\r'
 104
 105 #define DELAY_VERYSHORT    0x01
 106 #define DELAY_SHORT        0x02
 107 #define DELAY_MEDIUM       0x03
 108 #define DELAY_LONG         0x05
 109 #define DELAY_MULTIPLE     0x02
 110
 111
 112 /*  AVR Device Codes - Can have a maximum of 14 but can be any you want.
 113     Note that these are completely irrelevent.  If AVRdude supports a device,
 114     then that device is programmable.  Use -F switch to ignore device codes. */
 115 #define AVRDEVCODE01    0x55 /* ATtiny12 */
 116 #define AVRDEVCODE02    0x56 /* ATtiny15 */
 117 #define AVRDEVCODE03    0x5E /* ATtiny261 */
 118 #define AVRDEVCODE04    0x76 /* ATmega8 */
 119 #define AVRDEVCODE05    0x74 /* ATmega16 */
 120 #define AVRDEVCODE06    0x72 /* ATmega32 */
 121 #define AVRDEVCODE07    0x45 /* ATmega64 */
 122 #define AVRDEVCODE08    0x74 /* ATmega644 */
 123 #define AVRDEVCODE09    0x43 /* ATmega128 */
 124 #define AVRDEVCODE10    0x63 /* ATmega162 */
 125 #define AVRDEVCODE11    0x78 /* ATmega169 */
 126 #define AVRDEVCODE12    0x6C /* AT90S4434 */
 127 #define AVRDEVCODE13    0x38 /* AT90S8515A */
 128 #define AVRDEVCODE14    0x65 /* AT90S8555 */
 129
 130
 131 /* Scheduler Task List */
 132 TASK_LIST
 133 {
 134         { Task: USB_USBTask          , TaskStatus: TASK_STOP },
 135         { Task: CDC_Task             , TaskStatus: TASK_STOP },
 136 };
 137
 138 /* Globals: */
 139 /** Contains the current baud rate and other settings of the virtual serial port.
 140  *
 141     These values are set by the host via a class-specific request, and the physical USART should be reconfigured to match the
 142     new settings each time they are changed by the host.
 143  */
 144 CDC_Line_Coding_t LineCoding = { BaudRateBPS: 9600,
 145                                  CharFormat:  OneStopBit,
 146                                  ParityType:  Parity_None,
 147                                  DataBits:    8            };
 148
 149 /** Ring (circular) buffer to hold the RX data - data from the host to the attached device on the serial port. */
 150 RingBuff_t Rx_Buffer;
 151
 152 /** Ring (circular) buffer to hold the TX data - data from the attached device on the serial port to the host. */
 153 RingBuff_t Tx_Buffer;
 154
 155 /** Flag to indicate if the USART is currently transmitting data from the Rx_Buffer circular buffer. */
 156 volatile bool Transmitting = false;
 157
 158 /* some global variables used throughout */
 159 uint16_t currAddress = 0;
 160
 161 /** Main program entry point. This routine configures the hardware required by the application, then
 162     starts the scheduler to run the application tasks.
 163  */
 164 int main(void)
 165 {
 166         /* Disable watchdog if enabled by bootloader/fuses */
 167         MCUSR &= ~(1 << WDRF);
 168         wdt_disable();
 169
 170         /* Disable Clock Division */
 171         SetSystemClockPrescaler(0);
 172
 173         /* Hardware Initialization */
 174         LEDs_Init();
 175         ReconfigureSPI();
 176
 177         DDRC |= ((1 << PC2) | (1 << PC4) | (1 << PC5) | (1 << PC6) | (1 << PC7)); //AT90USBxx2
 178         // PC2 is also used for RESET, so set it HIGH initially - note 'P' command sets it to LOW (Active)
 179         PORTC |= ((1 << PC2) | (1 << PC4) | (1 << PC5) | (1 << PC6) | (1 << PC7)); //AT90USBxx2
 180         DDRD = 0;
 181         PORTD = (1 << PB7); // only PB7(HWB) should be High as this is the bootloader pin
 182         // Prepare PortB for SPI - set PB0(^SS), PB1(SCK), PB2(MOSI) as output as well as all other pins except PB3(MISO)
 183         DDRB = (1 << PB0) | (1 << PB1) | (1 << PB2) | (0 << PB3) | (1 << PB4) | (1 << PB5) | (1 << PB6) | (1 << PB7);
 184         PORTB |= (1 << PB0);
 185     // make sure DataFlash devices to not interfere - deselect them by setting PE0 and PE1 HIGH:
 186     PORTE = 0xFF;
 187     DDRE  = 0xFF;
 188
 189         /* Ringbuffer Initialization */
 190         Buffer_Initialize(&Rx_Buffer);
 191         Buffer_Initialize(&Tx_Buffer);
 192
 193         /* Indicate USB not ready */
 194         UpdateStatus(Status_USBNotReady);
 195
 196         /* Initialize Scheduler so that it can be used */
 197         Scheduler_Init();
 198
 199         /* Initialize USB Subsystem */
 200         USB_Init();
 201
 202         /* Scheduling - routine never returns, so put this last in the main function */
 203         Scheduler_Start();
 204 }
 205
 206 /** Event handler for the USB_Connect event. This indicates that the device is enumerating via the status LEDs and
 207     starts the library USB task to begin the enumeration and USB management process.
 208  */
 209 EVENT_HANDLER(USB_Connect)
 210 {
 211         /* Start USB management task */
 212         Scheduler_SetTaskMode(USB_USBTask, TASK_RUN);
 213
 214         /* Indicate USB enumerating */
 215         UpdateStatus(Status_USBEnumerating);
 216 }
 217
 218 /** Event handler for the USB_Disconnect event. This indicates that the device is no longer connected to a host via
 219     the status LEDs and stops the USB management and CDC management tasks.
 220  */
 221 EVENT_HANDLER(USB_Disconnect)
 222 {
 223         /* Stop running CDC and USB management tasks */
 224         Scheduler_SetTaskMode(CDC_Task, TASK_STOP);
 225         Scheduler_SetTaskMode(USB_USBTask, TASK_STOP);
 226
 227         /* Indicate USB not ready */
 228         UpdateStatus(Status_USBNotReady);
 229 }
 230
 231 /** Event handler for the USB_ConfigurationChanged event. This is fired when the host set the current configuration
 232     of the USB device after enumeration - the device endpoints are configured and the CDC management task started.
 233  */
 234 EVENT_HANDLER(USB_ConfigurationChanged)
 235 {
 236         /* Setup CDC Notification, Rx and Tx Endpoints */
 237         Endpoint_ConfigureEndpoint(CDC_NOTIFICATION_EPNUM, EP_TYPE_INTERRUPT,
 238                                        ENDPOINT_DIR_IN, CDC_NOTIFICATION_EPSIZE,
 239                                    ENDPOINT_BANK_SINGLE);
 240
 241         Endpoint_ConfigureEndpoint(CDC_TX_EPNUM, EP_TYPE_BULK,
 242                                        ENDPOINT_DIR_IN, CDC_TXRX_EPSIZE,
 243                                    ENDPOINT_BANK_SINGLE);
 244
 245         Endpoint_ConfigureEndpoint(CDC_RX_EPNUM, EP_TYPE_BULK,
 246                                        ENDPOINT_DIR_OUT, CDC_TXRX_EPSIZE,
 247                                    ENDPOINT_BANK_SINGLE);
 248
 249         /* Indicate USB connected and ready */
 250         UpdateStatus(Status_USBReady);
 251
 252         /* Start CDC task */
 253         Scheduler_SetTaskMode(CDC_Task, TASK_RUN);
 254 }
 255
 256 /** Event handler for the USB_UnhandledControlPacket event. This is used to catch standard and class specific
 257     control requests that are not handled internally by the USB library (including the CDC control commands,
 258     which are all issued via the control endpoint), so that they can be handled appropriately for the application.
 259  */
 260 EVENT_HANDLER(USB_UnhandledControlPacket)
 261 {
 262         uint8_t* LineCodingData = (uint8_t*)&LineCoding;
 263
 264         /* Process CDC specific control requests */
 265         switch (bRequest)
 266         {
 267                 case REQ_GetLineEncoding:
 268                         if (bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
 269                         {
 270                                 /* Acknowedge the SETUP packet, ready for data transfer */
 271                                 Endpoint_ClearSetupReceived();
 272
 273                                 /* Write the line coding data to the control endpoint */
 274                                 Endpoint_Write_Control_Stream_LE(LineCodingData, sizeof(LineCoding));
 275
 276                                 /* Finalize the stream transfer to send the last packet or clear the host abort */
 277                                 Endpoint_ClearSetupOUT();
 278                         }
 279
 280                         break;
 281                 case REQ_SetLineEncoding:
 282                         if (bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
 283                         {
 284                                 /* Acknowedge the SETUP packet, ready for data transfer */
 285                                 Endpoint_ClearSetupReceived();
 286
 287                                 /* Read the line coding data in from the host into the global struct */
 288                                 Endpoint_Read_Control_Stream_LE(LineCodingData, sizeof(LineCoding));
 289
 290                                 /* Finalize the stream transfer to clear the last packet from the host */
 291                                 Endpoint_ClearSetupIN();
 292
 293                                 /* Reconfigure the USART with the new settings */
 294                                 ReconfigureSPI();
 295                         }
 296
 297                         break;
 298                 case REQ_SetControlLineState:
 299                         if (bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
 300                         {
 301                                 /* Acknowedge the SETUP packet, ready for data transfer */
 302                                 Endpoint_ClearSetupReceived();
 303
 304                                 /* Send an empty packet to acknowedge the command */
 305                                 Endpoint_ClearSetupIN();
 306                         }
 307
 308                         break;
 309         }
 310 }
 311
 312 /** Task to manage CDC data transmission and reception to and from the host, from and to the physical USART. */
 313 TASK(CDC_Task)
 314 {
 315         if (USB_IsConnected)
 316         {
 317                 /* Select the Serial Rx Endpoint */
 318                 Endpoint_SelectEndpoint(CDC_RX_EPNUM);
 319
 320                 if (Endpoint_ReadWriteAllowed())
 321                 {
 322                         /* Read the received data endpoint into the transmission buffer */
 323                         while (Endpoint_BytesInEndpoint())
 324                         {
 325                                 /* Wait until the buffer has space for a new character */
 326                                 while (!((BUFF_STATICSIZE - Rx_Buffer.Elements)));
 327
 328                                 /* Store each character from the endpoint */
 329                                 Buffer_StoreElement(&Rx_Buffer, Endpoint_Read_Byte());
 330
 331                 /* Run the given command once enough data is available. */
 332                 if (Rx_Buffer.Elements)
 333                                 {
 334                                         const uint8_t ZeroDataByteCommands[]  = {'P', 'a', 'm', 'R', 'd', 'e', 'L', 's', 't', 'S', 'V', 'v', 'p', 'F'};
 335                                         const uint8_t OneDataByteCommands[]   = {'T', 'c', 'C', 'D', 'l', 'f', 'x', 'y'};
 336                                         const uint8_t TwoDataByteCommands[]   = {'A', 'Z'};
 337                                         const uint8_t ThreeDataByteCommands[] = {':'};
 338                                         const uint8_t FourDataByteCommands[]  = {'.'};
 339
 340                                         const struct
 341                                         {
 342                                                 const uint8_t  TotalCommands;
 343                                                 const uint8_t* CommandBytes;
 344                                         } AVR910Commands[] = {{sizeof(ZeroDataByteCommands),  ZeroDataByteCommands},
 345                                                               {sizeof(OneDataByteCommands),   OneDataByteCommands},
 346                                                               {sizeof(TwoDataByteCommands),   TwoDataByteCommands},
 347                                                               {sizeof(ThreeDataByteCommands), ThreeDataByteCommands},
 348                                                               {sizeof(FourDataByteCommands),  FourDataByteCommands}};
 349
 350                                         /* Determine the data length of the issued command */
 351                                         uint8_t CommandDataLength = (Rx_Buffer.Elements - 1);
 352
 353                                         /* Loop through each of the possible command bytes allowable from the given command data length */
 354                                         for (uint8_t CurrentCommand = 0; CurrentCommand < AVR910Commands[CommandDataLength].TotalCommands; CurrentCommand++)
 355                                         {
 356                                                 /* If issues command matches an allowable command, process it */
 357                                                 if (Buffer_PeekElement(&Rx_Buffer) == AVR910Commands[CommandDataLength].CommandBytes[CurrentCommand])
 358                                                   processHostSPIRequest();
 359                                         }
 360                 }
 361                         }
 362
 363                         /* Clear the endpoint buffer */
 364                         Endpoint_ClearCurrentBank();
 365                 }
 366
 367                 /* Select the Serial Tx Endpoint */
 368                 Endpoint_SelectEndpoint(CDC_TX_EPNUM);
 369
 370                 /* Check if the Tx buffer contains anything to be sent to the host */
 371                 if (Tx_Buffer.Elements)
 372                 {
 373                         /* Wait until Serial Tx Endpoint Ready for Read/Write */
 374                         while (!(Endpoint_ReadWriteAllowed()));
 375
 376                         /* Check before sending the data if the endpoint is completely full */
 377                         bool IsFull = (Endpoint_BytesInEndpoint() == CDC_TXRX_EPSIZE);
 378
 379                         /* Write the transmission buffer contents to the received data endpoint */
 380                         while (Tx_Buffer.Elements && (Endpoint_BytesInEndpoint() < CDC_TXRX_EPSIZE))
 381                           Endpoint_Write_Byte(Buffer_GetElement(&Tx_Buffer));
 382
 383                         /* Send the data */
 384                         Endpoint_ClearCurrentBank();
 385
 386                         /* If a full endpoint was sent, we need to send an empty packet afterwards to terminate the transfer */
 387                         if (IsFull)
 388                         {
 389                                 /* Wait until Serial Tx Endpoint Ready for Read/Write */
 390                                 while (!(Endpoint_ReadWriteAllowed()));
 391
 392                                 /* Send an empty packet to terminate the transfer */
 393                                 Endpoint_ClearCurrentBank();
 394                         }
 395                 }
 396         }
 397 }
 398
 399 /** Function to manage status updates to the user. This is done via LEDs on the given board, if available, but may be changed to
 400  *  log to a serial port, or anything else that is suitable for status updates.
 401  *
 402  *  \param CurrentStatus  Current status of the system, from the USBtoSerial_StatusCodes_t enum
 403  */
 404 void UpdateStatus(uint8_t CurrentStatus)
 405 {
 406         uint8_t LEDMask = LEDS_NO_LEDS;
 407
 408         /* Set the LED mask to the appropriate LED mask based on the given status code */
 409         switch (CurrentStatus)
 410         {
 411                 case Status_USBNotReady:
 412                         LEDMask = (LEDS_LED1);
 413                         break;
 414                 case Status_USBEnumerating:
 415                         LEDMask = (LEDS_LED1 | LEDS_LED2);
 416                         break;
 417                 case Status_USBReady:
 418                         LEDMask = (LEDS_LED2 | LEDS_LED4);
 419                         break;
 420         }
 421
 422         /* Set the board LEDs to the new LED mask */
 423         LEDs_SetAllLEDs(LEDMask);
 424 }
 425
 426 /** Reconfigures SPI to match the current serial port settings issued by the host. */
 427 void ReconfigureSPI(void)
 428 {
 429         uint8_t SPCRmask = (1 << SPE) | (1 << MSTR); // always enable SPI as Master
 430         uint8_t SPSRmask = 0;
 431
 432         /* Determine stop bits - 1.5 stop bits is set as 1 stop bit due to hardware limitations */
 433         /* For SPI, determine whether format is LSB or MSB */
 434         if (LineCoding.CharFormat == TwoStopBits) {
 435                 SPCRmask |= (1 << DORD);
 436         } else if (LineCoding.CharFormat == OneStopBit) {
 437                 SPCRmask |= (0 << DORD);
 438         }
 439
 440         /* Determine data size - 5, 6, 7, or 8 bits are supported */
 441         /* Changing line coding changes SPI Mode
 442                 CPOL=0, CPHA=0 Sample (Rising) Setup (Falling) SPI-Mode0 == 8 bits line coding
 443                 CPOL=0, CPHA=1 Setup (Rising) Sample (Falling) SPI-Mode1 == 7 bits line coding
 444                 CPOL=1, CPHA=0 Sample (Falling) Setup (Rising) SPI-Mode2 == 6 bits line coding
 445                 CPOL=1, CPHA=1 Setup (Falling) Sample (Rising) SPI-Mode3 == 5 bits line coding
 446         */
 447         if (LineCoding.DataBits == 5) {
 448                 SPCRmask |= ((1 << CPOL) | (1 << CPHA));
 449         } else if (LineCoding.DataBits == 6) {
 450                 SPCRmask |= ((1 << CPOL) | (0 << CPHA));
 451         } else if (LineCoding.DataBits == 7) {
 452                 SPCRmask |= ((0 << CPOL) | (1 << CPHA));
 453         } else if (LineCoding.DataBits == 8) {
 454                 SPCRmask |= ((0 << CPOL) | (0 << CPHA));
 455         }
 456
 457
 458         /* Set the USART baud rate register to the desired baud rate value */
 459         /* also alter the SPI speed via value of baud rate */
 460         if        (LineCoding.BaudRateBPS == 9600) {    // 2Mhz SPI (Fosc / 4)
 461                 SPCRmask |= ((0 << SPR1) | (0 << SPR0));
 462                 SPSRmask |= (0 << SPI2X);
 463         } else if (LineCoding.BaudRateBPS == 14400) {   // 1Mhz SPI (Fosc / 8)
 464                 SPCRmask |= ((0 << SPR1) | (1 << SPR0));
 465                 SPSRmask |= (1 << SPI2X);
 466         } else if (LineCoding.BaudRateBPS == 57600) {   // 500kHz SPI (Fosc / 16)
 467                 SPCRmask |= ((0 << SPR1) | (1 << SPR0));
 468                 SPSRmask |= (0 << SPI2X);
 469         } else if (LineCoding.BaudRateBPS == 38400) {   // 250kHz SPI (Fosc / 32)
 470                 SPCRmask |= ((1 << SPR1) | (0 << SPR0));
 471                 SPSRmask |= (1 << SPI2X);
 472         } else if (LineCoding.BaudRateBPS == 19200) {   // 125kHz SPI (Fosc / 64)
 473                 SPCRmask |= ((1 << SPR1) | (0 << SPR0));
 474                 SPSRmask |= (0 << SPI2X);
 475         } else if (LineCoding.BaudRateBPS == 115200) {  // 62.5kHz SPI (Fosc / 128)
 476                 SPCRmask |= ((1 << SPR1) | (1 << SPR0));
 477                 SPSRmask |= (0 << SPI2X);
 478         }
 479
 480         SPCR = SPCRmask;
 481         SPSR = SPSRmask;
 482 }
 483
 484
 485 /* process data according to AVR910 protocol */
 486 void processHostSPIRequest(void) {
 487
 488         uint8_t readByte1 = 0;
 489         uint8_t readByte2 = 0;
 490         uint8_t readByte3 = 0;
 491         uint8_t readByte4 = 0;
 492         uint8_t firstByte = 0;
 493
 494         /*      Taken from a90isp_ver23.asm:
 495                 +-------------+------------+------+
 496                 ;*  Commands                           | Host writes | Host reads |      |
 497                 ;*  --------                           +-----+-------+------+-----+      |
 498                 ;*                                     | ID  | data  | data |     | Note |
 499                 ;* +-----------------------------------+-----+-------+------+-----+------+
 500                 ;* | Enter programming mode            | 'P' |       |      | 13d |   1  |
 501                 ;* | Report autoincrement address      | 'a' |       |      | 'Y' |      |
 502                 ;* | Set address                       | 'A' | ah al |      | 13d |   2  |
 503                 ;* | Write program memory, low byte    | 'c' |    dd |      | 13d |   3  |
 504                 ;* | Write program memory, high byte   | 'C' |    dd |      | 13d |   3  |
 505                 ;* | Issue Page Write                  | 'm' |       |      | 13d |      |
 506                 ;* | Read program memory               | 'R' |       |dd(dd)|     |   4  |
 507                 ;* | Write data memory                 | 'D' |    dd |      | 13d |      |
 508                 ;* | Read data memory                  | 'd' |       |   dd |     |      |
 509                 ;* | Chip erase                        | 'e' |       |      | 13d |      |
 510                 ;* | Write lock bits                   | 'l' |    dd |      | 13d |      |
 511                 ;* | Write fuse bits                   | 'f' |    dd |      | 13d |  11  |
 512                 ;* | Read fuse and lock bits           | 'F' |       |   dd |     |  11  |
 513                 ;* | Leave programming mode            | 'L' |       |      | 13d |   5  |
 514                 ;* | Select device type                | 'T' |    dd |      | 13d |   6  |
 515                 ;* | Read signature bytes              | 's' |       | 3*dd |     |      |
 516                 ;* | Return supported device codes     | 't' |       | n*dd | 00d |   7  |
 517                 ;* | Return software identifier        | 'S' |       | s[7] |     |   8  |
 518                 ;* | Return sofware version            | 'V' |       |dd dd |     |   9  |
 519                 ;* | Return hardware version           | 'v' |       |dd dd |     |   9  |
 520                 ;* | Return programmer type            | 'p' |       |   dd |     |  10  |
 521                 ;* | Set LED                           | 'x' |    dd |      | 13d |  12  |
 522                 ;* | Clear LED                         | 'y' |    dd |      | 13d |  12  |
 523                 ;* | Universial command                | ':' |  3*dd |   dd | 13d |      |
 524                 ;* | New universal command                 | '.' |  4*dd |   dd | 13d |      |
 525                 ;* | Special test command                  | 'Z' |  2*dd |   dd |     |      |
 526         */
 527
 528         firstByte = Buffer_GetElement(&Rx_Buffer);
 529         Buffer_Initialize(&Tx_Buffer); // make sure the buffer is clear before proceeding
 530
 531         if        (firstByte == 'P') { // enter Programming mode
 532                 // enable SPI -- already done
 533                 // enter programming mode on target:
 534                 //PORTB = 0; // set clock to zero
 535                 RESETPORT = (1 << RESETPIN); // set RESET pin on target to 1
 536                 RESETPORT2 = (1 << RESETPIN2);
 537                 _delay_ms(DELAY_SHORT);
 538                 //RESETPORT = (RESETPORT & ~(1 << RESETPIN)); // set RESET pin on target to 0 - Active
 539                 RESETPORT = 0x00;
 540                 RESETPORT2 = 0;
 541                 _delay_ms(DELAY_SHORT);
 542                 SPI_SendByte(0xAC);
 543                 SPI_SendByte(0x53);
 544                 SPI_SendByte(0x00);
 545                 SPI_SendByte(0x00);
 546                 _delay_ms(DELAY_VERYSHORT);
 547                 Buffer_StoreElement(&Tx_Buffer, CR_HEX); // return carriage return (CR_HEX) if successful
 548
 549         } else if (firstByte == 'T') { // Select device type
 550                 Buffer_GetElement(&Rx_Buffer); // set device type
 551                 Buffer_StoreElement(&Tx_Buffer, CR_HEX); // return carriage return (CR_HEX) if successful
 552
 553         } else if (firstByte == 'a') { // Report autoincrement address
 554                 Buffer_StoreElement(&Tx_Buffer, 'Y'); // return 'Y' - Auto-increment enabled
 555
 556         } else if (firstByte == 'A') { //Load Address
 557                 // get two bytes over serial and set currAddress to them
 558                 readByte1 = Buffer_GetElement(&Rx_Buffer); // high byte
 559                 readByte2 = Buffer_GetElement(&Rx_Buffer); // low byte
 560                 currAddress = (readByte1 << 8) | (readByte2);
 561                 Buffer_StoreElement(&Tx_Buffer, CR_HEX); // return carriage return (CR_HEX) if successful
 562
 563         } else if (firstByte == 'c') { // Write program memory, low byte
 564                 // send 4 bytes over SPI; 0x40, then Address High Byte, then Low, then data
 565                 readByte1 = Buffer_GetElement(&Rx_Buffer);
 566                 SPI_SendByte(0x40);
 567                 SPI_SendByte((currAddress >> 8)); // high byte
 568                 SPI_SendByte((currAddress)); // low byte
 569                 SPI_SendByte(readByte1); // data
 570                 _delay_ms(DELAY_MEDIUM); // certain MCUs require a delay of about 24585 cycles
 571                 Buffer_StoreElement(&Tx_Buffer, CR_HEX); // return carriage return (CR_HEX) if successful
 572
 573         } else if (firstByte == 'C') { // Write program memory, high byte
 574                 // send 4 bytes over SPI; 0x48, then Address High Byte, then Low, then data
 575                 readByte1 = Buffer_GetElement(&Rx_Buffer);
 576                 SPI_SendByte(0x48);
 577                 SPI_SendByte((currAddress >> 8)); // high byte
 578                 SPI_SendByte((currAddress)); // low byte
 579                 SPI_SendByte(readByte1); // data
 580                 currAddress++; // increment currAddress
 581                 Buffer_StoreElement(&Tx_Buffer, CR_HEX); // return carriage return (CR_HEX) if successful
 582
 583         } else if (firstByte == 'm') { // Write Program Memory Page
 584                 // send 4 bytes over SPI; 0x4c, then Address High Byte, then Low, then 0x00
 585                 SPI_SendByte(0x4C);
 586                 SPI_SendByte((currAddress >> 8)); // high byte
 587                 SPI_SendByte((currAddress)); // low byte
 588                 SPI_SendByte(0x00);
 589                 _delay_ms(DELAY_LONG);
 590                 Buffer_StoreElement(&Tx_Buffer, CR_HEX); // return carriage return (CR_HEX) if successful
 591
 592         } else if (firstByte == 'R') { // Read Program Memory
 593                 // send 4 bytes over SPI; 0x28, then Address High Byte, then Low, then send back read data from 4th byte over serial
 594                 SPI_SendByte(0x28);
 595                 SPI_SendByte((currAddress >> 8)); // high byte
 596                 SPI_SendByte((currAddress)); // low byte
 597                 readByte1 = SPI_TransferByte(0x00); // read in data
 598                 Buffer_StoreElement(&Tx_Buffer, readByte1);
 599                 // send 4 bytes over SPI; 0x20, then Address High Byte, then Low, then send back read data from 4th byte over serial
 600                 SPI_SendByte(0x20);
 601                 SPI_SendByte((currAddress >> 8)); // high byte
 602                 SPI_SendByte((currAddress)); // low byte
 603                 readByte2 = SPI_TransferByte(0x00); // read in data
 604                 Buffer_StoreElement(&Tx_Buffer, readByte2);
 605                 currAddress++; // increment currAddress
 606
 607         } else if (firstByte == 'D') { // Write Data Memory
 608                 // send 4 bytes over SPI; 0xc0, then Address High Byte, then Low, then data
 609                 readByte1 = Buffer_GetElement(&Rx_Buffer);
 610                 SPI_SendByte(0xC0);
 611                 SPI_SendByte((currAddress >> 8)); // high byte
 612                 SPI_SendByte((currAddress)); // low byte
 613                 SPI_SendByte(readByte1); // data
 614                 _delay_ms(DELAY_MEDIUM);
 615                 currAddress++; // increment currAddress
 616                 Buffer_StoreElement(&Tx_Buffer, CR_HEX); // return carriage return (CR_HEX) if successful
 617
 618         } else if (firstByte == 'd') { // Read Data Memory
 619                 // send 4 bytes over SPI; 0xa0, then Address High Byte, then Low, then send back read data from 4th byte over serial
 620                 SPI_SendByte(0xA0);
 621                 SPI_SendByte((currAddress >> 8)); // high byte
 622                 SPI_SendByte((currAddress)); // low byte
 623                 readByte1 = SPI_TransferByte(0x00); // read in data
 624                 Buffer_StoreElement(&Tx_Buffer, readByte1);
 625                 currAddress++; // increment currAddress
 626
 627         } else if (firstByte == 'e') { // erase the target device
 628                 // send 4 bytes over SPI; 0xac, 0x80, 0x04, 0x00
 629                 SPI_SendByte(0xAC);
 630                 SPI_SendByte(0x80);
 631                 SPI_SendByte(0x04);
 632                 SPI_SendByte(0x00);
 633                 _delay_ms(DELAY_LONG);
 634                 Buffer_StoreElement(&Tx_Buffer, CR_HEX); // return carriage return (CR_HEX) if successful
 635
 636         } else if (firstByte == 'l') { // write lock bits
 637                 // send 4 bytes over SPI; 0xac, [andi s_data 0x06], 0xe0, 0x00
 638                 readByte1 = Buffer_GetElement(&Rx_Buffer); // read in lock bits data
 639                 SPI_SendByte(0xAC);
 640                 SPI_SendByte(((0x06 & readByte1) | 0xE0)); // TODO - is this correct???
 641                 SPI_SendByte(0x00);
 642                 SPI_SendByte(0x00);
 643                 _delay_ms(DELAY_MEDIUM);
 644                 Buffer_StoreElement(&Tx_Buffer, CR_HEX); // return carriage return (CR_HEX) if successful
 645
 646         } else if (firstByte == 'f') { // write fuse bits
 647                 // ignore this command, but need to remove data from the receive buffer
 648                 readByte1 = Buffer_GetElement(&Rx_Buffer);
 649                 Buffer_StoreElement(&Tx_Buffer, CR_HEX); // return carriage return (CR_HEX) if successful
 650
 651         } else if (firstByte == 'L') { // leave programming mode
 652                 RESETPORT |= (1 << RESETPIN); // set RESET pin on target to 1
 653                 RESETPORT2 |= (1 << RESETPIN2); // set RESET pin on target to 1
 654                 Buffer_StoreElement(&Tx_Buffer, CR_HEX); // return carriage return (CR_HEX) if successful
 655
 656         } else if (firstByte == 's') { // Read signature bytes
 657                 // send 4 bytes over SPI; 0x30, 0x00, 0x02, read and send last byte over serial
 658                 SPI_SendByte(0x30);
 659                 SPI_SendByte(0x00);
 660                 SPI_SendByte(0x02);
 661                 readByte1 = SPI_TransferByte(0x00); // read in data
 662                 Buffer_StoreElement(&Tx_Buffer, readByte1);
 663                 SPI_SendByte(0x30);
 664                 SPI_SendByte(0x00);
 665                 SPI_SendByte(0x01);
 666                 readByte1 = SPI_TransferByte(0x00); // read in data
 667                 Buffer_StoreElement(&Tx_Buffer, readByte1);
 668                 SPI_SendByte(0x30);
 669                 SPI_SendByte(0x00);
 670                 SPI_SendByte(0x00);
 671                 readByte1 = SPI_TransferByte(0x00); // read in data
 672                 Buffer_StoreElement(&Tx_Buffer, readByte1);
 673
 674         } else if (firstByte == 't') { // Return supported device codes
 675                 Buffer_StoreElement(&Tx_Buffer, AVRDEVCODE01);
 676                 Buffer_StoreElement(&Tx_Buffer, AVRDEVCODE02);
 677                 Buffer_StoreElement(&Tx_Buffer, AVRDEVCODE03);
 678                 Buffer_StoreElement(&Tx_Buffer, AVRDEVCODE04);
 679                 Buffer_StoreElement(&Tx_Buffer, AVRDEVCODE05);
 680                 Buffer_StoreElement(&Tx_Buffer, AVRDEVCODE06);
 681                 Buffer_StoreElement(&Tx_Buffer, AVRDEVCODE07);
 682                 Buffer_StoreElement(&Tx_Buffer, AVRDEVCODE08);
 683                 Buffer_StoreElement(&Tx_Buffer, AVRDEVCODE09);
 684                 Buffer_StoreElement(&Tx_Buffer, AVRDEVCODE10);
 685                 Buffer_StoreElement(&Tx_Buffer, AVRDEVCODE11);
 686                 Buffer_StoreElement(&Tx_Buffer, AVRDEVCODE12);
 687                 Buffer_StoreElement(&Tx_Buffer, AVRDEVCODE13);
 688                 Buffer_StoreElement(&Tx_Buffer, AVRDEVCODE14);
 689                 Buffer_StoreElement(&Tx_Buffer, 0x00);
 690
 691         } else if (firstByte == 'S') { // Return software identifier
 692                 // return string[7] with "AVR ISP"
 693                 Buffer_StoreElement(&Tx_Buffer, 'A');
 694                 Buffer_StoreElement(&Tx_Buffer, 'V');
 695                 Buffer_StoreElement(&Tx_Buffer, 'R');
 696                 Buffer_StoreElement(&Tx_Buffer, 0x20);
 697                 Buffer_StoreElement(&Tx_Buffer, 'I');
 698                 Buffer_StoreElement(&Tx_Buffer, 'S');
 699                 Buffer_StoreElement(&Tx_Buffer, 'P');
 700
 701         } else if (firstByte == 'V') { // Return sofware version
 702                 //return two bytes, software Major then Minor
 703                 Buffer_StoreElement(&Tx_Buffer, '2');
 704                 Buffer_StoreElement(&Tx_Buffer, '3');
 705
 706         } else if (firstByte == 'v') { // Return hardware version
 707                 //return two bytes, hardware Major then Minor
 708                 Buffer_StoreElement(&Tx_Buffer, ('1'));
 709                 Buffer_StoreElement(&Tx_Buffer, ('0'));
 710
 711         } else if (firstByte == 'p') { // Return programmer type
 712                 // return 'S' for Serial Programmer
 713                 Buffer_StoreElement(&Tx_Buffer, 'S');
 714
 715         } else if (firstByte == 'x') { // set LED
 716                 // ignore this command, but need to remove data from the receive buffer
 717                 readByte1 = Buffer_GetElement(&Rx_Buffer);
 718                 Buffer_StoreElement(&Tx_Buffer, CR_HEX); // return carriage return (CR_HEX) if successful
 719
 720         } else if (firstByte == 'y') { // clear LED
 721                 // ignore this command, but need to remove data from the receive buffer
 722                 readByte1 = Buffer_GetElement(&Rx_Buffer);
 723                 Buffer_StoreElement(&Tx_Buffer, CR_HEX); // return carriage return (CR_HEX) if successful
 724
 725         } else if (firstByte == ':') { // Universal Command
 726                 // get 3 bytes over serial
 727                 readByte1 = Buffer_GetElement(&Rx_Buffer);
 728                 readByte2 = Buffer_GetElement(&Rx_Buffer);
 729                 readByte3 = Buffer_GetElement(&Rx_Buffer);
 730                 SPI_SendByte(readByte1);
 731                 SPI_SendByte(readByte2);
 732                 SPI_SendByte(readByte3);
 733                 readByte1 = SPI_TransferByte(0x00);
 734                 Buffer_StoreElement(&Tx_Buffer, readByte1);
 735                 _delay_ms(DELAY_MEDIUM);
 736                 Buffer_StoreElement(&Tx_Buffer, CR_HEX); // return carriage return (CR_HEX) if successful
 737
 738         } else if (firstByte == '.') { // New Universal Command
 739                 // get 4 bytes over serial
 740                 readByte1 = Buffer_GetElement(&Rx_Buffer);
 741                 readByte2 = Buffer_GetElement(&Rx_Buffer);
 742                 readByte3 = Buffer_GetElement(&Rx_Buffer);
 743                 readByte4 = Buffer_GetElement(&Rx_Buffer);
 744                 SPI_SendByte(readByte1);
 745                 SPI_SendByte(readByte2);
 746                 SPI_SendByte(readByte3);
 747                 readByte1 = SPI_TransferByte(readByte4);
 748                 Buffer_StoreElement(&Tx_Buffer, readByte1);
 749                 _delay_ms(DELAY_MEDIUM);
 750                 Buffer_StoreElement(&Tx_Buffer, CR_HEX); // return carriage return (CR_HEX) if successful
 751
 752         } else if (firstByte == 'Z') { // Special test command
 753                 // do nothing, but need to remove data from the receive buffer
 754                 readByte1 = Buffer_GetElement(&Rx_Buffer);
 755                 readByte2 = Buffer_GetElement(&Rx_Buffer);
 756
 757         } else {
 758                 // do nothing, but need to return with a carriage return
 759                 Buffer_StoreElement(&Tx_Buffer, CR_HEX); // return carriage return (CR_HEX) if successful
 760         }
 761 }
 762