533 lines
16 KiB
C++
533 lines
16 KiB
C++
//####################################################################################################################################
|
|
//####################################################################################################################################
|
|
//####################################################################################################################################
|
|
//
|
|
// EEPROM Programmer - code for an Arduino Nano V3.0 && Arduino Uno (anys Atmega328) - Written by BM Devs (Bouletmarc)
|
|
//
|
|
// This software presents a 115200-8N1 serial port.
|
|
// It is made to Read/Write Data from EEPROM directly with the Arduino!
|
|
// This program is made to read 28pins Chips such as 27c256, 27sf512
|
|
//
|
|
// For more informations visit : https://www.github.com/bouletmarc/BMBurner/
|
|
//
|
|
//
|
|
//---------------------------------------------------------------------------------------------------------------------------------------------------------
|
|
// COMMANDS : | OUTPUTS : | DESC :
|
|
//---------------------------------------------------------------------------------------------------------------------------------------------------------
|
|
// 2 + R + "MMSB" + "MSB" + "LSB" + "CS" | "B1" + "B2" + "...B256" + "CS" | Reads 256 bytes of data from the EEPROM at address "MSB" + "LSB" ... On Chip Type 2
|
|
// 3 + W + "MMSB" + "MSB" + "LSB" + "B1" + "B2" + "..." + "CS" | "O" (0x4F) | Writes 256 bytes of data to the EEPROM at address "MSB" + "LSB", This output 'O' (0x79) for telling 'OK' ... On Chip Type 3
|
|
// 5 + E + "CS" | "O" (0x4F) | Erase all the data on Chip Type 5 (SST)
|
|
// V + CS (V+V) | "V1" + "V2" + "V3" | Prints the version bytes of the BMBurner PCB Board for Moates Compatibility (Ex: V5.1.0 = 0x05, 0x01, 0x00)
|
|
// V + F | "V1" + "V2" | Prints the version bytes of the BMBurner Firmware aka Arduino Project Version (Ex: V1.1 = 0x01, 0x01)
|
|
//
|
|
//**MMSB is always 0, this is only for compatibility with moates softwares on baud 115200, since the all chips arent more than 64KB (0xFFFF) there are no MMSB**
|
|
//####################################################################################################################################
|
|
//####################################################################################################################################
|
|
//####################################################################################################################################
|
|
|
|
byte BoardVersionBytes[] = {
|
|
5, 1, 0 //Burn2 Version = 5, 15, 70
|
|
};
|
|
|
|
byte FirmwareVersionBytes[] = {
|
|
1, 2
|
|
};
|
|
|
|
//Define chips predefinied model numbers (2-5 is for moates compatibility, 4 is never ever as it should be used for 27SF040 which is not compatible with this project at all)
|
|
unsigned int chipType;
|
|
#define CHIP27C128 1
|
|
#define CHIP27C256 2 //INCLUDED : 29C256, 27SF256
|
|
#define CHIP27C32 3 //INCLUDED : 2732A
|
|
#define CHIP27SF512 5 //INCLUDED : 27C512, W27E512, W27C512
|
|
#define CHIP28C64 6 //INCLUDED : 27C64
|
|
#define CHIP28C256 7
|
|
|
|
// define the IO lines for the data - bus
|
|
#define D0 2
|
|
#define D1 3
|
|
#define D2 4
|
|
#define D3 5
|
|
#define D4 6
|
|
#define D5 7
|
|
#define D6 8
|
|
#define D7 10
|
|
|
|
// for high voltage programming supply
|
|
#define VH 11 //Erase Pin (A9) 12v
|
|
#define VPP 12 //OE Pin = VPP 12v
|
|
|
|
// shiftOut part
|
|
#define DS A0
|
|
#define LATCH A1
|
|
#define CLOCK A2
|
|
|
|
// define the IO lines for the eeprom control
|
|
#define CE A3
|
|
#define OE A4
|
|
#define A15VPP A5 //A15 on SST, VPP on 27C256
|
|
#define A10 13
|
|
|
|
// direct access to port
|
|
#define STROBE_PORT PORTC
|
|
#define STROBE_DS 0
|
|
#define STROBE_LATCH 1
|
|
#define STROBE_CLOCK 2
|
|
#define STROBE_CE 3
|
|
#define STROBE_OE 4
|
|
#define STROBE_WE 5
|
|
|
|
//a buffer for bytes to burn
|
|
#define BUFFERSIZE 256
|
|
byte buffer[BUFFERSIZE + 1]; // +1 for checksum
|
|
|
|
//command buffer for parsing commands
|
|
int COMMANDSIZE = 2; //Commands are set automatically when detecting commands
|
|
byte cmdbuf[262];
|
|
|
|
//flag set if we are on the first write pass
|
|
boolean firstWritePass = true;
|
|
|
|
//Last Address (used for sending high/low output at only 1 specific location on the 74HC595
|
|
unsigned int Last_Address = 0;
|
|
|
|
//###############################################################
|
|
//###############################################################
|
|
//###############################################################
|
|
|
|
void setup() {
|
|
//define the shiftOut Pins as output
|
|
pinMode(DS, OUTPUT);
|
|
pinMode(LATCH, OUTPUT);
|
|
pinMode(CLOCK, OUTPUT);
|
|
|
|
//define the boost pins as output (take care that they are LOW)
|
|
digitalWrite(VH, LOW);
|
|
pinMode(VH, OUTPUT);
|
|
digitalWrite(VPP, LOW);
|
|
pinMode(VPP, OUTPUT);
|
|
|
|
//define the EEPROM Pins as output (take care that they are HIGH)
|
|
digitalWrite(OE, HIGH);
|
|
pinMode(OE, OUTPUT);
|
|
digitalWrite(CE, HIGH);
|
|
pinMode(CE, OUTPUT);
|
|
digitalWrite(A15VPP, HIGH);
|
|
pinMode(A15VPP, OUTPUT);
|
|
digitalWrite(A10, HIGH);
|
|
pinMode(A10, OUTPUT);
|
|
|
|
//set speed of serial connection
|
|
Serial.begin(115200);
|
|
//Serial.begin(921600); //doesnt works, need 14.7456mhz crystal
|
|
//Serial.begin(1000000);
|
|
}
|
|
|
|
void loop() {
|
|
readCommand();
|
|
if (cmdbuf[0] == 'V' && cmdbuf[1] == 'V') Serial.write(BoardVersionBytes, 3);
|
|
if (cmdbuf[0] == 'V' && cmdbuf[1] == 'F') Serial.write(FirmwareVersionBytes, 2);
|
|
if (cmdbuf[1] == 'R') Read();
|
|
if (cmdbuf[1] == 'W') Write();
|
|
if (cmdbuf[0] == '5' && cmdbuf[1] == 'E') EraseSST();
|
|
//if (cmdbuf[0] == 'S' && cmdbuf[1] == 0 && cmdbuf[2] == 'S') Serial.write(0x4F); //moates commands for 921.6k baudrates
|
|
}
|
|
|
|
//###############################################################
|
|
// Serial Bytes functions
|
|
//###############################################################
|
|
|
|
void readCommand() {
|
|
for(int i=0; i< COMMANDSIZE;i++) cmdbuf[i] = 0;
|
|
int idx = 0;
|
|
COMMANDSIZE = 2;
|
|
|
|
do {
|
|
if(Serial.available()) cmdbuf[idx++] = Serial.read();
|
|
if (cmdbuf[1] == 'R') COMMANDSIZE = 6;
|
|
if (cmdbuf[1] == 'W') COMMANDSIZE = 262;
|
|
if (cmdbuf[0] == '5' && cmdbuf[1] == 'E') COMMANDSIZE = 3;
|
|
//if (cmdbuf[0] == 'S' && cmdbuf[1] == 0) COMMANDSIZE = 3; //moates commands for 921.6k baudrates
|
|
}
|
|
while (idx < (COMMANDSIZE));
|
|
}
|
|
|
|
void ChecksumThis() {
|
|
byte num = 0;
|
|
for (int i = 0; i < BUFFERSIZE; i++)
|
|
num = (byte) (num + buffer[i]);
|
|
buffer[256] = num;
|
|
}
|
|
|
|
//###############################################################
|
|
// Commands functions
|
|
//###############################################################
|
|
|
|
void Read() {
|
|
//Get Parameters
|
|
chipType = (int) cmdbuf[0] - 48;
|
|
long addr = ((long) cmdbuf[3] * 256) + (long) cmdbuf[4];
|
|
Last_Address = addr;
|
|
|
|
//Read
|
|
read_start();
|
|
for (int x = 0; x < BUFFERSIZE; ++x) {
|
|
buffer[x] = read_byte(addr+x);
|
|
delayMicroseconds(100);
|
|
}
|
|
read_end();
|
|
|
|
//return Array+Checksum to say it passed
|
|
ChecksumThis();
|
|
Serial.write(buffer, sizeof(buffer));
|
|
}
|
|
|
|
void Write() {
|
|
//Get Parameters
|
|
chipType = (int) cmdbuf[0] - 48;
|
|
long addr = ((long) cmdbuf[3] * 256) + (long) cmdbuf[4];
|
|
Last_Address = addr;
|
|
|
|
//Write
|
|
write_start();
|
|
for (int x = 0; x < BUFFERSIZE; ++x) fast_write(addr + x, cmdbuf[x+5]);
|
|
write_end();
|
|
|
|
//return 0x4F (79) to say it passed
|
|
Serial.write(0x4F);
|
|
}
|
|
|
|
void EraseSST() {
|
|
//chipType = (int) cmdbuf[0] - 48;
|
|
chipType = 5;
|
|
set_ce(HIGH);
|
|
set_oe(HIGH);
|
|
set_vh(HIGH);
|
|
set_vpp(HIGH);
|
|
delay(1);
|
|
|
|
//erase pulse
|
|
set_ce(LOW);
|
|
delay(350);
|
|
set_ce(HIGH);
|
|
delayMicroseconds(1);
|
|
|
|
//Turning Off
|
|
set_vh(LOW);
|
|
set_vpp(LOW);
|
|
delayMicroseconds(1);
|
|
|
|
//return 0x4F (79) to say it passed
|
|
Serial.write(0x4F);
|
|
}
|
|
|
|
//###############################################################
|
|
// COMMANDS SUBS functions
|
|
//###############################################################
|
|
|
|
void read_start() {
|
|
data_bus_input();
|
|
//enable chip select
|
|
set_ce(LOW);
|
|
//enable output
|
|
set_oe(LOW);
|
|
|
|
//Set VPP to Low/High (27C2128, 27C256)
|
|
if (chipType == CHIP27C128) {
|
|
digitalWrite(A15VPP, LOW);
|
|
Set_Output_At(15, HIGH);
|
|
}
|
|
else if (chipType == CHIP27C256 || chipType == CHIP28C64) {
|
|
digitalWrite(A15VPP, HIGH); //the 28C64 doesnt care but the 27C64 is VPP
|
|
}
|
|
else if (chipType == CHIP27C32) {
|
|
digitalWrite(A15VPP, LOW); //normally used for A15/VPP, this pin is not used on 24pin chips
|
|
Set_Output_At(15, LOW); //normally used for A14, this pin is not used on 24pin chips
|
|
Set_Output_At(14, HIGH); //**** normally used for A13, this pin is now VCC (5v) ****
|
|
Set_Output_At(13, LOW); //normally used for A12, this pin is not used on 24pin chips
|
|
delayMicroseconds(5);
|
|
}
|
|
}
|
|
|
|
void read_end() {
|
|
//disable output
|
|
set_oe(HIGH);
|
|
//disable chip select
|
|
set_ce(HIGH);
|
|
|
|
//Set VPP to Low/High (27C2128, 27C256)
|
|
if (chipType == CHIP27C128) Set_Output_At(15, LOW);
|
|
else if (chipType == CHIP27C256) digitalWrite(A15VPP, LOW);
|
|
}
|
|
|
|
inline byte read_byte(unsigned int address)
|
|
{
|
|
set_address_bus(address);
|
|
return read_data_bus();
|
|
}
|
|
|
|
void write_start() {
|
|
firstWritePass = true;
|
|
//disable output
|
|
set_oe(HIGH);
|
|
set_vpp(HIGH);
|
|
//Set VPP to low on 29C256 (not 27C256/27SF256 as its read only)
|
|
if (chipType == CHIP27C256){digitalWrite(A15VPP, LOW); delayMicroseconds(5);}
|
|
|
|
data_bus_output();
|
|
}
|
|
|
|
void write_end() {
|
|
set_vpp(LOW);
|
|
data_bus_input();
|
|
}
|
|
|
|
inline void fast_write(unsigned int address, byte data)
|
|
{
|
|
if (chipType == CHIP28C64 || chipType == CHIP28C256) {
|
|
//this function uses /DATA polling to get the end of the page write cycle. This is much faster than waiting 10ms
|
|
static unsigned int lastAddress = 0;
|
|
static byte lastData = 0;
|
|
|
|
//enable chip select
|
|
set_ce(LOW);
|
|
|
|
//data poll
|
|
if (((lastAddress ^ address) & 0xFFC0 || chipType == CHIP28C64) && !firstWritePass)
|
|
{
|
|
unsigned long startTime = millis();
|
|
|
|
//poll data until data matches
|
|
data_bus_input();
|
|
set_oe(LOW);
|
|
|
|
//set timeout here longer than JBurn timeout
|
|
while(lastData != read_data_bus()) {
|
|
if (millis() - startTime > 3000) return false;
|
|
}
|
|
|
|
set_oe(HIGH);
|
|
delayMicroseconds(1);
|
|
data_bus_output();
|
|
}
|
|
|
|
//set address and data for write
|
|
set_address_bus(address);
|
|
write_data_bus(data);
|
|
delayMicroseconds(1);
|
|
|
|
//strobe write
|
|
set_we(LOW);
|
|
set_we(HIGH);
|
|
//disable chip select
|
|
set_ce(HIGH);
|
|
|
|
lastAddress = address;
|
|
lastData = data;
|
|
firstWritePass = false;
|
|
}
|
|
else
|
|
{
|
|
set_address_bus(address);
|
|
write_data_bus(data);
|
|
delayMicroseconds(1);
|
|
|
|
//programming pulse
|
|
set_ce(LOW);
|
|
delayMicroseconds(100); // for W27E512, works for 27SF512 also (but 27SF512 should be 20ms)
|
|
set_ce(HIGH);
|
|
delayMicroseconds(1);
|
|
}
|
|
}
|
|
|
|
//###############################################################
|
|
// DATA BUS functions
|
|
//###############################################################
|
|
|
|
void data_bus_input() {
|
|
pinMode(D0, INPUT);
|
|
pinMode(D1, INPUT);
|
|
pinMode(D2, INPUT);
|
|
pinMode(D3, INPUT);
|
|
pinMode(D4, INPUT);
|
|
pinMode(D5, INPUT);
|
|
pinMode(D6, INPUT);
|
|
pinMode(D7, INPUT);
|
|
}
|
|
|
|
void data_bus_output() {
|
|
pinMode(D0, OUTPUT);
|
|
pinMode(D1, OUTPUT);
|
|
pinMode(D2, OUTPUT);
|
|
pinMode(D3, OUTPUT);
|
|
pinMode(D4, OUTPUT);
|
|
pinMode(D5, OUTPUT);
|
|
pinMode(D6, OUTPUT);
|
|
pinMode(D7, OUTPUT);
|
|
}
|
|
|
|
byte read_data_bus()
|
|
{
|
|
byte b = 0;
|
|
if (digitalRead(D0) == HIGH) b |= 1;
|
|
if (digitalRead(D1) == HIGH) b |= 2;
|
|
if (digitalRead(D2) == HIGH) b |= 4;
|
|
if (digitalRead(D3) == HIGH) b |= 8;
|
|
if (digitalRead(D4) == HIGH) b |= 16;
|
|
if (digitalRead(D5) == HIGH) b |= 32;
|
|
if (digitalRead(D6) == HIGH) b |= 64;
|
|
if (digitalRead(D7) == HIGH) b |= 128;
|
|
return(b);
|
|
}
|
|
|
|
inline void write_data_bus(byte data)
|
|
{
|
|
digitalWrite(D0, data & 1);
|
|
digitalWrite(D1, data & 2);
|
|
digitalWrite(D2, data & 4);
|
|
digitalWrite(D3, data & 8);
|
|
digitalWrite(D4, data & 16);
|
|
digitalWrite(D5, data & 32);
|
|
digitalWrite(D6, data & 64);
|
|
digitalWrite(D7, data & 128);
|
|
}
|
|
|
|
//###############################################################
|
|
// FAST SWIFT functions
|
|
//###############################################################
|
|
inline void set_address_bus(unsigned int address)
|
|
{
|
|
byte hi, low;
|
|
hi = (address >> 8);
|
|
low = address & 0xff;
|
|
//A14 become WE on 28C64 && 28C256, make sure dont use the output that were generally used for A14
|
|
if (chipType == CHIP28C64 || chipType == CHIP28C256) bitSet(hi, 6); //set ouput 7 on hi byte
|
|
else if (chipType == CHIP27C32) {
|
|
bitClear(hi, 6); //set ouput 7 on hi byte
|
|
bitSet(hi, 5); //set ouput 6 on hi byte, this is now VCC
|
|
bitClear(hi, 4); //set ouput 5 on hi byte
|
|
}
|
|
|
|
ApplyShiftAt(hi, low);
|
|
|
|
digitalWrite(A10, (address & 1024)?HIGH:LOW );
|
|
if (chipType == CHIP28C64 || chipType == CHIP28C256) digitalWrite(A15VPP, (address & 16384)?HIGH:LOW); //A15/VPP become A14 on 28C64 && 28C256
|
|
else if (chipType == CHIP27SF512) digitalWrite(A15VPP, (address & 32768)?HIGH:LOW);
|
|
}
|
|
|
|
inline void Set_Output_At(unsigned int Position, bool IsHigh)
|
|
{
|
|
byte hi, low;
|
|
hi = (Last_Address >> 8);
|
|
low = Last_Address & 0xff;
|
|
if (Position >= 8) {
|
|
if (IsHigh) bitSet(hi, Position - 8);
|
|
else bitClear(hi, Position - 8);
|
|
}
|
|
else {
|
|
if (IsHigh) bitSet(low, Position);
|
|
else bitClear(low, Position);
|
|
}
|
|
ApplyShiftAt(hi, low);
|
|
}
|
|
|
|
void ApplyShiftAt(byte hi, byte low)
|
|
{
|
|
fastShiftOut(hi);
|
|
fastShiftOut(low);
|
|
//strobe latch line
|
|
bitSet(STROBE_PORT,STROBE_LATCH);
|
|
bitClear(STROBE_PORT,STROBE_LATCH);
|
|
delayMicroseconds(1);
|
|
}
|
|
|
|
void fastShiftOut(byte data) {
|
|
//clear
|
|
bitClear(STROBE_PORT,STROBE_DS);
|
|
|
|
//Loop for the 8x outputs
|
|
for (int i=7; i>=0; i--) {
|
|
//clear clock pin
|
|
bitClear(STROBE_PORT,STROBE_CLOCK);
|
|
|
|
//Enable/Disable pin Output
|
|
if (bitRead(data,i) == 1) bitSet(STROBE_PORT,STROBE_DS);
|
|
else bitClear(STROBE_PORT,STROBE_DS);
|
|
|
|
//register shifts bits on upstroke of clock pin
|
|
bitSet(STROBE_PORT,STROBE_CLOCK);
|
|
//clear after shift to prevent bleed through
|
|
bitClear(STROBE_PORT,STROBE_DS);
|
|
}
|
|
|
|
//stop shifting
|
|
bitClear(STROBE_PORT,STROBE_CLOCK);
|
|
}
|
|
|
|
int GetAddress(unsigned int Position)
|
|
{
|
|
int Address = 0;
|
|
if (Position == 1) Address = 1;
|
|
if (Position == 2) Address = 2;
|
|
if (Position == 3) Address = 4;
|
|
if (Position == 4) Address = 8;
|
|
if (Position == 5) Address = 16;
|
|
if (Position == 6) Address = 32;
|
|
if (Position == 7) Address = 64;
|
|
if (Position == 8) Address = 128;
|
|
if (Position == 9) Address = 256;
|
|
if (Position == 10) Address = 512;
|
|
if (Position == 11) Address = 1024; //This pin is not wired to anything on the BMBurner, refer to pin D13 on arduino instead
|
|
if (Position == 12) Address = 2048;
|
|
if (Position == 13) Address = 4096;
|
|
if (Position == 14) Address = 8192;
|
|
if (Position == 15) Address = 16384;
|
|
if (Position == 16) Address = 32768; //This pin is not wired to anything on the BMBurner, refer to pin A5 on arduino instead
|
|
return Address;
|
|
}
|
|
|
|
//###############################################################
|
|
// PINS functions
|
|
//###############################################################
|
|
|
|
//**attention, this line is LOW - active**
|
|
inline void set_oe (byte state)
|
|
{
|
|
digitalWrite(OE, state);
|
|
}
|
|
|
|
//**attention, this line is LOW - active**
|
|
inline void set_ce (byte state)
|
|
{
|
|
digitalWrite(CE, state);
|
|
}
|
|
|
|
//**attention, this line is LOW - active**
|
|
inline void set_we (byte state)
|
|
{
|
|
if (chipType == CHIP28C64 || chipType == CHIP28C256) Set_Output_At(15, state); //output 15 become WE (since there are 8 outputs by 74HC595, its the #7 ouputs on the 2nd 74HC595)
|
|
}
|
|
|
|
//Boost VPP 12V
|
|
void set_vpp (byte state)
|
|
{
|
|
switch (chipType) {
|
|
case CHIP27SF512:
|
|
digitalWrite(VPP, state);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
//Boost Erase 12V
|
|
void set_vh (byte state)
|
|
{
|
|
switch (chipType) {
|
|
case CHIP27SF512:
|
|
digitalWrite(VH, state);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|