2011-12-29 00:34:05 +01:00
|
|
|
// ArduinoISP version 04m3
|
|
|
|
// Copyright (c) 2008-2011 Randall Bohn
|
2013-10-21 09:58:40 +02:00
|
|
|
// If you require a license, see
|
2011-12-29 00:34:05 +01:00
|
|
|
// http://www.opensource.org/licenses/bsd-license.php
|
|
|
|
//
|
|
|
|
// This sketch turns the Arduino into a AVRISP
|
|
|
|
// using the following arduino pins:
|
|
|
|
//
|
|
|
|
// pin name: not-mega: mega(1280 and 2560)
|
2013-10-21 09:58:40 +02:00
|
|
|
// slave reset: 10: 53
|
|
|
|
// MOSI: 11: 51
|
|
|
|
// MISO: 12: 50
|
|
|
|
// SCK: 13: 52
|
2011-12-29 00:34:05 +01:00
|
|
|
//
|
2009-11-01 18:00:31 +01:00
|
|
|
// Put an LED (with resistor) on the following pins:
|
2011-12-29 00:34:05 +01:00
|
|
|
// 9: Heartbeat - shows the programmer is running
|
|
|
|
// 8: Error - Lights up if something goes wrong (use red if that makes sense)
|
2009-11-01 18:00:31 +01:00
|
|
|
// 7: Programming - In communication with the slave
|
|
|
|
//
|
2011-12-29 00:34:05 +01:00
|
|
|
// 23 July 2011 Randall Bohn
|
|
|
|
// -Address Arduino issue 509 :: Portability of ArduinoISP
|
|
|
|
// http://code.google.com/p/arduino/issues/detail?id=509
|
|
|
|
//
|
|
|
|
// October 2010 by Randall Bohn
|
|
|
|
// - Write to EEPROM > 256 bytes
|
|
|
|
// - Better use of LEDs:
|
|
|
|
// -- Flash LED_PMODE on each flash commit
|
|
|
|
// -- Flash LED_PMODE while writing EEPROM (both give visual feedback of writing progress)
|
|
|
|
// - Light LED_ERR whenever we hit a STK_NOSYNC. Turn it off when back in sync.
|
|
|
|
// - Use pins_arduino.h (should also work on Arduino Mega)
|
|
|
|
//
|
2009-11-01 18:00:31 +01:00
|
|
|
// October 2009 by David A. Mellis
|
|
|
|
// - Added support for the read signature command
|
2013-10-21 09:58:40 +02:00
|
|
|
//
|
2009-11-01 18:00:31 +01:00
|
|
|
// February 2009 by Randall Bohn
|
|
|
|
// - Added support for writing to EEPROM (what took so long?)
|
|
|
|
// Windows users should consider WinAVR's avrdude instead of the
|
|
|
|
// avrdude included with Arduino software.
|
|
|
|
//
|
|
|
|
// January 2008 by Randall Bohn
|
|
|
|
// - Thanks to Amplificar for helping me with the STK500 protocol
|
|
|
|
// - The AVRISP/STK500 (mk I) protocol is used in the arduino bootloader
|
2013-10-21 09:58:40 +02:00
|
|
|
// - The SPI functions herein were developed for the AVR910_ARD programmer
|
2009-11-01 18:00:31 +01:00
|
|
|
// - More information at http://code.google.com/p/mega-isp
|
|
|
|
|
2011-12-29 00:34:05 +01:00
|
|
|
#include "pins_arduino.h"
|
|
|
|
#define RESET SS
|
2009-11-01 18:00:31 +01:00
|
|
|
|
2011-12-29 00:34:05 +01:00
|
|
|
#define LED_HB 9
|
|
|
|
#define LED_ERR 8
|
2009-11-01 18:00:31 +01:00
|
|
|
#define LED_PMODE 7
|
2011-12-29 00:34:05 +01:00
|
|
|
#define PROG_FLICKER true
|
2009-11-01 18:00:31 +01:00
|
|
|
|
|
|
|
#define HWVER 2
|
|
|
|
#define SWMAJ 1
|
|
|
|
#define SWMIN 18
|
|
|
|
|
|
|
|
// STK Definitions
|
2011-12-29 00:34:05 +01:00
|
|
|
#define STK_OK 0x10
|
|
|
|
#define STK_FAILED 0x11
|
2009-11-01 18:00:31 +01:00
|
|
|
#define STK_UNKNOWN 0x12
|
2011-12-29 00:34:05 +01:00
|
|
|
#define STK_INSYNC 0x14
|
|
|
|
#define STK_NOSYNC 0x15
|
|
|
|
#define CRC_EOP 0x20 //ok it is a space...
|
2009-11-01 18:00:31 +01:00
|
|
|
|
|
|
|
void pulse(int pin, int times);
|
|
|
|
|
|
|
|
void setup() {
|
2012-02-18 15:18:29 +01:00
|
|
|
Serial.begin(9600);
|
2011-12-29 00:34:05 +01:00
|
|
|
pinMode(LED_PMODE, OUTPUT);
|
|
|
|
pulse(LED_PMODE, 2);
|
|
|
|
pinMode(LED_ERR, OUTPUT);
|
|
|
|
pulse(LED_ERR, 2);
|
|
|
|
pinMode(LED_HB, OUTPUT);
|
|
|
|
pulse(LED_HB, 2);
|
2009-11-01 18:00:31 +01:00
|
|
|
}
|
|
|
|
|
2013-10-21 09:58:40 +02:00
|
|
|
int error = 0;
|
|
|
|
int pmode = 0;
|
2009-11-01 18:00:31 +01:00
|
|
|
// address for reading and writing, set by 'U' command
|
|
|
|
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;
|
2012-01-31 13:51:18 +01:00
|
|
|
uint8_t flashpoll;
|
|
|
|
uint16_t eeprompoll;
|
|
|
|
uint16_t pagesize;
|
|
|
|
uint16_t eepromsize;
|
|
|
|
uint32_t flashsize;
|
|
|
|
}
|
2009-11-01 18:00:31 +01:00
|
|
|
parameter;
|
|
|
|
|
|
|
|
parameter param;
|
|
|
|
|
|
|
|
// this provides a heartbeat on pin 9, so you can tell the software is running.
|
2013-10-21 09:58:40 +02:00
|
|
|
uint8_t hbval = 128;
|
|
|
|
int8_t hbdelta = 8;
|
2009-11-01 18:00:31 +01:00
|
|
|
void heartbeat() {
|
2015-07-06 15:18:33 +02:00
|
|
|
if (hbval > 192) {
|
|
|
|
hbdelta = -hbdelta;
|
|
|
|
}
|
|
|
|
if (hbval < 32) {
|
|
|
|
hbdelta = -hbdelta;
|
|
|
|
}
|
2009-11-01 18:00:31 +01:00
|
|
|
hbval += hbdelta;
|
|
|
|
analogWrite(LED_HB, hbval);
|
2012-03-16 00:00:24 +01:00
|
|
|
delay(20);
|
2009-11-01 18:00:31 +01:00
|
|
|
}
|
2011-12-29 00:34:05 +01:00
|
|
|
|
2009-11-01 18:00:31 +01:00
|
|
|
|
|
|
|
void loop(void) {
|
|
|
|
// is pmode active?
|
2015-07-06 15:18:33 +02:00
|
|
|
if (pmode) {
|
|
|
|
digitalWrite(LED_PMODE, HIGH);
|
|
|
|
} else {
|
|
|
|
digitalWrite(LED_PMODE, LOW);
|
|
|
|
}
|
2009-11-01 18:00:31 +01:00
|
|
|
// is there an error?
|
2015-07-06 15:18:33 +02:00
|
|
|
if (error) {
|
|
|
|
digitalWrite(LED_ERR, HIGH);
|
|
|
|
} else {
|
|
|
|
digitalWrite(LED_ERR, LOW);
|
|
|
|
}
|
2011-12-29 00:34:05 +01:00
|
|
|
|
2009-11-01 18:00:31 +01:00
|
|
|
// light the heartbeat LED
|
|
|
|
heartbeat();
|
|
|
|
if (Serial.available()) {
|
|
|
|
avrisp();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
uint8_t getch() {
|
2013-10-21 09:58:40 +02:00
|
|
|
while (!Serial.available());
|
2009-11-01 18:00:31 +01:00
|
|
|
return Serial.read();
|
|
|
|
}
|
2011-12-29 00:34:05 +01:00
|
|
|
void fill(int n) {
|
2009-11-01 18:00:31 +01:00
|
|
|
for (int x = 0; x < n; x++) {
|
2011-12-29 00:34:05 +01:00
|
|
|
buff[x] = getch();
|
2009-11-01 18:00:31 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#define PTIME 30
|
|
|
|
void pulse(int pin, int times) {
|
|
|
|
do {
|
|
|
|
digitalWrite(pin, HIGH);
|
|
|
|
delay(PTIME);
|
|
|
|
digitalWrite(pin, LOW);
|
|
|
|
delay(PTIME);
|
2015-07-06 15:18:33 +02:00
|
|
|
} while (times--);
|
2009-11-01 18:00:31 +01:00
|
|
|
}
|
|
|
|
|
2011-12-29 00:34:05 +01:00
|
|
|
void prog_lamp(int state) {
|
2015-07-06 15:18:33 +02:00
|
|
|
if (PROG_FLICKER) {
|
2011-12-29 00:34:05 +01:00
|
|
|
digitalWrite(LED_PMODE, state);
|
2015-07-06 15:18:33 +02:00
|
|
|
}
|
2011-12-29 00:34:05 +01:00
|
|
|
}
|
|
|
|
|
2009-11-01 18:00:31 +01:00
|
|
|
void spi_init() {
|
|
|
|
uint8_t x;
|
|
|
|
SPCR = 0x53;
|
2013-10-21 09:58:40 +02:00
|
|
|
x = SPSR;
|
|
|
|
x = SPDR;
|
2009-11-01 18:00:31 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void spi_wait() {
|
|
|
|
do {
|
2015-07-06 15:18:33 +02:00
|
|
|
} while (!(SPSR & (1 << SPIF)));
|
2009-11-01 18:00:31 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
uint8_t spi_send(uint8_t b) {
|
|
|
|
uint8_t reply;
|
2013-10-21 09:58:40 +02:00
|
|
|
SPDR = b;
|
2009-11-01 18:00:31 +01:00
|
|
|
spi_wait();
|
|
|
|
reply = SPDR;
|
|
|
|
return reply;
|
|
|
|
}
|
|
|
|
|
|
|
|
uint8_t spi_transaction(uint8_t a, uint8_t b, uint8_t c, uint8_t d) {
|
|
|
|
uint8_t n;
|
2013-10-21 09:58:40 +02:00
|
|
|
spi_send(a);
|
|
|
|
n = spi_send(b);
|
2009-11-01 18:00:31 +01:00
|
|
|
//if (n != a) error = -1;
|
2013-10-21 09:58:40 +02:00
|
|
|
n = spi_send(c);
|
2009-11-01 18:00:31 +01:00
|
|
|
return spi_send(d);
|
|
|
|
}
|
|
|
|
|
|
|
|
void empty_reply() {
|
|
|
|
if (CRC_EOP == getch()) {
|
|
|
|
Serial.print((char)STK_INSYNC);
|
|
|
|
Serial.print((char)STK_OK);
|
2015-07-06 15:18:33 +02:00
|
|
|
} else {
|
2011-12-29 00:34:05 +01:00
|
|
|
error++;
|
2009-11-01 18:00:31 +01:00
|
|
|
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);
|
2015-07-06 15:18:33 +02:00
|
|
|
} else {
|
2011-12-29 00:34:05 +01:00
|
|
|
error++;
|
2009-11-01 18:00:31 +01:00
|
|
|
Serial.print((char)STK_NOSYNC);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void get_version(uint8_t c) {
|
2013-10-21 09:58:40 +02:00
|
|
|
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);
|
2009-11-01 18:00:31 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void set_parameters() {
|
|
|
|
// call this after reading paramter packet into buff[]
|
|
|
|
param.devicecode = buff[0];
|
2011-12-29 00:34:05 +01:00
|
|
|
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];
|
2013-10-21 09:58:40 +02:00
|
|
|
param.flashpoll = buff[8];
|
2009-11-01 18:00:31 +01:00
|
|
|
// ignore buff[9] (= buff[8])
|
|
|
|
// following are 16 bits (big endian)
|
|
|
|
param.eeprompoll = beget16(&buff[10]);
|
2011-12-29 00:34:05 +01:00
|
|
|
param.pagesize = beget16(&buff[12]);
|
2009-11-01 18:00:31 +01:00
|
|
|
param.eepromsize = beget16(&buff[14]);
|
|
|
|
|
|
|
|
// 32 bits flashsize (big endian)
|
|
|
|
param.flashsize = buff[16] * 0x01000000
|
2013-10-21 09:58:40 +02:00
|
|
|
+ buff[17] * 0x00010000
|
|
|
|
+ buff[18] * 0x00000100
|
|
|
|
+ buff[19];
|
2009-11-01 18:00:31 +01:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
void start_pmode() {
|
|
|
|
spi_init();
|
|
|
|
// following delays may not work on all targets...
|
|
|
|
pinMode(RESET, OUTPUT);
|
|
|
|
digitalWrite(RESET, HIGH);
|
|
|
|
pinMode(SCK, OUTPUT);
|
|
|
|
digitalWrite(SCK, LOW);
|
|
|
|
delay(50);
|
|
|
|
digitalWrite(RESET, LOW);
|
|
|
|
delay(50);
|
|
|
|
pinMode(MISO, INPUT);
|
|
|
|
pinMode(MOSI, OUTPUT);
|
|
|
|
spi_transaction(0xAC, 0x53, 0x00, 0x00);
|
|
|
|
pmode = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
void end_pmode() {
|
|
|
|
pinMode(MISO, INPUT);
|
|
|
|
pinMode(MOSI, INPUT);
|
|
|
|
pinMode(SCK, INPUT);
|
|
|
|
pinMode(RESET, INPUT);
|
|
|
|
pmode = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void universal() {
|
|
|
|
int w;
|
|
|
|
uint8_t ch;
|
|
|
|
|
2011-12-29 00:34:05 +01:00
|
|
|
fill(4);
|
2009-11-01 18:00:31 +01:00
|
|
|
ch = spi_transaction(buff[0], buff[1], buff[2], buff[3]);
|
|
|
|
breply(ch);
|
|
|
|
}
|
|
|
|
|
|
|
|
void flash(uint8_t hilo, int addr, uint8_t data) {
|
2013-10-21 09:58:40 +02:00
|
|
|
spi_transaction(0x40 + 8 * hilo,
|
|
|
|
addr >> 8 & 0xFF,
|
|
|
|
addr & 0xFF,
|
|
|
|
data);
|
2009-11-01 18:00:31 +01:00
|
|
|
}
|
|
|
|
void commit(int addr) {
|
2015-07-06 15:18:33 +02:00
|
|
|
if (PROG_FLICKER) {
|
|
|
|
prog_lamp(LOW);
|
|
|
|
}
|
2009-11-01 18:00:31 +01:00
|
|
|
spi_transaction(0x4C, (addr >> 8) & 0xFF, addr & 0xFF, 0);
|
2011-12-29 00:34:05 +01:00
|
|
|
if (PROG_FLICKER) {
|
|
|
|
delay(PTIME);
|
|
|
|
prog_lamp(HIGH);
|
|
|
|
}
|
2009-11-01 18:00:31 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
//#define _current_page(x) (here & 0xFFFFE0)
|
|
|
|
int current_page(int addr) {
|
2015-07-06 15:18:33 +02:00
|
|
|
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;
|
|
|
|
}
|
2009-11-01 18:00:31 +01:00
|
|
|
return here;
|
|
|
|
}
|
2011-12-29 00:34:05 +01:00
|
|
|
|
|
|
|
|
|
|
|
void write_flash(int length) {
|
|
|
|
fill(length);
|
|
|
|
if (CRC_EOP == getch()) {
|
|
|
|
Serial.print((char) STK_INSYNC);
|
|
|
|
Serial.print((char) write_flash_pages(length));
|
2015-07-06 15:18:33 +02:00
|
|
|
} else {
|
2011-12-29 00:34:05 +01:00
|
|
|
error++;
|
|
|
|
Serial.print((char) STK_NOSYNC);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
uint8_t write_flash_pages(int length) {
|
2009-11-01 18:00:31 +01:00
|
|
|
int x = 0;
|
2011-12-29 00:34:05 +01:00
|
|
|
int page = current_page(here);
|
2009-11-01 18:00:31 +01:00
|
|
|
while (x < length) {
|
|
|
|
if (page != current_page(here)) {
|
|
|
|
commit(page);
|
|
|
|
page = current_page(here);
|
|
|
|
}
|
|
|
|
flash(LOW, here, buff[x++]);
|
|
|
|
flash(HIGH, here, buff[x++]);
|
|
|
|
here++;
|
|
|
|
}
|
|
|
|
|
|
|
|
commit(page);
|
|
|
|
|
|
|
|
return STK_OK;
|
|
|
|
}
|
|
|
|
|
2011-12-29 00:34:05 +01:00
|
|
|
#define EECHUNK (32)
|
2009-11-01 18:00:31 +01:00
|
|
|
uint8_t write_eeprom(int length) {
|
2011-12-29 00:34:05 +01:00
|
|
|
// here is a word address, get the byte address
|
|
|
|
int start = here * 2;
|
|
|
|
int remaining = length;
|
|
|
|
if (length > param.eepromsize) {
|
|
|
|
error++;
|
|
|
|
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(int start, int length) {
|
2009-11-01 18:00:31 +01:00
|
|
|
// this writes byte-by-byte,
|
|
|
|
// page writing may be faster (4 bytes at a time)
|
2011-12-29 00:34:05 +01:00
|
|
|
fill(length);
|
|
|
|
prog_lamp(LOW);
|
2009-11-01 18:00:31 +01:00
|
|
|
for (int x = 0; x < length; x++) {
|
2013-10-21 09:58:40 +02:00
|
|
|
int addr = start + x;
|
|
|
|
spi_transaction(0xC0, (addr >> 8) & 0xFF, addr & 0xFF, buff[x]);
|
2009-11-01 18:00:31 +01:00
|
|
|
delay(45);
|
2011-12-29 00:34:05 +01:00
|
|
|
}
|
2013-10-21 09:58:40 +02:00
|
|
|
prog_lamp(HIGH);
|
2009-11-01 18:00:31 +01:00
|
|
|
return STK_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
void program_page() {
|
|
|
|
char result = (char) STK_FAILED;
|
2011-12-29 00:34:05 +01:00
|
|
|
int length = 256 * getch();
|
|
|
|
length += getch();
|
2009-11-01 18:00:31 +01:00
|
|
|
char memtype = getch();
|
2011-12-29 00:34:05 +01:00
|
|
|
// flash memory @here, (length) bytes
|
|
|
|
if (memtype == 'F') {
|
|
|
|
write_flash(length);
|
|
|
|
return;
|
2009-11-01 18:00:31 +01:00
|
|
|
}
|
2011-12-29 00:34:05 +01:00
|
|
|
if (memtype == 'E') {
|
|
|
|
result = (char)write_eeprom(length);
|
|
|
|
if (CRC_EOP == getch()) {
|
|
|
|
Serial.print((char) STK_INSYNC);
|
|
|
|
Serial.print(result);
|
2015-07-06 15:18:33 +02:00
|
|
|
} else {
|
2011-12-29 00:34:05 +01:00
|
|
|
error++;
|
|
|
|
Serial.print((char) STK_NOSYNC);
|
|
|
|
}
|
|
|
|
return;
|
2009-11-01 18:00:31 +01:00
|
|
|
}
|
2011-12-29 00:34:05 +01:00
|
|
|
Serial.print((char)STK_FAILED);
|
|
|
|
return;
|
2009-11-01 18:00:31 +01:00
|
|
|
}
|
2011-12-29 00:34:05 +01:00
|
|
|
|
2009-11-01 18:00:31 +01:00
|
|
|
uint8_t flash_read(uint8_t hilo, int addr) {
|
|
|
|
return spi_transaction(0x20 + hilo * 8,
|
2013-10-21 09:58:40 +02:00
|
|
|
(addr >> 8) & 0xFF,
|
|
|
|
addr & 0xFF,
|
|
|
|
0);
|
2009-11-01 18:00:31 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
char flash_read_page(int length) {
|
2013-10-21 09:58:40 +02:00
|
|
|
for (int x = 0; x < length; x += 2) {
|
2009-11-01 18:00:31 +01:00
|
|
|
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
|
2011-12-29 00:34:05 +01:00
|
|
|
int start = here * 2;
|
2009-11-01 18:00:31 +01:00
|
|
|
for (int x = 0; x < length; x++) {
|
2011-12-29 00:34:05 +01:00
|
|
|
int addr = start + x;
|
|
|
|
uint8_t ee = spi_transaction(0xA0, (addr >> 8) & 0xFF, addr & 0xFF, 0xFF);
|
2009-11-01 18:00:31 +01:00
|
|
|
Serial.print((char) ee);
|
|
|
|
}
|
|
|
|
return STK_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
void read_page() {
|
|
|
|
char result = (char)STK_FAILED;
|
2011-12-29 00:34:05 +01:00
|
|
|
int length = 256 * getch();
|
|
|
|
length += getch();
|
2009-11-01 18:00:31 +01:00
|
|
|
char memtype = getch();
|
|
|
|
if (CRC_EOP != getch()) {
|
2011-12-29 00:34:05 +01:00
|
|
|
error++;
|
2009-11-01 18:00:31 +01:00
|
|
|
Serial.print((char) STK_NOSYNC);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
Serial.print((char) STK_INSYNC);
|
2015-07-06 15:18:33 +02:00
|
|
|
if (memtype == 'F') {
|
|
|
|
result = flash_read_page(length);
|
|
|
|
}
|
|
|
|
if (memtype == 'E') {
|
|
|
|
result = eeprom_read_page(length);
|
|
|
|
}
|
2009-11-01 18:00:31 +01:00
|
|
|
Serial.print(result);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
void read_signature() {
|
|
|
|
if (CRC_EOP != getch()) {
|
2011-12-29 00:34:05 +01:00
|
|
|
error++;
|
2009-11-01 18:00:31 +01:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
//////////////////////////////////////////
|
|
|
|
//////////////////////////////////////////
|
|
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////
|
|
|
|
////////////////////////////////////
|
2013-10-21 09:58:40 +02:00
|
|
|
int avrisp() {
|
2009-11-01 18:00:31 +01:00
|
|
|
uint8_t data, low, high;
|
|
|
|
uint8_t ch = getch();
|
|
|
|
switch (ch) {
|
2013-10-21 09:58:40 +02:00
|
|
|
case '0': // signon
|
|
|
|
error = 0;
|
|
|
|
empty_reply();
|
|
|
|
break;
|
|
|
|
case '1':
|
|
|
|
if (getch() == CRC_EOP) {
|
|
|
|
Serial.print((char) STK_INSYNC);
|
|
|
|
Serial.print("AVR ISP");
|
|
|
|
Serial.print((char) STK_OK);
|
|
|
|
}
|
|
|
|
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':
|
2012-02-18 15:18:29 +01:00
|
|
|
if (pmode) {
|
|
|
|
pulse(LED_ERR, 3);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
start_pmode();
|
|
|
|
}
|
2013-10-21 09:58:40 +02:00
|
|
|
empty_reply();
|
|
|
|
break;
|
|
|
|
case 'U': // set address (word)
|
|
|
|
here = getch();
|
|
|
|
here += 256 * getch();
|
|
|
|
empty_reply();
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 0x60: //STK_PROG_FLASH
|
|
|
|
low = getch();
|
|
|
|
high = getch();
|
|
|
|
empty_reply();
|
|
|
|
break;
|
|
|
|
case 0x61: //STK_PROG_DATA
|
|
|
|
data = getch();
|
|
|
|
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
|
|
|
|
error = 0;
|
|
|
|
end_pmode();
|
|
|
|
empty_reply();
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 0x75: //STK_READ_SIGN 'u'
|
|
|
|
read_signature();
|
|
|
|
break;
|
|
|
|
|
2015-07-06 15:18:33 +02:00
|
|
|
// expecting a command, not CRC_EOP
|
|
|
|
// this is how we can get back in sync
|
2013-10-21 09:58:40 +02:00
|
|
|
case CRC_EOP:
|
|
|
|
error++;
|
|
|
|
Serial.print((char) STK_NOSYNC);
|
|
|
|
break;
|
2011-12-29 00:34:05 +01:00
|
|
|
|
2015-07-06 15:18:33 +02:00
|
|
|
// anything else we will return STK_UNKNOWN
|
2013-10-21 09:58:40 +02:00
|
|
|
default:
|
|
|
|
error++;
|
2015-07-06 15:18:33 +02:00
|
|
|
if (CRC_EOP == getch()) {
|
2013-10-21 09:58:40 +02:00
|
|
|
Serial.print((char)STK_UNKNOWN);
|
2015-07-06 15:18:33 +02:00
|
|
|
} else {
|
2013-10-21 09:58:40 +02:00
|
|
|
Serial.print((char)STK_NOSYNC);
|
2015-07-06 15:18:33 +02:00
|
|
|
}
|
2009-11-01 18:00:31 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-12-29 00:34:05 +01:00
|
|
|
|
|
|
|
|