AVRFreaks.net

#define SPH    _SFR_IO8(0x3E)
#define SPL    _SFR_IO8(0x3D)
register uint8_t myR1 asm("r1");
   myR1 = 0;  //C uses R1 as __zero_reg
   SREG = myR1;
   SPH = 0x4;
   SPL = 0x5F;

#include <avr/io.h>
#include <avr/pgmspace.h>

#define SPH    _SFR_IO8(0x3E)
#define SPL    _SFR_IO8(0x3D)

typedef void (*p_fn_t)(void);

uint8_t commands[] = {    'a', 'A', 'b', 'B', 'c', 'C', 'd', 'D',
                  'e', 'E', 'F', 'g', 'l', 'L', 'm', 'N',
                  'p', 'P', 'Q', 'r', 'R', 's', 'S', 't',
                  'T', 'V', 'x', 'y' };

register uint8_t myR1 asm("r1");
register uint8_t ch asm("r5");

extern unsigned char * _etext;

void uartGet(void) __attribute__ ((noinline));
void uartGet(void){
 ch = UDR;
}

void cmd_a(void){
 UDR = 'a';
 return;
}

void cmd_A(void){
 UDR = 'A';
}

p_fn_t funcs[] = { cmd_a, cmd_A };

int main(void) __attribute__ ((section(".init3"))) __attribute__ ((naked));
int main(void)
{
   register uint8_t i;
   register uint8_t *src_ptr = (uint8_t *) &_etext;
   register uint8_t *dst_ptr = (uint8_t *) 0x60;
   myR1 = 0;
   SREG = myR1;
   SPH = 0x4;
   SPL = 0x5F;
   for (i=0; i<(sizeof(commands)+sizeof(funcs)); i++) {
      *dst_ptr++ = pgm_read_byte(src_ptr++);   
   }
   while (1) {
      uartGet();
      for (i=0; i<sizeof(commands); i++) {
         if (ch == commands[i]) {
            funcs[i]();
         }
      }
   }
}

#include <avr/io.h>
#include <avr/pgmspace.h>
#include "defines.h"

#define SPH    _SFR_IO8(0x3E)
#define SPL    _SFR_IO8(0x3D)

typedef void (*p_fn_t)(void);
typedef union {
   uint8_t bytes[2];
   uint16_t word;
} split_t;

uint8_t commands[] = {    'a', 'A', 'b', 'B', 'c', 'C', 'd', 'D',
                  'e', 'E', 'F', 'g', 'l', 'L', 'm', 'N',
                  'p', 'P', 'Q', 'r', 'R', 's', 'S', 't',
                  'T', 'V', 'x', 'y' };

register uint8_t myR1 asm("r1");
register uint8_t ch asm("r24");
register split_t address asm("r18");

extern unsigned char * _etext;

void uartSend(void) __attribute__ ((noinline));
void uartSend(void)
{
   UART_DATA_REG = ch;                                   // prepare transmission
   while (!(UART_STATUS_REG & (1 << TRANSMIT_COMPLETE_BIT)));// wait until byte sendt
   UART_STATUS_REG |= (1 << TRANSMIT_COMPLETE_BIT);          // delete TXCflag
}


void uartGet(void) __attribute__ ((noinline));
void uartGet(void){
   while(!(UART_STATUS_REG & (1 << RECEIVE_COMPLETE_BIT)));  // wait for data
   ch = UART_DATA_REG;
}

void uartSendY(void) __attribute__ ((noinline));
void uartSendY(void){
   ch = 'Y';
   uartSend();
}

void uartSendCR(void) __attribute__ ((noinline));
void uartSendCR(void){
   ch = '\r';
   uartSend();
}

// auto-increment supported?
void cmd_a(void){
   uartSendY();          // Yes we support auto-increment
}

// set 'address'
void cmd_A(void){
   uartGet();            // Set 'address'
   address.bytes[1] = ch;
   uartGet();
   address.bytes[0] = ch;
   uartSendCR();
}

// check for block mode support
void cmd_b(void) {
   uartSendY();         // Yes we suppport block mode
   ch = ((PAGESIZE>>8) & 0xFF); // MSB first.
   uartSend();
   ch = (PAGESIZE&0xFF); // Report BLOCKSIZE (bytes).
   uartSend();
}

// Block mode programming
void cmd_B(void) {
}

// write program memory low byte
void cmd_c(void) {
}

// write program memory high byte
void cmd_C(void) {
}

// read EEPROM byte
void cmd_d(void) {
}

// write EEPROM byte
void cmd_D(void) {
}

// chip erase
void cmd_e(void) {
}

// exit bootloader
void cmd_E(void) {
}

// read low fuse bits
void cmd_F(void) {
}

// block read
void cmd_g(void) {
}

// write lock bits
void cmd_l(void) {
}

// enter/leave programming mode (just answer \r)
void cmd_LP(void) {
   uartSendCR();
}

// write page
void cmd_m(void) {
}

// read high fuse bits
void cmd_N(void) {
}

// get programmer type (S=serial)
void cmd_p(void) {
   ch = 'S';
   uartSend();
}

// read extended fuse bits
void cmd_Q(void) {
}

// read lock bits
void cmd_r(void) {
}

// read program memory
void cmd_R(void) {
}

// send signature bytes
void cmd_s(void) {
    ch = SIGNATURE_BYTE_3;
   uartSend();
    ch = SIGNATURE_BYTE_2;
   uartSend();
    ch = SIGNATURE_BYTE_1;
   uartSend();
}

// return programmer identifier "AVRBOOT"
void cmd_S(void) {
   ch = 'A';
   uartSend();
   ch = 'V';
   uartSend();
   ch = 'R';
   uartSend();
   ch = 'B';
   uartSend();
   ch = 'O';
   uartSend();
   ch = 'O';
   uartSend();
   ch = 'T';
   uartSend();
}

// return supported PARTCODE
void cmd_t(void) {
#if PARTCODE+0 > 0
   ch =  PARTCODE; // Supports only this device, of course.
   uartSend();
#endif /* PARTCODE */
   ch = 0; // Send list terminator.
   uartSend();
}

void cmd_Txy(void) {
   uartGet();          // absorb ignored character
   uartSendCR();
}

// send software version "15"
void cmd_V(void) {
   ch = '1';
   uartSend();
   ch = '5';
   uartSend();
}

p_fn_t funcs[] = {    cmd_a, // auto-increment supported?
               cmd_A, // set 'address'
               cmd_b, // check for block mode support
               cmd_B, // Block mode programming
               cmd_c, // write program memory low byte
               cmd_C, // write program memory high byte
               cmd_d, // read EEPROM byte
               cmd_D, // write EEPROM byte
               cmd_e, // chip erase
               cmd_E, // exit bootloader
               cmd_F, // read low fuse bits
               cmd_g, // block read
               cmd_l, // write lock bits
               cmd_LP, // enter/leave programming mode (just answer \r)
               cmd_m, // write page
               cmd_N, // read high fuse bits
               cmd_p, // get programmer type (S=serial)
               cmd_LP, // enter/leave programming mode (just answer \r)
               cmd_Q, // read extended fuse bits
               cmd_r, // read lock bits
               cmd_R, // read program memory
               cmd_s, // send signature bytes
               cmd_S, // return programmer identifier "AVRBOOT"
               cmd_t, // return supported PARTCODE
               cmd_Txy, // ignored LED function
               cmd_V, // send software version "15"
               cmd_Txy, // ignored LED function
               cmd_Txy  // ignored LED function
               };

int main(void) __attribute__ ((section(".init3"))) __attribute__ ((naked));
int main(void)
{
   register uint8_t i;
   register uint8_t *src_ptr = (uint8_t *) &_etext;
   register uint8_t *dst_ptr = (uint8_t *) 0x60;
   myR1 = 0;
   SREG = myR1;
   SPH = 0x4;
   SPL = 0x5F;
   for (i=0; i<(sizeof(commands)+sizeof(funcs)); i++) {
      *dst_ptr++ = pgm_read_byte(src_ptr++);   
   }
   BAUD_RATE_LOW_REG = BRREG_VALUE;
   UART_CONTROL_REG = (1<<ENABLE_TRANSMITTER_BIT) | (1<<ENABLE_RECEIVER_BIT);
   // loop here waiting for a character that is not ESC for a while

   // enter while() with 'ch' already holding a command code
   while (1) {
      for (i=0; i<sizeof(commands); i++) {
         if (ch == commands[i]) {
            funcs[i]();
         }
      }
      uartGet();
   }
}