Programmer facilement les Atmel AT89 avec Arduino Uno – Guide pas à pas

Composants et fournitures

• Arduino UNO (×1)
• LED générique (×1)
• Microcontrôleur AT89C52
• Condensateur 10 µF
• Fils de connexion (jumper wires)
• Résistance 8,2 kΩ
• Condensateur 510 Ω (note: probablement une résistance 510 Ω)
• Cristal 12 MHz
• 2 × condensateurs 33 pF
• Fer à souder (générique)

Outils et machines nécessaires

• Fer à souder (générique)

Applications et services en ligne

• Arduino IDE
• 8051 SPI Programmer (logiciel pour graver le fichier Hex)

À propos du projet

Ce tutoriel montre comment graver un fichier Hex sur un AT89C52 en utilisant un Arduino Uno comme programmateur SPI, en quelques étapes simples. On interface l'AT89C52 à l'Arduino Uno et on ajoute une LED pour indication visuelle.

Étape 1 : Liste du matériel (Bill Of Materials)

• Arduino UNO
• Microcontrôleur AT89C52
• Condensateur 10 µF
• Fils de connexion
• Résistance 8,2 kΩ
• Résistance 510 Ω
• LED
• Cristal 12 MHz
• 2 × condensateurs 33 pF

Étape 2 : Connexion du microcontrôleur

Connectez le microcontrôleur comme suit :

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

Étape 3 : Quartz (Cristal)

Connectez un quartz entre les broches 18 et 19 de l'AT89C52, puis deux condensateurs 33 pF de chaque broche vers la masse (GND). Voir la section Schémas pour le schéma complet.

Étape 4 : VCC et GND

Connectez la broche 5V de l'Arduino Uno à la broche 40 (VCC) de l'AT89C52 et la broche GND à la broche 20 (GND).

Étape 5 : Interface LED

Interfacez la LED selon le schéma fourni dans la section Schémas.

Étape 6 : Logiciel

Nous avons besoin du logiciel 8051 SPI Programmer pour graver le fichier Hex sur l'AT89C52. Le lien est fourni dans la section Applications. Téléversez le code fourni sur l'Arduino UNO et votre programmateur est prêt.

Code

Programme Arduino (C/C++)

#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;

/* Définition des variables */
byte data;
byte AL, AH; // Adresse 16 bits
byte lockByte; // Bits de verrouillage
byte SigH, SigL; // Octets de signature

void setup() {
  pinMode(_MISO, INPUT);
  pinMode(_MOSI, OUTPUT);
  pinMode(_CLK, OUTPUT);
  pinMode(RST, OUTPUT);
  Serial.begin(115200); // Dépend du réglage du PC hôte
}

void loop() {
  while (!Serial.available()); // Attendre un caractère
  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++) {
    if (intData & 0x80) digitalWrite(_MOSI,1); else digitalWrite(_MOSI,0);
    digitalWrite(_CLK,1);
    delayMicroseconds(1);
    t = digitalRead(_MISO);
    digitalWrite(_CLK,0);
    if (t) retval |= 1; else retval &= 0xFE;
    retval <<= 1;
    intData <<= 1;
    delayMicroseconds(1);
  }
  if (intData & 0x80) digitalWrite(_MOSI,1); else digitalWrite(_MOSI,0);
  digitalWrite(_CLK,1);
  delayMicroseconds(1);
  t = digitalRead(_MISO);
  digitalWrite(_CLK,0);
  if (t) retval |= 1; else retval &= 0xFE;
  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);
}

Schémas