Programação "Alta Voltagem" do ATmega - Parte 3

Decisões tomadas, é hora de partir para a prática. No caso montar um protótipo na protoboard.

Nesta etapa vou usar um Arduino Nano e interagir com o hardware através da interface serial. Não estou montando ainda display, botão, encoder e memória EEProm. São apenas quatro elementos na protoboard principal:

• Arduino Nano, que fará o controle da programação
• PCF8574A, expansor de I/O através do qual serão colocados os dados
• TLP521, um acoplador ótico usado para chavear os 12 volts
• Soquete ZIF onde será colocado o ATmega a ser gravado

O circuito fica assim:

A alimentação de 5V para o PCF8574A vem do Arduino Nano, os 12V vem de uma fonte linear simples com um regulador 78L12, montada em uma protoboard miniatura. O circuito da fonte de 12V é o seguinte:

A primeira aplicação para o Nano é um software simples para testar as conexões. Os sinais são acionados um a um a cada digitação de Enter no monitor serial da IDE do Arduino para conferência com um multímetro no soquete ZIF.

view plaincopy to clipboardprint?

1. #include <Wire.h>  
2.   
3. /* 
4.  * ATmegaDetonator 
5.  * Teste das conexões ao ATmega que será gravado 
6.  *  
7.  * (C) 2020, Daniel Quadros 
8.  */  
9.   
10.   
11. // Conexões ao ATmega que será gravado  
12. const int pinVcc = 2;  
13. const int pin12V = 3;  
14. const int pinOE = 4;  
15. const int pinWR = 5;  
16. const int pinBS1 = 6;  
17. const int pinBS2 =7;  
18. const int pinXA0 = 8;  
19. const int pinXA1 = 9;  
20. const int pinPAGEL = 10;  
21. const int pinXTAL1 = 11;  
22. const int pinRdy = A3;  
23.   
24. // Endereço do PF8574A  
25. // (para PCF7584 usar 0x20)  
26. const byte PCF8574_Addr = 0x38;  
27.   
28. struct {  
29.   char *nome;  
30.   int pino;  
31. } conexoes[] = {  
32.   { "Vcc ", pinVcc },  
33.   { "12V ", pin12V },  
34.   { "OE  ", pinOE },  
35.   { "WR  ", pinWR },  
36.   { "BS1 ", pinBS1 },  
37.   { "BS2 ", pinBS2 },  
38.   { "XA0 ", pinXA0 },  
39.   { "XA1 ", pinXA1 },  
40.   { "PGL ", pinPAGEL },  
41.   { "XTL1", pinXTAL1 },  
42.   { "", 0 }  
43. };  
44.   
45. // Inicia todos os pinos como saída e nível baixo  
46. void setup() {  
47.   int i = 0;  
48.   while (conexoes[i].pino != 0) {  
49.     pinMode(conexoes[i].pino, OUTPUT);  
50.     digitalWrite(conexoes[i].pino, LOW);  
51.     i++;  
52.   }  
53.   Wire.begin();  
54.   PCF8574_Write(0);  
55.   Serial.begin(115200);  
56.   Serial.println();  
57.   Serial.println("Testando!");  
58. }  
59.   
60. // Aciona cada um dos pinos por 5 segundos  
61. void loop() {  
62.   static int i = 0;  
63.   static int j = 0;  
64.   
65.   if (conexoes[i].pino == 0) {  
66.     if (j == 8) {  
67.       PCF8574_Write(0);  
68.       i = j = 0;  
69.     } else {  
70.       PCF8574_Write(1 << j);  
71.       Serial.print("D");  
72.       Serial.print(j);  
73.       Serial.print("\n");  
74.       espera();  
75.       j++;  
76.       return;  
77.     }  
78.   }  
79.   Serial.print(conexoes[i].nome);  
80.   digitalWrite(conexoes[i].pino, HIGH);  
81.   espera();  
82.   digitalWrite(conexoes[i].pino, LOW);  
83.   Serial.print("\n");  
84.   i++;  
85. }  
86.   
87. void espera() {  
88.   while (Serial.read() < 0) {  
89.     delay (100);  
90.   }  
91. }  
92.   
93. void PCF8574_Write(byte dado) {  
94.   Wire.beginTransmission(PCF8574_Addr);  
95.   Wire.write(dado);  
96.   Wire.endTransmission();  
97. }  

#include <Wire.h>

/*
 * ATmegaDetonator
 * Teste das conexões ao ATmega que será gravado
 * 
 * (C) 2020, Daniel Quadros
 */


// Conexões ao ATmega que será gravado
const int pinVcc = 2;
const int pin12V = 3;
const int pinOE = 4;
const int pinWR = 5;
const int pinBS1 = 6;
const int pinBS2 =7;
const int pinXA0 = 8;
const int pinXA1 = 9;
const int pinPAGEL = 10;
const int pinXTAL1 = 11;
const int pinRdy = A3;

// Endereço do PF8574A
// (para PCF7584 usar 0x20)
const byte PCF8574_Addr = 0x38;

struct {
  char *nome;
  int pino;
} conexoes[] = {
  { "Vcc ", pinVcc },
  { "12V ", pin12V },
  { "OE  ", pinOE },
  { "WR  ", pinWR },
  { "BS1 ", pinBS1 },
  { "BS2 ", pinBS2 },
  { "XA0 ", pinXA0 },
  { "XA1 ", pinXA1 },
  { "PGL ", pinPAGEL },
  { "XTL1", pinXTAL1 },
  { "", 0 }
};

// Inicia todos os pinos como saída e nível baixo
void setup() {
  int i = 0;
  while (conexoes[i].pino != 0) {
    pinMode(conexoes[i].pino, OUTPUT);
    digitalWrite(conexoes[i].pino, LOW);
    i++;
  }
  Wire.begin();
  PCF8574_Write(0);
  Serial.begin(115200);
  Serial.println();
  Serial.println("Testando!");
}

// Aciona cada um dos pinos por 5 segundos
void loop() {
  static int i = 0;
  static int j = 0;

  if (conexoes[i].pino == 0) {
    if (j == 8) {
      PCF8574_Write(0);
      i = j = 0;
    } else {
      PCF8574_Write(1 << j);
      Serial.print("D");
      Serial.print(j);
      Serial.print("\n");
      espera();
      j++;
      return;
    }
  }
  Serial.print(conexoes[i].nome);
  digitalWrite(conexoes[i].pino, HIGH);
  espera();
  digitalWrite(conexoes[i].pino, LOW);
  Serial.print("\n");
  i++;
}

void espera() {
  while (Serial.read() < 0) {
    delay (100);
  }
}

void PCF8574_Write(byte dado) {
  Wire.beginTransmission(PCF8574_Addr);
  Wire.write(dado);
  Wire.endTransmission();
}

Estou colocando toda a documentação e código do projeto no github: https://github.com/dquadros/ATmegaDetonator

No próximo post vamos ver se conseguimos colocar um ATmega no modo programação.