Controle remoto para Canon

Olá humano!

Bom, é facil imaginar que eu tenho uma camera para registrar as fotos que faço para usar aqui no blog. No inicio eu usava meu celular, mas com o tempo fui verificando a necessidade de usar um tripe, e conseguir algumas fotos com um pouco mais de qualidade e liberdade, e tambem precisei trocar de celular, e o novo tem uma camera muito inferior ao anterior. Com isso comprei uma camera DSLR, da Canon, modelo T3 (modelo de entrada, semi-profissional, da época).

Essa camera possui muitas funções (e como tudo na vida, ainda mais as opções mais baratas, não tem algumas opções interessantes como entrada de microfone externo), uma delas é a entrada para um controle remoto (permite acionar o foco automatico e disparar fotos). Eu poderia ter comprado um controle remoto pronto, ou fazer um. Como fica evidente, resolvi fazer um.

Material usado
Material usado

Continue lendo “Controle remoto para Canon”

Placa de experimentos com PIC

Olá humano!

Algumas vezes (não foram poucas) pessoas próximas me pedem para ‘ensinar’ a programar microcontroladores PIC. Decidi então colocar alguns posts por aqui, ensinando algumas coisas destes microcontroladores.

Vamos começar pelo começo (ao menos neste post). PIC é uma família (muito grande) de microcontroladores fabricados pela empresa Microchip. Eles podem vir nos sabores núcleos de 8, 16 e 32 bits, e também existem os DSP (Digital Signal Processors), que são outra historia a parte.

Como normalmente as maiores duvidas são de iniciantes neste ramo (microcontroladores), resolvi fazer uma placa que usasse um PIC de 8 bits, bastante conhecido, com muito material disponível na internet, mas que nem por isso é limitado, o PIC18F4550. Este microcontrolador pode funcionar até 48MHz de clock, o que resulta em um processamento de 12 MIPS (Milhões de Instruções por Segundo), uma vez que a arquitetura da Microchip utiliza 4 ciclos de clock para cada instrução. Continue lendo “Placa de experimentos com PIC”

Placa Adaptadora Gravação

Olá humano!

Vou começar do fim para o inicio. Antes de escrever um post sobre o gravador de PIC USB, que é mais complexo e portanto maior, requerendo assim mais tempo deste que vos escreve, vou escrever sobre uma placa para adaptar o cabo de gravação que sai do gravador (que assim como no original ICD2 é um conector RJ11 de seis vias).

Neste projeto tentei resolver pelo menos dois problemas que tinha quanto a saída do gravador em questão, uma placa para gravar um (qualquer) PIC fora de um circuito, portanto preciso de um soquete para o microcontrolador em questão e um conector compatível com o gravador. A questão é, uma vez que quero ter a possibilidade de gravar uma grande variedade de modelos optei por deixar um (ou como veremos, dois) conector numa extremidade da placa, e conectores ao lado do soquete, de forma que com fios de jumpers eu possa ‘configurar’ os sinais de alimentação e gravação para cada modelo de microcontrolador.

O soquete que escolhi para este projeto é um do tipo textool da empresa 3M. Não tenho certeza se este que comprei é original, mas de qualquer forma me pareceu bom o suficiente. Este soquete é bem maior (e também mais caro…), e possui uma alavanca em uma das extremidades. Quando acionamos esta alavanca, optamos por duas posições, na primeira temos os contatos do soquete mais afastados, permitindo a inserção e a retirada do circuito integrado sem nenhum esforço e sem estragar nenhum dos terminais. Na outra posição da alavanca, os contatos do soquete se aproximam, fazendo uma ‘pressão’ contra os contatos do circuito integrado e dessa forma fazendo o contato do soquete com os terminais, com isso temos a posição de uso durante a gravação, nesta posição o circuito fica solidário ao soquete e não pode ser removido com facilidade.

Também optei por deixar um conector de dez pinos (tipo IDC, usado com o flat cable). Eu acostumei a usar este conector nas ultimas placas que projetei, pois acho mais pratico, e simples de usar do que o conector RJ11. Dessa forma posso utilizar esta placa para gravar um PIC fora do circuito e também funcionar como um ‘simples’ conversor RJ11-IDC.

Bom, sem muito mais a acrescentar, uma vez que o projeto é bastante simples, podemos verificar abaixo as fotos da placa. Os arquivos da projeto (em EAGLE) podem ser baixados aqui e o arquivo (.pdf) para impressão da placa pode ser baixado aqui.

Conjunto de gravador e placa adaptadora
Figura 01: Conjunto de gravador e placa adaptadora
Placa configurada com os jumpers
Figura 02: Placa configurada com os jumpers
Detalhe do conector IDC
Figura 03: Detalhe do conector IDC

Abaixo coloquei duas fotos, para exemplificar o uso do conector IDC em uma placa (do circuito Dual DAC), a primeira mostrando o conector e a segunda com o cabo da placa adaptadora conectado para realizar uma gravação.

Conector IDC (ICSP)
Figura 04: Conector IDC (ICSP)
Conector IDC (ICSP)
Figura 05: Conector IDC (ICSP), em uso

Fica a dica para quem esta precisando de algo deste tipo. Até a próxima!

Double-Precision DAC (Dual DAC) – Parte II

Olá humano!

Dando continuidade (enfim), ao teste do circuito Dual DAC, vou colocar o firmware e os resultados que obtive com o circuito proposto.

Abaixo temos o código (em Pascal) utilizado neste projeto:

[sourcecode language=”pascal”]
program Dual_DAC;

{ Declarations section }
//****************************************************************************//
// www.sbampato.com/blogbr (pt-br) //
// //
// Author: Mario Sbampato //
// License: Free, at anyway //
// Date: 15.08.2014 //
// Version: 1.0.0.0 //
// Contact: mario@sbampato.com //
// //
// www.sbampato.com/blogbr (english) //
//****************************************************************************//

//Hardware: placa de teste dual DAC
//PIC18F4550
//20MHz – Quartz Cristal
//
// MAX232 ligado nos pinos TX/RX do pic, para com. serial
// Pin 19 (RD0/SPP0) – Chip Select (~CS) do DAC01
// Pin 20 (RD1/SPP1) – Chip Select (~CS) do DAC02
// Pin 21 (RD2/SPP2) – ~LDAC dos DAC
// Pin 33 (RB0/SDI) – Ligado aos pinos SDI dos DAC
// Pin 34 (RB1/SCK) – Ligado aos pinos SCK dos DAC
// Pin 35 (RB2/INT2) – NC
// Pin 26 (RC7/SDO) – NC
//
// DAC – 2x MCP4921 (SPI DAC / 12 bits resolution)

// Variables list

// DAC01 CS
var Chip_Select02 : sbit at RD0_bit;
Chip_Select_Direction02 : sbit at TRISD0_bit;
// End DAC01 CS

// DAC02 CS
var Chip_Select01 : sbit at RD1_bit;
Chip_Select_Direction01 : sbit at TRISD1_bit;
// End DAC02 CS

// DAC module connections
var
SoftSpi_CLK : sbit at RB1_bit;
SoftSpi_SDI : sbit at RB2_bit; // Note: Input signal
SoftSpi_SDO : sbit at RB0_bit;

var
SoftSpi_CLK_Direction : sbit at TRISB1_bit;
SoftSpi_SDI_Direction : sbit at TRISB2_bit;
SoftSpi_SDO_Direction : sbit at TRISB0_bit;
// End DAC module connections

var value : word;
value2 : word;
uart_rd01: byte;
uart_rd02: byte;
uart_rd03: byte;
uart_rd04: byte;
str1 : string[13];
vlstr1 : string[4];
vlstr2 : string[4];
i, j : byte;

//Added Routines and procedures

procedure InitMain();
begin
Chip_Select01 := 1; // Deselect DAC01
Chip_Select_Direction01 := 0; // Set CS# pin as Output
Chip_Select02 := 1; // Deselect DAC02
Chip_Select_Direction02 := 0; // Set CS# pin as Output
Soft_SPI_Init(); // Initialize SPI module
end;

// DAC increments (0..4095) –> output voltage (0..Vref)
procedure DAC01_Output( valueDAC : word);
var temp : byte;
begin
Chip_Select01 := 0; // Select DAC chip

// Send High Byte
temp := word(valueDAC shr 8) and 0x0F; // Store valueDAC[11..8] to temp[3..0]
temp := temp or 0x30; // Define DAC setting, see MCP4921 datasheet
Soft_SPI_Write(temp); // Send high byte via SPI

// Send Low Byte
temp := valueDAC; // Store valueDAC[7..0] to temp[7..0]
Soft_SPI_Write(temp); // Send low byte via SPI

Chip_Select01 := 1; // Deselect DAC chip
end;

// DAC increments (0..4095) –> output voltage (0..Vref)
procedure DAC02_Output( valueDAC : word);
var temp : byte;
begin
Chip_Select02 := 0; // Select DAC chip

// Send High Byte
temp := word(valueDAC shr 8) and 0x0F; // Store valueDAC[11..8] to temp[3..0]
temp := temp or 0x30; // Define DAC setting, see MCP4921 datasheet
Soft_SPI_Write(temp); // Send high byte via SPI

// Send Low Byte
temp := valueDAC; // Store valueDAC[7..0] to temp[7..0]
Soft_SPI_Write(temp); // Send low byte via SPI

Chip_Select02 := 1; // Deselect DAC chip
end;

//Main routine
begin
{ Main program }

TRISB := 0; // Configure PORTB all Output
PORTB := 0; // Turn off all PORTB
TRISA := 0; // Configure PORTA all Output
PORTA := 0; // Turn off all PORTA
TRISD := 0; // Configure PORTD all Output
PORTD := 7; // Turn off all PORTD
ADCON1 := 0x0F; // Configure all ports with analog function as digital
CMCON := CMCON or 7; // Configure AN pins as digital I/O

InitMain(); // Call Soft_SPI ini procedure

value := 1206; // Set DAC_01 = 1.200V
value2:= 0; // Set DAC_02 = 0.000V
PORTD := 7; // Hold DAC latch
DAC01_Output(value); // Send value to DAC01 chip
DAC02_Output(value2); // Send value to DAC02 chip
PORTD := 0; // Release DAC latch
Delay_ms(300); // Wait 0.3 seconds
PORTD := 7; // Lock DAC registers latch

uart_rd01 := 0;
uart_rd02 := 0;
uart_rd03 := 0;
uart_rd04 := 0;

str1 := ”;
vlstr1 := ”;
vlstr2 := ”;

UART1_Init(9600); // Initialize UART module at 9600 bps
Delay_ms(120); // Wait for UART module to stabilize
UART1_Write(13); //
UART1_Write(10); // Add a break line – as ‘enter’
UART1_Write_Text(‘****************************************’);
UART1_Write(13); //
UART1_Write(10); // Add a break line – as ‘enter’
UART1_Write_Text(‘Author: Mario Sbampato’);
UART1_Write(13); //
UART1_Write(10); // Add a break line – as ‘enter’
UART1_Write_Text(‘Contact: contact@sbampato.com’);
UART1_Write(13); //
UART1_Write(10); // Add a break line – as ‘enter’
UART1_Write_Text(‘Website: www.sbampato.com/blog’);
UART1_Write(13); //
UART1_Write(10); // Add a break line – as ‘enter’
UART1_Write_Text(‘—————————————-‘);
UART1_Write(13); //
UART1_Write(10); // Add a break line – as ‘enter’
UART1_Write_Text(‘Send data in this format:’);
UART1_Write(13); //
UART1_Write(10); // Add a break line – as ‘enter’
UART1_Write_Text(‘M:XXXX;YYYY;S’);
UART1_Write(13); //
UART1_Write(10); // Add a break line – as ‘enter’
UART1_Write_Text(‘Where XXXX —> Data to DAC01, [0..4095]’);
UART1_Write(13); //
UART1_Write(10); // Add a break line – as ‘enter’
UART1_Write_Text(‘and’);
UART1_Write(13); //
UART1_Write(10); // Add a break line – as ‘enter’
UART1_Write_Text(‘YYYY —> Data to DAC02, [0..4095]’);
UART1_Write(13); //
UART1_Write(10); // Add a break line – as ‘enter’
UART1_Write_Text(‘Always use four digits for the values!’);
UART1_Write(13); //
UART1_Write(10); // Add a break line – as ‘enter’
UART1_Write_Text(‘—————————————–‘);
UART1_Write(13); //
UART1_Write(10); // Add a break line – as ‘enter’
UART1_Write_Text(‘Sao Carlos / SP. August, 2014. ‘);
UART1_Write(13); //
UART1_Write(10); // Add a break line – as ‘enter’
UART1_Write_Text(‘****************************************’);
UART1_Write(13); //
UART1_Write(10); // Add a break line – as ‘enter’

UART1_Write(13); //
UART1_Write(10); // Add a break line – as ‘enter’
UART1_Write_Text(‘Dual DAC Test Board Ready!’);
UART1_Write(13); //
UART1_Write(10); // Add a break line – as ‘enter’
UART1_Write(13); //
UART1_Write(10); // Add a break line – as ‘enter’

while (TRUE) do // Endless loop
begin
i := 0;

if (UART1_Data_Ready() = 1) then
begin
for i:=0 to 11 do // if data is received
begin
str1[i] := UART1_Read();
while (UART1_Data_Ready() <> 1) do
begin
j := i;
end;
end;

Inc(i);
str1[i] := UART1_Read();

vlstr1 := ‘0000’;
for i:=0 to 3 do
vlstr1[i] := str1[i+2];

vlstr2 := ‘0000’;
for i:=0 to 3 do
vlstr2[i] := str1[i+7];

Delay_ms(12);
UART1_Write(13);
UART1_Write(10);

UART1_Write_Text(‘Received: ‘);
UART1_Write_Text(str1);
UART1_Write(13);
UART1_Write(10);

UART1_Write_Text(‘Value DAC1: ‘);
UART1_Write_Text(vlstr1);
UART1_Write(13);
UART1_Write(10);

UART1_Write_Text(‘Value DAC2: ‘);
UART1_Write_Text(vlstr2);
UART1_Write(13);
UART1_Write(10);

//value := 1206; // Set DAC_01 = 1.200V
//value2:= 0; // Set DAC_02 = 0.000V

value := StrToWord(vlstr1);
value2:= StrToWord(vlstr2);

if (value < 0) then
value := 0
else
if (value > 4095) then
value := 4095;

if (value2 < 0) then
value2 := 0
else
if (value2 > 4095) then
value2 := 4095;

PORTD := 7; // Hold DAC latch
DAC01_Output(value); // Send value to DAC01 chip
DAC02_Output(value2); // Send value to DAC02 chip
PORTD := 0;
Delay_ms(120);
PORTD := 7; // Lock DAC registers latch

UART1_Write_Text(‘Values updated:’);
UART1_Write(13);
UART1_Write(10);
str1 := ‘0’;
WordToStr(value, str1);
UART1_Write_Text(‘DAC01:’);
UART1_Write_Text(str1);
UART1_Write(13);
UART1_Write(10);
str1 := ‘0’;
WordToStr(value2, str1);
UART1_Write_Text(‘DAC02:’);
UART1_Write_Text(str1);
UART1_Write(13);
UART1_Write(10);
end; // Release DAC latch

end;

end.
[/sourcecode]

O código também pode ser copiado aqui.

Após fazer o download do firmware no PIC, procedi o teste utilizando a ferramenta de terminal (USART Terminal) do próprio MikroPascal. E com isso pude enviar os comandos e variar os valores de tensão da maneira que achei mais interessante. O formato do dado que envio é o seguinte: M:XXXX;YYYY;S. Sendo M e S os indicadores de inicio e fim do dado e XXXX e YYYY os valores dos DAC01 e DAC02, respectivamente.

A montagem para o teste do circuito pode ser vista abaixo:

Circuito em teste
Figura 07: Circuito em teste
Set-up utilizado no teste
Figura 08: Set-up utilizado no teste
Foto dos equipamentos utilizados
Figura 09: Foto dos equipamentos utilizados

Com este set-up, variei primeiramente o DAC01 (onde cada incremento é 100 vezes menor que o incremento do DAC02), de zero até o final da escala (4095), obviamente que não na totalidade de pontos. Posteriormente variei o DAC02, porem até o valor de 50, uma vez que notei que o valor apresentado no display do multímetro oscilava muito (na casa das dezenas e centenas de μV).

Mesmo sem ter tomado todos os pontos, decidi parar o teste, e depois, se achar interessante, refaze-lo de maneira mais completa num outro dia.

Abaixo podemos verificar uma analise dos dados obtidos, e a quem interessar, estes dados podem ser baixados aqui em formato Excel, para analise.

Na tabela do Excel, onde os valores enviados se repetirem significa que após ir aumentando os valores, eu voltava algum valor anterior (mais baixo) para verificar se o circuito apresentava histerese, o que não consegui notar.

Pretendo fazer uma parte III deste circuito, com algumas mudanças, como a adição de um capacitor na saída final de forma a evitar a oscilação que percebi quando variava o valor do DAC02. Outras opções, opiniões etc… podem surgir. Um outro teste, seria colocar um osciloscópio e tentar enxergar esta oscilação da tensão, se conseguirmos verificar uma variação de tensão tão pequena. Uma outra possibilidade ainda, seria ligar o multímetro no computador e montar um software que faça leituras automáticas, possibilitando assim a obtenção dos valores para cada ponto dos conversores (mais de 8100 medições se variarmos cada um de um em um, ou 16 769 025 variações caso verificarmos todas as combinações possíveis…).

Conclusões até o momento:

* O circuito é parece funcionar (bom)
* O erro quando comparado valores ideais (calculados) e reais é bem pequeno (ao menos, quando usado somente um dos conversores, que não apresentava oscilação na saída)

* O circuito é complexo (muito mais complicado dois conversores, mais dois resistores, mais um amplificador operacional, quando comparamos com somente um conversor de maior resolução)
* O circuito apresentou uma oscilação quando um dos conversores era exigido, quando o outro era exigido esta oscilação não se apresentava (necessita mais investigação)
* O algoritmo para correlacionar valor (valores) e tensão de saída é mais complexo do que de um conversor de maior resolução nativa.

Se alguém (dos meus poucos leitores) possuir alguma duvida, ou sugestão para testar/modificar o circuito, por favor entre em contato. Manterei esta placa pelo menos por mais algum tempo, para pensar se vale mais investigação.

Os arquivos que utilizei neste projeto podem ser baixados aqui.

Até a próxima!

Confecção de Placa de Circuito Impresso (PCI)

Olá humano!

Neste post vou discutir uma técnica bastante usada para obtenção de placas de circuito impresso (PCI), ou também chamada de PCB (do inglês Printed Circuit Board), que é o método da transferência térmica, ou somente transfer. Este método é o que eu utilizo no meu serviço, sendo que em casa eu utilizo também o processo fotográfico (quem sabe posso discuti-lo em um próximo post) além deste método.

Basicamente o que é necessário é um papel especifico para transferência térmica, conhecido no ramo de estamparia de camisetas. Este papel normalmente tem um custo mais elevado do que as outras alternativas discutidas em outros sites ou forums, porem a facilidade de uso e a certeza de bons resultados recompensam. Aqui em minha cidade, é possível pagar R$0,90 em cada folha (embalagem de 100 folhas) que na minha opinião é um ótimo custo-benefício. A folha transfer que utilizo é originalmente vendida para ser utilizada para estampar canecas plásticas, com uso de impressoras laser.

Não tenho a intenção de aprofundar esta explicação, mas para entendimento do leitor o processo consiste basicamente de utilizar o toner (pó que é utilizado nas impressoras laser) para proteger as trilhas de cobre na placa virgem e posteriormente podermos corroê-la. Primeiramente imprimimos o layout da placa (espelhado) na folha de transfer (que possui uma superfície bastante lisa, não permitindo uma aderência definitiva do toner), e depois aplicando uma temperatura suficiente para fazer com que o pó se funda novamente (a primeira fusão ocorre dentro da impressora laser, no cilindro oportunamente chamado de fusor), de forma que ele descole da folha e se fixe no cobre da placa.

Vale lembrar que o funcionamento da impressora laser é o seguinte, a folha de papel é carregada eletricamente nos pontos onde a tinta (pó) deve se fixar, uma vez que o pó do toner tem carga elétrica oposta aquela da folha, quando o papel passa próximo do pó, este se atrai e ‘gruda’ na folha, mas se nesse momento a folha for retirada antes de passar pelo fusor, ao passarmos o dedo na pagina o toner irá sair da folha e grudar em nosso dedo. Após a folha estar com o toner ela passa por um cilindro que trabalha aquecido dentro da impressora, de forma que a temperatura, e a pressão exercida pelo mecanismo, faça com que o pó se funda se fixando assim ao papel. Estas razões fazem com que o toner (como também é usualmente chamado todo o mecanismo que contem fusor, pó de tinta, etc..) seja caro, uma vez que é necessário um elemento aquecedor, um rolo fusor (que precisa ter sua superfície muito lisa, de forma que a tinta ao fundir-se não se fixe a superfície do fusor), além da tinta em pó e toda a parte plástica necessária para agrupar estes elementos.

Bom depois desta chata longa descrição do funcionamento da impressora laser, podemos voltar ao que interessa, e discutir sobre o processo.

Antes de mais nada, é necessário um tratamento inicial para o cobre da placa de circuito impresso. O procedimento que eu utilizo é o seguinte: Usando luvas de látex (para que a gordura das mãos não suje o cobre) eu passo um pouco de palha de aço, a mesma que é utilizada na limpeza de utensílios de cozinha, de forma a obter uma superfície brilhante, livre de qualquer oxidação. Após isso, limpo com solvente (eu utilizo thinner, ou álcool isopropílico) utilizando uma folha de papel (pode ser papel higiênico, papel toalha) daqueles de secar a mão, comumente encontrados em banheiros públicos. Nesta hora, limpe bem a placa, e após isto, não coloque mais a mão na superfície do cobre. O antes e o depois da placa podem ser vistos na figura 1 abaixo:

Limpeza da placa
Figura 01: Diferença entre placa antes (acima) e depois (abaixo) da ‘limpeza’

Podemos perceber que o cobre da placa, depois de limpo, fica com uma aparência mais clara, sem manchas, e passa a refletir melhor a luz. Quanto melhor o processo de limpeza, melhor o resultado final.

Após isto é necessário que se imprima o layout da placa a ser corroída no papel transfer (acho que neste ponto já é óbvio que o uso da impressora laser é obrigatório). Cabe dizer que o layout da placa precisa estar espelhado, ou seja, vai parecer correto se olharmos a impressão através de um espelho. Outro detalhe é que dependendo do software (CAD) utilizado, a impressão já estará espelhada por padrão, como no caso do EAGLE CAD (software que eu utilizo). Detalhe numero dois, no EAGLE somente o layer botton é impresso espelhado por padrão, todos os outros precisam ser espelhados (escolhendo esta opção na hora da impressão). Na figura abaixo podemos notar a tela de impressão do EAGLE onde existem as opções de impressão, devemos sempre imprimir com a escala (scale) 1, com a opção black selecionada (preferencialmente), e em alguns casos com a primeira opção (mirror) selecionada. Detalhe numero três (e ultimo desta parte) é que quanto mais toner melhor, então entre nas opções de impressão e selecione o máximo nível de toner.

Detalhe do software EAGLE
Figura 02: Detalhe do software EAGLE

Uma vez o layout impresso, devemos recortar a folha, de forma a facilitar o uso, e então fixá-lo (fita crepe é uma ótima opção) com o lado impresso em contato com o cobre, como podemos verificar abaixo na figura 03

Papel transfer fixado na PCI
Figura 03: Papel transfer fixado na PCI

Após prepararmos a placa com o papel transfer passamos a etapa da transferência de fato, onde iremos aplicar uma alta temperatura, e uma pressão neste conjunto, de forma a obtermos a transferência do toner para a placa.

Aqui cabe alguns dados: No equipamento que utilizo no meu trabalho, utilizo 210ºC aplicados na placa durante 130 segundos. A pressão fica mais complicado de estipular, uma vez que o ajuste é manual, sem escala, utilizando um varão roscado da prensa térmica (prensa para fazer camisetas estampadas). Em casa, utilizo um ferro de passar velho com a temperatura media, aplicando força ‘manual’ durante aproximadamente 120 segundos. A placa que estou mostrando neste post foi feita usando o ferro de passar.

Abaixo, nas figuras 4 e 5 podemos ver que após a ‘prensagem’ o toner adere muito bem ao cobre, e alguns minutos após (tempo suficiente para a temperatura da placa abaixar a ponto de ser possível o toque da mão) o papel pode ser retirado sem nenhum esforço. Alias aqui é encontrada a grande diferença do uso de um papel próprio versus outros papeis (algumas pessoas, ou sites, indicam papel glossy, de folha de revista, papel poliéster, papel couché, etc…), o papel transfer sai com muita facilidade, e não retém nenhuma parte do toner, fazendo o processo todo mais simples.

Placa após etapa de prensagem
Figura 04: Placa após etapa de prensagem
Placa depois de transferida
Figura 05: Placa depois de transferida

Após esta etapa, é necessário uma inspeção, que irá determinar uma das seguintes opções:

A: A transferência foi satisfatória, podemos proceder direto a corrosão.
B: A transferência foi parcialmente satisfatória, é possível retocar pequenos defeitos.
C: A transferência foi insatisfatória, muitos defeitos, tornando inviável os retoques, ou uma área com detalhes muito pequenos foi afetada, etc…

Caso aconteça A, prosseguimos com a corrosão. Caso aconteça C, voltamos ao inicio e começamos tudo de novo (limpando o toner com thinner). Caso aconteça B, podemos retocar utilizando caneta de retroprojetor (ou de escrever em CD), mas CUIDADO, normalmente as canetas de ponta fina, não são resistentes ao Cloreto de Ferro III (Percloreto de Ferro).

No caso desta placa em particular, optei por corrigir alguns pontos onde o toner ficou ‘fraco’, que pode acontecer principalmente em grandes áreas de toner como planos de terra por exemplo. Abaixo, na figura 6, podemos verificar a placa depois de retocada, antes de ir ao ataque químico:

Placa após correção com caneta para retroprojetor
Figura 06: Placa após retoques

Agora procedemos com o banho químico, que irá retirar o cobre exposto e como resultado obtemos a placa como na figura 7, abaixo:

Placa após corrosão
Figura 07: Placa após corrosão

Agora neste momento os retoques de caneta ficaram mais aparentes.

Pronto, agora que o ácido (na verdade um sal ácido) retirou todo o cobre exposto, e após confirmarmos que o ataque foi suficiente, podemos proceder com a limpeza do toner. Para isto basta uma estopa, ou pano, embebido com thinner ou acetona (ainda nunca utilizei acetona para isto). Após a limpeza, o cobre fica exposto, permitindo a solda.

Eu ainda costumo, após a limpeza e antes da furação da placa, ‘estanhar’ todo o cobre da placa, para isto eu passo pasta de solda (ou fluxo) em toda a placa, e estanho com o ferro de solda mesmo. Após isto, limpo novamente a placa com thinner e então furo toda a placa. Faço isto antes de furar, pois senão a pasta de solda (ou fluxo) entram nos furos, e sua limpeza fica muito mais complicada.

Pronto já temos uma placa pronta, com uma boa qualidade.

Agora, se acharem necessário, podemos realizar a mascara de componentes, com toner. Basta imprimir a mascara (aqui no caso do EAGLE preciso escolher a opção mirror), alinhar o papel transfer com a furação dos componentes, e então proceder com a prensagem. O resultado fica bastante bom com a pratica.

Abaixo coloquei algumas figuras da placa depois de terminada.

Placa com legenda dos componentes
Figura 08: Placa com legenda dos componentes
Placa montada
Figura 09: Placa montada
Vista superior
Figura 10: Vista superior

 

Caso alguém fique curioso, esta placa é para um adaptador de gravação de PIC ‘universal’. Mais informações no próximo post.

Para os mais interessados ou detalhistas, a impressora que melhor funcionou entre as que testei foi uma HP LaserJet 1020, com toner original. (Não, infelizmente não tenho nenhum patrocínio da HP… é só para quem quiser comparar, 🙂 ).

PS: Graças a dica ai do comentário abaixo (Alexandre), corrigi o erro de português (e do inglês também) e o correto é TONER (e não tonner como eu havia grafado primeiramente)

Até a próxima!