paged write, enable disable sdp working ok

Author: ibaldachini

Arduino/AT28C_Programmer/AT28C.cpp

@@ -14,11 +14,11 @@
 //******************************************************************************************************************//
 void setDataBusMode(int mode)
 {
-if (mode == INPUT || mode == OUTPUT) {
-for (int i = 0; i < 8; i++) {
-pinMode(dataPins[i], mode);
-}
-}
+ if (mode == INPUT || mode == OUTPUT) {
+ for (int i = 0; i < 8; i++) {
+ pinMode(dataPins[i], mode);
+ }
+ }
 }
 
 //******************************************************************************************************************//
@@ -28,7 +28,7 @@ byte readByte(unsigned int address) {
 
  // Imposta il bus dati in input
  setDataBusMode(INPUT);
- 
+
  digitalWrite(EEPROM_CE_PIN, HIGH);
  digitalWrite(EEPROM_OE_PIN, HIGH);
  digitalWrite(EEPROM_WE_PIN, HIGH);
@@ -68,20 +68,18 @@ byte writeByte(unsigned int address, byte value)
  digitalWrite(EEPROM_CE_PIN, HIGH);
  digitalWrite(EEPROM_OE_PIN, HIGH);
  digitalWrite(EEPROM_WE_PIN, HIGH);
- delayMicroseconds(1);
 
  // Imposta il bus di dati in output
-setDataBusMode(OUTPUT);
+ setDataBusMode(OUTPUT);
 
  // Imposta indirizzo
  addressWrite(address);
 
  // Scrittura pins D2/D9 (Bus Dati)
-for (int i = 0; i < 8; i++)
-{
-//int a = (value & (1 << i)) > 0;
-digitalWrite(dataPins[i], bitRead(value, i));
-}
+ for (int i = 0; i < 8; i++)
+ {
+ digitalWrite(dataPins[i], bitRead(value, i));
+ }
  delayMicroseconds(1);
 
  digitalWrite(EEPROM_CE_PIN, LOW);
@@ -93,9 +91,43 @@ byte writeByte(unsigned int address, byte value)
  digitalWrite(EEPROM_WE_PIN, HIGH);
  delayMicroseconds(1);
 
+ digitalWrite(EEPROM_CE_PIN, HIGH);
+ delayMicroseconds(1);
+
+ return value;
+}
+
+//******************************************************************************************************************//
+//* Scrittura di una pagina di 64 byte all'indirizzo selezionato
+//******************************************************************************************************************//
+byte writePage(unsigned int address, byte* page, unsigned int size)
+{
+ digitalWrite(EEPROM_CE_PIN, HIGH);
+ digitalWrite(EEPROM_OE_PIN, HIGH);
+ digitalWrite(EEPROM_WE_PIN, HIGH);
+
+ // Imposta il bus di dati in output
+ setDataBusMode(OUTPUT);
+
+ byte value; // valore da scrivere, ultimo valore scritto
+ for (unsigned int idx = 0; idx < size; idx++) {
+ value = writeByte(address + idx, page[idx]);
+ }
+
+ return value;
+}
+
+//******************************************************************************************************************//
+//* Attende il termine della scrittura di un byte e ne verifica la corretta valorizzazione
+//******************************************************************************************************************//
+byte waitAndCheckWrite(byte value)
+{
  // Imposta il bus dati in input
  setDataBusMode(INPUT);
 
+ digitalWrite(EEPROM_CE_PIN, LOW);
+ delayMicroseconds(1);
+
  digitalWrite(EEPROM_OE_PIN, LOW);
  delayMicroseconds(1);
 
@@ -118,6 +150,7 @@ byte writeByte(unsigned int address, byte value)
 
  digitalWrite(EEPROM_OE_PIN, HIGH);
  delayMicroseconds(1);
+
  digitalWrite(EEPROM_CE_PIN, HIGH);
  delayMicroseconds(1);
 
@@ -128,29 +161,12 @@ byte writeByte(unsigned int address, byte value)
 //* Lettura della EEPROM
 //******************************************************************************************************************//
 void readEEPROM(unsigned int size) {
- //Serial.println("START DUMP (" + (String)size + " byte)");
-
  unsigned int addr = 0;
 
- // Azzera lo shift register
- //addressWrite(0x0000);
-
-// byte buffer[256];
-// int index = 0;
  for (int i = 0; i < size; i++) {
  byte bval = readByte(addr + i);
-// buffer[index] = bval;
-// index ++;
- //Serial.println(bval, DEC);
- 
-// if (index == 256) {
-// Serial.write(buffer, 1);
-// index = 0;
-// }
- Serial.write(&bval, 1);
+ Serial.write(&bval, 1);
  }
- 
- //Serial.println("END DUMP");
 }
 
 //******************************************************************************************************************//
@@ -159,16 +175,48 @@ void readEEPROM(unsigned int size) {
 void writeEEPROM(unsigned int size)
 {
  unsigned int address = 0; 
- //for (unsigned int i = 1; i <= size; i++)
+
  while (address < size)
  {
+ // single byte write 
  byte val = 0;
  if (Serial.available() > 0) {
  val = Serial.read();
- byte wval = writeByte(address, val);
+ writeByte(address, val);
+ byte wval = waitAndCheckWrite(val);
  Serial.write(&wval, 1);
  address++;
- } 
+ }
+ }
+}
+
+//******************************************************************************************************************//
+//* Scrittura della EEPROM in modo paginato
+//******************************************************************************************************************//
+void writePagedEEPROM(unsigned int size, unsigned int pagesize)
+{
+ unsigned int address = 0; 
+
+ while (address < size)
+ {
+ // page write
+ unsigned int idx = 0;
+ #define PAGE_SIZE 64
+ byte page[PAGE_SIZE];
+ while (idx < PAGE_SIZE) {
+ if (Serial.available() > 0) {
+ page[idx++] = Serial.read();
+ }
+ }
+ byte val = writePage(address, page, PAGE_SIZE);
+ byte wval = waitAndCheckWrite(val);
+ // feedback al programmatore dei bytes letti da EPROM
+ idx = 0;
+ while (idx < PAGE_SIZE) {
+ byte val = readByte(address + idx++);
+ Serial.write(&val, 1);
+ }
+ address += PAGE_SIZE;
  }
 }
 
@@ -193,4 +241,4 @@ void enableSDP()
  writeByte(0x5555, 0xaa);
  writeByte(0x2aaa, 0x55);
  writeByte(0x5555, 0xa0);
-}
+}

Arduino/AT28C_Programmer/AT28C.h

@@ -22,6 +22,11 @@ byte writeByte(unsigned int address, byte value);
 //******************************************************************************************************************//
 void writeEEPROM(unsigned int size);
 
+//******************************************************************************************************************//
+//* Scrittura della EEPROM in modo paginato
+//******************************************************************************************************************//
+void writePagedEEPROM(unsigned int size, unsigned int pagesize);
+
 //******************************************************************************************************************//
 //* Lettura della EEPROM
 //******************************************************************************************************************//

Arduino/AT28C_Programmer/AT28C_Programmer.ino

@@ -132,7 +132,11 @@ void ParseComands(String s) {
  GetComandParams(s, params);
  // Serial.println("PARAM: " + params[0]);
  if (params[0] != "") {
- writeEEPROM(params[0].toInt());
+ if (params[1] != "") {
+ writePagedEEPROM(params[0].toInt(), params[1].toInt());
+ } else {
+ writeEEPROM(params[0].toInt());
+ }
  //Serial.println("+++");
  }
  }

Linux/AT28CProgrammer/AT28CProgrammer.c

@@ -25,7 +25,7 @@ int requestFirmware(int fd);
 int requestRead(int fd, e_rom_type romtype);
 
 // invia il comando di richiesta scrittura della memoria
-int requestWrite(int fd, e_rom_type romtype);
+int requestWrite(int fd, e_rom_type romtype, bool paged);
 
 // legge e visualizza la risposta dal programmatore
 int readAnswer(int fd, long msec);
@@ -37,7 +37,7 @@ int readEprom(int fd, e_rom_type romtype, char* filename, long msec);
 int verifyEprom(int fd, e_rom_type romtype, char* filename, long msec);
 
 // invia al prorammatore i dati da scrivere leggendoli dal file indicato, per ogni byte attende al massimo msecforbyte millisecondi
-int writeEprom(int fd, e_rom_type romtype, char* filename, long msecforbyte);
+int writeEprom(int fd, e_rom_type romtype, bool paged, char* filename, long msecforbyte);
 
 // setup Software Data Protection
 int setupSDP(int fd, bool enable, long msec);
@@ -56,6 +56,9 @@ int main (int argc, char **argv) {
  // indicatore operazione
  char operation = 0;
 
+ // indicatore operazione paginata
+ bool paged = false;
+
  // nome del device seriale a cui è collegato il programmatore
  char *device = NULL;
 
@@ -92,6 +95,10 @@ int main (int argc, char **argv) {
  // opzione per la scrittura della memoria
  if (optarg[0] == 'w') {
  operation = 'w';
+ // opzione per la scrittura della memoria paginata
+ if (optarg[1] == 'p') {
+ paged = true;
+ }
  // opzione per la verifica della memoria
  } else if (optarg[0] == 'v') {
  operation = 'v';
@@ -266,13 +273,13 @@ int main (int argc, char **argv) {
  }
  } else {
  // invia il comando di richiesta scrittura della memoria selezionata
- if (requestWrite(fd, romtype) == -1) {
+ if (requestWrite(fd, romtype, paged) == -1) {
  close(fd);
  printf("error request write eprom\n");
  return -1;
  }
  // invia il contenuto del file da scrivere, per ogny byte scritto attende al massimo 10 ms per la scrittura
- if (writeEprom(fd, romtype, filename, 100) == -1) {
+ if (writeEprom(fd, romtype, paged, filename, 100) == -1) {
  close(fd);
  printf("error write eprom\n");
  return -1;
@@ -350,15 +357,25 @@ int requestRead(int fd, e_rom_type romtype) {
 }
 
 // invia il comando di richiesta scrittura della memoria
-int requestWrite(int fd, e_rom_type romtype) {
+int requestWrite(int fd, e_rom_type romtype, bool paged) {
  tcflush(fd, TCIOFLUSH);
 
- const char* cmdWriteAT28C64 = "WRITEEEPROM=8192\r";
- const char* cmdWriteAT28C256 = "WRITEEEPROM=32768\r";
  if (romtype == AT28C64) {
- return write(fd, cmdWriteAT28C64, strlen(cmdWriteAT28C64));
+ if (paged) {
+ const char* cmdWrite = "WRITEEEPROM=8192,64\r";
+ return write(fd, cmdWrite, strlen(cmdWrite));
+ } else {
+ const char* cmdWrite = "WRITEEEPROM=8192\r";
+ return write(fd, cmdWrite, strlen(cmdWrite));
+ }
  } else if (romtype == AT28C256) {
- return write(fd, cmdWriteAT28C256, strlen(cmdWriteAT28C256));
+ if (paged) {
+ const char* cmdWrite = "WRITEEEPROM=32768,64\r";
+ return write(fd, cmdWrite, strlen(cmdWrite));
+ } else {
+ const char* cmdWrite = "WRITEEEPROM=32768\r";
+ return write(fd, cmdWrite, strlen(cmdWrite));
+ }
  }
  return -1;
 }
@@ -556,9 +573,9 @@ int verifyEprom(int fd, e_rom_type romtype, char* filename, long msec) {
 }
 
 // invia al prorammatore i dati da scrivere leggendoli dal file indicato, per ogni byte attende al massimo msecforbyte millisecondi
-int writeEprom(int fd, e_rom_type romtype, char* filename, long msecforbyte) {
- int totalbytes = 0;
- int written = 0;
+int writeEprom(int fd, e_rom_type romtype, bool paged, char* filename, long msecforbyte) {
+ size_t totalbytes = 0;
+ size_t written = 0;
  int lastperc = -1;
  if (romtype == AT28C64) {
  totalbytes = 8192;
@@ -572,36 +589,52 @@ int writeEprom(int fd, e_rom_type romtype, char* filename, long msecforbyte) {
  return -1;
  }
  char c;
- while (read(readfd, &c, 1) == 1) {
- write(fd, &c, 1);
-
- fd_set rfds;
- struct timeval tv;
- int retval;
-
- FD_ZERO(&rfds);
- FD_SET(fd, &rfds);
-
- tv.tv_sec = (msecforbyte * 1000) / 1000000;
- tv.tv_usec = (msecforbyte * 1000) % 1000000;
+ size_t blocksize = paged ? 64 : 1;
+ unsigned char buf[blocksize];
+ while (read(readfd, buf, blocksize) == blocksize) {
+ write(fd, buf, blocksize);
+
+ size_t recvd = 0;
+ unsigned char rbuf[blocksize];
+ while (recvd < blocksize) {
+ fd_set rfds;
+ struct timeval tv;
+ int retval;
+
+ FD_ZERO(&rfds);
+ FD_SET(fd, &rfds);
+
+ tv.tv_sec = (msecforbyte * 1000) / 1000000;
+ tv.tv_usec = (msecforbyte * 1000) % 1000000;
+
+ retval = select(fd + 1, &rfds, NULL, NULL, &tv);
+ if (retval == -1) {
+ printf("error select\n");
+ return -1;
+ } else if (retval > 0) {
+ char rc;
+ recvd += read(fd, rbuf + recvd, blocksize - recvd);
+ } else {
+ // timeout attesa risposta scrittura byte
+ printf("write timeout\n");
+ break;
+ }
+ }
 
- retval = select(fd + 1, &rfds, NULL, NULL, &tv);
- if (retval == -1) {
- printf("error select\n");
- return -1;
- } else if (retval > 0) {
- char rc;
- read(fd, &rc, 1);
- if (rc != c) {
- printf("-> written byte: 0x%02X, read byte: 0x%02X\r", (unsigned char)c, (unsigned char)rc);
- break;
+ bool err = false;
+ for (size_t idx = 0; idx < blocksize; idx++) {
+ if (rbuf[idx] != buf[idx]) {
+ printf("\n-> written byte: 0x%02X, read byte: 0x%02X\n", buf[idx], rbuf[idx]);
+ err = true;
+ break;
  }
- } else {
- // timeout attesa risposta scrittura byte
+ }
+
+ if (err) {
  break;
  }
 
- written++;
+ written += blocksize;
  int perc = written * 100 / totalbytes;
  if (perc != lastperc) {
  printf("-> write percent: %d%%\r", perc);