Fluxo de trabalho da semana

Estudar as placas de entrada do Neil → decidir o tipo de entrada → desenhar esquemático/placa → fresar a placa → soldar os componentes → depurar → editar e publicar o site

---

Ferramentas usadas

• Estação de solda
• CNC do TaoBao
• Equipamentos de teste: multímetro digital, osciloscópio, fonte de alimentação regulada

---

Software usado

• Autodesk Eagle
• ULP PCB-Gcode para o Autodesk Eagle
• Auto Leveller
• Fab Modules
• Gimp

---

Arquivos

1. Arquivos do Eagle
2. Arquivos de G-code
3. Arquivos de código

---

Tarefa em grupo

Veja a página da tarefa em grupo para mais detalhes.

---

Projeto individual

Nesta semana me concentrei em testar um termistor, que é essencial para o meu projeto de chocadeira medir e controlar a temperatura.

O termistor que escolhi é o B57560G0104. Segundo o datasheet, ele tem resistência de 100K a 25 graus Celsius.

A resistência do termistor cai quando a temperatura sobe. Como o CI lê tensão no pino do ADC, e não resistência, é preciso um divisor de tensão para chegar à resistência dele.

Liguei o termistor em série com um resistor ao VCC. Uma ponta do termistor vai no terra, e a outra fica em série.

Hero shot da minha placa com o sensor de temperatura

---

Referências

Como fiz na semana 6, comecei revisando as placas do Neil. A que redesenhei foi a placa de entrada de luz visível.

A placa de temperatura do Professor Neil

---

Experimentando com um Arduino

O objetivo deste experimento era entender e testar o termistor e o código. Apesar de ter funcionado, as leituras de temperatura não ficaram muito precisas. Sem instrumentos precisos para calibrar, fervi água para garantir uma temperatura de uns 100 graus Celsius.

Fervendo água com um ferro de solda. Termistor mergulhado no líquido.

Detalhe do termistor junto com a sonda de temperatura.

---

Programando o ATtiny com um USBasp

Programador USBasp num ATtiny45

O vídeo abaixo mostra o processo de programação.

Vídeo em alta resolução no YouTube

---

Experimento com a placa que projetei

Hero shot da minha placa com o sensor de temperatura

---

Projetando a PCB

O datasheet do ATtiny45 aqui

Como normalmente programo com a Arduino IDE, é bem útil ter não só o datasheet mas também um diagrama que converte os pinos de uma plataforma de programação para a outra.

Numa olhada rápida, dá para ver que há 4 pinos analógicos do Arduino. Todos têm conversor analógico-digital (ADC0, ADC1, ADC2, ADC3), então também poderiam ser usados como pinos digitais, junto com os pinos 1, 0 e 2.

Para esta tarefa, vou precisar de 1 pino analógico e 2 pinos digitais. No pino analógico vou ligar o termistor, e os pinos digitais são para a comunicação serial.

A placa vai ter um conector para o programador ISP, 2 conectores nas laterais para poder usar e testar todos os pinos quando precisar, e também um LED só para mostrar que está chegando energia.

O Autodesk Eagle é a arma escolhida, mas vou gerar o G-code com o add-in pcb-gcode.

Cálculo dos resistores

Para calcular os valores dos resistores, examinei os datasheets abaixo, e aqui estão os cálculos/observações que fiz:

LED azul

Trecho do datasheet

Cálculo do resistor

Abaixo está o esquemático do meu projeto:

Esquemático da placa com ATtiny45

Placa de dispositivos de entrada com ATtiny45

A placa do termistor

Na minha placa do termistor, usei:

1. Vishay Dale NTHS1206N01N1003KE NTC 100KOHM 3964K 1206, datasheet aqui.
2. Um resistor de 100k como pull-down

A resistência de um termistor NTC cai quando a temperatura sobe, e vice-versa. Para calcular a resistência, usa-se um resistor conhecido para medir a queda de tensão. O ATtiny45 não mede resistência diretamente, então a fórmula usada no programa é: RT = ((VCC*R-R*VRT)/VRT)

Esquemático da placa do termistor

Desenho da placa do termistor

---

Código para o ATtiny45

Usei três conjuntos de código nesta tarefa:

1. Fontes sobre software serial: fonte1 fonte2

   Como a serial por hardware normal não podia ser usada no ATtiny, incluí uma biblioteca para ter essa função:

   #include "SoftwareSerial.h"
   SoftwareSerial Monitor(1, 0);
   
   void setup() 
   {
       Monitor.begin(9600);
       pinMode(0, OUTPUT);
       pinMode(1, INPUT);
   }
               

   O print é feito de outro jeito:

   Monitor.println(whatever you want to print here);
               

2. Leitura de temperatura com Arduino

   O código usado nos experimentos com Arduino veio do Arduino Project Hub: How Easy Is It to Use a Thermistor?!, de Marcazzan_M:

   //Thermometer with thermistor
   
   /*thermistor parameters:
    * RT0: 10 000 Ω
    * B: 3977 K +- 0.75%
    * T0:  25 C
    * +- 5%
    */
   
   //These values are in the datasheet
   #define RT0 10000   // Ω
   #define B 3977      // K
   //--------------------------------------
   
   #define VCC 5    //Supply voltage
   #define R 10000  //R=10KΩ
   
   //Variables
   float RT, VR, ln, TX, T0, VRT;
   
   void setup() {
     Serial.begin(9600);
     T0 = 25 + 273.15;                 //Temperature T0 from datasheet, conversion from Celsius to kelvin
   }
   
   void loop() {
     VRT = analogRead(A0);              //Acquisition analog value of VRT
     VRT = (5.00 / 1023.00) * VRT;      //Conversion to voltage
     VR = VCC - VRT;
     RT = VRT / (VR / R);               //Resistance of RT
   
     ln = log(RT / RT0);
     TX = (1 / ((ln / B) + (1 / T0))); //Temperature from thermistor
   
     TX = TX - 273.15;                 //Conversion to Celsius
   
     Serial.print("Temperature:");
     Serial.print("\t");
     Serial.print(TX);
     Serial.print("C\t\t");
     Serial.print(TX + 273.15);        //Conversion to Kelvin
     Serial.print("K\t\t");
     Serial.print((TX * 1.8) + 32);    //Conversion to Fahrenheit
     Serial.println("F");
     delay(500);
   }
               

3. A minha versão do código junta a software serial e parte do código do Marcazzan, porque o ATtiny não compilava com a software serial e os cálculos de logaritmo juntos. O código tinha que caber em só 4k depois de compilado.

   O código aqui

   #include "SoftwareSerial.h"
   #define VCC 5    //Supply voltage
   #define R 100000  //R=100KΩ
   
   float RT,VRT,VR;
   
   SoftwareSerial Monitor(1, 0);
   
   void setup() {
       Monitor.begin(9600);
       pinMode(0, OUTPUT);
       pinMode(1, INPUT);
   }
   
   void loop() {
       VRT = analogRead(3);              //Acquisition analog value of VRT
       VRT = (5.00 / 1023.00) * VRT;      //Conversion to voltage
       VR = VCC - VRT;
       RT = ((VCC*R-R*VRT)/VRT);               //Resistance of RT
   
       // Monitor.println("Voltage Read:");
       // Monitor.print(VRT,10);
       // Monitor.println("Voltage drop:");
       // Monitor.print(VR,10);
       Monitor.print("Resistance:");
       Monitor.println(RT);
      
       delay(1000);
   }
               

   A fórmula original para achar a resistência não funcionou para mim porque na minha placa o termistor e o resistor estão trocados: o termistor vai no VCC e o resistor de 100k vai no terra. Mudei a fórmula para:

   RT = ((VCC*R-R*VRT)/VRT);               //Resistance of RT
               

---

Projetando e fazendo a PCB

Depois de mudar o meu fluxo de trabalho, atualizei para incluir o uso do ULP PCB-Gcode e do software Autoleveller.

---

Desenho no Autodesk Eagle

Com o esquemático pronto, siga estes passos:

1. Clique em SCH/BRD para abrir uma caixa de diálogo.
2. Na caixa de diálogo, clique em yes para colocar os componentes ao lado da área da placa.

Os componentes ficam ao lado do quadrado que representa a placa; a placa vai ser redimensionada depois.

Digite "move" e aperte enter, depois clique em cada componente e arraste para dentro da placa.

Aqui comecei a arrastar o ATtiny45 para dentro dos limites da placa. Para clicar em cada componente não precisa digitar "move" de novo, a não ser que aperte "esc" ou use outro comando.

Todos os componentes foram arrastados, e os limites de cima estão sendo arrastados e redimensionados com o comando "move". Outro jeito de mover componentes é digitar "info" e clicar com o botão esquerdo no componente, o que deixa você digitar as coordenadas do elemento em vez de arrastar.

O comando "rotate" permite girar o componente para a orientação ideal para um roteamento eficiente. As linhas amarelas representam as ligações criadas no esquemático.

Aqui estou criando um contorno com o comando "polygon". Quando ele fecha, abre uma caixa de diálogo.

Depois de terminar o polígono, a caixa de diálogo abre. Digitar "GND" liga o polígono ao terra.

Digitar "ratsnest" ou clicar no ícone dele preenche toda a área da placa com a camada de terra. Agora, digitando "autoroute" ou usando o comando "route", dá para ligar os componentes.

Antes de rotear os componentes, vá em edit → design rules para definir as distâncias entre cada elemento.

Na aba "sizes", defina a largura mínima da trilha. Na minha experiência, 0.2mm funciona muito bem.

A aba "clearance" define a distância entre cada elemento da PCB. Hoje estou usando 0.3mm em todos os sinais.

Com todas as regras de projeto definidas, digitar "autorouter" ou clicar no ícone dele inicia o processo de ligar cada componente.

Uma configuração importante é clicar na caixa chamada "bottom" e selecionar N/A se não quiser as duas faces. Depois, apertar vai iniciar o processo.

Depois, escolha uma das opções e clique em "evaluate" ou "end job" para voltar ao layout da placa.

Circulei em amarelo para mostrar a camada de baixo da placa, em azul. Não quero isso, então vou refazer a placa no próximo passo.

Aqui dá para ver o efeito do comando "ratsnest". Esse comando preenche com o terra todos os espaços que não estão ocupados por uma via.

Como quero que o autorouter refaça tudo, digitei "ripup" e selecionei tudo, assim todas as rotas são desfeitas.

E refaço o processo de autoroute.

Aqui a rota está feita, mas ainda sem o "ratsnest".

Aqui o "ratsnest" foi aplicado.

Neste passo, mexi nos componentes para diminuir um pouco a placa. Isso é feito com o comando "move". Se quiser mover vários componentes, selecione-os e digite "group", depois digite "move" e clique com o botão direito neles para mover o grupo inteiro.

---

O dilema do ratsnest

Abaixo dá para ver uma placa com e sem "ratsnest".

A primeira placa está com o "ratsnest". Fica um pouco mais poluída. Uma vantagem é térmica: ter uma superfície de cobre maior ajuda a refrigerar a placa, e também dá mais condutividade, principalmente em placas de 2 faces, onde uma face pode ser o terra e a outra o VCC, deixando quase toda a superfície para a transferência de energia. A segunda placa fica mais limpa.

Hoje prefiro fazer placas sem "ratsnest", porque a solda manual pode ser imprecisa, curtos-circuitos acontecem fácil, e o "ratsnest" pode aumentar esse risco.

O contorno grosso azul-claro desenhado na camada "milling" é usado pelo ULP pcb-gcode para criar um contorno de fresagem em G-code. O software usa isso para criar os limites, e o corte pode ser usado para soltar a placa da chapa de cobre. A espessura do polígono define o tamanho da fresa.

---

BOM da placa

---

PCB-Gcode

Há um tempo, comecei a usar o User Language Program (ULP) chamado PCB-Gcode. É um ótimo programa, com muitas configurações, que fui descobrindo em parte lendo a documentação e em parte na tentativa e erro.

Abaixo mostro como configurei para gerar o G-code sem dor de cabeça.

1. Clique em file
2. Depois em Run ULP
3. Depois clique em pcb-gcode-setup

As configurações que personalizei são:

1. Escolhi gerar só top outlines e top drills: -o primeiro é o G-code da placa para cortá-la da chapa. -o segundo são os furos que a placa possa ter. A espessura da fresa ou da broca é escolhida na aba machine
2. Aqui dá para definir a espessura da placa. As minhas placas saem bem separadas com um corte de 1.72mm, e em "num Slices" escolhi 6, ou seja, a placa vai ser cortada em 6 passadas.
3. Os spot drill holes são marcações leves feitas durante a gravação das vias e de todos os elementos do desenho da placa. Servem para alinhar a broca que vai fazer o furo e evitar que a ponta da broca escorregue na placa. A minha escolha é 0.055mm, o mesmo que uso para a gravação.
4. A isolação foi uma das configurações mais importantes. Essa configuração pode deixar o computador bem lento se o máximo for alto demais. O que funciona para mim é: -mínimo 0.0254mm (padrão); máximo 1.5mm; passo 0.05mm. Este último, junto com o máximo, garante 30 passadas, o que garante que não sobra cobre entre as trilhas e que elas ficam bem isoladas, reduzindo o risco de curtos. Esses números podem ser um exagero, mas está funcionando muito bem e estou tirando placas lindas. No futuro, talvez eu diminua ou aumente o passo.

Na aba Machine são escolhidas configurações como profundidade de corte, unidade, avanços e diâmetro da ferramenta.

1. - Z high está em 12.7 (padrão), essa configuração deve dar folga para fixações que possam estar no caminho; -Z up é a altura acima da placa quando a máquina se desloca de um ponto a outro; -Z down é a profundidade do corte. Esse número é muito importante no meu caso, porque uso uma fresa V de 10 graus. Se eu for fundo demais, corto mais do que devia, e se for raso demais, corto menos. Claro, 10 graus não é muito íngreme e perdoa mais um erro de profundidade do que uma fresa de gravação mais íngreme; - a profundidade de furação é a profundidade dos furos passantes, e em geral deve ser um pouco maior que a espessura da placa virgem para compensar imperfeições; o drill dwell é a pausa entre cada furo, ela deixa a broca esfriar, deixo no padrão.
2. Aqui defino a unidade como mm
3. Todos os meus avanços de gravação estão no padrão
4. O diâmetro da ferramenta que uso é 0.1 mm

A aba G-code style serve para escolher o pós-processador. Uso o Mach3.

Aqui está a visualização do G-code gerada pelo ULP. Dá para usar as setas para andar pela imagem, e também os sinais de mais e menos.

São gerados quatro arquivos:

1. *.bot.mill.gcode: é a fresagem de baixo (contorno), não uso esse arquivo.
2. *.top.drill.gcode: é o G-code dos furos
3. *.top.mill.gcode: é o arquivo do contorno da camada de cima, esses arquivos permitem soltar a PCB.
4. Por fim, *.top.etch.gcode é o G-code da gravação da PCB com todos os elementos desenhados.

Abaixo está a visualização da isolação da placa do termistor.

---

Autoleveller

O Autoleveller é um ótimo software. Ele sonda a placa virgem e depois usa o arquivo gerado para ajustar a profundidade de corte do G-code, garantindo que a fresadora acompanhe o relevo da placa virgem. Abro o Autoleveller rodando o executável; no Linux não precisa instalar nada. Depois, clique em File e em Original GCode File (OGF): isso carrega o G-code original no programa.

Clique no G-code original.

Clique em yes para as configurações serem baseadas no arquivo carregado.

Depois, clique em Generate PFG no canto inferior direito da janela. Isso cria um G-code com uma série de instruções. Ele vai: -primeiro sondar o Z 0; -segundo sondar vários pontos na área da placa; - terceiro, pedir um lugar para salvar o arquivo bruto, que depois vai ser usado para criar o G-code autonivelado.

Aqui o arquivo PFG está sendo salvo. Depois, carregue esse G-code na CNC e siga as instruções na área do G-code.

Agora é hora de prender a placa virgem na mesa da CNC. Não uso mais fita dupla face, porque ela não é tão eficiente quanto as fixações, e ainda tem que limpar os restos de fita depois.

Na minha CNC, usinei antes um rebaixo para a placa ter uma posição fixa, o que ajuda a imobilizar a placa virgem.

Na CNC, com o PFG carregado, siga as instruções na tela, ligando a sonda.

Aqui estou ligando a sonda na superfície da placa e a garra jacaré na fresa.

Este vídeo mostra o processo de sondagem.

Terminada a sondagem, salve o arquivo bruto, leve para o Autoleveller e carregue.

Carregue o arquivo bruto da sondagem de volta no Autoleveller.

Por fim, salve o G-code ajustado clicando em Autolevel no canto inferior direito da tela. Salve o arquivo e leve para a CNC para começar a fresagem.

Vídeos da usinagem

Vídeo em câmera lenta do processo de gravação (fresagem).

O resultado final está aqui. Às vezes uso lixa grão 1000 para dar um acabamento melhor.

Agora vou mostrar a borda sendo cortada.

Fresando as bordas da placa

---

Os resultados

Placa do termistor logo antes da solda.

Placa do termistor depois da solda e da limpeza com álcool isopropílico.

Placa do ATtiny45 mais a placa do termistor, prontas para trabalhar.

Notas

avrdude -Cavrdude.conf -v -pattiny45 -cusbasp -Pusb -e -Uefuse:w:0xff:m -Uhfuse:w:0xdf:m -Ulfuse:w:0xe2:m

Monitor serial: vídeo no YouTube

Projeto de controlador de ventoinha com ATtiny: Robot Room

Leitura de temperatura com Arduino e termistor NTC: Circuit Digest

Configurar o Arduino 022: High-Low Tech

Projeto de forno de refusão (reflow): Pleasant Software

Resistor de pull-up (RES SMD 10K OHM 1% 1/4W 1206) do RST ao VCC

Capacitor de desacoplamento (CAP CER 1UF 50V X7R 1206) do VCC ao GND para reduzir ruído

← (25 mar) Programação Embarcada · todas as semanas · Aplicações e Implicações (15 abr) →

Relacionadas: Projeto Eletrônico, Dispositivos de Saída, Redes e Comunicação, Moldagem e Fundição