28c_programmer/firmware/interface.cpp at master · raltmeyer/28c_programmer · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
/*
 * interface.cpp
 *
 *  Created on: Feb 26, 2020
 *      Author: raltmeyer
 *
 *   Interface between arduino and EEPROM/latches
 *
 */

#include "28c_programmer.h"
#include "pin_defs.h"
#include <Arduino.h>

char PINS_DATA[] = {PIN_DATA_D0, PIN_DATA_D1, PIN_DATA_D2, PIN_DATA_D3,
                    PIN_DATA_D4, PIN_DATA_D5, PIN_DATA_D6, PIN_DATA_D7};

//*********
//* Set the address A0 to A15 through the latches
void setAddress(int address) {
  // send all 16 address bits and trigger the latch to store
  shiftOut(PIN_SHIFTREG_SER, PIN_SHIFTREG_SRCLK, MSBFIRST, (address >> 8));
  shiftOut(PIN_SHIFTREG_SER, PIN_SHIFTREG_SRCLK, MSBFIRST, address);
  digitalWrite(PIN_SHIFTREG_RCLK, LOW);
  digitalWrite(PIN_SHIFTREG_RCLK, HIGH);
  digitalWrite(PIN_SHIFTREG_RCLK, LOW);
}

//*********
//* Set the data on the pins of eeprom
void setData(byte data) {
  for (int n = 0; n < 8; n += 1) {
    digitalWrite(PINS_DATA[n], data & 1);
    data = data >> 1;
  }
}

//*********
//* Get the data avaiable on the eeprom data pins
byte getData(void) {
  byte data = 0;
  for (int n = 7; n >= 0; n -= 1) {
    data = data << 1;
    data = data + digitalRead(PINS_DATA[n]);
  }
  return data;
}

//*********
//* Change the pinmode on data pins on nano
void setDataPinsMode(boolean readWrite) {
  digitalWrite(PIN_ROM_WE, HIGH); // disable Write
  digitalWrite(PIN_ROM_OE, HIGH); // disable Read

  for (int n = 0; n < 8; n += 1) {
    if (readWrite == DATA_PIN_MODE_WRITE) {
      pinMode(PINS_DATA[n], OUTPUT);
    } else {
      pinMode(PINS_DATA[n], INPUT);
    }
  }
}

//*********
//* Do all steps to write data on the eeprom
void flashWrite(int address, byte data) {

  setDataPinsMode(DATA_PIN_MODE_WRITE);
  setAddress(address);
  setData(data);

  // Pulsa para gravar na flash
  digitalWrite(PIN_ROM_WE, LOW);
  delayMicroseconds(1);
  digitalWrite(PIN_ROM_WE, HIGH);

  // DATA Polling (Bit 7) to wait for write completion
  setDataPinsMode(DATA_PIN_MODE_READ);
  digitalWrite(PIN_ROM_OE, LOW);
  delayMicroseconds(1);

  // The 28C256 outputs the logical complement of bit 7 during a write cycle.
  // We poll until bit 7 of the read data matches bit 7 of the written data.
  byte status;
  unsigned long start_time = millis();
  while (millis() - start_time <
         20) { // 20ms timeout as safety (max is typically 10ms)
    status = getData();
    if ((status & 0x80) == (data & 0x80)) {
      break; // Write completed
    }
  }

  digitalWrite(PIN_ROM_OE, HIGH);
}

//*********
//* Do all steps to read data on the EEPROM
byte flashRead(int address) {
  byte data = 0;

  setDataPinsMode(DATA_PIN_MODE_READ);
  setAddress(address);

  digitalWrite(PIN_ROM_OE, LOW);
  delayMicroseconds(1);
  data = getData();
  digitalWrite(PIN_ROM_OE, HIGH);

  return data;
}

//*********
//* Similar to flashRead is only used to change the
//* SDP status on the EEPROM
void SDPWrite(int address, byte data) {
  setAddress(address);
  setData(data);
  digitalWrite(PIN_ROM_WE, LOW);
  delayMicroseconds(1);
  digitalWrite(PIN_ROM_WE, HIGH);
  delay(1);
}

//*********
//* Change the SDP (Software Data Protection) status
void SDPmode(int mode) {

  setDataPinsMode(DATA_PIN_MODE_WRITE);
  if (mode) {
    SDPWrite(0x5555, 0xAA);
    SDPWrite(0x2AAA, 0x55);
    SDPWrite(0x5555, 0x80);
    SDPWrite(0x5555, 0xAA);
    SDPWrite(0x2AAA, 0x55);
    SDPWrite(0x5555, 0x20);

    SDPWrite(0x1555, 0xAA);
    SDPWrite(0x0AAA, 0x55);
    SDPWrite(0x1555, 0x80);
    SDPWrite(0x1555, 0xAA);
    SDPWrite(0x0AAA, 0x55);
    SDPWrite(0x1555, 0x20);

  } else {
    SDPWrite(0x5555, 0xAA);
    SDPWrite(0x2AAA, 0x55);
    SDPWrite(0x5555, 0xA0);

    SDPWrite(0x1555, 0xAA);
    SDPWrite(0x0AAA, 0x55);
    SDPWrite(0x1555, 0xA0);
  }

  flashRead(0);
}