first commit

ArduinoISP/ArduinoISP.ino

@@ -0,0 +1,858 @@
+//AVRISP Specifique pour platine HVSPreset
+
+
+#define I2C_SCL   PC5 // I2C Serial Clock (SCK)
+#define I2C_SDA   PC4 // I2C Serial Data (SDA)
+
+#define I2C_SDA_HIGH()  DDRC &= ~(1<<I2C_SDA) // release SDA   -> pulled HIGH by resistor
+#define I2C_SDA_LOW()   DDRC |=  (1<<I2C_SDA) // SDA as output -> pulled LOW  by MCU
+#define I2C_SCL_HIGH()  DDRC &= ~(1<<I2C_SCL) // release SCL   -> pulled HIGH by resistor
+#define I2C_SCL_LOW()   DDRC |=  (1<<I2C_SCL) // SCL as output -> pulled LOW  by MCU
+#define I2C_DELAY()     asm("lpm")            // delay 3 clock cycles
+#define I2C_CLOCKOUT()  I2C_SCL_HIGH();I2C_DELAY();I2C_SCL_LOW()  // clock out
+
+
+
+#include "Arduino.h"
+#undef SERIAL
+
+
+#define PROG_FLICKER true
+
+// Configure SPI clock (in Hz).
+// E.g. for an ATtiny @ 128 kHz: the datasheet states that both the high and low
+// SPI clock pulse must be > 2 CPU cycles, so take 3 cycles i.e. divide target
+// f_cpu by 6:
+//     #define SPI_CLOCK            (128000/6)
+//
+// A clock slow enough for an ATtiny85 @ 1 MHz, is a reasonable default:
+
+#define SPI_CLOCK 		(1000000/6)
+
+
+// Select hardware or software SPI, depending on SPI clock.
+// Currently only for AVR, for other architectures (Due, Zero,...), hardware SPI
+// is probably too fast anyway.
+
+#if defined(ARDUINO_ARCH_AVR)
+
+#if SPI_CLOCK > (F_CPU / 128)
+#define USE_HARDWARE_SPI
+#endif
+
+#endif
+
+// Configure which pins to use:
+
+#define VCC       8
+#define RESET     13 // Use pin 10 to reset the target rather than SS
+#define PIN_MOSI	9
+#define PIN_MISO	10
+#define PIN_SCK		11
+#define PIN2      12
+
+// By default, use hardware SPI pins:
+#ifndef PIN_MOSI
+#define PIN_MOSI 	MOSI
+#endif
+
+#ifndef PIN_MISO
+#define PIN_MISO 	MISO
+#endif
+
+#ifndef PIN_SCK
+#define PIN_SCK 	SCK
+#endif
+
+// Force bitbanged SPI if not using the hardware SPI pins:
+#if (PIN_MISO != MISO) ||  (PIN_MOSI != MOSI) || (PIN_SCK != SCK)
+#undef USE_HARDWARE_SPI
+#endif
+
+
+// Configure the serial port to use.
+//
+// Prefer the USB virtual serial port (aka. native USB port), if the Arduino has one:
+//   - it does not autoreset (except for the magic baud rate of 1200).
+//   - it is more reliable because of USB handshaking.
+//
+// Leonardo and similar have an USB virtual serial port: 'Serial'.
+// Due and Zero have an USB virtual serial port: 'SerialUSB'.
+//
+// On the Due and Zero, 'Serial' can be used too, provided you disable autoreset.
+// To use 'Serial': #define SERIAL Serial
+
+#ifdef SERIAL_PORT_USBVIRTUAL
+#define SERIAL SERIAL_PORT_USBVIRTUAL
+#else
+#define SERIAL Serial
+#endif
+
+
+// Configure the baud rate:
+
+#define BAUDRATE	19200
+// #define BAUDRATE	115200
+// #define BAUDRATE	1000000
+
+
+#define HWVER 2
+#define SWMAJ 1
+#define SWMIN 18
+
+// STK Definitions
+#define STK_OK      0x10
+#define STK_FAILED  0x11
+#define STK_UNKNOWN 0x12
+#define STK_INSYNC  0x14
+#define STK_NOSYNC  0x15
+#define CRC_EOP     0x20 //ok it is a space...
+
+void pulse(int pin, int times);
+
+#ifdef USE_HARDWARE_SPI
+#include "SPI.h"
+#else
+
+#define SPI_MODE0 0x00
+
+#if !defined(ARDUINO_API_VERSION) || ARDUINO_API_VERSION != 10001 // A SPISettings class is declared by ArduinoCore-API 1.0.1
+class SPISettings {
+  public:
+    // clock is in Hz
+    SPISettings(uint32_t clock, uint8_t bitOrder, uint8_t dataMode) : clockFreq(clock) {
+      (void) bitOrder;
+      (void) dataMode;
+    };
+
+    uint32_t getClockFreq() const {
+      return clockFreq;
+    }
+
+  private:
+    uint32_t clockFreq;
+};
+#endif  // !defined(ARDUINO_API_VERSION)
+
+class BitBangedSPI {
+  public:
+    void begin() {
+      digitalWrite(PIN_SCK, LOW);
+      digitalWrite(PIN_MOSI, LOW);
+      pinMode(PIN_SCK, OUTPUT);
+      pinMode(PIN_MOSI, OUTPUT);
+      pinMode(PIN_MISO, INPUT);
+    }
+
+    void beginTransaction(SPISettings settings) {
+      pulseWidth = (500000 + settings.getClockFreq() - 1) / settings.getClockFreq();
+      if (pulseWidth == 0) {
+        pulseWidth = 1;
+      }
+    }
+
+    void end() {}
+
+    uint8_t transfer(uint8_t b) {
+      for (unsigned int i = 0; i < 8; ++i) {
+        digitalWrite(PIN_MOSI, (b & 0x80) ? HIGH : LOW);
+        digitalWrite(PIN_SCK, HIGH);
+        delayMicroseconds(pulseWidth);
+        b = (b << 1) | digitalRead(PIN_MISO);
+        digitalWrite(PIN_SCK, LOW); // slow pulse
+        delayMicroseconds(pulseWidth);
+      }
+      return b;
+    }
+
+  private:
+    unsigned long pulseWidth; // in microseconds
+};
+
+static BitBangedSPI SPI;
+
+#endif
+
+const char TitleScreen[] PROGMEM =
+"    AVRISP Mode:     "
+"                     "
+"Disconnect 12 Volts !";
+  
+void setup() {
+  SERIAL.begin(BAUDRATE);
+  pinMode(VCC,OUTPUT);
+  pinMode(PIN2,OUTPUT);
+  digitalWrite(VCC,HIGH);
+  digitalWrite(PIN2,LOW);
+  reset_target(false);
+  OLED_init();
+  OLED_clearScreen();
+  OLED_setCursor(0,0);
+  OLED_printPrg(TitleScreen);
+}
+
+int ISPError = 0;
+int pmode = 0;
+// address for reading and writing, set by 'U' command
+unsigned int here;
+uint8_t buff[256]; // global block storage
+
+#define beget16(addr) (*addr * 256 + *(addr+1) )
+typedef struct param {
+  uint8_t devicecode;
+  uint8_t revision;
+  uint8_t progtype;
+  uint8_t parmode;
+  uint8_t polling;
+  uint8_t selftimed;
+  uint8_t lockbytes;
+  uint8_t fusebytes;
+  uint8_t flashpoll;
+  uint16_t eeprompoll;
+  uint16_t pagesize;
+  uint16_t eepromsize;
+  uint32_t flashsize;
+}
+parameter;
+
+parameter param;
+
+// this provides a heartbeat on pin 9, so you can tell the software is running.
+uint8_t hbval = 128;
+int8_t hbdelta = 8;
+void heartbeat() {
+  static unsigned long last_time = 0;
+  unsigned long now = millis();
+  if ((now - last_time) < 40) {
+    return;
+  }
+  last_time = now;
+  if (hbval > 192) {
+    hbdelta = -hbdelta;
+  }
+  if (hbval < 32) {
+    hbdelta = -hbdelta;
+  }
+  hbval += hbdelta;
+
+}
+
+static bool rst_active_high;
+
+void reset_target(bool reset) {
+  digitalWrite(RESET, ((reset && rst_active_high) || (!reset && !rst_active_high)) ? HIGH : LOW);
+}
+
+void loop(void) {
+  // is pmode active?
+  if (pmode) {
+
+  } else {
+
+  }
+  // is there an error?
+  if (ISPError) {
+
+  } else {
+
+  }
+
+  // light the heartbeat LED
+  heartbeat();
+  if (SERIAL.available()) {
+    avrisp();
+  }
+}
+
+uint8_t getch() {
+  while (!SERIAL.available());
+  return SERIAL.read();
+}
+void fill(int n) {
+  for (int x = 0; x < n; x++) {
+    buff[x] = getch();
+  }
+}
+
+#define PTIME 30
+void pulse(int pin, int times) {
+  do {
+    digitalWrite(pin, HIGH);
+    delay(PTIME);
+    digitalWrite(pin, LOW);
+    delay(PTIME);
+  } while (times--);
+}
+
+void prog_lamp(int state) {
+  if (PROG_FLICKER) {
+   }
+}
+
+uint8_t spi_transaction(uint8_t a, uint8_t b, uint8_t c, uint8_t d) {
+  SPI.transfer(a);
+  SPI.transfer(b);
+  SPI.transfer(c);
+  return SPI.transfer(d);
+}
+
+void empty_reply() {
+  if (CRC_EOP == getch()) {
+    SERIAL.print((char)STK_INSYNC);
+    SERIAL.print((char)STK_OK);
+  } else {
+    ISPError++;
+    SERIAL.print((char)STK_NOSYNC);
+  }
+}
+
+void breply(uint8_t b) {
+  if (CRC_EOP == getch()) {
+    SERIAL.print((char)STK_INSYNC);
+    SERIAL.print((char)b);
+    SERIAL.print((char)STK_OK);
+  } else {
+    ISPError++;
+    SERIAL.print((char)STK_NOSYNC);
+  }
+}
+
+void get_version(uint8_t c) {
+  switch (c) {
+    case 0x80:
+      breply(HWVER);
+      break;
+    case 0x81:
+      breply(SWMAJ);
+      break;
+    case 0x82:
+      breply(SWMIN);
+      break;
+    case 0x93:
+      breply('S'); // serial programmer
+      break;
+    default:
+      breply(0);
+  }
+}
+
+void set_parameters() {
+  // call this after reading parameter packet into buff[]
+  param.devicecode = buff[0];
+  param.revision   = buff[1];
+  param.progtype   = buff[2];
+  param.parmode    = buff[3];
+  param.polling    = buff[4];
+  param.selftimed  = buff[5];
+  param.lockbytes  = buff[6];
+  param.fusebytes  = buff[7];
+  param.flashpoll  = buff[8];
+  // ignore buff[9] (= buff[8])
+  // following are 16 bits (big endian)
+  param.eeprompoll = beget16(&buff[10]);
+  param.pagesize   = beget16(&buff[12]);
+  param.eepromsize = beget16(&buff[14]);
+
+  // 32 bits flashsize (big endian)
+  param.flashsize = buff[16] * 0x01000000
+                    + buff[17] * 0x00010000
+                    + buff[18] * 0x00000100
+                    + buff[19];
+
+  // AVR devices have active low reset, AT89Sx are active high
+  rst_active_high = (param.devicecode >= 0xe0);
+}
+
+void start_pmode() {
+
+  // Reset target before driving PIN_SCK or PIN_MOSI
+
+  // SPI.begin() will configure SS as output, so SPI master mode is selected.
+  // We have defined RESET as pin 10, which for many Arduinos is not the SS pin.
+  // So we have to configure RESET as output here,
+  // (reset_target() first sets the correct level)
+  reset_target(false); //true
+  pinMode(RESET, OUTPUT);
+  SPI.begin();
+  SPI.beginTransaction(SPISettings(SPI_CLOCK, MSBFIRST, SPI_MODE0));
+
+  // See AVR datasheets, chapter "SERIAL_PRG Programming Algorithm":
+
+  // Pulse RESET after PIN_SCK is low:
+  digitalWrite(PIN_SCK, LOW);
+  delay(20); // discharge PIN_SCK, value arbitrarily chosen
+  reset_target(true); //false
+  // Pulse must be minimum 2 target CPU clock cycles so 100 usec is ok for CPU
+  // speeds above 20 KHz
+  delayMicroseconds(100);
+  reset_target(false); //true
+
+  // Send the enable programming command:
+  delay(50); // datasheet: must be > 20 msec
+  spi_transaction(0xAC, 0x53, 0x00, 0x00);
+  pmode = 1;
+}
+
+void end_pmode() {
+  SPI.end();
+  // We're about to take the target out of reset so configure SPI pins as input
+  pinMode(PIN_MOSI, INPUT);
+  pinMode(PIN_SCK, INPUT);
+  reset_target(true); //false
+  pinMode(RESET, INPUT);
+  pmode = 0;
+}
+
+void universal() {
+  uint8_t ch;
+
+  fill(4);
+  ch = spi_transaction(buff[0], buff[1], buff[2], buff[3]);
+  breply(ch);
+}
+
+void flash(uint8_t hilo, unsigned int addr, uint8_t data) {
+  spi_transaction(0x40 + 8 * hilo,
+                  addr >> 8 & 0xFF,
+                  addr & 0xFF,
+                  data);
+}
+void commit(unsigned int addr) {
+  if (PROG_FLICKER) {
+    prog_lamp(LOW);
+  }
+  spi_transaction(0x4C, (addr >> 8) & 0xFF, addr & 0xFF, 0);
+  if (PROG_FLICKER) {
+    delay(PTIME);
+    prog_lamp(HIGH);
+  }
+}
+
+unsigned int current_page() {
+  if (param.pagesize == 32) {
+    return here & 0xFFFFFFF0;
+  }
+  if (param.pagesize == 64) {
+    return here & 0xFFFFFFE0;
+  }
+  if (param.pagesize == 128) {
+    return here & 0xFFFFFFC0;
+  }
+  if (param.pagesize == 256) {
+    return here & 0xFFFFFF80;
+  }
+  return here;
+}
+
+
+void write_flash(int length) {
+  fill(length);
+  if (CRC_EOP == getch()) {
+    SERIAL.print((char) STK_INSYNC);
+    SERIAL.print((char) write_flash_pages(length));
+  } else {
+    ISPError++;
+    SERIAL.print((char) STK_NOSYNC);
+  }
+}
+
+uint8_t write_flash_pages(int length) {
+  int x = 0;
+  unsigned int page = current_page();
+  while (x < length) {
+    if (page != current_page()) {
+      commit(page);
+      page = current_page();
+    }
+    flash(LOW, here, buff[x++]);
+    flash(HIGH, here, buff[x++]);
+    here++;
+  }
+
+  commit(page);
+
+  return STK_OK;
+}
+
+#define EECHUNK (32)
+uint8_t write_eeprom(unsigned int length) {
+  // here is a word address, get the byte address
+  unsigned int start = here * 2;
+  unsigned int remaining = length;
+  if (length > param.eepromsize) {
+    ISPError++;
+    return STK_FAILED;
+  }
+  while (remaining > EECHUNK) {
+    write_eeprom_chunk(start, EECHUNK);
+    start += EECHUNK;
+    remaining -= EECHUNK;
+  }
+  write_eeprom_chunk(start, remaining);
+  return STK_OK;
+}
+// write (length) bytes, (start) is a byte address
+uint8_t write_eeprom_chunk(unsigned int start, unsigned int length) {
+  // this writes byte-by-byte, page writing may be faster (4 bytes at a time)
+  fill(length);
+  prog_lamp(LOW);
+  for (unsigned int x = 0; x < length; x++) {
+    unsigned int addr = start + x;
+    spi_transaction(0xC0, (addr >> 8) & 0xFF, addr & 0xFF, buff[x]);
+    delay(45);
+  }
+  prog_lamp(HIGH);
+  return STK_OK;
+}
+
+void program_page() {
+  char result = (char) STK_FAILED;
+  unsigned int length = 256 * getch();
+  length += getch();
+  char memtype = getch();
+  // flash memory @here, (length) bytes
+  if (memtype == 'F') {
+    write_flash(length);
+    return;
+  }
+  if (memtype == 'E') {
+    result = (char)write_eeprom(length);
+    if (CRC_EOP == getch()) {
+      SERIAL.print((char) STK_INSYNC);
+      SERIAL.print(result);
+    } else {
+      ISPError++;
+      SERIAL.print((char) STK_NOSYNC);
+    }
+    return;
+  }
+  SERIAL.print((char)STK_FAILED);
+  return;
+}
+
+uint8_t flash_read(uint8_t hilo, unsigned int addr) {
+  return spi_transaction(0x20 + hilo * 8,
+                         (addr >> 8) & 0xFF,
+                         addr & 0xFF,
+                         0);
+}
+
+char flash_read_page(int length) {
+  for (int x = 0; x < length; x += 2) {
+    uint8_t low = flash_read(LOW, here);
+    SERIAL.print((char) low);
+    uint8_t high = flash_read(HIGH, here);
+    SERIAL.print((char) high);
+    here++;
+  }
+  return STK_OK;
+}
+
+char eeprom_read_page(int length) {
+  // here again we have a word address
+  int start = here * 2;
+  for (int x = 0; x < length; x++) {
+    int addr = start + x;
+    uint8_t ee = spi_transaction(0xA0, (addr >> 8) & 0xFF, addr & 0xFF, 0xFF);
+    SERIAL.print((char) ee);
+  }
+  return STK_OK;
+}
+
+void read_page() {
+  char result = (char)STK_FAILED;
+  int length = 256 * getch();
+  length += getch();
+  char memtype = getch();
+  if (CRC_EOP != getch()) {
+    ISPError++;
+    SERIAL.print((char) STK_NOSYNC);
+    return;
+  }
+  SERIAL.print((char) STK_INSYNC);
+  if (memtype == 'F') {
+    result = flash_read_page(length);
+  }
+  if (memtype == 'E') {
+    result = eeprom_read_page(length);
+  }
+  SERIAL.print(result);
+}
+
+void read_signature() {
+  if (CRC_EOP != getch()) {
+    ISPError++;
+    SERIAL.print((char) STK_NOSYNC);
+    return;
+  }
+  SERIAL.print((char) STK_INSYNC);
+  uint8_t high = spi_transaction(0x30, 0x00, 0x00, 0x00);
+  SERIAL.print((char) high);
+  uint8_t middle = spi_transaction(0x30, 0x00, 0x01, 0x00);
+  SERIAL.print((char) middle);
+  uint8_t low = spi_transaction(0x30, 0x00, 0x02, 0x00);
+  SERIAL.print((char) low);
+  SERIAL.print((char) STK_OK);
+}
+//////////////////////////////////////////
+//////////////////////////////////////////
+
+
+////////////////////////////////////
+////////////////////////////////////
+void avrisp() {
+  uint8_t ch = getch();
+  switch (ch) {
+    case '0': // signon
+      ISPError = 0;
+      empty_reply();
+      break;
+    case '1':
+      if (getch() == CRC_EOP) {
+        SERIAL.print((char) STK_INSYNC);
+        SERIAL.print("AVR ISP");
+        SERIAL.print((char) STK_OK);
+      } else {
+        ISPError++;
+        SERIAL.print((char) STK_NOSYNC);
+      }
+      break;
+    case 'A':
+      get_version(getch());
+      break;
+    case 'B':
+      fill(20);
+      set_parameters();
+      empty_reply();
+      break;
+    case 'E': // extended parameters - ignore for now
+      fill(5);
+      empty_reply();
+      break;
+    case 'P':
+      if (!pmode) {
+        start_pmode();
+      }
+      empty_reply();
+      break;
+    case 'U': // set address (word)
+      here = getch();
+      here += 256 * getch();
+      empty_reply();
+      break;
+
+    case 0x60: //STK_PROG_FLASH
+      getch(); // low addr
+      getch(); // high addr
+      empty_reply();
+      break;
+    case 0x61: //STK_PROG_DATA
+      getch(); // data
+      empty_reply();
+      break;
+
+    case 0x64: //STK_PROG_PAGE
+      program_page();
+      break;
+
+    case 0x74: //STK_READ_PAGE 't'
+      read_page();
+      break;
+
+    case 'V': //0x56
+      universal();
+      break;
+    case 'Q': //0x51
+      ISPError = 0;
+      end_pmode();
+      empty_reply();
+      break;
+
+    case 0x75: //STK_READ_SIGN 'u'
+      read_signature();
+      break;
+
+    // expecting a command, not CRC_EOP
+    // this is how we can get back in sync
+    case CRC_EOP:
+      ISPError++;
+      SERIAL.print((char) STK_NOSYNC);
+      break;
+
+    // anything else we will return STK_UNKNOWN
+    default:
+      ISPError++;
+      if (CRC_EOP == getch()) {
+        SERIAL.print((char)STK_UNKNOWN);
+      } else {
+        SERIAL.print((char)STK_NOSYNC);
+      }
+  }
+}
+
+void I2C_init(void) {
+  DDRC  &= ~((1<<I2C_SDA)|(1<<I2C_SCL));  // pins as input (HIGH-Z) -> lines released
+  PORTC &= ~((1<<I2C_SDA)|(1<<I2C_SCL));  // should be LOW when as ouput
+}
+
+void I2C_write(uint8_t data) {
+  for(uint8_t i = 8; i; i--, data<<=1) {  // transmit 8 bits, MSB first
+    (data & 0x80) ? (I2C_SDA_HIGH()) : (I2C_SDA_LOW());  // SDA HIGH if bit is 1
+    I2C_CLOCKOUT();                       // clock out -> slave reads the bit
+  }
+  I2C_DELAY();                            // delay 3 clock cycles
+  I2C_SDA_HIGH();                         // release SDA for ACK bit of slave
+  I2C_CLOCKOUT();                         // 9th clock pulse is for the ignored ACK bit
+}
+
+// I2C start transmission
+void I2C_start(uint8_t addr) {
+  I2C_SDA_LOW();                          // start condition: SDA goes LOW first
+  I2C_SCL_LOW();                          // start condition: SCL goes LOW second
+  I2C_write(addr);                        // send slave address
+}
+
+// I2C stop transmission
+void I2C_stop(void) {
+  I2C_SDA_LOW();                          // prepare SDA for LOW to HIGH transition
+  I2C_SCL_HIGH();                         // stop condition: SCL goes HIGH first
+  I2C_SDA_HIGH();                         // stop condition: SDA goes HIGH second
+}
+
+// ===================================================================================
+// OLED Implementation
+// ===================================================================================
+
+// OLED definitions
+#define OLED_ADDR       0x78              // OLED write address
+#define OLED_CMD_MODE   0x00              // set command mode
+#define OLED_DAT_MODE   0x40              // set data mode
+#define OLED_INIT_LEN   9                 // length of init command array
+
+// OLED 5x8 pixels character set
+const uint8_t OLED_FONT[] PROGMEM = {
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2F, 0x00, 0x00, 0x00, 0x07, 0x00, 0x07, 0x00,
+  0x14, 0x7F, 0x14, 0x7F, 0x14, 0x24, 0x2A, 0x7F, 0x2A, 0x12, 0x23, 0x13, 0x08, 0x64, 0x62,
+  0x36, 0x49, 0x55, 0x22, 0x50, 0x00, 0x05, 0x03, 0x00, 0x00, 0x00, 0x1C, 0x22, 0x41, 0x00,
+  0x00, 0x41, 0x22, 0x1C, 0x00, 0x14, 0x08, 0x3E, 0x08, 0x14, 0x08, 0x08, 0x3E, 0x08, 0x08,
+  0x00, 0x00, 0xA0, 0x60, 0x00, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00, 0x60, 0x60, 0x00, 0x00,
+  0x20, 0x10, 0x08, 0x04, 0x02, 0x3E, 0x51, 0x49, 0x45, 0x3E, 0x00, 0x42, 0x7F, 0x40, 0x00,
+  0x42, 0x61, 0x51, 0x49, 0x46, 0x21, 0x41, 0x45, 0x4B, 0x31, 0x18, 0x14, 0x12, 0x7F, 0x10,
+  0x27, 0x45, 0x45, 0x45, 0x39, 0x3C, 0x4A, 0x49, 0x49, 0x30, 0x01, 0x71, 0x09, 0x05, 0x03,
+  0x36, 0x49, 0x49, 0x49, 0x36, 0x06, 0x49, 0x49, 0x29, 0x1E, 0x00, 0x36, 0x36, 0x00, 0x00,
+  0x00, 0x56, 0x36, 0x00, 0x00, 0x08, 0x14, 0x22, 0x41, 0x00, 0x14, 0x14, 0x14, 0x14, 0x14,
+  0x00, 0x41, 0x22, 0x14, 0x08, 0x02, 0x01, 0x51, 0x09, 0x06, 0x32, 0x49, 0x59, 0x51, 0x3E,
+  0x7C, 0x12, 0x11, 0x12, 0x7C, 0x7F, 0x49, 0x49, 0x49, 0x36, 0x3E, 0x41, 0x41, 0x41, 0x22,
+  0x7F, 0x41, 0x41, 0x22, 0x1C, 0x7F, 0x49, 0x49, 0x49, 0x41, 0x7F, 0x09, 0x09, 0x09, 0x01,
+  0x3E, 0x41, 0x49, 0x49, 0x7A, 0x7F, 0x08, 0x08, 0x08, 0x7F, 0x00, 0x41, 0x7F, 0x41, 0x00,
+  0x20, 0x40, 0x41, 0x3F, 0x01, 0x7F, 0x08, 0x14, 0x22, 0x41, 0x7F, 0x40, 0x40, 0x40, 0x40,
+  0x7F, 0x02, 0x0C, 0x02, 0x7F, 0x7F, 0x04, 0x08, 0x10, 0x7F, 0x3E, 0x41, 0x41, 0x41, 0x3E,
+  0x7F, 0x09, 0x09, 0x09, 0x06, 0x3E, 0x41, 0x51, 0x21, 0x5E, 0x7F, 0x09, 0x19, 0x29, 0x46,
+  0x46, 0x49, 0x49, 0x49, 0x31, 0x01, 0x01, 0x7F, 0x01, 0x01, 0x3F, 0x40, 0x40, 0x40, 0x3F,
+  0x1F, 0x20, 0x40, 0x20, 0x1F, 0x3F, 0x40, 0x38, 0x40, 0x3F, 0x63, 0x14, 0x08, 0x14, 0x63,
+  0x07, 0x08, 0x70, 0x08, 0x07, 0x61, 0x51, 0x49, 0x45, 0x43, 0x00, 0x7F, 0x41, 0x41, 0x00,
+  0x02, 0x04, 0x08, 0x10, 0x20, 0x00, 0x41, 0x41, 0x7F, 0x00, 0x04, 0x02, 0x01, 0x02, 0x04,
+  0x40, 0x40, 0x40, 0x40, 0x40, 0x00, 0x01, 0x02, 0x04, 0x00, 0x20, 0x54, 0x54, 0x54, 0x78,
+  0x7F, 0x48, 0x44, 0x44, 0x38, 0x38, 0x44, 0x44, 0x44, 0x20, 0x38, 0x44, 0x44, 0x48, 0x7F,
+  0x38, 0x54, 0x54, 0x54, 0x18, 0x08, 0x7E, 0x09, 0x01, 0x02, 0x18, 0xA4, 0xA4, 0xA4, 0x7C,
+  0x7F, 0x08, 0x04, 0x04, 0x78, 0x00, 0x44, 0x7D, 0x40, 0x00, 0x40, 0x80, 0x84, 0x7D, 0x00,
+  0x7F, 0x10, 0x28, 0x44, 0x00, 0x00, 0x41, 0x7F, 0x40, 0x00, 0x7C, 0x04, 0x18, 0x04, 0x78,
+  0x7C, 0x08, 0x04, 0x04, 0x78, 0x38, 0x44, 0x44, 0x44, 0x38, 0xFC, 0x24, 0x24, 0x24, 0x18,
+  0x18, 0x24, 0x24, 0x18, 0xFC, 0x7C, 0x08, 0x04, 0x04, 0x08, 0x48, 0x54, 0x54, 0x54, 0x20,
+  0x04, 0x3F, 0x44, 0x40, 0x20, 0x3C, 0x40, 0x40, 0x20, 0x7C, 0x1C, 0x20, 0x40, 0x20, 0x1C,
+  0x3C, 0x40, 0x30, 0x40, 0x3C, 0x44, 0x28, 0x10, 0x28, 0x44, 0x1C, 0xA0, 0xA0, 0xA0, 0x7C,
+  0x44, 0x64, 0x54, 0x4C, 0x44, 0x08, 0x36, 0x41, 0x41, 0x00, 0x00, 0x00, 0x7F, 0x00, 0x00,
+  0x00, 0x41, 0x41, 0x36, 0x08, 0x08, 0x04, 0x08, 0x10, 0x08, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
+};
+
+// OLED init settings
+const uint8_t OLED_INIT_CMD[] PROGMEM = {
+  0xC8, 0xA1,   // flip screen
+  0xA8, 0x1F,   // set multiplex ratio
+  0xDA, 0x02,   // set com pins hardware configuration
+  0x8D, 0x14,   // set DC-DC enable
+  0xAF          // display on
+};
+
+// OLED variables
+uint8_t OLED_x, OLED_y;                   // current cursor position
+
+// OLED init function
+void OLED_init(void) {
+  I2C_init();                             // initialize I2C first
+  I2C_start(OLED_ADDR);                   // start transmission to OLED
+  I2C_write(OLED_CMD_MODE);               // set command mode
+  for(uint8_t i = 0; i < OLED_INIT_LEN; i++)
+    I2C_write(pgm_read_byte(&OLED_INIT_CMD[i])); // send the command bytes
+  I2C_stop();                             // stop transmission
+}
+
+// OLED set the cursor
+void OLED_setCursor(uint8_t xpos, uint8_t ypos) {
+  I2C_start(OLED_ADDR);                   // start transmission to OLED
+  I2C_write(OLED_CMD_MODE);               // set command mode
+  I2C_write(xpos & 0x0F);                 // set low nibble of start column
+  I2C_write(0x10 | (xpos >> 4));          // set high nibble of start column
+  I2C_write(0xB0 | (ypos & 0x07));        // set start page
+  I2C_stop();                             // stop transmission
+  OLED_x = xpos; OLED_y = ypos;           // set the cursor variables
+}
+
+// OLED clear line
+void OLED_clearLine(uint8_t line) {
+  OLED_setCursor(0, line);                // set cursor to line start
+  I2C_start(OLED_ADDR);                   // start transmission to OLED
+  I2C_write(OLED_DAT_MODE);               // set data mode
+  for(uint8_t i=128; i; i--) I2C_write(0x00); // clear the line
+  I2C_stop();                             // stop transmission
+}
+
+// OLED clear screen
+void OLED_clearScreen(void) {
+  for(uint8_t i=0; i<4; i++)              // 4 lines
+    OLED_clearLine(i);                    // clear line
+}
+
+// OLED print a single character
+void OLED_printChar(char c) {
+  uint16_t ptr = c - 32;                  // character pointer
+  ptr += ptr << 2;                        // -> ptr = (ch - 32) * 5;
+  I2C_write(0x00);                        // write space between characters
+  for(uint8_t i=5 ; i; i--) I2C_write(pgm_read_byte(&OLED_FONT[ptr++]));
+  OLED_x += 6;                            // update cursor
+  if(OLED_x > 122) {                      // line end ?
+    I2C_stop();                           // stop data transmission
+    OLED_setCursor(0,++OLED_y);           // set next line start
+    I2C_start(OLED_ADDR);                 // start transmission to OLED
+    I2C_write(OLED_DAT_MODE);             // set data mode
+  }
+}
+
+// OLED print a string from program memory
+void OLED_printPrg(const char* p) {
+  I2C_start(OLED_ADDR);                   // start transmission to OLED
+  I2C_write(OLED_DAT_MODE);               // set data mode
+  char ch = pgm_read_byte(p);             // read first character from program memory
+  while(ch) {                             // repeat until string terminator
+    OLED_printChar(ch);                   // print character on OLED
+    ch = pgm_read_byte(++p);              // read next character
+  }
+  I2C_stop();                             // stop transmission
+}
+
+// OLED convert byte nibble into hex character and prints it
+void OLED_printNibble(uint8_t nibble) {
+  char c;
+  if(nibble <= 9)  c = '0' + nibble;
+  else             c = 'A' + nibble - 10;
+  OLED_printChar(c);
+}
+
+// OLED print byte as hex
+void OLED_printHex(uint8_t value) {
+  I2C_start(OLED_ADDR);                   // start transmission to OLED
+  I2C_write(OLED_DAT_MODE);               // set data mode
+  OLED_printNibble(value >> 4);           // print high nibble
+  OLED_printNibble(value & 0x0F);         // print low nibble
+  I2C_stop();                             // stop transmission
+}

README.md

@@ -0,0 +1,10 @@
+## ATtinyHVSP Toolbox
+
+Collection programme dédié à la carte ATtinyHVSP breadboard
+- TinyHVSP => reset fuse high voltage
+- ArduinoISP => AVRISP dédié à cette carte
+- Test_outputs => test de connection de la carte + scanner i2c
+- DualBootloader => 2 softs sur le même arduino (ajout d'une puce ram I2C)
+
+
+

Test_outputs/Test_outputs.ino

@@ -0,0 +1,355 @@
+//test ports pour platine HVSP
+//test des entrées/sortie et I2C_Scanner
+//Oled Screen 0x3C
+//Ram 0x50
+
+#include <avr/io.h>       // for GPIO
+#include <avr/pgmspace.h> // to store data in programm memory
+#include <util/delay.h>   // for delays
+#include <Wire.h>
+
+/* Rappel connections : 
+#define RST_PIN   PB5 //13 // 12V !RESET                       Pin 1 of target device
+#define SCI_PIN   PB4 //12 // Serial Clock Input (SCI)         Pin 2 of target device
+#define SDO_PIN   PB3 //11 // Serial Data Output (SDO)         Pin 7 of target device
+#define SII_PIN   PB2 //10 // Serial Instruction Input (SII)   Pin 6 of target device
+#define SDI_PIN   PB1 //9  // Serial Data Input (SDI)          Pin 5 of target device
+#define VCC_PIN   PB0 //8  // Target VCC                       Pin 8 of target device
+#define I2C_SCL   PC5 // I2C Serial Clock (SCK)
+#define I2C_SDA   PC4 // I2C Serial Data (SDA)
+#define BUTTON    PD7 // OK-Button
+*/
+int boucle;
+
+#define PIN PB0
+
+#define I2C_SCL   PC5 // I2C Serial Clock (SCK)
+#define I2C_SDA   PC4 // I2C Serial Data (SDA)
+
+// ===================================================================================
+// I2C Implementation
+// ===================================================================================
+
+// I2C macros
+#define I2C_SDA_HIGH()  DDRC &= ~(1<<I2C_SDA) // release SDA   -> pulled HIGH by resistor
+#define I2C_SDA_LOW()   DDRC |=  (1<<I2C_SDA) // SDA as output -> pulled LOW  by MCU
+#define I2C_SCL_HIGH()  DDRC &= ~(1<<I2C_SCL) // release SCL   -> pulled HIGH by resistor
+#define I2C_SCL_LOW()   DDRC |=  (1<<I2C_SCL) // SCL as output -> pulled LOW  by MCU
+#define I2C_DELAY()     asm("lpm")            // delay 3 clock cycles
+#define I2C_CLOCKOUT()  I2C_SCL_HIGH();I2C_DELAY();I2C_SCL_LOW()  // clock out
+
+// I2C init function
+void I2C_init(void) {
+  DDRC  &= ~((1<<I2C_SDA)|(1<<I2C_SCL));  // pins as input (HIGH-Z) -> lines released
+  PORTC &= ~((1<<I2C_SDA)|(1<<I2C_SCL));  // should be LOW when as ouput
+}
+
+// I2C transmit one data byte to the slave, ignore ACK bit, no clock stretching allowed
+void I2C_write(uint8_t data) {
+  for(uint8_t i = 8; i; i--, data<<=1) {  // transmit 8 bits, MSB first
+    (data & 0x80) ? (I2C_SDA_HIGH()) : (I2C_SDA_LOW());  // SDA HIGH if bit is 1
+    I2C_CLOCKOUT();                       // clock out -> slave reads the bit
+  }
+  I2C_DELAY();                            // delay 3 clock cycles
+  I2C_SDA_HIGH();                         // release SDA for ACK bit of slave
+  I2C_CLOCKOUT();                         // 9th clock pulse is for the ignored ACK bit
+}
+
+// I2C start transmission
+void I2C_start(uint8_t addr) {
+  I2C_SDA_LOW();                          // start condition: SDA goes LOW first
+  I2C_SCL_LOW();                          // start condition: SCL goes LOW second
+  I2C_write(addr);                        // send slave address
+}
+
+// I2C stop transmission
+void I2C_stop(void) {
+  I2C_SDA_LOW();                          // prepare SDA for LOW to HIGH transition
+  I2C_SCL_HIGH();                         // stop condition: SCL goes HIGH first
+  I2C_SDA_HIGH();                         // stop condition: SDA goes HIGH second
+}
+
+// ===================================================================================
+// OLED Implementation
+// ===================================================================================
+
+// OLED definitions
+#define OLED_ADDR       0x78              // OLED write address
+#define OLED_CMD_MODE   0x00              // set command mode
+#define OLED_DAT_MODE   0x40              // set data mode
+#define OLED_INIT_LEN   9                 // length of init command array
+
+// OLED 5x8 pixels character set
+const uint8_t OLED_FONT[] PROGMEM = {
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2F, 0x00, 0x00, 0x00, 0x07, 0x00, 0x07, 0x00,
+  0x14, 0x7F, 0x14, 0x7F, 0x14, 0x24, 0x2A, 0x7F, 0x2A, 0x12, 0x23, 0x13, 0x08, 0x64, 0x62,
+  0x36, 0x49, 0x55, 0x22, 0x50, 0x00, 0x05, 0x03, 0x00, 0x00, 0x00, 0x1C, 0x22, 0x41, 0x00,
+  0x00, 0x41, 0x22, 0x1C, 0x00, 0x14, 0x08, 0x3E, 0x08, 0x14, 0x08, 0x08, 0x3E, 0x08, 0x08,
+  0x00, 0x00, 0xA0, 0x60, 0x00, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00, 0x60, 0x60, 0x00, 0x00,
+  0x20, 0x10, 0x08, 0x04, 0x02, 0x3E, 0x51, 0x49, 0x45, 0x3E, 0x00, 0x42, 0x7F, 0x40, 0x00,
+  0x42, 0x61, 0x51, 0x49, 0x46, 0x21, 0x41, 0x45, 0x4B, 0x31, 0x18, 0x14, 0x12, 0x7F, 0x10,
+  0x27, 0x45, 0x45, 0x45, 0x39, 0x3C, 0x4A, 0x49, 0x49, 0x30, 0x01, 0x71, 0x09, 0x05, 0x03,
+  0x36, 0x49, 0x49, 0x49, 0x36, 0x06, 0x49, 0x49, 0x29, 0x1E, 0x00, 0x36, 0x36, 0x00, 0x00,
+  0x00, 0x56, 0x36, 0x00, 0x00, 0x08, 0x14, 0x22, 0x41, 0x00, 0x14, 0x14, 0x14, 0x14, 0x14,
+  0x00, 0x41, 0x22, 0x14, 0x08, 0x02, 0x01, 0x51, 0x09, 0x06, 0x32, 0x49, 0x59, 0x51, 0x3E,
+  0x7C, 0x12, 0x11, 0x12, 0x7C, 0x7F, 0x49, 0x49, 0x49, 0x36, 0x3E, 0x41, 0x41, 0x41, 0x22,
+  0x7F, 0x41, 0x41, 0x22, 0x1C, 0x7F, 0x49, 0x49, 0x49, 0x41, 0x7F, 0x09, 0x09, 0x09, 0x01,
+  0x3E, 0x41, 0x49, 0x49, 0x7A, 0x7F, 0x08, 0x08, 0x08, 0x7F, 0x00, 0x41, 0x7F, 0x41, 0x00,
+  0x20, 0x40, 0x41, 0x3F, 0x01, 0x7F, 0x08, 0x14, 0x22, 0x41, 0x7F, 0x40, 0x40, 0x40, 0x40,
+  0x7F, 0x02, 0x0C, 0x02, 0x7F, 0x7F, 0x04, 0x08, 0x10, 0x7F, 0x3E, 0x41, 0x41, 0x41, 0x3E,
+  0x7F, 0x09, 0x09, 0x09, 0x06, 0x3E, 0x41, 0x51, 0x21, 0x5E, 0x7F, 0x09, 0x19, 0x29, 0x46,
+  0x46, 0x49, 0x49, 0x49, 0x31, 0x01, 0x01, 0x7F, 0x01, 0x01, 0x3F, 0x40, 0x40, 0x40, 0x3F,
+  0x1F, 0x20, 0x40, 0x20, 0x1F, 0x3F, 0x40, 0x38, 0x40, 0x3F, 0x63, 0x14, 0x08, 0x14, 0x63,
+  0x07, 0x08, 0x70, 0x08, 0x07, 0x61, 0x51, 0x49, 0x45, 0x43, 0x00, 0x7F, 0x41, 0x41, 0x00,
+  0x02, 0x04, 0x08, 0x10, 0x20, 0x00, 0x41, 0x41, 0x7F, 0x00, 0x04, 0x02, 0x01, 0x02, 0x04,
+  0x40, 0x40, 0x40, 0x40, 0x40, 0x00, 0x01, 0x02, 0x04, 0x00, 0x20, 0x54, 0x54, 0x54, 0x78,
+  0x7F, 0x48, 0x44, 0x44, 0x38, 0x38, 0x44, 0x44, 0x44, 0x20, 0x38, 0x44, 0x44, 0x48, 0x7F,
+  0x38, 0x54, 0x54, 0x54, 0x18, 0x08, 0x7E, 0x09, 0x01, 0x02, 0x18, 0xA4, 0xA4, 0xA4, 0x7C,
+  0x7F, 0x08, 0x04, 0x04, 0x78, 0x00, 0x44, 0x7D, 0x40, 0x00, 0x40, 0x80, 0x84, 0x7D, 0x00,
+  0x7F, 0x10, 0x28, 0x44, 0x00, 0x00, 0x41, 0x7F, 0x40, 0x00, 0x7C, 0x04, 0x18, 0x04, 0x78,
+  0x7C, 0x08, 0x04, 0x04, 0x78, 0x38, 0x44, 0x44, 0x44, 0x38, 0xFC, 0x24, 0x24, 0x24, 0x18,
+  0x18, 0x24, 0x24, 0x18, 0xFC, 0x7C, 0x08, 0x04, 0x04, 0x08, 0x48, 0x54, 0x54, 0x54, 0x20,
+  0x04, 0x3F, 0x44, 0x40, 0x20, 0x3C, 0x40, 0x40, 0x20, 0x7C, 0x1C, 0x20, 0x40, 0x20, 0x1C,
+  0x3C, 0x40, 0x30, 0x40, 0x3C, 0x44, 0x28, 0x10, 0x28, 0x44, 0x1C, 0xA0, 0xA0, 0xA0, 0x7C,
+  0x44, 0x64, 0x54, 0x4C, 0x44, 0x08, 0x36, 0x41, 0x41, 0x00, 0x00, 0x00, 0x7F, 0x00, 0x00,
+  0x00, 0x41, 0x41, 0x36, 0x08, 0x08, 0x04, 0x08, 0x10, 0x08, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
+};
+
+// OLED init settings
+const uint8_t OLED_INIT_CMD[] PROGMEM = {
+  0xC8, 0xA1,   // flip screen
+  0xA8, 0x1F,   // set multiplex ratio
+  0xDA, 0x02,   // set com pins hardware configuration
+  0x8D, 0x14,   // set DC-DC enable
+  0xAF          // display on
+};
+
+// OLED variables
+uint8_t OLED_x, OLED_y;                   // current cursor position
+
+// OLED init function
+void OLED_init(void) {
+  I2C_init();                             // initialize I2C first
+  I2C_start(OLED_ADDR);                   // start transmission to OLED
+  I2C_write(OLED_CMD_MODE);               // set command mode
+  for(uint8_t i = 0; i < OLED_INIT_LEN; i++)
+    I2C_write(pgm_read_byte(&OLED_INIT_CMD[i])); // send the command bytes
+  I2C_stop();                             // stop transmission
+}
+
+// OLED set the cursor
+void OLED_setCursor(uint8_t xpos, uint8_t ypos) {
+  I2C_start(OLED_ADDR);                   // start transmission to OLED
+  I2C_write(OLED_CMD_MODE);               // set command mode
+  I2C_write(xpos & 0x0F);                 // set low nibble of start column
+  I2C_write(0x10 | (xpos >> 4));          // set high nibble of start column
+  I2C_write(0xB0 | (ypos & 0x07));        // set start page
+  I2C_stop();                             // stop transmission
+  OLED_x = xpos; OLED_y = ypos;           // set the cursor variables
+}
+
+// OLED clear line
+void OLED_clearLine(uint8_t line) {
+  OLED_setCursor(0, line);                // set cursor to line start
+  I2C_start(OLED_ADDR);                   // start transmission to OLED
+  I2C_write(OLED_DAT_MODE);               // set data mode
+  for(uint8_t i=128; i; i--) I2C_write(0x00); // clear the line
+  I2C_stop();                             // stop transmission
+}
+
+// OLED clear screen
+void OLED_clearScreen(void) {
+  for(uint8_t i=0; i<4; i++)              // 4 lines
+    OLED_clearLine(i);                    // clear line
+}
+
+// OLED print a single character
+void OLED_printChar(char c) {
+  uint16_t ptr = c - 32;                  // character pointer
+  ptr += ptr << 2;                        // -> ptr = (ch - 32) * 5;
+  I2C_write(0x00);                        // write space between characters
+  for(uint8_t i=5 ; i; i--) I2C_write(pgm_read_byte(&OLED_FONT[ptr++]));
+  OLED_x += 6;                            // update cursor
+  if(OLED_x > 122) {                      // line end ?
+    I2C_stop();                           // stop data transmission
+    OLED_setCursor(0,++OLED_y);           // set next line start
+    I2C_start(OLED_ADDR);                 // start transmission to OLED
+    I2C_write(OLED_DAT_MODE);             // set data mode
+  }
+}
+
+// OLED print a string from program memory
+void OLED_printPrg(const char* p) {
+  I2C_start(OLED_ADDR);                   // start transmission to OLED
+  I2C_write(OLED_DAT_MODE);               // set data mode
+  char ch = pgm_read_byte(p);             // read first character from program memory
+  while(ch) {                             // repeat until string terminator
+    OLED_printChar(ch);                   // print character on OLED
+    ch = pgm_read_byte(++p);              // read next character
+  }
+  I2C_stop();                             // stop transmission
+}
+
+// OLED convert byte nibble into hex character and prints it
+void OLED_printNibble(uint8_t nibble) {
+  char c;
+  if(nibble <= 9)  c = '0' + nibble;
+  else             c = 'A' + nibble - 10;
+  OLED_printChar(c);
+}
+
+// OLED print byte as hex
+void OLED_printHex(uint8_t value) {
+  I2C_start(OLED_ADDR);                   // start transmission to OLED
+  I2C_write(OLED_DAT_MODE);               // set data mode
+  OLED_printNibble(value >> 4);           // print high nibble
+  OLED_printNibble(value & 0x0F);         // print low nibble
+  I2C_stop();                             // stop transmission
+}
+
+
+
+
+const char TitleScreen[] PROGMEM = "Virtual  PIN : ";
+const char TitlePb[] PROGMEM = "PB";
+const char TitlePd[] PROGMEM = "PD";
+const char TitleScreen2[] PROGMEM = "Physical PIN : ";
+const char BaudScreen[]   PROGMEM = "I2Cscanner 115200 bds";
+
+void setup() {
+OLED_init();                            // setup I2C OLED
+OLED_clearScreen(); 
+OLED_setCursor(0,0);
+OLED_printPrg(TitleScreen);
+Serial.begin(9600);
+Serial.println("\nI2C Scanner :");
+
+
+switch (PIN) {
+case PB0:
+         DDRB  |= (1<<PIN);
+         OLED_printPrg(TitlePb);
+         OLED_printHex(0x00);
+         OLED_setCursor(0,1);
+         OLED_printPrg(TitleScreen2);
+         OLED_printHex(0x08);
+         OLED_setCursor(0,3);
+         OLED_printPrg(BaudScreen);
+         break;
+case PB1:
+         DDRB  |= (1<<PIN);
+         OLED_printPrg(TitlePb);
+         OLED_printHex(0x01);
+         OLED_setCursor(0,2);
+         OLED_printPrg(TitleScreen2);
+         OLED_printHex(0x09);
+         break;
+case PB2:
+         DDRB  |= (1<<PIN);
+         OLED_printPrg(TitlePb);
+         OLED_printHex(0x02);
+         OLED_setCursor(0,2);
+         OLED_printPrg(TitleScreen2);
+         OLED_printHex(0x10);
+         break;
+case PB3:
+         DDRB  |= (1<<PIN);
+         OLED_printPrg(TitlePb);
+         OLED_printHex(0x03);
+         OLED_setCursor(0,2);
+         OLED_printPrg(TitleScreen2);
+         OLED_printHex(0x11);
+         break;
+case PB4:
+         DDRB  |= (1<<PIN);
+         OLED_printPrg(TitlePb);
+         OLED_printHex(0x04);
+         OLED_setCursor(0,2);
+         OLED_printPrg(TitleScreen2);
+         OLED_printHex(0x12);
+         break;
+         
+case PB5:
+         DDRB  |= (1<<PIN);
+         OLED_printPrg(TitlePb);
+         OLED_printHex(0x05);
+         OLED_setCursor(0,2);
+         OLED_printPrg(TitleScreen2);
+         OLED_printHex(0x13);
+         break;
+         
+case PD7:
+         DDRD |= (1<<PIN);
+         OLED_printPrg(TitlePd);
+         OLED_printHex(0x07);
+         OLED_setCursor(0,2);
+         OLED_printPrg(TitleScreen2);
+         OLED_printHex(0x07);
+         break;
+default: 
+         break;
+}
+ 
+
+ 
+ 
+}
+
+void loop() {
+  byte error, address;
+  int nDevices;
+  
+
+switch (boucle){
+  case 10:
+          Serial.println("Scanning...");
+          nDevices = 0;
+          for(address = 1; address < 127; address++ )
+          { 
+          Wire.beginTransmission(address);
+          error = Wire.endTransmission();
+          if (error == 0)
+          {
+          Serial.print("I2C device found at address 0x");
+          if (address<16) 
+          Serial.print("0");
+          Serial.print(address,HEX);
+          Serial.println("  !");
+          nDevices++;
+          }
+          else if (error==4) 
+          {
+          Serial.print("Unknow error at address 0x");
+          if (address<16) 
+          Serial.print("0");
+          Serial.println(address,HEX);
+          }    
+          }
+          if (nDevices == 0)
+          Serial.println("No I2C devices found\n");
+          else
+          Serial.println("done\n");
+          boucle=0;
+          break;
+   
+   default:
+          boucle++;
+}
+ 
+  switch (PIN) {
+  case PD7 :
+           PORTD &= ~(1<<PIN);
+           delay(100);
+           PORTD |=  (1<<PIN);
+           delay(100);
+           break;
+  default:
+           PORTB &= ~(1<<PIN);
+           delay(100);
+           PORTB |=  (1<<PIN);
+           delay(100);
+           break;
+  
+}
+
+}

TinyHVSP/TinyHVSP.ino

@@ -0,0 +1,576 @@
+
+//Tiny HVSP V1.4
+//Platine arduino uno (mini pro flashé en uno)
+//validé pour T13 , T25 , T45 , T84 , T85 , T24
+
+
+// ===================================================================================
+// Libraries and Definitions
+// ===================================================================================
+
+// Libraries
+#include <avr/io.h>       // for GPIO
+#include <avr/pgmspace.h> // to store data in programm memory
+#include <util/delay.h>   // for delays
+
+// Pin definitions
+#define RST_PIN   PB5 //13 // 12V !RESET                       Pin 1 of target device
+#define SCI_PIN   PB4 //12 // Serial Clock Input (SCI)         Pin 2 of target device
+#define SDO_PIN   PB3 //11 // Serial Data Output (SDO)         Pin 7 of target device
+#define SII_PIN   PB2 //10 // Serial Instruction Input (SII)   Pin 6 of target device
+#define SDI_PIN   PB1 //9  // Serial Data Input (SDI)          Pin 5 of target device
+#define VCC_PIN   PB0 //8  // Target VCC                       Pin 8 of target device
+#define I2C_SCL   PC5 // I2C Serial Clock (SCK)
+#define I2C_SDA   PC4 // I2C Serial Data (SDA)
+#define BUTTON    PD7 // OK-Button
+
+#define ERRORLED  PD4 //4 led rouge
+#define GOODLED   PD3 //3 led verte
+// Global variables
+uint8_t  inLFUSE, inHFUSE, inEFUSE;           // for reading fuses
+uint8_t  outLFUSE, outHFUSE, outEFUSE;        // for writing fuses
+uint8_t  inLOCK;                              // for reading lock bits
+uint16_t signature;                           // for reading signature
+
+// ===================================================================================
+// I2C Implementation
+// ===================================================================================
+
+// I2C macros
+#define I2C_SDA_HIGH()  DDRC &= ~(1<<I2C_SDA) // release SDA   -> pulled HIGH by resistor
+#define I2C_SDA_LOW()   DDRC |=  (1<<I2C_SDA) // SDA as output -> pulled LOW  by MCU
+#define I2C_SCL_HIGH()  DDRC &= ~(1<<I2C_SCL) // release SCL   -> pulled HIGH by resistor
+#define I2C_SCL_LOW()   DDRC |=  (1<<I2C_SCL) // SCL as output -> pulled LOW  by MCU
+#define I2C_DELAY()     asm("lpm")            // delay 3 clock cycles
+#define I2C_CLOCKOUT()  I2C_SCL_HIGH();I2C_DELAY();I2C_SCL_LOW()  // clock out
+
+// I2C init function
+void I2C_init(void) {
+  DDRC  &= ~((1<<I2C_SDA)|(1<<I2C_SCL));  // pins as input (HIGH-Z) -> lines released
+  PORTC &= ~((1<<I2C_SDA)|(1<<I2C_SCL));  // should be LOW when as ouput
+}
+
+// I2C transmit one data byte to the slave, ignore ACK bit, no clock stretching allowed
+void I2C_write(uint8_t data) {
+  for(uint8_t i = 8; i; i--, data<<=1) {  // transmit 8 bits, MSB first
+    (data & 0x80) ? (I2C_SDA_HIGH()) : (I2C_SDA_LOW());  // SDA HIGH if bit is 1
+    I2C_CLOCKOUT();                       // clock out -> slave reads the bit
+  }
+  I2C_DELAY();                            // delay 3 clock cycles
+  I2C_SDA_HIGH();                         // release SDA for ACK bit of slave
+  I2C_CLOCKOUT();                         // 9th clock pulse is for the ignored ACK bit
+}
+
+// I2C start transmission
+void I2C_start(uint8_t addr) {
+  I2C_SDA_LOW();                          // start condition: SDA goes LOW first
+  I2C_SCL_LOW();                          // start condition: SCL goes LOW second
+  I2C_write(addr);                        // send slave address
+}
+
+// I2C stop transmission
+void I2C_stop(void) {
+  I2C_SDA_LOW();                          // prepare SDA for LOW to HIGH transition
+  I2C_SCL_HIGH();                         // stop condition: SCL goes HIGH first
+  I2C_SDA_HIGH();                         // stop condition: SDA goes HIGH second
+}
+
+// ===================================================================================
+// OLED Implementation
+// ===================================================================================
+
+// OLED definitions
+#define OLED_ADDR       0x78              // OLED write address
+#define OLED_CMD_MODE   0x00              // set command mode
+#define OLED_DAT_MODE   0x40              // set data mode
+#define OLED_INIT_LEN   9                 // length of init command array
+
+// OLED 5x8 pixels character set
+const uint8_t OLED_FONT[] PROGMEM = {
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2F, 0x00, 0x00, 0x00, 0x07, 0x00, 0x07, 0x00,
+  0x14, 0x7F, 0x14, 0x7F, 0x14, 0x24, 0x2A, 0x7F, 0x2A, 0x12, 0x23, 0x13, 0x08, 0x64, 0x62,
+  0x36, 0x49, 0x55, 0x22, 0x50, 0x00, 0x05, 0x03, 0x00, 0x00, 0x00, 0x1C, 0x22, 0x41, 0x00,
+  0x00, 0x41, 0x22, 0x1C, 0x00, 0x14, 0x08, 0x3E, 0x08, 0x14, 0x08, 0x08, 0x3E, 0x08, 0x08,
+  0x00, 0x00, 0xA0, 0x60, 0x00, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00, 0x60, 0x60, 0x00, 0x00,
+  0x20, 0x10, 0x08, 0x04, 0x02, 0x3E, 0x51, 0x49, 0x45, 0x3E, 0x00, 0x42, 0x7F, 0x40, 0x00,
+  0x42, 0x61, 0x51, 0x49, 0x46, 0x21, 0x41, 0x45, 0x4B, 0x31, 0x18, 0x14, 0x12, 0x7F, 0x10,
+  0x27, 0x45, 0x45, 0x45, 0x39, 0x3C, 0x4A, 0x49, 0x49, 0x30, 0x01, 0x71, 0x09, 0x05, 0x03,
+  0x36, 0x49, 0x49, 0x49, 0x36, 0x06, 0x49, 0x49, 0x29, 0x1E, 0x00, 0x36, 0x36, 0x00, 0x00,
+  0x00, 0x56, 0x36, 0x00, 0x00, 0x08, 0x14, 0x22, 0x41, 0x00, 0x14, 0x14, 0x14, 0x14, 0x14,
+  0x00, 0x41, 0x22, 0x14, 0x08, 0x02, 0x01, 0x51, 0x09, 0x06, 0x32, 0x49, 0x59, 0x51, 0x3E,
+  0x7C, 0x12, 0x11, 0x12, 0x7C, 0x7F, 0x49, 0x49, 0x49, 0x36, 0x3E, 0x41, 0x41, 0x41, 0x22,
+  0x7F, 0x41, 0x41, 0x22, 0x1C, 0x7F, 0x49, 0x49, 0x49, 0x41, 0x7F, 0x09, 0x09, 0x09, 0x01,
+  0x3E, 0x41, 0x49, 0x49, 0x7A, 0x7F, 0x08, 0x08, 0x08, 0x7F, 0x00, 0x41, 0x7F, 0x41, 0x00,
+  0x20, 0x40, 0x41, 0x3F, 0x01, 0x7F, 0x08, 0x14, 0x22, 0x41, 0x7F, 0x40, 0x40, 0x40, 0x40,
+  0x7F, 0x02, 0x0C, 0x02, 0x7F, 0x7F, 0x04, 0x08, 0x10, 0x7F, 0x3E, 0x41, 0x41, 0x41, 0x3E,
+  0x7F, 0x09, 0x09, 0x09, 0x06, 0x3E, 0x41, 0x51, 0x21, 0x5E, 0x7F, 0x09, 0x19, 0x29, 0x46,
+  0x46, 0x49, 0x49, 0x49, 0x31, 0x01, 0x01, 0x7F, 0x01, 0x01, 0x3F, 0x40, 0x40, 0x40, 0x3F,
+  0x1F, 0x20, 0x40, 0x20, 0x1F, 0x3F, 0x40, 0x38, 0x40, 0x3F, 0x63, 0x14, 0x08, 0x14, 0x63,
+  0x07, 0x08, 0x70, 0x08, 0x07, 0x61, 0x51, 0x49, 0x45, 0x43, 0x00, 0x7F, 0x41, 0x41, 0x00,
+  0x02, 0x04, 0x08, 0x10, 0x20, 0x00, 0x41, 0x41, 0x7F, 0x00, 0x04, 0x02, 0x01, 0x02, 0x04,
+  0x40, 0x40, 0x40, 0x40, 0x40, 0x00, 0x01, 0x02, 0x04, 0x00, 0x20, 0x54, 0x54, 0x54, 0x78,
+  0x7F, 0x48, 0x44, 0x44, 0x38, 0x38, 0x44, 0x44, 0x44, 0x20, 0x38, 0x44, 0x44, 0x48, 0x7F,
+  0x38, 0x54, 0x54, 0x54, 0x18, 0x08, 0x7E, 0x09, 0x01, 0x02, 0x18, 0xA4, 0xA4, 0xA4, 0x7C,
+  0x7F, 0x08, 0x04, 0x04, 0x78, 0x00, 0x44, 0x7D, 0x40, 0x00, 0x40, 0x80, 0x84, 0x7D, 0x00,
+  0x7F, 0x10, 0x28, 0x44, 0x00, 0x00, 0x41, 0x7F, 0x40, 0x00, 0x7C, 0x04, 0x18, 0x04, 0x78,
+  0x7C, 0x08, 0x04, 0x04, 0x78, 0x38, 0x44, 0x44, 0x44, 0x38, 0xFC, 0x24, 0x24, 0x24, 0x18,
+  0x18, 0x24, 0x24, 0x18, 0xFC, 0x7C, 0x08, 0x04, 0x04, 0x08, 0x48, 0x54, 0x54, 0x54, 0x20,
+  0x04, 0x3F, 0x44, 0x40, 0x20, 0x3C, 0x40, 0x40, 0x20, 0x7C, 0x1C, 0x20, 0x40, 0x20, 0x1C,
+  0x3C, 0x40, 0x30, 0x40, 0x3C, 0x44, 0x28, 0x10, 0x28, 0x44, 0x1C, 0xA0, 0xA0, 0xA0, 0x7C,
+  0x44, 0x64, 0x54, 0x4C, 0x44, 0x08, 0x36, 0x41, 0x41, 0x00, 0x00, 0x00, 0x7F, 0x00, 0x00,
+  0x00, 0x41, 0x41, 0x36, 0x08, 0x08, 0x04, 0x08, 0x10, 0x08, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
+};
+
+// OLED init settings
+const uint8_t OLED_INIT_CMD[] PROGMEM = {
+  0xC8, 0xA1,   // flip screen
+  0xA8, 0x1F,   // set multiplex ratio
+  0xDA, 0x02,   // set com pins hardware configuration
+  0x8D, 0x14,   // set DC-DC enable
+  0xAF          // display on
+};
+
+// OLED variables
+uint8_t OLED_x, OLED_y;                   // current cursor position
+
+// OLED init function
+void OLED_init(void) {
+  I2C_init();                             // initialize I2C first
+  I2C_start(OLED_ADDR);                   // start transmission to OLED
+  I2C_write(OLED_CMD_MODE);               // set command mode
+  for(uint8_t i = 0; i < OLED_INIT_LEN; i++)
+    I2C_write(pgm_read_byte(&OLED_INIT_CMD[i])); // send the command bytes
+  I2C_stop();                             // stop transmission
+}
+
+// OLED set the cursor
+void OLED_setCursor(uint8_t xpos, uint8_t ypos) {
+  I2C_start(OLED_ADDR);                   // start transmission to OLED
+  I2C_write(OLED_CMD_MODE);               // set command mode
+  I2C_write(xpos & 0x0F);                 // set low nibble of start column
+  I2C_write(0x10 | (xpos >> 4));          // set high nibble of start column
+  I2C_write(0xB0 | (ypos & 0x07));        // set start page
+  I2C_stop();                             // stop transmission
+  OLED_x = xpos; OLED_y = ypos;           // set the cursor variables
+}
+
+// OLED clear line
+void OLED_clearLine(uint8_t line) {
+  OLED_setCursor(0, line);                // set cursor to line start
+  I2C_start(OLED_ADDR);                   // start transmission to OLED
+  I2C_write(OLED_DAT_MODE);               // set data mode
+  for(uint8_t i=128; i; i--) I2C_write(0x00); // clear the line
+  I2C_stop();                             // stop transmission
+}
+
+// OLED clear screen
+void OLED_clearScreen(void) {
+  for(uint8_t i=0; i<4; i++)              // 4 lines
+    OLED_clearLine(i);                    // clear line
+}
+
+// OLED print a single character
+void OLED_printChar(char c) {
+  uint16_t ptr = c - 32;                  // character pointer
+  ptr += ptr << 2;                        // -> ptr = (ch - 32) * 5;
+  I2C_write(0x00);                        // write space between characters
+  for(uint8_t i=5 ; i; i--) I2C_write(pgm_read_byte(&OLED_FONT[ptr++]));
+  OLED_x += 6;                            // update cursor
+  if(OLED_x > 122) {                      // line end ?
+    I2C_stop();                           // stop data transmission
+    OLED_setCursor(0,++OLED_y);           // set next line start
+    I2C_start(OLED_ADDR);                 // start transmission to OLED
+    I2C_write(OLED_DAT_MODE);             // set data mode
+  }
+}
+
+// OLED print a string from program memory
+void OLED_printPrg(const char* p) {
+  I2C_start(OLED_ADDR);                   // start transmission to OLED
+  I2C_write(OLED_DAT_MODE);               // set data mode
+  char ch = pgm_read_byte(p);             // read first character from program memory
+  while(ch) {                             // repeat until string terminator
+    OLED_printChar(ch);                   // print character on OLED
+    ch = pgm_read_byte(++p);              // read next character
+  }
+  I2C_stop();                             // stop transmission
+}
+
+// OLED convert byte nibble into hex character and prints it
+void OLED_printNibble(uint8_t nibble) {
+  char c;
+  if(nibble <= 9)  c = '0' + nibble;
+  else             c = 'A' + nibble - 10;
+  OLED_printChar(c);
+}
+
+// OLED print byte as hex
+void OLED_printHex(uint8_t value) {
+  I2C_start(OLED_ADDR);                   // start transmission to OLED
+  I2C_write(OLED_DAT_MODE);               // set data mode
+  OLED_printNibble(value >> 4);           // print high nibble
+  OLED_printNibble(value & 0x0F);         // print low nibble
+  I2C_stop();                             // stop transmission
+}
+
+// ===================================================================================
+// High-Voltage Serial Programmer Implementation
+// ===================================================================================
+
+// Desired fuse configuration (defaults) for ATtiny13
+#define T13_LFUSE         0x6A
+#define T13_HFUSE         0xFF
+
+// Desired fuse configuration (defaults) for ATtiny25/45/85
+#define Tx5_LFUSE         0x62
+#define Tx5_HFUSE         0xDF
+
+// Desired fuse configuration (defaults) for ATtiny24/44/84
+#define Tx4_LFUSE         0xE2
+#define Tx4_HFUSE         0xDF
+
+// Signatures
+#define T13_SIG           0x9007
+#define T15_SIG           0x9006
+#define T24_SIG           0x910b
+#define T25_SIG           0x9108
+#define T44_SIG           0x9207
+#define T45_SIG           0x9206
+#define T84_SIG           0x930c
+#define T85_SIG           0x930b
+
+
+
+// HVSP macros
+#define HVSP_RST_12V()    PORTB &= ~(1<<RST_PIN)
+#define HVSP_RST_LOW()    PORTB |=  (1<<RST_PIN)
+#define HVSP_VCC_ON()     PORTB |=  (1<<VCC_PIN)
+#define HVSP_VCC_OFF()    PORTB &= ~(1<<VCC_PIN)
+#define HVSP_SCI_HIGH()   PORTB |=  (1<<SCI_PIN)
+#define HVSP_SCI_LOW()    PORTB &= ~(1<<SCI_PIN)
+#define HVSP_SII_HIGH()   PORTB |=  (1<<SII_PIN)
+#define HVSP_SII_LOW()    PORTB &= ~(1<<SII_PIN)
+#define HVSP_SDI_HIGH()   PORTB |=  (1<<SDI_PIN)
+#define HVSP_SDI_LOW()    PORTB &= ~(1<<SDI_PIN)
+#define HVSP_SDO_REL()    DDRB  &= ~(1<<SDO_PIN)
+#define HVSP_SDO_BIT      (PINB &   (1<<SDO_PIN))
+#define HVSP_CLOCKOUT()   {HVSP_SCI_HIGH(); HVSP_SCI_LOW();}
+
+//LEDs
+void error_led(void) {
+  PORTD |=  (1<<ERRORLED);
+}
+
+void good_led(void) {
+  PORTD |=  (1<<GOODLED);
+}
+
+void off_led(void) {
+  PORTD &= ~(1<<ERRORLED);
+  PORTD &= ~(1<<GOODLED);
+}
+
+// HVSP set up all control lines
+void HVSP_init(void) {
+  PORTB &= ~((1<<SCI_PIN) | (1<<SDO_PIN) | (1<<SII_PIN) | (1<<SDI_PIN) | (1<<VCC_PIN));
+  PORTB |=   (1<<RST_PIN);
+  DDRB  |=   (1<<SCI_PIN) | (1<<SDO_PIN) | (1<<SII_PIN) | (1<<SDI_PIN) | (1<<VCC_PIN) | (1<<RST_PIN);
+}
+
+// HVSP release all control lines (except RST)
+void HVSP_release(void) {
+  PORTB &= ~((1<<SCI_PIN) | (1<<SDO_PIN) | (1<<SII_PIN) | (1<<SDI_PIN) | (1<<VCC_PIN));
+  DDRB  &= ~((1<<SCI_PIN) | (1<<SDO_PIN) | (1<<SII_PIN) | (1<<SDI_PIN) | (1<<VCC_PIN));
+}
+
+// HVSP enter the programming mode
+void HVSP_enterProgMode(void) {
+  HVSP_init();                            // initialize control lines
+  HVSP_VCC_ON();                          // apply VCC to target
+  _delay_us(20);                          // wait 20us
+  HVSP_RST_12V();                         // apply 12V to RESET pin of target
+  _delay_us(10);                          // wait 10us
+  HVSP_SDO_REL();                          // release SDO line
+  _delay_us(300);                         // delay 300us
+}
+
+// HVSP exit the programming mode
+void HVSP_exitProgMode(void) {
+  HVSP_SCI_LOW();                         // set SCI line LOW
+  HVSP_RST_LOW();                         // RESET to 0V
+  HVSP_VCC_OFF();                         // power down the target
+  HVSP_release();                         // release all control lines
+}
+
+// HVSP send instruction and receive reply
+uint8_t HVSP_sendInstr(uint8_t SDI_BYTE, uint8_t SII_BYTE) {
+  uint8_t SDO_BYTE = 0;                   // received byte from target
+
+  // wait until SDO_PIN goes high (target ready) or 10ms time-out
+  for(uint8_t i=10; i; i--) {             // 10 x 1ms
+    if(HVSP_SDO_BIT) break;               // check SDO line
+    _delay_ms(1);                         // delay 1ms
+  }
+       
+  // send start bit (SDI/SII = '0')
+  HVSP_SDI_LOW();                         // SDI = '0'
+  HVSP_SII_LOW();                         // SII = '0'
+  HVSP_CLOCKOUT();                        // SCI HIGH, SCI LOW
+
+  // send instruction bytes, MSB first; receive reply
+  for(uint8_t i=8; i; i--) {
+    (SDI_BYTE & 0x80) ? (HVSP_SDI_HIGH()) : (HVSP_SDI_LOW());
+    (SII_BYTE & 0x80) ? (HVSP_SII_HIGH()) : (HVSP_SII_LOW());
+    SDI_BYTE <<= 1;
+    SII_BYTE <<= 1;
+    SDO_BYTE <<= 1;
+    if(HVSP_SDO_BIT) SDO_BYTE |= 1;
+    HVSP_CLOCKOUT();
+  }
+      
+  // send end bits (two times SDI/SII = '0')
+  HVSP_SDI_LOW();                         // SDI = '0'
+  HVSP_SII_LOW();                         // SII = '0'
+  HVSP_CLOCKOUT();                        // SCI HIGH, SCI LOW
+  HVSP_CLOCKOUT();                        // SCI HIGH, SCI LOW
+        
+  return SDO_BYTE;                        // return read SDO byte
+}
+
+// HVSP read signature of target device
+void HVSP_readSignature(void) {
+  HVSP_sendInstr(0x08, 0x4C);             // Instr1: read sig/calib command
+  HVSP_sendInstr(0x01, 0x0C);             // Instr2: select signature byte 1
+  HVSP_sendInstr(0x00, 0x68);             // Instr3: signature, not calibration
+  signature = HVSP_sendInstr(0x00, 0x6C); // Instr4: read the signature byte
+  signature <<= 8;                        // shift left 8 bits
+  HVSP_sendInstr(0x02, 0x0C);             // Instr2: select signature byte 2
+  HVSP_sendInstr(0x00, 0x68);             // Instr3: signature, not calibration
+  signature |= HVSP_sendInstr(0x00, 0x6C);// Instr4: read the signature byte
+  
+}
+
+// HVSP read lock bits
+void HVSP_readLock(void) {
+  HVSP_sendInstr(0x04, 0x4C);             // Instr1: read fuses/lock command
+  HVSP_sendInstr(0x00, 0x78);             // Instr2: select lock bits
+  inLOCK  = HVSP_sendInstr(0x00, 0x7C);   // Instr3: read lock bits
+  inLOCK &= 0x03;                         // mask the lock bits
+}
+
+// HVSP read current fuse settings from target device
+void HVSP_readFuses(void) {
+  HVSP_sendInstr(0x04, 0x4C);             // Instr1: read fuses/lock command
+  HVSP_sendInstr(0x00, 0x68);             // Instr2: select low fuse
+  inLFUSE = HVSP_sendInstr(0x00, 0x6C);   // Instr3: read low fuse
+
+  HVSP_sendInstr(0x00, 0x7A);             // Instr2: select high fuse
+  inHFUSE = HVSP_sendInstr(0x00, 0x7E);   // Instr3: read high fuse
+
+  HVSP_sendInstr(0x00, 0x6A);             // Instr2: select extended fuse
+  inEFUSE = HVSP_sendInstr(0x00, 0x6E);   // Instr3: read extended fuse
+}
+
+// HVSP write fuse settings to target device
+void HVSP_writeFuses(void) {
+  HVSP_sendInstr(0x40,  0x4C);            // Instr1: write fuses/lock command
+  HVSP_sendInstr(outLFUSE, 0x2C);         // Instr2: write low fuse
+  HVSP_sendInstr(0x00,  0x64);            // Instr3: select low fuse
+  HVSP_sendInstr(0x00,  0x6C);            // Instr4: select low fuse
+
+  HVSP_sendInstr(outHFUSE, 0x2C);         // Instr2: write high fuse
+  HVSP_sendInstr(0x00,  0x74);            // Instr3: select high fuse
+  HVSP_sendInstr(0x00,  0x7C);            // Instr4: select high fuse
+
+  HVSP_sendInstr(outEFUSE & 0x01, 0x2C);  // Instr2: write extended fuse
+  HVSP_sendInstr(0x00,  0x66);            // Instr3: select extended fuse
+  HVSP_sendInstr(0x00,  0x6E);            // Instr4: select extended fuse
+
+  while(!HVSP_SDO_BIT);                   // wait for write cycle to finish
+}
+
+// HVSP perform chip erase
+void HVSP_eraseChip(void) {
+  HVSP_sendInstr(0x80, 0x4C);             // Instr1: chip erase command
+  HVSP_sendInstr(0x00, 0x64);             // Instr2
+  HVSP_sendInstr(0x00, 0x6C);             // Instr3
+  while(!HVSP_SDO_BIT);                   // wait for the chip erase cycle to finish
+  HVSP_sendInstr(0x00, 0x4C);             // no operation command to finish chip erase
+}
+
+// ===================================================================================
+// Additional Functions
+// ===================================================================================
+
+// Text strings stored in program memory
+const char CurrentFuseStr[] PROGMEM = "Current fuse settings";
+const char LowStr[] PROGMEM =         "l: ";
+const char HighStr[] PROGMEM =        " - h: ";
+const char ExtendedStr[] PROGMEM =    " - e: ";
+
+// Print current fuse settings on the OLED
+void printFuses() {
+  OLED_setCursor(0,1); OLED_printPrg(CurrentFuseStr);
+  OLED_printPrg(LowStr); OLED_printHex(inLFUSE);
+  OLED_printPrg(HighStr); OLED_printHex(inHFUSE);
+  OLED_printPrg(ExtendedStr); OLED_printHex(inEFUSE);
+}
+
+// Wait until OK-Button was pressed
+void waitButton() {
+  while(~PIND & (1<<BUTTON));             // wait for button released
+  _delay_ms(10);                          // debounce
+  while( PIND & (1<<BUTTON));             // wait for button pressed
+}
+
+// ===================================================================================
+// Main Function
+// ===================================================================================
+
+// Text strings stored in program memory
+const char TitleScreen[] PROGMEM =
+  "Tiny HVSP Version 1.5"
+  "Insert  ATtiny  into "
+  "the socket and press "
+  "OK-Button to continue";
+const char ErrorScreen[] PROGMEM =
+  "Check correct place- "
+  "ment of the chip and "
+  "press <OK> to retry. ";
+const char EraseScreen[] PROGMEM = 
+  "Error burning fuses !"
+  "Press <OK> to perform"
+  "a chip erase and     "
+  "retry burning fuses. ";
+const char DetectedStr[] PROGMEM =  "Detected:    ";
+const char ATtinyStr[] PROGMEM =    "ATtiny";
+const char ErrorStr[] PROGMEM =     " Error !";
+const char DefaultStr[] PROGMEM =   "<OK> to burn defaults";
+const char BurnedStr[] PROGMEM =    "Fuses burned         ";
+const char QuitStr[] PROGMEM =      "Press <OK> to quit.  ";
+
+int main(void) {
+  // Setup
+  DDRB  |= (1<<RST_PIN);                  // RST pin as ouput
+  PORTB |= (1<<RST_PIN);                  // RST HIGH -> shut off 12V
+  PORTD |= (1<<BUTTON);                   // pullup on button pin
+  DDRD  |= (1<<ERRORLED);                 // errorled as output
+  DDRD  |= (1<<GOODLED);                 // goodled as outpu
+  PORTD &= ~(1<<ERRORLED);
+  outEFUSE = 0xFF;                        // extended fuse default
+  OLED_init();                            // setup I2C OLED
+  OLED_clearScreen();                     // clear screen
+  off_led();
+  // Loop
+  while(1) {
+    // Print title screen    
+    OLED_setCursor(0,0);
+    OLED_printPrg(TitleScreen);
+    
+    // Start detection of device and repeat until positive detection
+    uint8_t chipDetected = 0;             // assume negative detection by now
+    while(!chipDetected) {                // repeat until a valid chip was detected
+      waitButton();                       // wait for OK-Button pressed
+      
+      chipDetected = 1;                   // assume positive detection by now
+      HVSP_enterProgMode();               // start programming mode
+      HVSP_readSignature();               // read device signature
+
+      // Prepare to show information on OLED
+      OLED_setCursor(0,0);
+      OLED_printPrg(DetectedStr);
+
+      // Make settings depending on detected device
+      switch(signature) {
+        case T13_SIG: OLED_printPrg(ATtinyStr);
+                      OLED_printHex(0x13);
+                      outLFUSE=T13_LFUSE;
+                      outHFUSE=T13_HFUSE;
+                      //good_led();
+                      break;
+
+        case T24_SIG: OLED_printPrg(ATtinyStr);
+                      OLED_printHex(0x24);
+                      outLFUSE=Tx4_LFUSE;
+                      outHFUSE=Tx4_HFUSE;
+                      //good_led();
+                      break;
+        
+        case T25_SIG: OLED_printPrg(ATtinyStr);
+                      OLED_printHex(0x25);
+                      outLFUSE=Tx5_LFUSE;
+                      outHFUSE=Tx5_HFUSE;
+                      //good_led();
+                      break;
+        
+        case T44_SIG: OLED_printPrg(ATtinyStr);
+                      OLED_printHex(0x44);
+                      outLFUSE=Tx5_LFUSE;
+                      outHFUSE=Tx5_HFUSE;
+                      //good_led();
+                      break;
+                                              
+        case T45_SIG: OLED_printPrg(ATtinyStr);
+                      OLED_printHex(0x45);
+                      outLFUSE=Tx5_LFUSE;
+                      outHFUSE=Tx5_HFUSE;
+                      //good_led();
+                      break;
+        
+        case T84_SIG: OLED_printPrg(ATtinyStr);
+                      OLED_printHex(0x84);
+                      outLFUSE=Tx4_LFUSE;
+                      outHFUSE=Tx4_HFUSE;
+                      //good_led();
+                      break;
+                      
+        case T85_SIG: OLED_printPrg(ATtinyStr);
+                      OLED_printHex(0x85);
+                      outLFUSE=Tx5_LFUSE;
+                      outHFUSE=Tx5_HFUSE;
+                      //good_led();
+                      break;
+        
+        default:      OLED_printPrg(ErrorStr);
+                      OLED_setCursor(0,1);
+                      OLED_printPrg(ErrorScreen);
+                      HVSP_exitProgMode();
+                      chipDetected = 0;
+                      error_led();
+                      break;
+      }
+    }
+
+    // Read and show detected fuse settings on OLED
+    HVSP_readFuses();                     // read current fuse setting
+    printFuses();                         // show detected fuse settings
+    OLED_printPrg(DefaultStr);
+
+    // Write and read back fuses
+    waitButton();                         // wait for OK-Button pressed
+    HVSP_writeFuses();                    // write default fuse settings
+    HVSP_readFuses();                     // read back fuse settings
+
+    // Check if fuses were burned correctly
+    if( (inLFUSE != outLFUSE) | (inHFUSE != outHFUSE) ) {
+      OLED_setCursor(0,0);
+      OLED_printPrg(EraseScreen);
+      waitButton();                       // wait for OK-Button pressed
+      HVSP_eraseChip();                   // perform chip erase
+      HVSP_writeFuses();                  // write default fuse settings
+      HVSP_readFuses();                   // read back fuse settings
+   
+    }
+
+    HVSP_exitProgMode();                  // exit programming mode
+
+    // Write information on OLED
+    OLED_setCursor(0,0);
+    OLED_printPrg(BurnedStr);
+    printFuses();
+    OLED_printPrg(QuitStr);
+    good_led();
+    waitButton();                         // wait for OK-Button pressed 
+    off_led();
+  }
+}

arduino_dualboot_bootloader/Makefile

@@ -0,0 +1,34 @@
+###################################################################
+# Makefile for arduino_dualboot hack
+# visit http://blog.vinu.co.in for more details
+###################################################################
+
+PROJECT=arduino_dualboot
+SOURCES=main.c i2c.c uart.c
+CC=avr-gcc
+OBJCOPY=avr-objcopy
+MMCU=atmega328p
+LD_FLAGS = -Wl,--section-start=.text=0x7800
+C_FLAGS = -mmcu=$(MMCU) -Os -Wall -std=c99
+PROGRAMMER=arduino
+BURN=../AVRDUDESS/avrdude.exe
+MCU=m328p
+COM=COM16
+
+
+$(PROJECT).hex: $(PROJECT).out
+	$(OBJCOPY) -j .text -j .data -O ihex $(PROJECT).out $(PROJECT).hex
+	
+
+$(PROJECT).out: $(SOURCES)
+	$(CC) $(C_FLAGS) $(LD_FLAGS) -I./ -o $(PROJECT).out $(SOURCES) 
+	avr-size $(PROJECT).out
+	
+p: $(PROJECT).hex
+	$(BURN) -c $(PROGRAMMER) -p $(MCU) -U flash:w:$(PROJECT).hex -b 19200 -P $(COM)
+
+f:
+	$(BURN) -c $(PROGRAMMER) -p $(MCU) -U lfuse:w:0xef:m -U hfuse:w:0xda:m -U efuse:w:0xfd:m -b 19200 -P $(COM)
+	
+clean:
+	rm arduino_dualboot.hex arduino_dualboot.out

arduino_dualboot_bootloader/README.txt

@@ -0,0 +1,8 @@
+
+This is a modified arduino bootloader which supports dual boot. Here the trick is to save a backup ROM in external eeprom which is then invoked from the bootloader on hardware reset. This dualboot feature will be invoked only if the pin 10 and 9 of arduino (here uno/pro mini) is shorted before and while a hardware reset is performed. After hardwareset the on board LED will glow for 1 seconds if the pin 10 and 11 are shorted while reset is performed. If we remove the short before 1 seconds (ie before the LED is turned off), then it enter into dualboot operation. It do a swap operation ie it will backup the current ROM to external eeprom and writes the existing rom in external eeprom to internal flash and starts booting into the new ROM. If we do the same again, the reverse will happen  as we are swapping between the backup ROM and current ROM. 
+
+At that same time, this is arduino supported bootloader so we can upload sketches via arduino software or commandline as usual.
+
+Currently You can try with UNO as the board even if the baord is pro-mini-16. Bootloader works at 115200 BAUD.
+
+For detailed explanation please visit http://blog.vinu.co.in

arduino_dualboot_bootloader/arduino_dualboot.hex

@@ -0,0 +1,107 @@
+:107800000C94343C0C94463C0C94463C0C94463C02
+:107810000C94463C0C94463C0C94463C0C94463CE0
+:107820000C94463C0C94463C0C94463C0C94463CD0
+:107830000C94463C0C94463C0C94463C0C94463CC0
+:107840000C94463C0C94463C0C94463C0C94463CB0
+:107850000C94463C0C94463C0C94463C0C94463CA0
+:107860000C94463C0C94463C11241FBECFEFD8E04C
+:10787000DEBFCDBF11E0A0E0B1E001C01D92AA3C87
+:10788000B107E1F70E94A53C0C94443F0C94003CE6
+:10789000E0E6F0E088E180831082EE27FF2709947C
+:1078A0000895CF93DF93362FDA01622FA89583E0F6
+:1078B000FA0187BFE89507B600FCFDCF832F972F0D
+:1078C0009C01E901AD0171E0888190E0398120E0FF
+:1078D000822B932B2296FA010C0177BFE895112495
+:1078E0004E5F5F4F625081F785E0FD0187BFE895ED
+:1078F00007B600FCFDCF81E180935700E895FFFFBC
+:107900000000DF91CF910895E0E6F0E098E19083E8
+:1079100080830895A89508950E943D3F803239F0F4
+:1079200088E1809360008EE080936000FFCF84E167
+:107930000E94353F08951F93182F0E943D3F11501C
+:10794000E1F70E948C3C1F9108952F923F924F9235
+:107950005F926F927F928F929F92AF92BF92DF92CF
+:10796000EF92FF920F931F93DF93CF93CDB7DEB7C4
+:10797000C050D1400FB6F894DEBF0FBECDBF84B764
+:1079800014BE98E190936000109260008D7039F001
+:107990009093600010926000EE27FF2709942D98C5
+:1079A000259A4098389A419A399880E49CE9019741
+:1079B000F1F72D9A31998BC080E197E220E931E00F
+:1079C000F9013197F1F70197D9F72D98319908C04E
+:1079D00088E18093600010926000EE27FF270994F1
+:1079E0000E94F83D88E18093600010926000EE24D0
+:1079F000FF243E010894611C711C61E8862E912CC5
+:107A00008C0E9D1E51E0252E352E2C0E3D1E40E481
+:107A1000442E4FE1542E30E2A32E80EA0E94FC3D1A
+:107A20008823D9F7BF2C8F2D0E94223EDE2C8E2D6D
+:107A30000E94223E81EA0E94FC3D00E010E00E948C
+:107A4000343EF301E00FF11F8083F801EE0DFF1DBE
+:107A5000E491D401A00FB11FEC930F5F1F4F0038CA
+:107A6000110569F70E94223F80EA0E94FC3D8B2DA0
+:107A70000E94223E8D2D0E94223E8401F8018191B8
+:107A80008F010E94223E02151305C1F70E94223F7A
+:107A900080E0B301A70120E80E94513CC201019798
+:107AA000F1F785B18A2585B9F0E8EF16FFE6FF0604
+:107AB00029F080E890E0E80EF91EAFCF319BFECFB1
+:107AC00088E18093600088E080936000FFCF0E948F
+:107AD000263F88E1809360008EE080936000A89547
+:107AE0008824992428E1622E9EE0792E0E943D3F51
+:107AF000813489F40E943D3F182F0E948C3C12383B
+:107B000011F482E005C0113811F486E001C083E071
+:107B10000E94353F69C0823411F484E103C085348A
+:107B200021F485E00E949B3C5FC0853581F40E9472
+:107B30003D3F082F10E00E943D3FB82EAA240A299D
+:107B40001B29000F111F0E948C3C48014DC0863537
+:107B500029F484E00E949B3C80E0DACF8436E1F493
+:107B60000E943D3F0E943D3FE82E0E943D3FD82E9F
+:107B7000FE2C02E011E00E943D3FF80181938F014D
+:107B8000FA94C9F70E948C3C8D2D62E071E0A4014B
+:107B90002E2D0E94513C28C0843791F40E943D3F15
+:107BA0000E943D3F182F0E943D3F0E948C3C740173
+:107BB000F70185917F010E94353F1150C9F714C02C
+:107BC000853751F40E948C3C8EE10E94353F85E957
+:107BD0000E94353F8FE09CCF813521F46092600098
+:107BE000709260000E948C3C80E10E94353F7ECF05
+:107BF00088E48093B8000895982F1092BC0084EA1E
+:107C00008093BC008091BC0087FFFCCF8091B900BD
+:107C1000887F883011F081E008959093BB0084E85C
+:107C20008093BC008091BC0087FFFCCF9091B9008D
+:107C3000987F983111F480E0089580E0903409F045
+:107C400081E008958093BB0084E88093BC0080911C
+:107C5000BC0087FFFCCF8091B90090E0887F88321C
+:107C600009F091E0892F089584EC8093BC00809105
+:107C7000BC0087FFFCCF8091BB00089584E880930F
+:107C8000BC008091BC0087FFFCCF8091BB000895B1
+:107C9000EF92FF920F931F93CF93DF937B018A01A3
+:107CA0000E94FC3D8823A1F4C0E0D0E009C0F701A8
+:107CB000EC0FFD1F80810E94223E882349F421960B
+:107CC000C017D107A0F384E98093BC0080E001C015
+:107CD00081E0DF91CF911F910F91FF90EF90089578
+:107CE0000F931F93CF93DF93EB018A0181600E9472
+:107CF000FC3D882311F081E029C020E030E0A8019C
+:107D00004150504094EC0EC09093BC008091BC0058
+:107D100087FFFCCF8091BB00FE01E20FF31F808341
+:107D20002F5F3F4F2417350778F384E88093BC001A
+:107D30008091BC0087FFFCCF8091BB00C00FD11F9A
+:107D40002197888384E98093BC0080E0DF91CF9104
+:107D50001F910F910895CF92DF92EF92FF921F93A0
+:107D6000CF93DF93162F6A0179010E94FC3D88238F
+:107D7000B9F4812F0E94223EC0E0D0E009C0F60194
+:107D8000EC0FFD1F80810E94223E882349F421963A
+:107D9000CE15DF05A0F384E98093BC0080E001C02C
+:107DA00081E0DF91CF911F91FF90EF90DF90CF9016
+:107DB0000895EF92FF920F931F93CF93DF93182FA5
+:107DC000062FEA0179010E94FC3D882399F5802F56
+:107DD0000E94223E812F81600E94FC3D882351F544
+:107DE00020E030E0A7014150504094EC0EC0909349
+:107DF000BC008091BC0087FFFCCF8091BB00FE01DE
+:107E0000E20FF31F80832F5F3F4F2417350778F36E
+:107E100084E88093BC008091BC0087FFFCCF8091F8
+:107E2000BB00CE0DDF1D2197888384E98093BC00C1
+:107E300080E001C081E0DF91CF911F910F91FF9011
+:107E4000EF90089584E98093BC0008951092C500D6
+:107E500080E18093C40088E18093C10086E0809334
+:107E6000C20082E08093C0000895982F8091C000E6
+:107E700085FFFCCF9093C60008958091C00087FFD6
+:0C7E8000FCCF8091C6000895F894FFCF5D
+:040000030000780081
+:00000001FF

arduino_dualboot_bootloader/boot.h

@@ -0,0 +1,848 @@
+/* Modified to use out for SPM access
+** Peter Knight, Optiboot project http://optiboot.googlecode.com
+**
+** Todo: Tidy up
+**
+** "_short" routines execute 1 cycle faster and use 1 less word of flash
+** by using "out" instruction instead of "sts".
+**
+** Additional elpm variants that trust the value of RAMPZ
+*/
+
+/* Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007  Eric B. Weddington
+   All rights reserved.
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are met:
+
+   * Redistributions of source code must retain the above copyright
+     notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in
+     the documentation and/or other materials provided with the
+     distribution.
+   * Neither the name of the copyright holders nor the names of
+     contributors may be used to endorse or promote products derived
+     from this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+  POSSIBILITY OF SUCH DAMAGE. */
+
+/* $Id: boot.h,v 1.27.2.3 2008/09/30 13:58:48 arcanum Exp $ */
+
+#ifndef _AVR_BOOT_H_
+#define _AVR_BOOT_H_    1
+
+/** \file */
+/** \defgroup avr_boot <avr/boot.h>: Bootloader Support Utilities
+    \code
+    #include <avr/io.h>
+    #include <avr/boot.h>
+    \endcode
+
+    The macros in this module provide a C language interface to the
+    bootloader support functionality of certain AVR processors. These
+    macros are designed to work with all sizes of flash memory.
+
+    Global interrupts are not automatically disabled for these macros. It
+    is left up to the programmer to do this. See the code example below. 
+    Also see the processor datasheet for caveats on having global interrupts 
+    enabled during writing of the Flash.
+
+    \note Not all AVR processors provide bootloader support. See your
+    processor datasheet to see if it provides bootloader support.
+
+    \todo From email with Marek: On smaller devices (all except ATmega64/128),
+    __SPM_REG is in the I/O space, accessible with the shorter "in" and "out"
+    instructions - since the boot loader has a limited size, this could be an
+    important optimization.
+
+    \par API Usage Example
+    The following code shows typical usage of the boot API.
+
+    \code
+    #include <inttypes.h>
+    #include <avr/interrupt.h>
+    #include <avr/pgmspace.h>
+    
+    void boot_program_page (uint32_t page, uint8_t *buf)
+    {
+        uint16_t i;
+        uint8_t sreg;
+
+        // Disable interrupts.
+
+        sreg = SREG;
+        cli();
+    
+        eeprom_busy_wait ();
+
+        boot_page_erase (page);
+        boot_spm_busy_wait ();      // Wait until the memory is erased.
+
+        for (i=0; i<SPM_PAGESIZE; i+=2)
+        {
+            // Set up little-endian word.
+
+            uint16_t w = *buf++;
+            w += (*buf++) << 8;
+        
+            boot_page_fill (page + i, w);
+        }
+
+        boot_page_write (page);     // Store buffer in flash page.
+        boot_spm_busy_wait();       // Wait until the memory is written.
+
+        // Reenable RWW-section again. We need this if we want to jump back
+        // to the application after bootloading.
+
+        boot_rww_enable ();
+
+        // Re-enable interrupts (if they were ever enabled).
+
+        SREG = sreg;
+    }\endcode */
+
+#include <avr/eeprom.h>
+#include <avr/io.h>
+#include <inttypes.h>
+#include <limits.h>
+
+/* Check for SPM Control Register in processor. */
+#if defined (SPMCSR)
+#  define __SPM_REG    SPMCSR
+#elif defined (SPMCR)
+#  define __SPM_REG    SPMCR
+#else
+#  error AVR processor does not provide bootloader support!
+#endif
+
+
+/* Check for SPM Enable bit. */
+#if defined(SPMEN)
+#  define __SPM_ENABLE  SPMEN
+#elif defined(SELFPRGEN)
+#  define __SPM_ENABLE  SELFPRGEN
+#else
+#  error Cannot find SPM Enable bit definition!
+#endif
+
+/** \ingroup avr_boot
+    \def BOOTLOADER_SECTION
+
+    Used to declare a function or variable to be placed into a
+    new section called .bootloader. This section and its contents
+    can then be relocated to any address (such as the bootloader
+    NRWW area) at link-time. */
+
+#define BOOTLOADER_SECTION    __attribute__ ((section (".bootloader")))
+
+/* Create common bit definitions. */
+#ifdef ASB
+#define __COMMON_ASB    ASB
+#else
+#define __COMMON_ASB    RWWSB
+#endif
+
+#ifdef ASRE
+#define __COMMON_ASRE   ASRE
+#else
+#define __COMMON_ASRE   RWWSRE
+#endif
+
+/* Define the bit positions of the Boot Lock Bits. */
+
+#define BLB12           5
+#define BLB11           4
+#define BLB02           3
+#define BLB01           2
+
+/** \ingroup avr_boot
+    \def boot_spm_interrupt_enable()
+    Enable the SPM interrupt. */
+
+#define boot_spm_interrupt_enable()   (__SPM_REG |= (uint8_t)_BV(SPMIE))
+
+/** \ingroup avr_boot
+    \def boot_spm_interrupt_disable()
+    Disable the SPM interrupt. */
+
+#define boot_spm_interrupt_disable()  (__SPM_REG &= (uint8_t)~_BV(SPMIE))
+
+/** \ingroup avr_boot
+    \def boot_is_spm_interrupt()
+    Check if the SPM interrupt is enabled. */
+
+#define boot_is_spm_interrupt()       (__SPM_REG & (uint8_t)_BV(SPMIE))
+
+/** \ingroup avr_boot
+    \def boot_rww_busy()
+    Check if the RWW section is busy. */
+
+#define boot_rww_busy()          (__SPM_REG & (uint8_t)_BV(__COMMON_ASB))
+
+/** \ingroup avr_boot
+    \def boot_spm_busy()
+    Check if the SPM instruction is busy. */
+
+#define boot_spm_busy()               (__SPM_REG & (uint8_t)_BV(__SPM_ENABLE))
+
+/** \ingroup avr_boot
+    \def boot_spm_busy_wait()
+    Wait while the SPM instruction is busy. */
+
+#define boot_spm_busy_wait()          do{}while(boot_spm_busy())
+
+#define __BOOT_PAGE_ERASE         (_BV(__SPM_ENABLE) | _BV(PGERS))
+#define __BOOT_PAGE_WRITE         (_BV(__SPM_ENABLE) | _BV(PGWRT))
+#define __BOOT_PAGE_FILL          _BV(__SPM_ENABLE)
+#define __BOOT_RWW_ENABLE         (_BV(__SPM_ENABLE) | _BV(__COMMON_ASRE))
+#define __BOOT_LOCK_BITS_SET      (_BV(__SPM_ENABLE) | _BV(BLBSET))
+
+#define __boot_page_fill_short(address, data)   \
+(__extension__({                                 \
+    __asm__ __volatile__                         \
+    (                                            \
+        "movw  r0, %3\n\t"                       \
+        "out %0, %1\n\t"                         \
+        "spm\n\t"                                \
+        "clr  r1\n\t"                            \
+        :                                        \
+        : "i" (_SFR_IO_ADDR(__SPM_REG)),        \
+          "r" ((uint8_t)__BOOT_PAGE_FILL),       \
+          "z" ((uint16_t)address),               \
+          "r" ((uint16_t)data)                   \
+        : "r0"                                   \
+    );                                           \
+}))
+
+#define __boot_page_fill_normal(address, data)   \
+(__extension__({                                 \
+    __asm__ __volatile__                         \
+    (                                            \
+        "movw  r0, %3\n\t"                       \
+        "sts %0, %1\n\t"                         \
+        "spm\n\t"                                \
+        "clr  r1\n\t"                            \
+        :                                        \
+        : "i" (_SFR_MEM_ADDR(__SPM_REG)),        \
+          "r" ((uint8_t)__BOOT_PAGE_FILL),       \
+          "z" ((uint16_t)address),               \
+          "r" ((uint16_t)data)                   \
+        : "r0"                                   \
+    );                                           \
+}))
+
+#define __boot_page_fill_alternate(address, data)\
+(__extension__({                                 \
+    __asm__ __volatile__                         \
+    (                                            \
+        "movw  r0, %3\n\t"                       \
+        "sts %0, %1\n\t"                         \
+        "spm\n\t"                                \
+        ".word 0xffff\n\t"                       \
+        "nop\n\t"                                \
+        "clr  r1\n\t"                            \
+        :                                        \
+        : "i" (_SFR_MEM_ADDR(__SPM_REG)),        \
+          "r" ((uint8_t)__BOOT_PAGE_FILL),       \
+          "z" ((uint16_t)address),               \
+          "r" ((uint16_t)data)                   \
+        : "r0"                                   \
+    );                                           \
+}))
+
+#define __boot_page_fill_extended(address, data) \
+(__extension__({                                 \
+    __asm__ __volatile__                         \
+    (                                            \
+        "movw  r0, %4\n\t"                       \
+        "movw r30, %A3\n\t"                      \
+        "sts %1, %C3\n\t"                        \
+        "sts %0, %2\n\t"                         \
+        "spm\n\t"                                \
+        "clr  r1\n\t"                            \
+        :                                        \
+        : "i" (_SFR_MEM_ADDR(__SPM_REG)),        \
+          "i" (_SFR_MEM_ADDR(RAMPZ)),            \
+          "r" ((uint8_t)__BOOT_PAGE_FILL),       \
+          "r" ((uint32_t)address),               \
+          "r" ((uint16_t)data)                   \
+        : "r0", "r30", "r31"                     \
+    );                                           \
+}))
+
+#define __boot_page_fill_extended_short(address, data) \
+(__extension__({                                 \
+    __asm__ __volatile__                         \
+    (                                            \
+        "movw  r0, %4\n\t"                       \
+        "movw r30, %A3\n\t"                      \
+        "out %1, %C3\n\t"                        \
+        "out %0, %2\n\t"                         \
+        "spm\n\t"                                \
+        "clr  r1\n\t"                            \
+        :                                        \
+        : "i" (_SFR_IO_ADDR(__SPM_REG)),        \
+          "i" (_SFR_IO_ADDR(RAMPZ)),            \
+          "r" ((uint8_t)__BOOT_PAGE_FILL),       \
+          "r" ((uint32_t)address),               \
+          "r" ((uint16_t)data)                   \
+        : "r0", "r30", "r31"                     \
+    );                                           \
+}))
+
+#define __boot_page_erase_short(address)        \
+(__extension__({                                 \
+    __asm__ __volatile__                         \
+    (                                            \
+        "out %0, %1\n\t"                         \
+        "spm\n\t"                                \
+        :                                        \
+        : "i" (_SFR_IO_ADDR(__SPM_REG)),        \
+          "r" ((uint8_t)__BOOT_PAGE_ERASE),      \
+          "z" ((uint16_t)address)                \
+    );                                           \
+}))
+
+
+#define __boot_page_erase_normal(address)        \
+(__extension__({                                 \
+    __asm__ __volatile__                         \
+    (                                            \
+        "sts %0, %1\n\t"                         \
+        "spm\n\t"                                \
+        :                                        \
+        : "i" (_SFR_MEM_ADDR(__SPM_REG)),        \
+          "r" ((uint8_t)__BOOT_PAGE_ERASE),      \
+          "z" ((uint16_t)address)                \
+    );                                           \
+}))
+
+#define __boot_page_erase_alternate(address)     \
+(__extension__({                                 \
+    __asm__ __volatile__                         \
+    (                                            \
+        "sts %0, %1\n\t"                         \
+        "spm\n\t"                                \
+        ".word 0xffff\n\t"                       \
+        "nop\n\t"                                \
+        :                                        \
+        : "i" (_SFR_MEM_ADDR(__SPM_REG)),        \
+          "r" ((uint8_t)__BOOT_PAGE_ERASE),      \
+          "z" ((uint16_t)address)                \
+    );                                           \
+}))
+
+#define __boot_page_erase_extended(address)      \
+(__extension__({                                 \
+    __asm__ __volatile__                         \
+    (                                            \
+        "movw r30, %A3\n\t"                      \
+        "sts  %1, %C3\n\t"                       \
+        "sts %0, %2\n\t"                         \
+        "spm\n\t"                                \
+        :                                        \
+        : "i" (_SFR_MEM_ADDR(__SPM_REG)),        \
+          "i" (_SFR_MEM_ADDR(RAMPZ)),            \
+          "r" ((uint8_t)__BOOT_PAGE_ERASE),      \
+          "r" ((uint32_t)address)                \
+        : "r30", "r31"                           \
+    );                                           \
+}))
+#define __boot_page_erase_extended_short(address)      \
+(__extension__({                                 \
+    __asm__ __volatile__                         \
+    (                                            \
+        "movw r30, %A3\n\t"                      \
+        "out  %1, %C3\n\t"                       \
+        "out %0, %2\n\t"                         \
+        "spm\n\t"                                \
+        :                                        \
+        : "i" (_SFR_IO_ADDR(__SPM_REG)),        \
+          "i" (_SFR_IO_ADDR(RAMPZ)),            \
+          "r" ((uint8_t)__BOOT_PAGE_ERASE),      \
+          "r" ((uint32_t)address)                \
+        : "r30", "r31"                           \
+    );                                           \
+}))
+
+#define __boot_page_write_short(address)        \
+(__extension__({                                 \
+    __asm__ __volatile__                         \
+    (                                            \
+        "out %0, %1\n\t"                         \
+        "spm\n\t"                                \
+        :                                        \
+        : "i" (_SFR_IO_ADDR(__SPM_REG)),        \
+          "r" ((uint8_t)__BOOT_PAGE_WRITE),      \
+          "z" ((uint16_t)address)                \
+    );                                           \
+}))
+
+#define __boot_page_write_normal(address)        \
+(__extension__({                                 \
+    __asm__ __volatile__                         \
+    (                                            \
+        "sts %0, %1\n\t"                         \
+        "spm\n\t"                                \
+        :                                        \
+        : "i" (_SFR_MEM_ADDR(__SPM_REG)),        \
+          "r" ((uint8_t)__BOOT_PAGE_WRITE),      \
+          "z" ((uint16_t)address)                \
+    );                                           \
+}))
+
+#define __boot_page_write_alternate(address)     \
+(__extension__({                                 \
+    __asm__ __volatile__                         \
+    (                                            \
+        "sts %0, %1\n\t"                         \
+        "spm\n\t"                                \
+        ".word 0xffff\n\t"                       \
+        "nop\n\t"                                \
+        :                                        \
+        : "i" (_SFR_MEM_ADDR(__SPM_REG)),        \
+          "r" ((uint8_t)__BOOT_PAGE_WRITE),      \
+          "z" ((uint16_t)address)                \
+    );                                           \
+}))
+
+#define __boot_page_write_extended(address)      \
+(__extension__({                                 \
+    __asm__ __volatile__                         \
+    (                                            \
+        "movw r30, %A3\n\t"                      \
+        "sts %1, %C3\n\t"                        \
+        "sts %0, %2\n\t"                         \
+        "spm\n\t"                                \
+        :                                        \
+        : "i" (_SFR_MEM_ADDR(__SPM_REG)),        \
+          "i" (_SFR_MEM_ADDR(RAMPZ)),            \
+          "r" ((uint8_t)__BOOT_PAGE_WRITE),      \
+          "r" ((uint32_t)address)                \
+        : "r30", "r31"                           \
+    );                                           \
+}))
+#define __boot_page_write_extended_short(address)      \
+(__extension__({                                 \
+    __asm__ __volatile__                         \
+    (                                            \
+        "movw r30, %A3\n\t"                      \
+        "out %1, %C3\n\t"                        \
+        "out %0, %2\n\t"                         \
+        "spm\n\t"                                \
+        :                                        \
+        : "i" (_SFR_IO_ADDR(__SPM_REG)),        \
+          "i" (_SFR_IO_ADDR(RAMPZ)),            \
+          "r" ((uint8_t)__BOOT_PAGE_WRITE),      \
+          "r" ((uint32_t)address)                \
+        : "r30", "r31"                           \
+    );                                           \
+}))
+
+#define __boot_rww_enable_short()                      \
+(__extension__({                                 \
+    __asm__ __volatile__                         \
+    (                                            \
+        "out %0, %1\n\t"                         \
+        "spm\n\t"                                \
+        :                                        \
+        : "i" (_SFR_IO_ADDR(__SPM_REG)),        \
+          "r" ((uint8_t)__BOOT_RWW_ENABLE)       \
+    );                                           \
+}))
+
+#define __boot_rww_enable()                      \
+(__extension__({                                 \
+    __asm__ __volatile__                         \
+    (                                            \
+        "sts %0, %1\n\t"                         \
+        "spm\n\t"                                \
+        :                                        \
+        : "i" (_SFR_MEM_ADDR(__SPM_REG)),        \
+          "r" ((uint8_t)__BOOT_RWW_ENABLE)       \
+    );                                           \
+}))
+
+#define __boot_rww_enable_alternate()            \
+(__extension__({                                 \
+    __asm__ __volatile__                         \
+    (                                            \
+        "sts %0, %1\n\t"                         \
+        "spm\n\t"                                \
+        ".word 0xffff\n\t"                       \
+        "nop\n\t"                                \
+        :                                        \
+        : "i" (_SFR_MEM_ADDR(__SPM_REG)),        \
+          "r" ((uint8_t)__BOOT_RWW_ENABLE)       \
+    );                                           \
+}))
+
+/* From the mega16/mega128 data sheets (maybe others):
+
+     Bits by SPM To set the Boot Loader Lock bits, write the desired data to
+     R0, write "X0001001" to SPMCR and execute SPM within four clock cycles
+     after writing SPMCR. The only accessible Lock bits are the Boot Lock bits
+     that may prevent the Application and Boot Loader section from any
+     software update by the MCU.
+
+     If bits 5..2 in R0 are cleared (zero), the corresponding Boot Lock bit
+     will be programmed if an SPM instruction is executed within four cycles
+     after BLBSET and SPMEN (or SELFPRGEN) are set in SPMCR. The Z-pointer is 
+     don't care during this operation, but for future compatibility it is 
+     recommended to load the Z-pointer with $0001 (same as used for reading the 
+     Lock bits). For future compatibility It is also recommended to set bits 7, 
+     6, 1, and 0 in R0 to 1 when writing the Lock bits. When programming the 
+     Lock bits the entire Flash can be read during the operation. */
+
+#define __boot_lock_bits_set_short(lock_bits)                    \
+(__extension__({                                           \
+    uint8_t value = (uint8_t)(~(lock_bits));               \
+    __asm__ __volatile__                                   \
+    (                                                      \
+        "ldi r30, 1\n\t"                                   \
+        "ldi r31, 0\n\t"                                   \
+        "mov r0, %2\n\t"                                   \
+        "out %0, %1\n\t"                                   \
+        "spm\n\t"                                          \
+        :                                                  \
+        : "i" (_SFR_IO_ADDR(__SPM_REG)),                  \
+          "r" ((uint8_t)__BOOT_LOCK_BITS_SET),             \
+          "r" (value)                                      \
+        : "r0", "r30", "r31"                               \
+    );                                                     \
+}))
+
+#define __boot_lock_bits_set(lock_bits)                    \
+(__extension__({                                           \
+    uint8_t value = (uint8_t)(~(lock_bits));               \
+    __asm__ __volatile__                                   \
+    (                                                      \
+        "ldi r30, 1\n\t"                                   \
+        "ldi r31, 0\n\t"                                   \
+        "mov r0, %2\n\t"                                   \
+        "sts %0, %1\n\t"                                   \
+        "spm\n\t"                                          \
+        :                                                  \
+        : "i" (_SFR_MEM_ADDR(__SPM_REG)),                  \
+          "r" ((uint8_t)__BOOT_LOCK_BITS_SET),             \
+          "r" (value)                                      \
+        : "r0", "r30", "r31"                               \
+    );                                                     \
+}))
+
+#define __boot_lock_bits_set_alternate(lock_bits)          \
+(__extension__({                                           \
+    uint8_t value = (uint8_t)(~(lock_bits));               \
+    __asm__ __volatile__                                   \
+    (                                                      \
+        "ldi r30, 1\n\t"                                   \
+        "ldi r31, 0\n\t"                                   \
+        "mov r0, %2\n\t"                                   \
+        "sts %0, %1\n\t"                                   \
+        "spm\n\t"                                          \
+        ".word 0xffff\n\t"                                 \
+        "nop\n\t"                                          \
+        :                                                  \
+        : "i" (_SFR_MEM_ADDR(__SPM_REG)),                  \
+          "r" ((uint8_t)__BOOT_LOCK_BITS_SET),             \
+          "r" (value)                                      \
+        : "r0", "r30", "r31"                               \
+    );                                                     \
+}))
+
+/*
+   Reading lock and fuse bits:
+
+     Similarly to writing the lock bits above, set BLBSET and SPMEN (or 
+     SELFPRGEN) bits in __SPMREG, and then (within four clock cycles) issue an 
+     LPM instruction.
+
+     Z address:       contents:
+     0x0000           low fuse bits
+     0x0001           lock bits
+     0x0002           extended fuse bits
+     0x0003           high fuse bits
+
+     Sounds confusing, doesn't it?
+
+     Unlike the macros in pgmspace.h, no need to care for non-enhanced
+     cores here as these old cores do not provide SPM support anyway.
+ */
+
+/** \ingroup avr_boot
+    \def GET_LOW_FUSE_BITS
+    address to read the low fuse bits, using boot_lock_fuse_bits_get
+ */
+#define GET_LOW_FUSE_BITS           (0x0000)
+/** \ingroup avr_boot
+    \def GET_LOCK_BITS
+    address to read the lock bits, using boot_lock_fuse_bits_get
+ */
+#define GET_LOCK_BITS               (0x0001)
+/** \ingroup avr_boot
+    \def GET_EXTENDED_FUSE_BITS
+    address to read the extended fuse bits, using boot_lock_fuse_bits_get
+ */
+#define GET_EXTENDED_FUSE_BITS      (0x0002)
+/** \ingroup avr_boot
+    \def GET_HIGH_FUSE_BITS
+    address to read the high fuse bits, using boot_lock_fuse_bits_get
+ */
+#define GET_HIGH_FUSE_BITS          (0x0003)
+
+/** \ingroup avr_boot
+    \def boot_lock_fuse_bits_get(address)
+
+    Read the lock or fuse bits at \c address.
+
+    Parameter \c address can be any of GET_LOW_FUSE_BITS,
+    GET_LOCK_BITS, GET_EXTENDED_FUSE_BITS, or GET_HIGH_FUSE_BITS.
+
+    \note The lock and fuse bits returned are the physical values,
+    i.e. a bit returned as 0 means the corresponding fuse or lock bit
+    is programmed.
+ */
+#define boot_lock_fuse_bits_get_short(address)                   \
+(__extension__({                                           \
+    uint8_t __result;                                      \
+    __asm__ __volatile__                                   \
+    (                                                      \
+        "ldi r30, %3\n\t"                                  \
+        "ldi r31, 0\n\t"                                   \
+        "out %1, %2\n\t"                                   \
+        "lpm %0, Z\n\t"                                    \
+        : "=r" (__result)                                  \
+        : "i" (_SFR_IO_ADDR(__SPM_REG)),                  \
+          "r" ((uint8_t)__BOOT_LOCK_BITS_SET),             \
+          "M" (address)                                    \
+        : "r0", "r30", "r31"                               \
+    );                                                     \
+    __result;                                              \
+}))
+
+#define boot_lock_fuse_bits_get(address)                   \
+(__extension__({                                           \
+    uint8_t __result;                                      \
+    __asm__ __volatile__                                   \
+    (                                                      \
+        "ldi r30, %3\n\t"                                  \
+        "ldi r31, 0\n\t"                                   \
+        "sts %1, %2\n\t"                                   \
+        "lpm %0, Z\n\t"                                    \
+        : "=r" (__result)                                  \
+        : "i" (_SFR_MEM_ADDR(__SPM_REG)),                  \
+          "r" ((uint8_t)__BOOT_LOCK_BITS_SET),             \
+          "M" (address)                                    \
+        : "r0", "r30", "r31"                               \
+    );                                                     \
+    __result;                                              \
+}))
+
+/** \ingroup avr_boot
+    \def boot_signature_byte_get(address)
+
+    Read the Signature Row byte at \c address.  For some MCU types,
+    this function can also retrieve the factory-stored oscillator
+    calibration bytes.
+
+    Parameter \c address can be 0-0x1f as documented by the datasheet.
+    \note The values are MCU type dependent.
+*/
+
+#define __BOOT_SIGROW_READ (_BV(__SPM_ENABLE) | _BV(SIGRD))
+
+#define boot_signature_byte_get_short(addr) \
+(__extension__({                      \
+      uint16_t __addr16 = (uint16_t)(addr);     \
+      uint8_t __result;                         \
+      __asm__ __volatile__                      \
+      (                                         \
+        "out %1, %2\n\t"                        \
+        "lpm %0, Z" "\n\t"                      \
+        : "=r" (__result)                       \
+        : "i" (_SFR_IO_ADDR(__SPM_REG)),        \
+          "r" ((uint8_t) __BOOT_SIGROW_READ),   \
+          "z" (__addr16)                        \
+      );                                        \
+      __result;                                 \
+}))
+
+#define boot_signature_byte_get(addr) \
+(__extension__({                      \
+      uint16_t __addr16 = (uint16_t)(addr);     \
+      uint8_t __result;                         \
+      __asm__ __volatile__                      \
+      (                                         \
+        "sts %1, %2\n\t"                        \
+        "lpm %0, Z" "\n\t"                      \
+        : "=r" (__result)                       \
+        : "i" (_SFR_MEM_ADDR(__SPM_REG)),       \
+          "r" ((uint8_t) __BOOT_SIGROW_READ),   \
+          "z" (__addr16)                        \
+      );                                        \
+      __result;                                 \
+}))
+
+/** \ingroup avr_boot
+    \def boot_page_fill(address, data)
+
+    Fill the bootloader temporary page buffer for flash 
+    address with data word. 
+
+    \note The address is a byte address. The data is a word. The AVR 
+    writes data to the buffer a word at a time, but addresses the buffer
+    per byte! So, increment your address by 2 between calls, and send 2
+    data bytes in a word format! The LSB of the data is written to the lower 
+    address; the MSB of the data is written to the higher address.*/
+
+/** \ingroup avr_boot
+    \def boot_page_erase(address)
+
+    Erase the flash page that contains address.
+
+    \note address is a byte address in flash, not a word address. */
+
+/** \ingroup avr_boot
+    \def boot_page_write(address)
+
+    Write the bootloader temporary page buffer 
+    to flash page that contains address.
+    
+    \note address is a byte address in flash, not a word address. */
+
+/** \ingroup avr_boot
+    \def boot_rww_enable()
+
+    Enable the Read-While-Write memory section. */
+
+/** \ingroup avr_boot
+    \def boot_lock_bits_set(lock_bits)
+
+    Set the bootloader lock bits.
+
+    \param lock_bits A mask of which Boot Loader Lock Bits to set.
+
+    \note In this context, a 'set bit' will be written to a zero value.
+    Note also that only BLBxx bits can be programmed by this command.
+
+    For example, to disallow the SPM instruction from writing to the Boot
+    Loader memory section of flash, you would use this macro as such:
+
+    \code
+    boot_lock_bits_set (_BV (BLB11));
+    \endcode
+
+    \note Like any lock bits, the Boot Loader Lock Bits, once set,
+    cannot be cleared again except by a chip erase which will in turn
+    also erase the boot loader itself. */
+
+/* Normal versions of the macros use 16-bit addresses.
+   Extended versions of the macros use 32-bit addresses.
+   Alternate versions of the macros use 16-bit addresses and require special
+   instruction sequences after LPM.
+
+   FLASHEND is defined in the ioXXXX.h file.
+   USHRT_MAX is defined in <limits.h>. */ 
+
+#if defined(__AVR_ATmega161__) || defined(__AVR_ATmega163__) \
+    || defined(__AVR_ATmega323__)
+
+/* Alternate: ATmega161/163/323 and 16 bit address */
+#define boot_page_fill(address, data) __boot_page_fill_alternate(address, data)
+#define boot_page_erase(address)      __boot_page_erase_alternate(address)
+#define boot_page_write(address)      __boot_page_write_alternate(address)
+#define boot_rww_enable()             __boot_rww_enable_alternate()
+#define boot_lock_bits_set(lock_bits) __boot_lock_bits_set_alternate(lock_bits)
+
+#elif (FLASHEND > USHRT_MAX)
+
+/* Extended: >16 bit address */
+#define boot_page_fill(address, data) __boot_page_fill_extended_short(address, data)
+#define boot_page_erase(address)      __boot_page_erase_extended_short(address)
+#define boot_page_write(address)      __boot_page_write_extended_short(address)
+#define boot_rww_enable()             __boot_rww_enable_short()
+#define boot_lock_bits_set(lock_bits) __boot_lock_bits_set_short(lock_bits)
+
+#else
+
+/* Normal: 16 bit address */
+#define boot_page_fill(address, data) __boot_page_fill_short(address, data)
+#define boot_page_erase(address)      __boot_page_erase_short(address)
+#define boot_page_write(address)      __boot_page_write_short(address)
+#define boot_rww_enable()             __boot_rww_enable_short()
+#define boot_lock_bits_set(lock_bits) __boot_lock_bits_set_short(lock_bits)
+
+#endif
+
+/** \ingroup avr_boot
+
+    Same as boot_page_fill() except it waits for eeprom and spm operations to
+    complete before filling the page. */
+
+#define boot_page_fill_safe(address, data) \
+do { \
+    boot_spm_busy_wait();                       \
+    eeprom_busy_wait();                         \
+    boot_page_fill(address, data);              \
+} while (0)
+
+/** \ingroup avr_boot
+
+    Same as boot_page_erase() except it waits for eeprom and spm operations to
+    complete before erasing the page. */
+
+#define boot_page_erase_safe(address) \
+do { \
+    boot_spm_busy_wait();                       \
+    eeprom_busy_wait();                         \
+    boot_page_erase (address);                  \
+} while (0)
+
+/** \ingroup avr_boot
+
+    Same as boot_page_write() except it waits for eeprom and spm operations to
+    complete before writing the page. */
+
+#define boot_page_write_safe(address) \
+do { \
+    boot_spm_busy_wait();                       \
+    eeprom_busy_wait();                         \
+    boot_page_write (address);                  \
+} while (0)
+
+/** \ingroup avr_boot
+
+    Same as boot_rww_enable() except waits for eeprom and spm operations to
+    complete before enabling the RWW mameory. */
+
+#define boot_rww_enable_safe() \
+do { \
+    boot_spm_busy_wait();                       \
+    eeprom_busy_wait();                         \
+    boot_rww_enable();                          \
+} while (0)
+
+/** \ingroup avr_boot
+
+    Same as boot_lock_bits_set() except waits for eeprom and spm operations to
+    complete before setting the lock bits. */
+
+#define boot_lock_bits_set_safe(lock_bits) \
+do { \
+    boot_spm_busy_wait();                       \
+    eeprom_busy_wait();                         \
+    boot_lock_bits_set (lock_bits);             \
+} while (0)
+
+#endif /* _AVR_BOOT_H_ */

arduino_dualboot_bootloader/i2c.c

@@ -0,0 +1,158 @@
+#ifndef  F_CPU
+#define F_CPU 16000000UL
+#endif
+
+#include <avr/io.h>
+#include <util/twi.h>
+
+#include "i2c.h"
+
+#define F_SCL 100000UL		// SCL frequency
+#define Prescaler 1
+#define TWBR_val ((((F_CPU / F_SCL) / Prescaler) - 16 ) / 2)
+
+void i2c_init(void)
+{
+	TWBR = (uint8_t) TWBR_val;
+}
+
+uint8_t i2c_start(uint8_t address)
+{
+	// reset TWI control register
+	TWCR = 0;
+	// transmit START condition 
+	TWCR = (1 << TWINT) | (1 << TWSTA) | (1 << TWEN);
+	// wait for end of transmission
+	while (!(TWCR & (1 << TWINT))) ;
+
+	// check if the start condition was successfully transmitted
+	if ((TWSR & 0xF8) != TW_START) {
+		return 1;
+	}
+	// load slave address into data register
+	TWDR = address;
+	// start transmission of address
+	TWCR = (1 << TWINT) | (1 << TWEN);
+	// wait for end of transmission
+	while (!(TWCR & (1 << TWINT))) ;
+
+	// check if the device has acknowledged the READ / WRITE mode
+	uint8_t twst = TW_STATUS & 0xF8;
+	if ((twst != TW_MT_SLA_ACK) && (twst != TW_MR_SLA_ACK))
+		return 1;
+
+	return 0;
+}
+
+uint8_t i2c_write(uint8_t data)
+{
+	// load data into data register
+	TWDR = data;
+	// start transmission of data
+	TWCR = (1 << TWINT) | (1 << TWEN);
+	// wait for end of transmission
+	while (!(TWCR & (1 << TWINT))) ;
+
+	if ((TWSR & 0xF8) != TW_MT_DATA_ACK) {
+		return 1;
+	}
+
+	return 0;
+}
+
+uint8_t i2c_read_ack(void)
+{
+
+	// start TWI module and acknowledge data after reception
+	TWCR = (1 << TWINT) | (1 << TWEN) | (1 << TWEA);
+	// wait for end of transmission
+	while (!(TWCR & (1 << TWINT))) ;
+	// return received data from TWDR
+	return TWDR;
+}
+
+uint8_t i2c_read_nack(void)
+{
+
+	// start receiving without acknowledging reception
+	TWCR = (1 << TWINT) | (1 << TWEN);
+	// wait for end of transmission
+	while (!(TWCR & (1 << TWINT))) ;
+	// return received data from TWDR
+	return TWDR;
+}
+
+uint8_t i2c_transmit(uint8_t address, uint8_t * data, uint16_t length)
+{
+	if (i2c_start(address | I2C_WRITE))
+		return 1;
+
+	for (uint16_t i = 0; i < length; i++) {
+		if (i2c_write(data[i]))
+			return 1;
+	}
+
+	i2c_stop();
+
+	return 0;
+}
+
+uint8_t i2c_receive(uint8_t address, uint8_t * data, uint16_t length)
+{
+	if (i2c_start(address | I2C_READ))
+		return 1;
+
+	for (uint16_t i = 0; i < (length - 1); i++) {
+		data[i] = i2c_read_ack();
+	}
+	data[(length - 1)] = i2c_read_nack();
+
+	i2c_stop();
+
+	return 0;
+}
+
+uint8_t i2c_writeReg(uint8_t devaddr, uint8_t regaddr, uint8_t * data,
+		     uint16_t length)
+{
+	if (i2c_start(devaddr | 0x00))
+		return 1;
+
+	i2c_write(regaddr);
+
+	for (uint16_t i = 0; i < length; i++) {
+		if (i2c_write(data[i]))
+			return 1;
+	}
+
+	i2c_stop();
+
+	return 0;
+}
+
+uint8_t i2c_readReg(uint8_t devaddr, uint8_t regaddr, uint8_t * data,
+		    uint16_t length)
+{
+	if (i2c_start(devaddr))
+		return 1;
+
+	i2c_write(regaddr);
+
+	if (i2c_start(devaddr | 0x01))
+		return 1;
+
+	for (uint16_t i = 0; i < (length - 1); i++) {
+		data[i] = i2c_read_ack();
+	}
+	data[(length - 1)] = i2c_read_nack();
+
+	i2c_stop();
+
+	return 0;
+}
+
+void i2c_stop(void)
+{
+	// transmit STOP condition
+	TWCR = (1 << TWINT) | (1 << TWEN) | (1 << TWSTO);
+}

arduino_dualboot_bootloader/i2c.h

@@ -0,0 +1,18 @@
+#ifndef I2C_MASTER_H
+#define I2C_MASTER_H
+
+#define I2C_READ 0x01
+#define I2C_WRITE 0x00
+
+void i2c_init(void);
+uint8_t i2c_start(uint8_t address);
+uint8_t i2c_write(uint8_t data);
+uint8_t i2c_read_ack(void);
+uint8_t i2c_read_nack(void);
+uint8_t i2c_transmit(uint8_t address, uint8_t* data, uint16_t length);
+uint8_t i2c_receive(uint8_t address, uint8_t* data, uint16_t length);
+uint8_t i2c_writeReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t length);
+uint8_t i2c_readReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t length);
+void i2c_stop(void);
+
+#endif // I2C_MASTER_H

arduino_dualboot_bootloader/main.c

@@ -0,0 +1,347 @@
+/*
+    Author: Vinod S
+    http://blog.vinu.co.in
+    
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+	
+*/
+
+#include <avr/io.h>
+#define F_CPU 16000000
+#include <util/delay.h>
+#include "uart.h"
+#include "i2c.h"
+#include "boot.h"
+#include <inttypes.h>
+#include <avr/pgmspace.h>
+#include "stk500.h"
+#include "pin_defs.h"
+
+/////////////////////// definitions /////////////////////////////////////////////////////
+#define FUNC_READ 1
+#define FUNC_WRITE 1
+#define ER 0b10100001
+#define EW 0b10100000
+#define OPTIBOOT_MAJVER 6
+#define OPTIBOOT_MINVER 2
+#define LED_START_FLASHES 0
+#define GETLENGTH(len) (void) getch() /* skip high byte */; len = getch()
+#define save_vect_num (SPM_RDY_vect_num)
+#define appstart_vec (save_vect_num*2)
+#define WATCHDOG_1S     (_BV(WDP2) | _BV(WDP1) | _BV(WDE))
+#define WATCHDOG_OFF    (0)
+#define WATCHDOG_16MS   (_BV(WDE))
+
+////////////////////// global variables ////////////////////////////////////////////////
+volatile uint16_t dd = 0;
+typedef uint8_t pagelen_t;
+uint8_t buff[200];
+
+///////////////////// function prototypes //////////////////////////////////////////////
+static inline void writebuffer(int8_t memtype, uint8_t * mybuff,
+			       uint16_t address, pagelen_t len);
+static inline void read_mem(uint8_t memtype, uint16_t address,
+			    pagelen_t length);
+void watchdogReset();
+void verifySpace();
+void watchdogConfig(uint8_t x);
+void getNch(uint8_t count);
+
+//////////////////// JUMP to main application function ////////////////////////////////
+void app_start(void)
+{
+
+	watchdogConfig(WATCHDOG_OFF);
+	__asm__ __volatile__("clr r30\n" "clr r31\n" "ijmp");
+}
+
+///////////////// main function ////////////////////////////////////////////////////////
+int main()
+{
+
+	uint8_t ch;
+	uint16_t address = 0;
+
+	pagelen_t length;
+
+	ch = MCUSR;
+	MCUSR = 0;
+
+	watchdogConfig(WATCHDOG_OFF);
+
+	if (ch & (_BV(WDRF) | _BV(BORF) | _BV(PORF)))
+	app_start();
+
+	PORTB &= ~(1 << PB5);
+	DDRB |= 1 << PB5;
+
+	//PIN 10 of arduino as ZERO
+	PORTC &= ~(1 << PC0); //A0
+	//enable pin10 as output
+	DDRC |= 1 << PC0; //A0
+
+	//PULL UP pin 11 of arduino
+	PORTC |= 1 << PC1; //A1
+	//enable pin11 as input.
+	DDRC &= ~(1 << PC1); //A1
+
+	_delay_ms(10);
+
+	//check if 10 and 11 is shorted while MCU is reset.
+
+	//LED ON
+	PORTB |= 1 << PB5;
+
+	if ((PINC & (1 << PC1)) == 0) { //A1
+
+		uint8_t buff2[128];
+		uint8_t buff1[128];
+		_delay_ms(1000);
+		PORTB &= ~(1 << PB5);
+		if ((PINC & (1 << PC1)) == 0) { //A1
+			app_start();
+		}
+
+		i2c_init();
+
+		watchdogConfig(WATCHDOG_OFF);
+		uint16_t addr = 0;
+		for (int i = 0; i < 224; i++) {
+			while (i2c_start(EW)) ;
+			i2c_write(addr >> 8);
+			i2c_write(addr);
+			i2c_start(ER);
+			//read one page from i2c eeprom
+			//read one page from internal flash
+			for (int j = 0; j < 128; j++) {
+				buff2[j] = i2c_read_ack();
+				buff1[j] = pgm_read_byte_near(addr + j);
+			}
+			i2c_stop();
+			i2c_start(EW);
+			i2c_write(addr >> 8);
+			i2c_write(addr);
+			//write the page read from internal flash to i2c eeprom. (Swap write)
+			for (int j = 0; j < 128; j++) {
+				i2c_write(buff1[j]);
+			}
+
+			i2c_stop();
+
+			//write the page read from external eeprom to internal flash.
+			writebuffer(0, buff2, addr, 128);
+
+			_delay_ms(2);
+
+			//increment page address. Here both flash and eeprom are of same page size.
+			addr += 128;
+
+			//toggle LED
+			PORTB ^= 1 << PB5;
+		}
+
+	// wait while dualboot enable pin is LOW
+		while ((PINC & (1 << PC1)) == 0) ; //PB3
+
+		//forcefull watchdog reset for app start.
+		watchdogConfig(WATCHDOG_16MS);
+		while (1) ;
+	}
+
+	uart_init();
+	watchdogConfig(WATCHDOG_1S);
+	watchdogReset();
+
+	for (;;) {
+		/* get character from UART */
+		ch = getch();
+
+		if (ch == STK_GET_PARAMETER) {
+			unsigned char which = getch();
+			verifySpace();
+			/*
+			 * Send optiboot version as "SW version"
+			 * Note that the references to memory are optimized away.
+			 */
+			if (which == STK_SW_MINOR) {
+				putch((256 * 6 + 2) & 0xFF);
+			} else if (which == STK_SW_MAJOR) {
+				putch((256 * 6 + 2) >> 8);
+			} else {
+				/*
+				 * GET PARAMETER returns a generic 0x03 reply for
+				 * other parameters - enough to keep Avrdude happy
+				 */
+				putch(0x03);
+			}
+		} else if (ch == STK_SET_DEVICE) {
+			// SET DEVICE is ignored
+			getNch(20);
+		} else if (ch == STK_SET_DEVICE_EXT) {
+			// SET DEVICE EXT is ignored
+			getNch(5);
+		} else if (ch == STK_LOAD_ADDRESS) {
+			// LOAD ADDRESS
+			uint16_t newAddress;
+
+			newAddress = getch();
+			newAddress = (newAddress & 0xff) | (getch() << 8);
+
+			newAddress += newAddress;	// Convert from word address to byte address
+			address = newAddress;
+			verifySpace();
+		} else if (ch == STK_UNIVERSAL) {
+			// UNIVERSAL command is ignored
+			getNch(4);
+			putch(0x00);
+		}
+		/* Write memory, length is big endian and is in bytes */
+		else if (ch == STK_PROG_PAGE) {
+			// PROGRAM PAGE - we support flash programming only, not EEPROM
+			uint8_t desttype;
+			uint8_t *bufPtr;
+			pagelen_t savelength;
+
+			GETLENGTH(length);
+			savelength = length;
+			desttype = getch();
+
+			// read a page worth of contents
+			bufPtr = buff;
+			do
+				*bufPtr++ = getch();
+			while (--length);
+
+			// Read command terminator, start reply
+			verifySpace();
+
+			writebuffer(desttype, buff, address, savelength);
+
+		}
+		/* Read memory block mode, length is big endian.  */
+		else if (ch == STK_READ_PAGE) {
+			uint8_t desttype;
+			GETLENGTH(length);
+
+			desttype = getch();
+
+			verifySpace();
+
+			read_mem(desttype, address, length);
+		}
+
+		/* Get device signature bytes  */
+		else if (ch == STK_READ_SIGN) {
+			// READ SIGN - return what Avrdude wants to hear
+			verifySpace();
+			putch(SIGNATURE_0);
+			putch(SIGNATURE_1);
+			putch(SIGNATURE_2);
+		}
+
+		else if (ch == STK_LEAVE_PROGMODE) {	/* 'Q' */
+			// Adaboot no-wait mod
+			watchdogConfig(WATCHDOG_1S);
+			verifySpace();
+		} else {
+			// This covers the response to commands like STK_ENTER_PROGMODE
+			verifySpace();
+		}
+		putch(STK_OK);
+	}
+
+}
+
+/*
+ * void writebuffer(memtype, buffer, address, length)
+ */
+static inline void writebuffer(int8_t memtype, uint8_t * mybuff,
+			       uint16_t address, pagelen_t len)
+{
+	// Copy buffer into programming buffer
+	uint8_t *bufPtr = mybuff;
+	uint16_t addrPtr = (uint16_t) (void *)address;
+	watchdogReset();
+	/*
+	 * Start the page erase and wait for it to finish.  There
+	 * used to be code to do this while receiving the data over
+	 * the serial link, but the performance improvement was slight,
+	 * and we needed the space back.
+	 */
+	__boot_page_erase_short((uint16_t) (void *)address);
+	boot_spm_busy_wait();
+
+	/*
+	 * Copy data from the buffer into the flash write buffer.
+	 */
+	do {
+		uint16_t a;
+		a = *bufPtr++;
+		a |= (*bufPtr++) << 8;
+		__boot_page_fill_short((uint16_t) (void *)addrPtr, a);
+		addrPtr += 2;
+	} while (len -= 2);
+
+	/*
+	 * Actually Write the buffer to flash (and wait for it to finish.)
+	 */
+	__boot_page_write_short((uint16_t) (void *)address);
+	boot_spm_busy_wait();
+
+	__boot_rww_enable_alternate();
+
+}
+
+static inline void read_mem(uint8_t memtype, uint16_t address, pagelen_t length)
+{
+	uint8_t cc;
+	//watchdogReset();
+	// read a Flash byte and increment the address
+
+	do {
+ __asm__("lpm %0,Z+\n": "=r"(cc), "=z"(address):"1"(address));
+		putch(cc);
+	} while (--length);
+
+}
+
+void verifySpace()
+{
+	if (getch() != CRC_EOP) {
+		watchdogConfig(WATCHDOG_1S);	// shorten WD timeout
+		while (1)	// and busy-loop so that WD causes
+			;	//  a reset and app start.
+	}
+	putch(STK_INSYNC);
+}
+
+void getNch(uint8_t count)
+{
+	do
+		getch();
+	while (--count);
+	verifySpace();
+}
+
+void watchdogConfig(uint8_t x)
+{
+	WDTCSR = _BV(WDCE) | _BV(WDE);
+	WDTCSR = x;
+}
+
+// Watchdog functions. These are only safe with interrupts turned off.
+void watchdogReset()
+{
+	__asm__ __volatile__("wdr\n");
+}

arduino_dualboot_bootloader/pin_defs.h

@@ -0,0 +1,795 @@
+/*
+ * pin_defs.h
+ * optiboot helper defining the default pin assignments (LED, SOFT_UART)
+ * for the various chips that are supported.  This also has some ugly macros
+ * for selecting among various UARTs and LED possibilities using command-line
+ * defines like "UART=2 LED=B5"
+ *
+ * Copyright 2013-2015 by Bill Westfield.
+ * Copyright 2010 by Peter Knight.
+ * This software is licensed under version 2 of the Gnu Public Licence.
+ * See optiboot.c for details.
+ */
+
+/*------------------------------------------------------------------------ */
+#if defined(__AVR_ATmega168__) || defined(__AVR_ATmega168P__) || defined(__AVR_ATmega328__) || defined(__AVR_ATmega328P__) || defined(__AVR_ATmega88) || defined(__AVR_ATmega8__) || defined(__AVR_ATmega88__)
+/*------------------------------------------------------------------------ */
+
+/* Onboard LED is connected to pin PB5 in Arduino NG, Diecimila, and Duemilanove
+ */ 
+#if !defined(LED)
+#define LED B5
+#endif
+
+/* Ports for soft UART */
+#ifdef SOFT_UART
+#define UART_PORT   PORTD
+#define UART_PIN    PIND
+#define UART_DDR    DDRD
+#define UART_TX_BIT 1
+#define UART_RX_BIT 0
+#endif
+#endif
+
+/*
+ * Handle devices with up to 4 uarts (eg m1280.)  Rather inelegantly.
+ * Note that mega8/m32 still needs special handling, because ubrr is handled
+ * differently.
+ */
+#if UART == 0
+# define UART_SRA UCSR0A
+# define UART_SRB UCSR0B
+# define UART_SRC UCSR0C
+# define UART_SRL UBRR0L
+# define UART_UDR UDR0
+#elif UART == 1
+#if !defined(UDR1)
+#error UART == 1, but no UART1 on device
+#endif
+# define UART_SRA UCSR1A
+# define UART_SRB UCSR1B
+# define UART_SRC UCSR1C
+# define UART_SRL UBRR1L
+# define UART_UDR UDR1
+#elif UART == 2
+#if !defined(UDR2)
+#error UART == 2, but no UART2 on device
+#endif
+# define UART_SRA UCSR2A
+# define UART_SRB UCSR2B
+# define UART_SRC UCSR2C
+# define UART_SRL UBRR2L
+# define UART_UDR UDR2
+#elif UART == 3
+#if !defined(UDR3)
+#error UART == 3, but no UART3 on device
+#endif
+# define UART_SRA UCSR3A
+# define UART_SRB UCSR3B
+# define UART_SRC UCSR3C
+# define UART_SRL UBRR3L
+# define UART_UDR UDR3
+#endif
+
+#if defined(__AVR_ATmega8__) || defined (__AVR_ATmega32__) || defined (__AVR_ATmega16__)
+  //Name conversion R.Wiersma
+  #define UCSR0A	UCSRA
+  #define UDR0 		UDR
+  #define UDRE0 	UDRE
+  #define RXC0		RXC
+  #define FE0           FE
+  #define TIFR1 	TIFR
+  #define WDTCSR	WDTCR
+#endif
+#if defined (__AVR_ATmega32__) || defined (__AVR_ATmega16__)
+  #define WDCE		WDTOE
+#endif
+
+/* Luminet support */
+/*------------------------------------------------------------------------ */
+#if defined(__AVR_ATtiny84__)
+/*------------------------------------------------------------------------ */
+/* Red LED is connected to pin PA4 */ 
+#if !defined(LED)
+#define LED         A4
+#endif
+
+/* Ports for soft UART - left port only for now. TX/RX on PA2/PA3 */
+#ifdef SOFT_UART
+#define UART_PORT   PORTA
+#define UART_PIN    PINA
+#define UART_DDR    DDRA
+#define UART_TX_BIT 2
+#define UART_RX_BIT 3
+#endif
+#endif
+
+/*------------------------------------------------------------------------ */
+/* Sanguino support (and other 40pin DIP cpus) */
+#if defined(__AVR_ATmega644P__) || defined(__AVR_ATmega1284P__) || defined(__AVR_ATmega32__) || defined (__AVR_ATmega16__)
+/*------------------------------------------------------------------------ */
+/* Onboard LED is connected to pin PB0 on Sanguino */ 
+#if !defined(LED)
+#define LED         B0
+#endif
+
+/* Ports for soft UART */
+#ifdef SOFT_UART
+#define UART_PORT   PORTD
+#define UART_PIN    PIND
+#define UART_DDR    DDRD
+#define UART_TX_BIT 1
+#define UART_RX_BIT 0
+#endif
+#endif
+
+/*------------------------------------------------------------------------ */
+/* Mega support */
+#if defined(__AVR_ATmega1280__)
+/*------------------------------------------------------------------------ */
+/* Onboard LED is connected to pin PB7 on Arduino Mega */ 
+#if !defined(LED)
+#define LED         B7
+#endif
+
+/* Ports for soft UART */
+#ifdef SOFT_UART
+#define UART_PORT   PORTE
+#define UART_PIN    PINE
+#define UART_DDR    DDRE
+#define UART_TX_BIT 1
+#define UART_RX_BIT 0
+#endif
+#endif
+
+/*
+ * ------------------------------------------------------------------------
+ * A bunch of macros to enable the LED to be specifed as "B5" for bit 5 
+ * of port B, and similar.
+ */
+
+#define A0 0x100
+#define A1 0x101
+#define A2 0x102
+#define A3 0x103
+#define A4 0x104
+#define A5 0x105
+#define A6 0x106
+#define A7 0x107
+
+#define B0 0x200
+#define B1 0x201
+#define B2 0x202
+#define B3 0x203
+#define B4 0x204
+#define B5 0x205
+#define B6 0x206
+#define B7 0x207
+
+#define C0 0x300
+#define C1 0x301
+#define C2 0x302
+#define C3 0x303
+#define C4 0x304
+#define C5 0x305
+#define C6 0x306
+#define C7 0x307
+
+#define D0 0x400
+#define D1 0x401
+#define D2 0x402
+#define D3 0x403
+#define D4 0x404
+#define D5 0x405
+#define D6 0x406
+#define D7 0x407
+
+#define E0 0x500
+#define E1 0x501
+#define E2 0x502
+#define E3 0x503
+#define E4 0x504
+#define E5 0x505
+#define E6 0x506
+#define E7 0x507
+
+#define F0 0x600
+#define F1 0x601
+#define F2 0x602
+#define F3 0x603
+#define F4 0x604
+#define F5 0x605
+#define F6 0x606
+#define F7 0x607
+
+#define G0 0x700
+#define G1 0x701
+#define G2 0x702
+#define G3 0x703
+#define G4 0x704
+#define G5 0x705
+#define G6 0x706
+#define G7 0x707
+
+#define H0 0x800
+#define H1 0x801
+#define H2 0x802
+#define H3 0x803
+#define H4 0x804
+#define H5 0x805
+#define H6 0x806
+#define H7 0x807
+
+#define J0 0xA00
+#define J1 0xA01
+#define J2 0xA02
+#define J3 0xA03
+#define J4 0xA04
+#define J5 0xA05
+#define J6 0xA06
+#define J7 0xA07
+
+#define K0 0xB00
+#define K1 0xB01
+#define K2 0xB02
+#define K3 0xB03
+#define K4 0xB04
+#define K5 0xB05
+#define K6 0xB06
+#define K7 0xB07
+
+#define L0 0xC00
+#define L1 0xC01
+#define L2 0xC02
+#define L3 0xC03
+#define L4 0xC04
+#define L5 0xC05
+#define L6 0xC06
+#define L7 0xC07
+
+
+
+#if LED == B0
+#undef LED
+#define LED_DDR     DDRB
+#define LED_PORT    PORTB
+#define LED_PIN     PINB
+#define LED	    PINB0
+#elif LED == B1
+#undef LED
+#define LED_DDR     DDRB
+#define LED_PORT    PORTB
+#define LED_PIN     PINB
+#define LED	    PINB1
+#elif LED == B2
+#undef LED
+#define LED_DDR     DDRB
+#define LED_PORT    PORTB
+#define LED_PIN     PINB
+#define LED	    PINB2
+#elif LED == B3
+#undef LED
+#define LED_DDR     DDRB
+#define LED_PORT    PORTB
+#define LED_PIN     PINB
+#define LED	    PINB3
+#elif LED == B4
+#undef LED
+#define LED_DDR     DDRB
+#define LED_PORT    PORTB
+#define LED_PIN     PINB
+#define LED	    PINB4
+#elif LED == B5
+#undef LED
+#define LED_DDR     DDRB
+#define LED_PORT    PORTB
+#define LED_PIN     PINB
+#define LED	    PINB5
+#elif LED == B6
+#undef LED
+#define LED_DDR     DDRB
+#define LED_PORT    PORTB
+#define LED_PIN     PINB
+#define LED	    PINB6
+#elif LED == B7
+#undef LED
+#define LED_DDR     DDRB
+#define LED_PORT    PORTB
+#define LED_PIN     PINB
+#define LED	    PINB7
+
+#elif LED == C0
+#undef LED
+#define LED_DDR     DDRC
+#define LED_PORT    PORTC
+#define LED_PIN     PINC
+#define LED	    PINC0
+#elif LED == C1
+#undef LED
+#define LED_DDR     DDRC
+#define LED_PORT    PORTC
+#define LED_PIN     PINC
+#define LED	    PINC1
+#elif LED == C2
+#undef LED
+#define LED_DDR     DDRC
+#define LED_PORT    PORTC
+#define LED_PIN     PINC
+#define LED	    PINC2
+#elif LED == C3
+#undef LED
+#define LED_DDR     DDRC
+#define LED_PORT    PORTC
+#define LED_PIN     PINC
+#define LED	    PINC3
+#elif LED == C4
+#undef LED
+#define LED_DDR     DDRC
+#define LED_PORT    PORTC
+#define LED_PIN     PINC
+#define LED	    PINC4
+#elif LED == C5
+#undef LED
+#define LED_DDR     DDRC
+#define LED_PORT    PORTC
+#define LED_PIN     PINC
+#define LED	    PINC5
+#elif LED == C6
+#undef LED
+#define LED_DDR     DDRC
+#define LED_PORT    PORTC
+#define LED_PIN     PINC
+#define LED	    PINC6
+#elif LED == C7
+#undef LED
+#define LED_DDR     DDRC
+#define LED_PORT    PORTC
+#define LED_PIN     PINC
+#define LED	    PINC7
+
+#elif LED == D0
+#undef LED
+#define LED_DDR     DDRD
+#define LED_PORT    PORTD
+#define LED_PIN     PIND
+#define LED	    PIND0
+#elif LED == D1
+#undef LED
+#define LED_DDR     DDRD
+#define LED_PORT    PORTD
+#define LED_PIN     PIND
+#define LED	    PIND1
+#elif LED == D2
+#undef LED
+#define LED_DDR     DDRD
+#define LED_PORT    PORTD
+#define LED_PIN     PIND
+#define LED	    PIND2
+#elif LED == D3
+#undef LED
+#define LED_DDR     DDRD
+#define LED_PORT    PORTD
+#define LED_PIN     PIND
+#define LED	    PIND3
+#elif LED == D4
+#undef LED
+#define LED_DDR     DDRD
+#define LED_PORT    PORTD
+#define LED_PIN     PIND
+#define LED	    PIND4
+#elif LED == D5
+#undef LED
+#define LED_DDR     DDRD
+#define LED_PORT    PORTD
+#define LED_PIN     PIND
+#define LED	    PIND5
+#elif LED == D6
+#undef LED
+#define LED_DDR     DDRD
+#define LED_PORT    PORTD
+#define LED_PIN     PIND
+#define LED	    PIND6
+#elif LED == D7
+#undef LED
+#define LED_DDR     DDRD
+#define LED_PORT    PORTD
+#define LED_PIN     PIND
+#define LED	    PIND7
+
+#elif LED == E0
+#undef LED
+#define LED_DDR     DDRE
+#define LED_PORT    PORTE
+#define LED_PIN     PINE
+#define LED	    PINE0
+#elif LED == E1
+#undef LED
+#define LED_DDR     DDRE
+#define LED_PORT    PORTE
+#define LED_PIN     PINE
+#define LED	    PINE1
+#elif LED == E2
+#undef LED
+#define LED_DDR     DDRE
+#define LED_PORT    PORTE
+#define LED_PIN     PINE
+#define LED	    PINE2
+#elif LED == E3
+#undef LED
+#define LED_DDR     DDRE
+#define LED_PORT    PORTE
+#define LED_PIN     PINE
+#define LED	    PINE3
+#elif LED == E4
+#undef LED
+#define LED_DDR     DDRE
+#define LED_PORT    PORTE
+#define LED_PIN     PINE
+#define LED	    PINE4
+#elif LED == E5
+#undef LED
+#define LED_DDR     DDRE
+#define LED_PORT    PORTE
+#define LED_PIN     PINE
+#define LED	    PINE5
+#elif LED == E6
+#undef LED
+#define LED_DDR     DDRE
+#define LED_PORT    PORTE
+#define LED_PIN     PINE
+#define LED	    PINE6
+#elif LED == E7
+#undef LED
+#define LED_DDR     DDRE
+#define LED_PORT    PORTE
+#define LED_PIN     PINE
+#define LED	    PINE7
+
+#elif LED == F0
+#undef LED
+#define LED_DDR     DDRF
+#define LED_PORT    PORTF
+#define LED_PIN     PINF
+#define LED	    PINF0
+#elif LED == F1
+#undef LED
+#define LED_DDR     DDRF
+#define LED_PORT    PORTF
+#define LED_PIN     PINF
+#define LED	    PINF1
+#elif LED == F2
+#undef LED
+#define LED_DDR     DDRF
+#define LED_PORT    PORTF
+#define LED_PIN     PINF
+#define LED	    PINF2
+#elif LED == F3
+#undef LED
+#define LED_DDR     DDRF
+#define LED_PORT    PORTF
+#define LED_PIN     PINF
+#define LED	    PINF3
+#elif LED == F4
+#undef LED
+#define LED_DDR     DDRF
+#define LED_PORT    PORTF
+#define LED_PIN     PINF
+#define LED	    PINF4
+#elif LED == F5
+#undef LED
+#define LED_DDR     DDRF
+#define LED_PORT    PORTF
+#define LED_PIN     PINF
+#define LED	    PINF5
+#elif LED == F6
+#undef LED
+#define LED_DDR     DDRF
+#define LED_PORT    PORTF
+#define LED_PIN     PINF
+#define LED	    PINF6
+#elif LED == F7
+#undef LED
+#define LED_DDR     DDRF
+#define LED_PORT    PORTF
+#define LED_PIN     PINF
+#define LED	    PINF7
+
+#elif LED == G0
+#undef LED
+#define LED_DDR     DDRG
+#define LED_PORT    PORTG
+#define LED_PIN     PING
+#define LED	    PING0
+#elif LED == G1
+#undef LED
+#define LED_DDR     DDRG
+#define LED_PORT    PORTG
+#define LED_PIN     PING
+#define LED	    PING1
+#elif LED == G2
+#undef LED
+#define LED_DDR     DDRG
+#define LED_PORT    PORTG
+#define LED_PIN     PING
+#define LED	    PING2
+#elif LED == G3
+#undef LED
+#define LED_DDR     DDRG
+#define LED_PORT    PORTG
+#define LED_PIN     PING
+#define LED	    PING3
+#elif LED == G4
+#undef LED
+#define LED_DDR     DDRG
+#define LED_PORT    PORTG
+#define LED_PIN     PING
+#define LED	    PING4
+#elif LED == G5
+#undef LED
+#define LED_DDR     DDRG
+#define LED_PORT    PORTG
+#define LED_PIN     PING
+#define LED	    PING5
+#elif LED == G6
+#undef LED
+#define LED_DDR     DDRG
+#define LED_PORT    PORTG
+#define LED_PIN     PING
+#define LED	    PING6
+#elif LED == G7
+#undef LED
+#define LED_DDR     DDRG
+#define LED_PORT    PORTG
+#define LED_PIN     PING
+#define LED	    PING7
+
+#elif LED == H0
+#undef LED
+#define LED_DDR     DDRH
+#define LED_PORT    PORTH
+#define LED_PIN     PINH
+#define LED	    PINH0
+#elif LED == H1
+#undef LED
+#define LED_DDR     DDRH
+#define LED_PORT    PORTH
+#define LED_PIN     PINH
+#define LED	    PINH1
+#elif LED == H2
+#undef LED
+#define LED_DDR     DDRH
+#define LED_PORT    PORTH
+#define LED_PIN     PINH
+#define LED	    PINH2
+#elif LED == H3
+#undef LED
+#define LED_DDR     DDRH
+#define LED_PORT    PORTH
+#define LED_PIN     PINH
+#define LED	    PINH3
+#elif LED == H4
+#undef LED
+#define LED_DDR     DDRH
+#define LED_PORT    PORTH
+#define LED_PIN     PINH
+#define LED	    PINH4
+#elif LED == H5
+#undef LED
+#define LED_DDR     DDRH
+#define LED_PORT    PORTH
+#define LED_PIN     PINH
+#define LED	    PINH5
+#elif LED == H6
+#undef LED
+#define LED_DDR     DDRH
+#define LED_PORT    PORTH
+#define LED_PIN     PINH
+#define LED	    PINH6
+#elif LED == H7
+#undef LED
+#define LED_DDR     DDRH
+#define LED_PORT    PORTH
+#define LED_PIN     PINH
+#define LED	    PINH7
+
+#elif LED == J0
+#undef LED
+#define LED_DDR     DDRJ
+#define LED_PORT    PORTJ
+#define LED_PIN     PINJ
+#define LED	    PINJ0
+#elif LED == J1
+#undef LED
+#define LED_DDR     DDRJ
+#define LED_PORT    PORTJ
+#define LED_PIN     PINJ
+#define LED	    PINJ1
+#elif LED == J2
+#undef LED
+#define LED_DDR     DDRJ
+#define LED_PORT    PORTJ
+#define LED_PIN     PINJ
+#define LED	    PINJ2
+#elif LED == J3
+#undef LED
+#define LED_DDR     DDRJ
+#define LED_PORT    PORTJ
+#define LED_PIN     PINJ
+#define LED	    PINJ3
+#elif LED == J4
+#undef LED
+#define LED_DDR     DDRJ
+#define LED_PORT    PORTJ
+#define LED_PIN     PINJ
+#define LED	    PINJ4
+#elif LED == J5
+#undef LED
+#define LED_DDR     DDRJ
+#define LED_PORT    PORTJ
+#define LED_PIN     PINJ
+#define LED	    PINJ5
+#elif LED == J6
+#undef LED
+#define LED_DDR     DDRJ
+#define LED_PORT    PORTJ
+#define LED_PIN     PINJ
+#define LED	    PINJ6
+#elif LED == J7
+#undef LED
+#define LED_DDR     DDRJ
+#define LED_PORT    PORTJ
+#define LED_PIN     PINJ
+#define LED	    PINJ7
+
+#elif LED == K0
+#undef LED
+#define LED_DDR     DDRK
+#define LED_PORT    PORTK
+#define LED_PIN     PINK
+#define LED	    PINK0
+#elif LED == K1
+#undef LED
+#define LED_DDR     DDRK
+#define LED_PORT    PORTK
+#define LED_PIN     PINK
+#define LED	    PINK1
+#elif LED == K2
+#undef LED
+#define LED_DDR     DDRK
+#define LED_PORT    PORTK
+#define LED_PIN     PINK
+#define LED	    PINK2
+#elif LED == K3
+#undef LED
+#define LED_DDR     DDRK
+#define LED_PORT    PORTK
+#define LED_PIN     PINK
+#define LED	    PINK3
+#elif LED == K4
+#undef LED
+#define LED_DDR     DDRK
+#define LED_PORT    PORTK
+#define LED_PIN     PINK
+#define LED	    PINK4
+#elif LED == K5
+#undef LED
+#define LED_DDR     DDRK
+#define LED_PORT    PORTK
+#define LED_PIN     PINK
+#define LED	    PINK5
+#elif LED == K6
+#undef LED
+#define LED_DDR     DDRK
+#define LED_PORT    PORTK
+#define LED_PIN     PINK
+#define LED	    PINK6
+#elif LED == K7
+#undef LED
+#define LED_DDR     DDRK
+#define LED_PORT    PORTK
+#define LED_PIN     PINK
+#define LED	    PINK7
+
+#elif LED == L0
+#undef LED
+#define LED_DDR     DDRL
+#define LED_PORT    PORTL
+#define LED_PIN     PINL
+#define LED	    PINL0
+#elif LED == L1
+#undef LED
+#define LED_DDR     DDRL
+#define LED_PORT    PORTL
+#define LED_PIN     PINL
+#define LED	    PINL1
+#elif LED == L2
+#undef LED
+#define LED_DDR     DDRL
+#define LED_PORT    PORTL
+#define LED_PIN     PINL
+#define LED	    PINL2
+#elif LED == L3
+#undef LED
+#define LED_DDR     DDRL
+#define LED_PORT    PORTL
+#define LED_PIN     PINL
+#define LED	    PINL3
+#elif LED == L4
+#undef LED
+#define LED_DDR     DDRL
+#define LED_PORT    PORTL
+#define LED_PIN     PINL
+#define LED	    PINL4
+#elif LED == L5
+#undef LED
+#define LED_DDR     DDRL
+#define LED_PORT    PORTL
+#define LED_PIN     PINL
+#define LED	    PINL5
+#elif LED == L6
+#undef LED
+#define LED_DDR     DDRL
+#define LED_PORT    PORTL
+#define LED_PIN     PINL
+#define LED	    PINL6
+#elif LED == L7
+#undef LED
+#define LED_DDR     DDRL
+#define LED_PORT    PORTL
+#define LED_PIN     PINL
+#define LED	    PINL7
+
+#elif LED == A0
+#undef LED
+#define LED_DDR     DDRA
+#define LED_PORT    PORTA
+#define LED_PIN     PINA
+#define LED	    PINA0
+#elif LED == A1
+#undef LED
+#define LED_DDR     DDRA
+#define LED_PORT    PORTA
+#define LED_PIN     PINA
+#define LED	    PINA1
+#elif LED == A2
+#undef LED
+#define LED_DDR     DDRA
+#define LED_PORT    PORTA
+#define LED_PIN     PINA
+#define LED	    PINA2
+#elif LED == A3
+#undef LED
+#define LED_DDR     DDRA
+#define LED_PORT    PORTA
+#define LED_PIN     PINA
+#define LED	    PINA3
+#elif LED == A4
+#undef LED
+#define LED_DDR     DDRA
+#define LED_PORT    PORTA
+#define LED_PIN     PINA
+#define LED	    PINA4
+#elif LED == A5
+#undef LED
+#define LED_DDR     DDRA
+#define LED_PORT    PORTA
+#define LED_PIN     PINA
+#define LED	    PINA5
+#elif LED == A6
+#undef LED
+#define LED_DDR     DDRA
+#define LED_PORT    PORTA
+#define LED_PIN     PINA
+#define LED	    PINA6
+#elif LED == A7
+#undef LED
+#define LED_DDR     DDRA
+#define LED_PORT    PORTA
+#define LED_PIN     PINA
+#define LED	    PINA7
+
+#else
+#error -------------------------------------------
+#error Unrecognized LED name.  Should be like "B5"
+#error -------------------------------------------
+#endif

arduino_dualboot_bootloader/stk500.h

@@ -0,0 +1,46 @@
+/* STK500 constants list, from AVRDUDE
+ *
+ * Trivial set of constants derived from Atmel App Note AVR061
+ * Not copyrighted.  Released to the public domain.
+ */
+
+#define STK_OK              0x10
+#define STK_FAILED          0x11  // Not used
+#define STK_UNKNOWN         0x12  // Not used
+#define STK_NODEVICE        0x13  // Not used
+#define STK_INSYNC          0x14  // ' '
+#define STK_NOSYNC          0x15  // Not used
+#define ADC_CHANNEL_ERROR   0x16  // Not used
+#define ADC_MEASURE_OK      0x17  // Not used
+#define PWM_CHANNEL_ERROR   0x18  // Not used
+#define PWM_ADJUST_OK       0x19  // Not used
+#define CRC_EOP             0x20  // 'SPACE'
+#define STK_GET_SYNC        0x30  // '0'
+#define STK_GET_SIGN_ON     0x31  // '1'
+#define STK_SET_PARAMETER   0x40  // '@'
+#define STK_GET_PARAMETER   0x41  // 'A'
+#define STK_SET_DEVICE      0x42  // 'B'
+#define STK_SET_DEVICE_EXT  0x45  // 'E'
+#define STK_ENTER_PROGMODE  0x50  // 'P'
+#define STK_LEAVE_PROGMODE  0x51  // 'Q'
+#define STK_CHIP_ERASE      0x52  // 'R'
+#define STK_CHECK_AUTOINC   0x53  // 'S'
+#define STK_LOAD_ADDRESS    0x55  // 'U'
+#define STK_UNIVERSAL       0x56  // 'V'
+#define STK_PROG_FLASH      0x60  // '`'
+#define STK_PROG_DATA       0x61  // 'a'
+#define STK_PROG_FUSE       0x62  // 'b'
+#define STK_PROG_LOCK       0x63  // 'c'
+#define STK_PROG_PAGE       0x64  // 'd'
+#define STK_PROG_FUSE_EXT   0x65  // 'e'
+#define STK_READ_FLASH      0x70  // 'p'
+#define STK_READ_DATA       0x71  // 'q'
+#define STK_READ_FUSE       0x72  // 'r'
+#define STK_READ_LOCK       0x73  // 's'
+#define STK_READ_PAGE       0x74  // 't'
+#define STK_READ_SIGN       0x75  // 'u'
+#define STK_READ_OSCCAL     0x76  // 'v'
+#define STK_READ_FUSE_EXT   0x77  // 'w'
+#define STK_READ_OSCCAL_EXT 0x78  // 'x'
+#define STK_SW_MAJOR        0x81  // ' '
+#define STK_SW_MINOR        0x82  // ' '

arduino_dualboot_bootloader/tags

@@ -0,0 +1,741 @@
+!_TAG_FILE_FORMAT	2	/extended format; --format=1 will not append ;" to lines/
+!_TAG_FILE_SORTED	1	/0=unsorted, 1=sorted, 2=foldcase/
+!_TAG_PROGRAM_AUTHOR	Darren Hiebert	/dhiebert@users.sourceforge.net/
+!_TAG_PROGRAM_NAME	Exuberant Ctags	//
+!_TAG_PROGRAM_URL	http://ctags.sourceforge.net	/official site/
+!_TAG_PROGRAM_VERSION	5.9~svn20110310	//
+A0	pin_defs.h	151;"	d
+A1	pin_defs.h	152;"	d
+A2	pin_defs.h	153;"	d
+A3	pin_defs.h	154;"	d
+A4	pin_defs.h	155;"	d
+A5	pin_defs.h	156;"	d
+A6	pin_defs.h	157;"	d
+A7	pin_defs.h	158;"	d
+ADC_CHANNEL_ERROR	stk500.h	13;"	d
+ADC_MEASURE_OK	stk500.h	14;"	d
+B0	pin_defs.h	160;"	d
+B1	pin_defs.h	161;"	d
+B2	pin_defs.h	162;"	d
+B3	pin_defs.h	163;"	d
+B4	pin_defs.h	164;"	d
+B5	pin_defs.h	165;"	d
+B6	pin_defs.h	166;"	d
+B7	pin_defs.h	167;"	d
+BAUDRATE	uart.c	7;"	d	file:
+BLB01	boot.h	167;"	d
+BLB02	boot.h	166;"	d
+BLB11	boot.h	165;"	d
+BLB12	boot.h	164;"	d
+BOOTLOADER_SECTION	boot.h	147;"	d
+C0	pin_defs.h	169;"	d
+C1	pin_defs.h	170;"	d
+C2	pin_defs.h	171;"	d
+C3	pin_defs.h	172;"	d
+C4	pin_defs.h	173;"	d
+C5	pin_defs.h	174;"	d
+C6	pin_defs.h	175;"	d
+C7	pin_defs.h	176;"	d
+CRC_EOP	stk500.h	17;"	d
+D0	pin_defs.h	178;"	d
+D1	pin_defs.h	179;"	d
+D2	pin_defs.h	180;"	d
+D3	pin_defs.h	181;"	d
+D4	pin_defs.h	182;"	d
+D5	pin_defs.h	183;"	d
+D6	pin_defs.h	184;"	d
+D7	pin_defs.h	185;"	d
+E0	pin_defs.h	187;"	d
+E1	pin_defs.h	188;"	d
+E2	pin_defs.h	189;"	d
+E3	pin_defs.h	190;"	d
+E4	pin_defs.h	191;"	d
+E5	pin_defs.h	192;"	d
+E6	pin_defs.h	193;"	d
+E7	pin_defs.h	194;"	d
+ER	i2c.h	5;"	d
+EW	i2c.h	6;"	d
+F0	pin_defs.h	196;"	d
+F1	pin_defs.h	197;"	d
+F2	pin_defs.h	198;"	d
+F3	pin_defs.h	199;"	d
+F4	pin_defs.h	200;"	d
+F5	pin_defs.h	201;"	d
+F6	pin_defs.h	202;"	d
+F7	pin_defs.h	203;"	d
+FE0	pin_defs.h	80;"	d
+FUNC_READ	main.c	12;"	d	file:
+FUNC_WRITE	main.c	13;"	d	file:
+F_CPU	i2c.c	2;"	d	file:
+F_CPU	main.c	2;"	d	file:
+F_CPU	uart.c	2;"	d	file:
+F_SCL	i2c.c	10;"	d	file:
+G0	pin_defs.h	205;"	d
+G1	pin_defs.h	206;"	d
+G2	pin_defs.h	207;"	d
+G3	pin_defs.h	208;"	d
+G4	pin_defs.h	209;"	d
+G5	pin_defs.h	210;"	d
+G6	pin_defs.h	211;"	d
+G7	pin_defs.h	212;"	d
+GETLENGTH	main.c	21;"	d	file:
+GET_EXTENDED_FUSE_BITS	boot.h	597;"	d
+GET_HIGH_FUSE_BITS	boot.h	602;"	d
+GET_LOCK_BITS	boot.h	592;"	d
+GET_LOW_FUSE_BITS	boot.h	587;"	d
+H0	pin_defs.h	214;"	d
+H1	pin_defs.h	215;"	d
+H2	pin_defs.h	216;"	d
+H3	pin_defs.h	217;"	d
+H4	pin_defs.h	218;"	d
+H5	pin_defs.h	219;"	d
+H6	pin_defs.h	220;"	d
+H7	pin_defs.h	221;"	d
+I2C_MASTER_H	i2c.h	2;"	d
+I2C_READ	i2c.h	8;"	d
+I2C_WRITE	i2c.h	9;"	d
+J0	pin_defs.h	223;"	d
+J1	pin_defs.h	224;"	d
+J2	pin_defs.h	225;"	d
+J3	pin_defs.h	226;"	d
+J4	pin_defs.h	227;"	d
+J5	pin_defs.h	228;"	d
+J6	pin_defs.h	229;"	d
+J7	pin_defs.h	230;"	d
+K0	pin_defs.h	232;"	d
+K1	pin_defs.h	233;"	d
+K2	pin_defs.h	234;"	d
+K3	pin_defs.h	235;"	d
+K4	pin_defs.h	236;"	d
+K5	pin_defs.h	237;"	d
+K6	pin_defs.h	238;"	d
+K7	pin_defs.h	239;"	d
+L0	pin_defs.h	241;"	d
+L1	pin_defs.h	242;"	d
+L2	pin_defs.h	243;"	d
+L3	pin_defs.h	244;"	d
+L4	pin_defs.h	245;"	d
+L5	pin_defs.h	246;"	d
+L6	pin_defs.h	247;"	d
+L7	pin_defs.h	248;"	d
+LED	pin_defs.h	113;"	d
+LED	pin_defs.h	132;"	d
+LED	pin_defs.h	21;"	d
+LED	pin_defs.h	253;"	d
+LED	pin_defs.h	257;"	d
+LED	pin_defs.h	259;"	d
+LED	pin_defs.h	263;"	d
+LED	pin_defs.h	265;"	d
+LED	pin_defs.h	269;"	d
+LED	pin_defs.h	271;"	d
+LED	pin_defs.h	275;"	d
+LED	pin_defs.h	277;"	d
+LED	pin_defs.h	281;"	d
+LED	pin_defs.h	283;"	d
+LED	pin_defs.h	287;"	d
+LED	pin_defs.h	289;"	d
+LED	pin_defs.h	293;"	d
+LED	pin_defs.h	295;"	d
+LED	pin_defs.h	299;"	d
+LED	pin_defs.h	302;"	d
+LED	pin_defs.h	306;"	d
+LED	pin_defs.h	308;"	d
+LED	pin_defs.h	312;"	d
+LED	pin_defs.h	314;"	d
+LED	pin_defs.h	318;"	d
+LED	pin_defs.h	320;"	d
+LED	pin_defs.h	324;"	d
+LED	pin_defs.h	326;"	d
+LED	pin_defs.h	330;"	d
+LED	pin_defs.h	332;"	d
+LED	pin_defs.h	336;"	d
+LED	pin_defs.h	338;"	d
+LED	pin_defs.h	342;"	d
+LED	pin_defs.h	344;"	d
+LED	pin_defs.h	348;"	d
+LED	pin_defs.h	351;"	d
+LED	pin_defs.h	355;"	d
+LED	pin_defs.h	357;"	d
+LED	pin_defs.h	361;"	d
+LED	pin_defs.h	363;"	d
+LED	pin_defs.h	367;"	d
+LED	pin_defs.h	369;"	d
+LED	pin_defs.h	373;"	d
+LED	pin_defs.h	375;"	d
+LED	pin_defs.h	379;"	d
+LED	pin_defs.h	381;"	d
+LED	pin_defs.h	385;"	d
+LED	pin_defs.h	387;"	d
+LED	pin_defs.h	391;"	d
+LED	pin_defs.h	393;"	d
+LED	pin_defs.h	397;"	d
+LED	pin_defs.h	400;"	d
+LED	pin_defs.h	404;"	d
+LED	pin_defs.h	406;"	d
+LED	pin_defs.h	410;"	d
+LED	pin_defs.h	412;"	d
+LED	pin_defs.h	416;"	d
+LED	pin_defs.h	418;"	d
+LED	pin_defs.h	422;"	d
+LED	pin_defs.h	424;"	d
+LED	pin_defs.h	428;"	d
+LED	pin_defs.h	430;"	d
+LED	pin_defs.h	434;"	d
+LED	pin_defs.h	436;"	d
+LED	pin_defs.h	440;"	d
+LED	pin_defs.h	442;"	d
+LED	pin_defs.h	446;"	d
+LED	pin_defs.h	449;"	d
+LED	pin_defs.h	453;"	d
+LED	pin_defs.h	455;"	d
+LED	pin_defs.h	459;"	d
+LED	pin_defs.h	461;"	d
+LED	pin_defs.h	465;"	d
+LED	pin_defs.h	467;"	d
+LED	pin_defs.h	471;"	d
+LED	pin_defs.h	473;"	d
+LED	pin_defs.h	477;"	d
+LED	pin_defs.h	479;"	d
+LED	pin_defs.h	483;"	d
+LED	pin_defs.h	485;"	d
+LED	pin_defs.h	489;"	d
+LED	pin_defs.h	491;"	d
+LED	pin_defs.h	495;"	d
+LED	pin_defs.h	498;"	d
+LED	pin_defs.h	502;"	d
+LED	pin_defs.h	504;"	d
+LED	pin_defs.h	508;"	d
+LED	pin_defs.h	510;"	d
+LED	pin_defs.h	514;"	d
+LED	pin_defs.h	516;"	d
+LED	pin_defs.h	520;"	d
+LED	pin_defs.h	522;"	d
+LED	pin_defs.h	526;"	d
+LED	pin_defs.h	528;"	d
+LED	pin_defs.h	532;"	d
+LED	pin_defs.h	534;"	d
+LED	pin_defs.h	538;"	d
+LED	pin_defs.h	540;"	d
+LED	pin_defs.h	544;"	d
+LED	pin_defs.h	547;"	d
+LED	pin_defs.h	551;"	d
+LED	pin_defs.h	553;"	d
+LED	pin_defs.h	557;"	d
+LED	pin_defs.h	559;"	d
+LED	pin_defs.h	563;"	d
+LED	pin_defs.h	565;"	d
+LED	pin_defs.h	569;"	d
+LED	pin_defs.h	571;"	d
+LED	pin_defs.h	575;"	d
+LED	pin_defs.h	577;"	d
+LED	pin_defs.h	581;"	d
+LED	pin_defs.h	583;"	d
+LED	pin_defs.h	587;"	d
+LED	pin_defs.h	589;"	d
+LED	pin_defs.h	593;"	d
+LED	pin_defs.h	596;"	d
+LED	pin_defs.h	600;"	d
+LED	pin_defs.h	602;"	d
+LED	pin_defs.h	606;"	d
+LED	pin_defs.h	608;"	d
+LED	pin_defs.h	612;"	d
+LED	pin_defs.h	614;"	d
+LED	pin_defs.h	618;"	d
+LED	pin_defs.h	620;"	d
+LED	pin_defs.h	624;"	d
+LED	pin_defs.h	626;"	d
+LED	pin_defs.h	630;"	d
+LED	pin_defs.h	632;"	d
+LED	pin_defs.h	636;"	d
+LED	pin_defs.h	638;"	d
+LED	pin_defs.h	642;"	d
+LED	pin_defs.h	645;"	d
+LED	pin_defs.h	649;"	d
+LED	pin_defs.h	651;"	d
+LED	pin_defs.h	655;"	d
+LED	pin_defs.h	657;"	d
+LED	pin_defs.h	661;"	d
+LED	pin_defs.h	663;"	d
+LED	pin_defs.h	667;"	d
+LED	pin_defs.h	669;"	d
+LED	pin_defs.h	673;"	d
+LED	pin_defs.h	675;"	d
+LED	pin_defs.h	679;"	d
+LED	pin_defs.h	681;"	d
+LED	pin_defs.h	685;"	d
+LED	pin_defs.h	687;"	d
+LED	pin_defs.h	691;"	d
+LED	pin_defs.h	694;"	d
+LED	pin_defs.h	698;"	d
+LED	pin_defs.h	700;"	d
+LED	pin_defs.h	704;"	d
+LED	pin_defs.h	706;"	d
+LED	pin_defs.h	710;"	d
+LED	pin_defs.h	712;"	d
+LED	pin_defs.h	716;"	d
+LED	pin_defs.h	718;"	d
+LED	pin_defs.h	722;"	d
+LED	pin_defs.h	724;"	d
+LED	pin_defs.h	728;"	d
+LED	pin_defs.h	730;"	d
+LED	pin_defs.h	734;"	d
+LED	pin_defs.h	736;"	d
+LED	pin_defs.h	740;"	d
+LED	pin_defs.h	743;"	d
+LED	pin_defs.h	747;"	d
+LED	pin_defs.h	749;"	d
+LED	pin_defs.h	753;"	d
+LED	pin_defs.h	755;"	d
+LED	pin_defs.h	759;"	d
+LED	pin_defs.h	761;"	d
+LED	pin_defs.h	765;"	d
+LED	pin_defs.h	767;"	d
+LED	pin_defs.h	771;"	d
+LED	pin_defs.h	773;"	d
+LED	pin_defs.h	777;"	d
+LED	pin_defs.h	779;"	d
+LED	pin_defs.h	783;"	d
+LED	pin_defs.h	785;"	d
+LED	pin_defs.h	789;"	d
+LED	pin_defs.h	94;"	d
+LED_DDR	pin_defs.h	254;"	d
+LED_DDR	pin_defs.h	260;"	d
+LED_DDR	pin_defs.h	266;"	d
+LED_DDR	pin_defs.h	272;"	d
+LED_DDR	pin_defs.h	278;"	d
+LED_DDR	pin_defs.h	284;"	d
+LED_DDR	pin_defs.h	290;"	d
+LED_DDR	pin_defs.h	296;"	d
+LED_DDR	pin_defs.h	303;"	d
+LED_DDR	pin_defs.h	309;"	d
+LED_DDR	pin_defs.h	315;"	d
+LED_DDR	pin_defs.h	321;"	d
+LED_DDR	pin_defs.h	327;"	d
+LED_DDR	pin_defs.h	333;"	d
+LED_DDR	pin_defs.h	339;"	d
+LED_DDR	pin_defs.h	345;"	d
+LED_DDR	pin_defs.h	352;"	d
+LED_DDR	pin_defs.h	358;"	d
+LED_DDR	pin_defs.h	364;"	d
+LED_DDR	pin_defs.h	370;"	d
+LED_DDR	pin_defs.h	376;"	d
+LED_DDR	pin_defs.h	382;"	d
+LED_DDR	pin_defs.h	388;"	d
+LED_DDR	pin_defs.h	394;"	d
+LED_DDR	pin_defs.h	401;"	d
+LED_DDR	pin_defs.h	407;"	d
+LED_DDR	pin_defs.h	413;"	d
+LED_DDR	pin_defs.h	419;"	d
+LED_DDR	pin_defs.h	425;"	d
+LED_DDR	pin_defs.h	431;"	d
+LED_DDR	pin_defs.h	437;"	d
+LED_DDR	pin_defs.h	443;"	d
+LED_DDR	pin_defs.h	450;"	d
+LED_DDR	pin_defs.h	456;"	d
+LED_DDR	pin_defs.h	462;"	d
+LED_DDR	pin_defs.h	468;"	d
+LED_DDR	pin_defs.h	474;"	d
+LED_DDR	pin_defs.h	480;"	d
+LED_DDR	pin_defs.h	486;"	d
+LED_DDR	pin_defs.h	492;"	d
+LED_DDR	pin_defs.h	499;"	d
+LED_DDR	pin_defs.h	505;"	d
+LED_DDR	pin_defs.h	511;"	d
+LED_DDR	pin_defs.h	517;"	d
+LED_DDR	pin_defs.h	523;"	d
+LED_DDR	pin_defs.h	529;"	d
+LED_DDR	pin_defs.h	535;"	d
+LED_DDR	pin_defs.h	541;"	d
+LED_DDR	pin_defs.h	548;"	d
+LED_DDR	pin_defs.h	554;"	d
+LED_DDR	pin_defs.h	560;"	d
+LED_DDR	pin_defs.h	566;"	d
+LED_DDR	pin_defs.h	572;"	d
+LED_DDR	pin_defs.h	578;"	d
+LED_DDR	pin_defs.h	584;"	d
+LED_DDR	pin_defs.h	590;"	d
+LED_DDR	pin_defs.h	597;"	d
+LED_DDR	pin_defs.h	603;"	d
+LED_DDR	pin_defs.h	609;"	d
+LED_DDR	pin_defs.h	615;"	d
+LED_DDR	pin_defs.h	621;"	d
+LED_DDR	pin_defs.h	627;"	d
+LED_DDR	pin_defs.h	633;"	d
+LED_DDR	pin_defs.h	639;"	d
+LED_DDR	pin_defs.h	646;"	d
+LED_DDR	pin_defs.h	652;"	d
+LED_DDR	pin_defs.h	658;"	d
+LED_DDR	pin_defs.h	664;"	d
+LED_DDR	pin_defs.h	670;"	d
+LED_DDR	pin_defs.h	676;"	d
+LED_DDR	pin_defs.h	682;"	d
+LED_DDR	pin_defs.h	688;"	d
+LED_DDR	pin_defs.h	695;"	d
+LED_DDR	pin_defs.h	701;"	d
+LED_DDR	pin_defs.h	707;"	d
+LED_DDR	pin_defs.h	713;"	d
+LED_DDR	pin_defs.h	719;"	d
+LED_DDR	pin_defs.h	725;"	d
+LED_DDR	pin_defs.h	731;"	d
+LED_DDR	pin_defs.h	737;"	d
+LED_DDR	pin_defs.h	744;"	d
+LED_DDR	pin_defs.h	750;"	d
+LED_DDR	pin_defs.h	756;"	d
+LED_DDR	pin_defs.h	762;"	d
+LED_DDR	pin_defs.h	768;"	d
+LED_DDR	pin_defs.h	774;"	d
+LED_DDR	pin_defs.h	780;"	d
+LED_DDR	pin_defs.h	786;"	d
+LED_PIN	pin_defs.h	256;"	d
+LED_PIN	pin_defs.h	262;"	d
+LED_PIN	pin_defs.h	268;"	d
+LED_PIN	pin_defs.h	274;"	d
+LED_PIN	pin_defs.h	280;"	d
+LED_PIN	pin_defs.h	286;"	d
+LED_PIN	pin_defs.h	292;"	d
+LED_PIN	pin_defs.h	298;"	d
+LED_PIN	pin_defs.h	305;"	d
+LED_PIN	pin_defs.h	311;"	d
+LED_PIN	pin_defs.h	317;"	d
+LED_PIN	pin_defs.h	323;"	d
+LED_PIN	pin_defs.h	329;"	d
+LED_PIN	pin_defs.h	335;"	d
+LED_PIN	pin_defs.h	341;"	d
+LED_PIN	pin_defs.h	347;"	d
+LED_PIN	pin_defs.h	354;"	d
+LED_PIN	pin_defs.h	360;"	d
+LED_PIN	pin_defs.h	366;"	d
+LED_PIN	pin_defs.h	372;"	d
+LED_PIN	pin_defs.h	378;"	d
+LED_PIN	pin_defs.h	384;"	d
+LED_PIN	pin_defs.h	390;"	d
+LED_PIN	pin_defs.h	396;"	d
+LED_PIN	pin_defs.h	403;"	d
+LED_PIN	pin_defs.h	409;"	d
+LED_PIN	pin_defs.h	415;"	d
+LED_PIN	pin_defs.h	421;"	d
+LED_PIN	pin_defs.h	427;"	d
+LED_PIN	pin_defs.h	433;"	d
+LED_PIN	pin_defs.h	439;"	d
+LED_PIN	pin_defs.h	445;"	d
+LED_PIN	pin_defs.h	452;"	d
+LED_PIN	pin_defs.h	458;"	d
+LED_PIN	pin_defs.h	464;"	d
+LED_PIN	pin_defs.h	470;"	d
+LED_PIN	pin_defs.h	476;"	d
+LED_PIN	pin_defs.h	482;"	d
+LED_PIN	pin_defs.h	488;"	d
+LED_PIN	pin_defs.h	494;"	d
+LED_PIN	pin_defs.h	501;"	d
+LED_PIN	pin_defs.h	507;"	d
+LED_PIN	pin_defs.h	513;"	d
+LED_PIN	pin_defs.h	519;"	d
+LED_PIN	pin_defs.h	525;"	d
+LED_PIN	pin_defs.h	531;"	d
+LED_PIN	pin_defs.h	537;"	d
+LED_PIN	pin_defs.h	543;"	d
+LED_PIN	pin_defs.h	550;"	d
+LED_PIN	pin_defs.h	556;"	d
+LED_PIN	pin_defs.h	562;"	d
+LED_PIN	pin_defs.h	568;"	d
+LED_PIN	pin_defs.h	574;"	d
+LED_PIN	pin_defs.h	580;"	d
+LED_PIN	pin_defs.h	586;"	d
+LED_PIN	pin_defs.h	592;"	d
+LED_PIN	pin_defs.h	599;"	d
+LED_PIN	pin_defs.h	605;"	d
+LED_PIN	pin_defs.h	611;"	d
+LED_PIN	pin_defs.h	617;"	d
+LED_PIN	pin_defs.h	623;"	d
+LED_PIN	pin_defs.h	629;"	d
+LED_PIN	pin_defs.h	635;"	d
+LED_PIN	pin_defs.h	641;"	d
+LED_PIN	pin_defs.h	648;"	d
+LED_PIN	pin_defs.h	654;"	d
+LED_PIN	pin_defs.h	660;"	d
+LED_PIN	pin_defs.h	666;"	d
+LED_PIN	pin_defs.h	672;"	d
+LED_PIN	pin_defs.h	678;"	d
+LED_PIN	pin_defs.h	684;"	d
+LED_PIN	pin_defs.h	690;"	d
+LED_PIN	pin_defs.h	697;"	d
+LED_PIN	pin_defs.h	703;"	d
+LED_PIN	pin_defs.h	709;"	d
+LED_PIN	pin_defs.h	715;"	d
+LED_PIN	pin_defs.h	721;"	d
+LED_PIN	pin_defs.h	727;"	d
+LED_PIN	pin_defs.h	733;"	d
+LED_PIN	pin_defs.h	739;"	d
+LED_PIN	pin_defs.h	746;"	d
+LED_PIN	pin_defs.h	752;"	d
+LED_PIN	pin_defs.h	758;"	d
+LED_PIN	pin_defs.h	764;"	d
+LED_PIN	pin_defs.h	770;"	d
+LED_PIN	pin_defs.h	776;"	d
+LED_PIN	pin_defs.h	782;"	d
+LED_PIN	pin_defs.h	788;"	d
+LED_PORT	pin_defs.h	255;"	d
+LED_PORT	pin_defs.h	261;"	d
+LED_PORT	pin_defs.h	267;"	d
+LED_PORT	pin_defs.h	273;"	d
+LED_PORT	pin_defs.h	279;"	d
+LED_PORT	pin_defs.h	285;"	d
+LED_PORT	pin_defs.h	291;"	d
+LED_PORT	pin_defs.h	297;"	d
+LED_PORT	pin_defs.h	304;"	d
+LED_PORT	pin_defs.h	310;"	d
+LED_PORT	pin_defs.h	316;"	d
+LED_PORT	pin_defs.h	322;"	d
+LED_PORT	pin_defs.h	328;"	d
+LED_PORT	pin_defs.h	334;"	d
+LED_PORT	pin_defs.h	340;"	d
+LED_PORT	pin_defs.h	346;"	d
+LED_PORT	pin_defs.h	353;"	d
+LED_PORT	pin_defs.h	359;"	d
+LED_PORT	pin_defs.h	365;"	d
+LED_PORT	pin_defs.h	371;"	d
+LED_PORT	pin_defs.h	377;"	d
+LED_PORT	pin_defs.h	383;"	d
+LED_PORT	pin_defs.h	389;"	d
+LED_PORT	pin_defs.h	395;"	d
+LED_PORT	pin_defs.h	402;"	d
+LED_PORT	pin_defs.h	408;"	d
+LED_PORT	pin_defs.h	414;"	d
+LED_PORT	pin_defs.h	420;"	d
+LED_PORT	pin_defs.h	426;"	d
+LED_PORT	pin_defs.h	432;"	d
+LED_PORT	pin_defs.h	438;"	d
+LED_PORT	pin_defs.h	444;"	d
+LED_PORT	pin_defs.h	451;"	d
+LED_PORT	pin_defs.h	457;"	d
+LED_PORT	pin_defs.h	463;"	d
+LED_PORT	pin_defs.h	469;"	d
+LED_PORT	pin_defs.h	475;"	d
+LED_PORT	pin_defs.h	481;"	d
+LED_PORT	pin_defs.h	487;"	d
+LED_PORT	pin_defs.h	493;"	d
+LED_PORT	pin_defs.h	500;"	d
+LED_PORT	pin_defs.h	506;"	d
+LED_PORT	pin_defs.h	512;"	d
+LED_PORT	pin_defs.h	518;"	d
+LED_PORT	pin_defs.h	524;"	d
+LED_PORT	pin_defs.h	530;"	d
+LED_PORT	pin_defs.h	536;"	d
+LED_PORT	pin_defs.h	542;"	d
+LED_PORT	pin_defs.h	549;"	d
+LED_PORT	pin_defs.h	555;"	d
+LED_PORT	pin_defs.h	561;"	d
+LED_PORT	pin_defs.h	567;"	d
+LED_PORT	pin_defs.h	573;"	d
+LED_PORT	pin_defs.h	579;"	d
+LED_PORT	pin_defs.h	585;"	d
+LED_PORT	pin_defs.h	591;"	d
+LED_PORT	pin_defs.h	598;"	d
+LED_PORT	pin_defs.h	604;"	d
+LED_PORT	pin_defs.h	610;"	d
+LED_PORT	pin_defs.h	616;"	d
+LED_PORT	pin_defs.h	622;"	d
+LED_PORT	pin_defs.h	628;"	d
+LED_PORT	pin_defs.h	634;"	d
+LED_PORT	pin_defs.h	640;"	d
+LED_PORT	pin_defs.h	647;"	d
+LED_PORT	pin_defs.h	653;"	d
+LED_PORT	pin_defs.h	659;"	d
+LED_PORT	pin_defs.h	665;"	d
+LED_PORT	pin_defs.h	671;"	d
+LED_PORT	pin_defs.h	677;"	d
+LED_PORT	pin_defs.h	683;"	d
+LED_PORT	pin_defs.h	689;"	d
+LED_PORT	pin_defs.h	696;"	d
+LED_PORT	pin_defs.h	702;"	d
+LED_PORT	pin_defs.h	708;"	d
+LED_PORT	pin_defs.h	714;"	d
+LED_PORT	pin_defs.h	720;"	d
+LED_PORT	pin_defs.h	726;"	d
+LED_PORT	pin_defs.h	732;"	d
+LED_PORT	pin_defs.h	738;"	d
+LED_PORT	pin_defs.h	745;"	d
+LED_PORT	pin_defs.h	751;"	d
+LED_PORT	pin_defs.h	757;"	d
+LED_PORT	pin_defs.h	763;"	d
+LED_PORT	pin_defs.h	769;"	d
+LED_PORT	pin_defs.h	775;"	d
+LED_PORT	pin_defs.h	781;"	d
+LED_PORT	pin_defs.h	787;"	d
+LED_START_FLASHES	main.c	19;"	d	file:
+OPTIBOOT_MAJVER	main.c	15;"	d	file:
+OPTIBOOT_MINVER	main.c	16;"	d	file:
+PWM_ADJUST_OK	stk500.h	16;"	d
+PWM_CHANNEL_ERROR	stk500.h	15;"	d
+Prescaler	i2c.c	11;"	d	file:
+RXC0	pin_defs.h	79;"	d
+STK_CHECK_AUTOINC	stk500.h	27;"	d
+STK_CHIP_ERASE	stk500.h	26;"	d
+STK_ENTER_PROGMODE	stk500.h	24;"	d
+STK_FAILED	stk500.h	8;"	d
+STK_GET_PARAMETER	stk500.h	21;"	d
+STK_GET_SIGN_ON	stk500.h	19;"	d
+STK_GET_SYNC	stk500.h	18;"	d
+STK_INSYNC	stk500.h	11;"	d
+STK_LEAVE_PROGMODE	stk500.h	25;"	d
+STK_LOAD_ADDRESS	stk500.h	28;"	d
+STK_NODEVICE	stk500.h	10;"	d
+STK_NOSYNC	stk500.h	12;"	d
+STK_OK	stk500.h	7;"	d
+STK_PROG_DATA	stk500.h	31;"	d
+STK_PROG_FLASH	stk500.h	30;"	d
+STK_PROG_FUSE	stk500.h	32;"	d
+STK_PROG_FUSE_EXT	stk500.h	35;"	d
+STK_PROG_LOCK	stk500.h	33;"	d
+STK_PROG_PAGE	stk500.h	34;"	d
+STK_READ_DATA	stk500.h	37;"	d
+STK_READ_FLASH	stk500.h	36;"	d
+STK_READ_FUSE	stk500.h	38;"	d
+STK_READ_FUSE_EXT	stk500.h	43;"	d
+STK_READ_LOCK	stk500.h	39;"	d
+STK_READ_OSCCAL	stk500.h	42;"	d
+STK_READ_OSCCAL_EXT	stk500.h	44;"	d
+STK_READ_PAGE	stk500.h	40;"	d
+STK_READ_SIGN	stk500.h	41;"	d
+STK_SET_DEVICE	stk500.h	22;"	d
+STK_SET_DEVICE_EXT	stk500.h	23;"	d
+STK_SET_PARAMETER	stk500.h	20;"	d
+STK_SW_MAJOR	stk500.h	45;"	d
+STK_SW_MINOR	stk500.h	46;"	d
+STK_UNIVERSAL	stk500.h	29;"	d
+STK_UNKNOWN	stk500.h	9;"	d
+TIFR1	pin_defs.h	81;"	d
+TWBR_val	i2c.c	12;"	d	file:
+UART_DDR	pin_defs.h	101;"	d
+UART_DDR	pin_defs.h	120;"	d
+UART_DDR	pin_defs.h	139;"	d
+UART_DDR	pin_defs.h	28;"	d
+UART_PIN	pin_defs.h	100;"	d
+UART_PIN	pin_defs.h	119;"	d
+UART_PIN	pin_defs.h	138;"	d
+UART_PIN	pin_defs.h	27;"	d
+UART_PORT	pin_defs.h	118;"	d
+UART_PORT	pin_defs.h	137;"	d
+UART_PORT	pin_defs.h	26;"	d
+UART_PORT	pin_defs.h	99;"	d
+UART_RX_BIT	pin_defs.h	103;"	d
+UART_RX_BIT	pin_defs.h	122;"	d
+UART_RX_BIT	pin_defs.h	141;"	d
+UART_RX_BIT	pin_defs.h	30;"	d
+UART_SRA	pin_defs.h	40;"	d
+UART_SRA	pin_defs.h	49;"	d
+UART_SRA	pin_defs.h	58;"	d
+UART_SRA	pin_defs.h	67;"	d
+UART_SRB	pin_defs.h	41;"	d
+UART_SRB	pin_defs.h	50;"	d
+UART_SRB	pin_defs.h	59;"	d
+UART_SRB	pin_defs.h	68;"	d
+UART_SRC	pin_defs.h	42;"	d
+UART_SRC	pin_defs.h	51;"	d
+UART_SRC	pin_defs.h	60;"	d
+UART_SRC	pin_defs.h	69;"	d
+UART_SRL	pin_defs.h	43;"	d
+UART_SRL	pin_defs.h	52;"	d
+UART_SRL	pin_defs.h	61;"	d
+UART_SRL	pin_defs.h	70;"	d
+UART_TX_BIT	pin_defs.h	102;"	d
+UART_TX_BIT	pin_defs.h	121;"	d
+UART_TX_BIT	pin_defs.h	140;"	d
+UART_TX_BIT	pin_defs.h	29;"	d
+UART_UDR	pin_defs.h	44;"	d
+UART_UDR	pin_defs.h	53;"	d
+UART_UDR	pin_defs.h	62;"	d
+UART_UDR	pin_defs.h	71;"	d
+UCSR0A	pin_defs.h	76;"	d
+UDR0	pin_defs.h	77;"	d
+UDRE0	pin_defs.h	78;"	d
+USART_BAUD	uart.c	6;"	d	file:
+WATCHDOG_1S	main.c	27;"	d	file:
+WATCHDOG_OFF	main.c	28;"	d	file:
+WDCE	pin_defs.h	85;"	d
+WDTCSR	pin_defs.h	82;"	d
+_AVR_BOOT_H_	boot.h	43;"	d
+__BOOT_LOCK_BITS_SET	boot.h	209;"	d
+__BOOT_PAGE_ERASE	boot.h	205;"	d
+__BOOT_PAGE_FILL	boot.h	207;"	d
+__BOOT_PAGE_WRITE	boot.h	206;"	d
+__BOOT_RWW_ENABLE	boot.h	208;"	d
+__BOOT_SIGROW_READ	boot.h	663;"	d
+__COMMON_ASB	boot.h	151;"	d
+__COMMON_ASB	boot.h	153;"	d
+__COMMON_ASRE	boot.h	157;"	d
+__COMMON_ASRE	boot.h	159;"	d
+__SPM_ENABLE	boot.h	132;"	d
+__SPM_ENABLE	boot.h	134;"	d
+__SPM_REG	boot.h	122;"	d
+__SPM_REG	boot.h	124;"	d
+__UART_H_	uart.h	2;"	d
+__boot_lock_bits_set	boot.h	526;"	d
+__boot_lock_bits_set_alternate	boot.h	544;"	d
+__boot_lock_bits_set_short	boot.h	508;"	d
+__boot_page_erase_alternate	boot.h	331;"	d
+__boot_page_erase_extended	boot.h	346;"	d
+__boot_page_erase_extended_short	boot.h	362;"	d
+__boot_page_erase_normal	boot.h	318;"	d
+__boot_page_erase_short	boot.h	304;"	d
+__boot_page_fill_alternate	boot.h	245;"	d
+__boot_page_fill_extended	boot.h	264;"	d
+__boot_page_fill_extended_short	boot.h	284;"	d
+__boot_page_fill_normal	boot.h	228;"	d
+__boot_page_fill_short	boot.h	211;"	d
+__boot_page_write_alternate	boot.h	405;"	d
+__boot_page_write_extended	boot.h	420;"	d
+__boot_page_write_extended_short	boot.h	436;"	d
+__boot_page_write_normal	boot.h	392;"	d
+__boot_page_write_short	boot.h	379;"	d
+__boot_rww_enable	boot.h	465;"	d
+__boot_rww_enable_alternate	boot.h	477;"	d
+__boot_rww_enable_short	boot.h	453;"	d
+appstart_vec	main.c	26;"	d	file:
+boot_is_spm_interrupt	boot.h	185;"	d
+boot_lock_bits_set	boot.h	766;"	d
+boot_lock_bits_set	boot.h	775;"	d
+boot_lock_bits_set	boot.h	784;"	d
+boot_lock_bits_set_safe	boot.h	841;"	d
+boot_lock_fuse_bits_get	boot.h	634;"	d
+boot_lock_fuse_bits_get_short	boot.h	616;"	d
+boot_page_erase	boot.h	763;"	d
+boot_page_erase	boot.h	772;"	d
+boot_page_erase	boot.h	781;"	d
+boot_page_erase_safe	boot.h	805;"	d
+boot_page_fill	boot.h	762;"	d
+boot_page_fill	boot.h	771;"	d
+boot_page_fill	boot.h	780;"	d
+boot_page_fill_safe	boot.h	793;"	d
+boot_page_write	boot.h	764;"	d
+boot_page_write	boot.h	773;"	d
+boot_page_write	boot.h	782;"	d
+boot_page_write_safe	boot.h	817;"	d
+boot_rww_busy	boot.h	191;"	d
+boot_rww_enable	boot.h	765;"	d
+boot_rww_enable	boot.h	774;"	d
+boot_rww_enable	boot.h	783;"	d
+boot_rww_enable_safe	boot.h	829;"	d
+boot_signature_byte_get	boot.h	681;"	d
+boot_signature_byte_get_short	boot.h	665;"	d
+boot_spm_busy	boot.h	197;"	d
+boot_spm_busy_wait	boot.h	203;"	d
+boot_spm_interrupt_disable	boot.h	179;"	d
+boot_spm_interrupt_enable	boot.h	173;"	d
+buff	main.c	/^uint8_t  buff[200];\/\/    ((uint8_t*)(RAMSTART + 300))$/;"	v
+getch	uart.c	/^uint8_t getch(void)$/;"	f
+i2c_init	i2c.c	/^void i2c_init(void)$/;"	f
+i2c_readReg	i2c.c	/^uint8_t i2c_readReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t length)$/;"	f
+i2c_read_ack	i2c.c	/^uint8_t i2c_read_ack(void)$/;"	f
+i2c_read_nack	i2c.c	/^uint8_t i2c_read_nack(void)$/;"	f
+i2c_receive	i2c.c	/^uint8_t i2c_receive(uint8_t address, uint8_t* data, uint16_t length)$/;"	f
+i2c_start	i2c.c	/^uint8_t i2c_start(uint8_t address)$/;"	f
+i2c_stop	i2c.c	/^void i2c_stop(void)$/;"	f
+i2c_transmit	i2c.c	/^uint8_t i2c_transmit(uint8_t address, uint8_t* data, uint16_t length)$/;"	f
+i2c_write	i2c.c	/^uint8_t i2c_write(uint8_t data)$/;"	f
+i2c_writeReg	i2c.c	/^uint8_t i2c_writeReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t length)$/;"	f
+main	main.c	/^int main()$/;"	f
+pagelen_t	main.c	/^typedef uint8_t pagelen_t;$/;"	t	file:
+putch	uart.c	/^void putch(uint8_t c)$/;"	f
+save_vect_num	main.c	24;"	d	file:
+uart_init	uart.c	/^void uart_init()$/;"	f

arduino_dualboot_bootloader/uart.c

@@ -0,0 +1,29 @@
+#include<avr/io.h>
+#define F_CPU 16000000UL
+#include <util/delay.h>
+#include "uart.h"
+
+#define USART_BAUD 	115200UL
+#define BAUDRATE	(F_CPU/(8UL*USART_BAUD))-1
+
+void uart_init()
+{
+	/* Set baud rate */
+	UBRR0H = (uint8_t) ((BAUDRATE) >> 8);
+	UBRR0L = (uint8_t) BAUDRATE;
+	UCSR0B = (1 << RXEN0) | (1 << TXEN0);	// | (1 << RXCIE0);
+	UCSR0C = (3 << UCSZ00);
+	UCSR0A = 1 << U2X0;
+}
+
+void putch(uint8_t c)
+{
+	while (!(UCSR0A & (1 << UDRE0))) ;
+	UDR0 = c;
+}
+
+uint8_t getch(void)
+{
+	while (!(UCSR0A & (1 << RXC0))) ;
+	return UDR0;
+}

arduino_dualboot_bootloader/uart.h

@@ -0,0 +1,12 @@
+#ifndef __UART_H_
+#define __UART_H_
+
+/*===========================================================================
+ * Function declaration
+ *===========================================================================*/
+void putch(uint8_t);
+uint8_t getch();
+void uart_init();
+
+#endif //#ifndef __UART_H_
+