More poking...no more joy.

Hmm. The waveforms look about right.

There wasn't any software that would drive the parallel port breakout cable that I built. (Yes, I know it's ironic given my previous statement about how I wasn't prepared to solder up another DB25!!)

So I ended up crashing together an app in OpenWatcom for DOS to do the grabbing, and a C# program to display the data. Talk about a technology clash! I think at this point unless anyone can point out the problem with the attached code I'm going to concede defeat! For now ;)

ChaN's programmer is looking a lot more like the next project. I have a couple of old TTL-stuffed boards that I've been meaning to get the hot-air gun aimed towards. The need for a '299 for the programmer means I might just do that this weekend.

All this to recover a £3.25 microcontroller? No! Just for the sheer amusement!!

Here's the final draft of the code. I've been over it so many times now I've gone codeblind so if you see any howlers please keep your derision to good-humoured banter :)

// XA1 XA0   Action when XTAL1 is Pulsed
// --- ---   ---------------------------
//  0   0    Load Flash or EEPROM Address (High or low address byte determined by BS1)
//  0   1    Load Data (High or Low data byte for Flash determined by BS1)
//  1   0    Load Command
//  1   1    No Action, Idle
//
const byte XA_LOAD_ADDR = B00;
const byte XA_LOAD_DATA = B01;
const byte XA_LOAD_CMND = B10;
const byte XA_NOP       = B11;

const byte CMD_ERASE      = B10000000;
const byte CMD_WRITE_FUSE = B01000000;
const byte CMD_READ_SIG   = B00001000;
const byte CMD_READ_FUSE  = B00000100;

#define DLY delayMicroseconds(100)

inline void SETB(byte x)
{
  PORTB |= _BV(x);
  DLY;
}
inline void SETD(byte x)
{
  PORTD |= _BV(x);
  DLY;
}

inline void CLRB(byte x)
{
  PORTB &= ~_BV(x);
  DLY;
}
inline void CLRD(byte x)
{
  PORTD &= ~_BV(x);
  DLY;
}


// PORTB

#define PIN_BS1 0
#define PIN_XA0 1
#define PIN_XA1 2
#define PIN_BS2 3
#define PIN_PAGEL 4
#define PIN_POWERTOCHIP 5

#define SET_BS1 SETB(PIN_BS1)
#define CLR_BS1 CLRB(PIN_BS1)

void SET_XA(byte xtal_action)
{
  PORTB &= ~(_BV(PIN_XA1)|_BV(PIN_XA0));
  PORTB |= xtal_action << PIN_XA0;
  DLY;
}

void CLR_XA()
{
  PORTB &= ~(_BV(PIN_XA1)|_BV(PIN_XA0));
  DLY;
}

#define SET_BS2 SETB(PIN_BS2)
#define CLR_BS2 CLRB(PIN_BS2)

#define SET_PAGEL SETB(PIN_PAGEL)
#define CLR_PAGEL CLRB(PIN_PAGEL)

#define SET_POWERTOCHIP SETB(PIN_POWERTOCHIP)
#define CLR_POWERTOCHIP CLRB(PIN_POWERTOCHIP)


// PORTD

#define PIN_XTAL1 2
#define PIN_RDYNOTBSY 3
#define PIN_OE 4
#define PIN_WR 5

//  <- PORTD3 rdy/bsy
//
void AWAIT_READY()
{
  while ((PIND & _BV(PIN_RDYNOTBSY)) == 1);
  long time = millis();
  while ((PIND & _BV(PIN_RDYNOTBSY)) == 0);
  Serial.println(millis()-time,DEC);
}

#define SET_OE SETD(PIN_OE)
#define CLR_OE CLRD(PIN_OE)

#define SET_WR SETD(PIN_WR)
#define CLR_WR CLRD(PIN_WR)

void PULSE_WR(bool wait = true);
void PULSE_WR(bool wait)
{
  PORTD &= ~_BV(PIN_WR);
  delayMicroseconds(100);
  PORTD |= _BV(PIN_WR);
  if (wait)
  {
    AWAIT_READY();
  }
}

#define SET_XTAL1 SETD(PIN_XTAL1)
#define CLR_XTAL1 CLRD(PIN_XTAL1)

void PULSE_XTAL(bool wait = true);
void PULSE_XTAL(bool wait)
{
  PORTD |= _BV(PIN_XTAL1);
  delayMicroseconds(100);
  PORTD &= ~_BV(PIN_XTAL1);
  if (wait)
  {
    AWAIT_READY();
  }
}

// <-> PORTD6...7 will be used as DATA6...7
// <-> PORTC0...5 will be used as DATA0...5
//
void SET_DATA_IN(void)
{
  DDRC &= B11000000;
  DDRD &= B00111111;
}

byte GET_DATA()
{
  return (PORTC & B00111111) | (PORTD & B11000000);
}

void SET_DATA(byte data)
{
  DDRC |= B00111111;
  PORTC = (PORTC & B11000000) | (data & B00111111);

  DDRD |= B11000000;
  PORTD = (PORTD & B00111111) | (data & B11000000);

  DLY;
}

//
//
//


void LOAD_COMMAND(byte command)
{
  SET_XA(XA_LOAD_CMND);
  SET_DATA(command);
  PULSE_XTAL(); 
  CLR_XA();
}

void LOAD_ADDRESS(byte address)
{
  SET_XA(XA_LOAD_ADDR);
  SET_DATA(address);
  PULSE_XTAL(); 
  CLR_XA();
}

void LOAD_DATA(byte data, bool low)
{
  SET_XA(XA_LOAD_DATA);
  if (!low)
  {
    SET_BS1;
  }
  SET_DATA(data);
  PULSE_XTAL(); 
  CLR_XA();
  CLR_BS1;
}

byte GET_SIG(byte offset)
{
  LOAD_COMMAND(CMD_READ_SIG);
  LOAD_ADDRESS(offset);
  SET_DATA_IN();
  CLR_OE;
  byte x = GET_DATA();
  SET_OE;
}

inline void PROG_ENABLE(void)
{
  SET_POWERTOCHIP;
  delayMicroseconds(100);
}

inline void PROG_DISABLE(void)
{
  CLR_POWERTOCHIP;
}

inline void PROG_ENABLE_PROPER(void)
{
  SET_XTAL1;
  CLR_XTAL1;
  SET_XTAL1;
  CLR_XTAL1;
  SET_XTAL1;
  CLR_XTAL1;

  SET_POWERTOCHIP;
}

//
//
//

void setup(void)
{
  Serial.begin(115200);

  // PORTB 5...0 all outputs. Zero the ports before setting them as outputs
  // to prevent spikes.
  //
  PORTB = 0;
  DDRB |= B00111111;

  // Not interested in DATA pins, they'll get set later as required
  //
  // PORTD0/1 are rx/tx: leave alone
  // PORTD3 is input
  // D6/7 are set on demand
  // the rest are output
  //
  PORTD = 0;
  DDRD = (DDRD & B11110111) | B00110100;

  // bring the active low pins to their inactive state.
  //
  SET_OE;
  SET_WR;
}


void loop(void)
{
  Serial.println("Fuser 1.0 Ready.");
  while(!Serial.available());
  if (Serial.read() == 'p')
  {
    Serial.println("Sig: ");

    PROG_ENABLE_PROPER();
    Serial.println(GET_SIG(0),HEX);
    Serial.println(GET_SIG(1),HEX);
    Serial.println(GET_SIG(2),HEX);
  }
  else
  {
    Serial.println("Burn: ");

    PROG_ENABLE();

    delay(2);

    Serial.println("Erase: ");

    LOAD_COMMAND(CMD_ERASE);
    PULSE_WR();

    Serial.println("Lo fuse: ");

    LOAD_COMMAND(CMD_WRITE_FUSE);
    LOAD_DATA(0xE1, true);
    PULSE_WR();

    Serial.println("Hi fuse: ");

    LOAD_COMMAND(CMD_WRITE_FUSE);
    LOAD_DATA(0x99, false);
    PULSE_WR();
  }

  PROG_DISABLE();
}