ATmel AT89-Serie mühelos mit Arduino Uno programmieren – Schritt-für-Schritt-Anleitung

Benötigte Komponenten

Arduino UNO	1 Stück
AT89C52 Mikrocontroller	1 Stück
10 µF Kondensator	1 Stück
Steckbrücken (Jumper Wires)	Mehrere
8,2 kΩ Widerstand	1 Stück
510 Ω Widerstand (Hinweis: Im Original als „510 ohm Capacitor“ bezeichnet, es handelt sich um einen Widerstand)	1 Stück
LED (beliebig)	1 Stück
12 MHz Quarz	1 Stück
2 × 33 pF Kondensatoren	2 Stück

Benötigte Werkzeuge

• Lötkolben (allgemein)

Software & Online-Dienste

• Arduino IDE
• 8051 SPI Programmer (zum Brennen der Hex-Datei)

Projektbeschreibung

In diesem Tutorial zeige ich, wie Sie eine Hex-Datei in wenigen einfachen Schritten auf einen AT89C52 mit einem Arduino Uno brennen. Dazu wird der AT89C52 an den Arduino Uno angeschlossen und eine LED zur Funktionsanzeige an den AT89C52 angebunden.

Schritt 1: Stückliste

Siehe die Komponententabelle oben.

Schritt 2: Mikrocontroller verdrahten

Verbinden Sie den AT89C52 wie folgt mit dem Arduino Uno:

AT89C52 Pin	Arduino Uno Pin
Pin 6	Pin 5
Pin 7	Pin 4
Pin 8	Pin 3
Pin 9	Pin 2

Hinweis: Die genauen Verbindungen entnehmen Sie bitte dem Schaltplan im Abschnitt „Schematics“. Die Bilder im Original zeigen die Verdrahtung im Detail.

Schritt 3: Quarz-Oszillator

Verbinden Sie einen 12 MHz Quarz zwischen Pin 18 (XTAL1) und Pin 19 (XTAL2) des AT89C52. Schließen Sie je einen 33 pF Kondensator von Pin 18 und Pin 19 gegen Masse (GND) an.

Schritt 4: Spannungsversorgung (VCC & GND)

Verbinden Sie den 5V-Pin des Arduino Uno mit Pin 40 (VCC) des AT89C52 und den GND-Pin des Arduino mit Pin 20 (GND) des AT89C52.

Schritt 5: LED anschließen

Schließen Sie eine LED (mit Vorwiderstand, z. B. 510 Ω) an einen I/O-Port des AT89C52 an (z. B. Port 1.0), um die Programmierung visuell zu bestätigen. Die genaue Beschaltung entnehmen Sie dem Schaltplan.

Schritt 6: Software einrichten

Zum Brennen der Hex-Datei wird der „8051 SPI Programmer“ benötigt (Link im Software-Bereich). Laden Sie den bereitgestellten Arduino-Code auf den Arduino Uno hoch – dieser fungiert dann als SPI-Programmer. Anschließend können Sie über die serielle Schnittstelle (z. B. über ein Terminalprogramm) Befehle senden, um den Chip zu löschen, die Signatur zu lesen, die Hex-Datei zu schreiben usw.

Arduino-Code (SPI-Programmer)

Der folgende Code implementiert die SPI-Kommunikation zum Programmieren des AT89C52. Er wartet auf serielle Befehle (z. B. 'p' für Program Enable, 'e' für Chip Erase, 'w' für Write Program Memory, 'r' für Read Program Memory, 'S'/'s' für Signature Bytes).

#define dummyData 0xAA
#define RDY 75
#define NRDY 76
const int _MISO = 4;
const int _MOSI = 5;
const int _CLK = 3;
const int RST = 2;

byte data;
byte AL, AH;
byte lockByte;
byte SigH, SigL;

void setup() {
  pinMode(_MISO, INPUT);
  pinMode(_MOSI, OUTPUT);
  pinMode(_CLK, OUTPUT);
  pinMode(RST, OUTPUT);
  Serial.begin(115200);
}

void loop() {
  while (!Serial.available());
  if (Serial.available() > 0) {
    switch (Serial.read()) {
      case 'p': Serial.write(progEnable()); break;
      case 'r': readProgmem(); Serial.write(data); break;
      case 'a': while(!Serial.available()); AL = Serial.read(); break;
      case 'A': while(!Serial.available()); AH = Serial.read(); break;
      case 'd': while(!Serial.available()); data = Serial.read(); break;
      case 'S': AH = 0; AL = 0; SigH = readSign(); Serial.write(SigH); break;
      case 's': AH = 2; AL = 0; SigL = readSign(); Serial.write(SigL); AH = 1; AL = 0; SigL = readSign(); Serial.write(SigL); break;
      case 'o': digitalWrite(RST,1); break;
      case 'c': digitalWrite(RST,0); break;
      case 'e': eraseChip(); Serial.write(RDY); break;
      case 'j': break;
      case 'w': writeProgmem(); break;
    }
  }
}

unsigned char SendSPI(unsigned char data) {
  uint8_t retval = 0;
  uint8_t intData = data;
  int t;
  for (int ctr = 0; ctr < 7; ctr++) {
    digitalWrite(_MOSI, (intData & 0x80) ? HIGH : LOW);
    digitalWrite(_CLK, HIGH);
    delayMicroseconds(1);
    t = digitalRead(_MISO);
    digitalWrite(_CLK, LOW);
    retval = (retval << 1) | t;
    intData <<= 1;
    delayMicroseconds(1);
  }
  digitalWrite(_MOSI, (intData & 0x80) ? HIGH : LOW);
  digitalWrite(_CLK, HIGH);
  delayMicroseconds(1);
  t = digitalRead(_MISO);
  digitalWrite(_CLK, LOW);
  retval = (retval << 1) | t;
  return retval;
}

byte progEnable() {
  SendSPI(0xAC);
  SendSPI(0x53);
  SendSPI(dummyData);
  return SendSPI(dummyData);
}

void eraseChip() {
  SendSPI(0xAC);
  SendSPI(0x9F);
  SendSPI(dummyData);
  SendSPI(dummyData);
  delay(520);
}

void readProgmem() {
  SendSPI(0x20);
  SendSPI(AH);
  SendSPI(AL);
  data = SendSPI(dummyData);
}

void writeProgmem() {
  SendSPI(0x40);
  SendSPI(AH);
  SendSPI(AL);
  SendSPI(data);
}

void writeLockBits() {
  SendSPI(0xAC);
  SendSPI(lockByte);
  SendSPI(dummyData);
  SendSPI(dummyData);
}

void readLockBits() {
  SendSPI(0x24);
  SendSPI(dummyData);
  SendSPI(dummyData);
  lockByte = SendSPI(dummyData);
}

byte readSign() {
  SendSPI(0x28);
  SendSPI(AH);
  SendSPI(AL);
  return SendSPI(dummyData);
}

Schaltpläne

Im Abschnitt „Schematics“ finden Sie zwei Schaltplanbilder, die die vollständige Verdrahtung (inkl. Quarz, Kondensatoren, LED, Reset-Schaltung) zeigen.