Note: this document is written in PT-BR 🇧🇷
Caso seja de sua preferência, você também pode ler este texto no TabNews, ou no Medium.
Este projeto foi feito por pura diversão. A ideia dele é simplesmente capturar uma imagem de alguma coisa em escala microscópica, e olhar pra ela com um belo sorriso no rosto, porque é legal.
Como amostra utilizei uma lâmina de silício com a litografia de um microchip exposta. Onde foram capturadas imagens mostrando os pontos de contato do microchip.
IMAGE 1 | IMAGE 2 | IMAGE 3 |
Tendo em vista que em um espaço de 2mm cabem mais ou menos 10 pontos de contato (como mostra na imagem acima). Convertendo de milímetros para micrômetros, temos então 2000 micrômetros. Dividindo 2000 micrômetros por 10, temos o valor de 200 micrômetros por ponto de contato. Podemos então dizer que a imagem 1 capturada possui mais ou menos 200 micrômetros.
O truque aqui é compreender o conceito de CLSM e entender que as coisas refletem luz, e que podemos capturar essa luz e com ela montar uma imagem em grayscale.
Vamos para o experimento...
Para conseguir realizar essa brincadeirinha divertida vamos ter que reproduzir o conceito de (CLSM) Confocal Laser Scanning Microscope. Portanto, para esclarecer as coisas, vamos ter em mente do que se trata este conceito.
Image: ibidi.com |
Esta luz que saiu do laser e foi refletida pelo Beam Splitter seguirá indo na direção da Objective Lens, que é nossa lente objetiva, utilizada para focar o feixe da luz do laser num único ponto.
Logo abaixo de nossa lente objetiva, estará nossa amostra, ou seja, o material que queremos capturar uma imagem microscópica. Portanto, é importante que o laser esteja devidamente focalizado na amostra para que o dispositivo possa funcionar. Isto que acabamos de descrever se resume na imagem ao lado. Observe o caminho que a luz faz, simbolizado pelas setas em azul. |
Image: ibidi.com |
Agora observe nesta imagem ao lado. Ela nos mostra o que acontece após a luz do laser bater sobre nossa amostra.
A luz é refletida novamente para cima, atravessando novamente a lente objetiva, depois atravessando também nosso Beam Splitter, até atingir um sensor. Importante também observar que antes da luz atingir o sensor (que no caso é um sensor de luminosidade), ela primeiro atravessa o chamado Pinhole, que trata-se de um obstáculo para passar pouca luz (isto ajuda a remover ruídos). |
Portanto, resumindo tudo, a luz que sai de nosso laser é refletida pelo Beam Splitter, depois atravessa nossa lente objetiva responsável por realizar o foco em nossa amostra. Após a luz incidir sobre nossa amostra, a mesma é refletida para cima, atravessando nossa lente objetiva e atingindo novamente nosso Beam Spliter, mas agora fazendo o caminho inverso. Se tratando nosso Beam Splitter de um simples vidro transparente, parte da luz irá atravessá-lo, passando posteriormente por nosso obstáculo (Pinhole) e atingindo nosso sensor de luminosidade.
Desta maneira, utilizando algo como um sensor LDR convencional, teremos no máximo um ponto focalizado em nossa amostra, mas o que queremos é uma imagem. Logo, temos que ter algum mecanismo que nos permita realizar uma varredura nos eixos X,Y. Sendo este o nosso tão querido Scanner.
Desta maneira é possível realizar a varredura nos eixos X,Y de alguma amostra, e a cada ponto focalizado do laser, capturamos a intensidade luminosa com um sensor de luminosidade. Vamos então armazenando esses valores em algum software, para posteriormente gerar uma imagem com base nesses dados.
Estando claro o conceito descrito acima, vamos para a parte prática 🤩
A primeira coisa que vamos precisar fazer é ir em algum site e comprar um Arduíno e alguns componentes básicos, como resistores, capacitores, jumpers e coisas do tipo. Depois vamos precisar ir em algum ferro-velho e procurar alguns drivers de DVD. Segue abaixo a lista dos materiais.
Importante deixar claro que para construir este projeto, é necessário algumas noções básicas de eletrônica e programação.
Materiais comprados em lojas online:
- Uma protoboard e jumpers
- Arduino UNO
- Capacitores de 10k uf
- Resistores 330 ohms, 1k ohms, 10k ohms
- Sensor de luz LDR
- Transistores MOSFET (NPN)
- Um laser potente
Materiais comprados no ferro-velho:
- Drivers de DVD (eu usei 4, mas 2 servem)
Claro, coisas como cola-quente, papelão e isopor podem ajudar muito. Também é importante deixar claro que para este projeto é necessário um bom laser, o que utilizei eu comprei no Mercado Livre, e é este da imagem abaixo.
Sendo talvez a nossa parte mais importante do projeto, precisamos do scanner para realizar a varredura nos eixos X e Y. E isso nós faremos com as bobinas de foco das lentes dos próprios drivers de DVD.
Utilizando a mesma noção acima, mas agora controlando a bobina que realiza o movimento para as laterais, vamos ter nosso eixo X. |
Em seguida vamos precisar criar algumas perninhas para sustentar nosso dispositivo, ficando como nas imagens abaixo.
Note que os fios utilizados nas perninhas são na verdade fios de cabo de rede (os famosos RJ45). Desta maneira é possível movimentar toda nossa "mesinha" (sim, vamos chamar ela de mesinha daqui pra frente) com o controlador do eixo Y. Tendo assim o controle dos eixos X e Y.
Além desta ideia utilizando as bobinas dos driver de DVD, também é possível utilizar alto-falante para controlar os respectivos eixos X e Y.
Em todo caso o que necessitamos é realizar uma varredura nos citados eixos.
Para que consigamos focar a luz do laser devidamente sobre nossa amostra é necessário termos controle do eixo Z, para regulá-lo corretamente, de modo que após estar focado, comecemos nossa varredura.
Nesse caso eu utilizei um pedaço de latinha de refrigerante/cerveja, mas você pode utilizar um papel alumínio se preferir. |
Pegando tudo dito acima e juntando em uma caixa, fica mais ou menos como nessa imagem abaixo.
Note que nesta segunda imagem, fiz um suporte para o laser incidir de cima para baixo, onde ele atingirá a peça de DVD da nossa "mesinha". Tendo isto em mente, você já deve ter percebido que o projeto está com uma diferença. No caso a única diferença em relação ao conceito do CLSM abordado anteriormente, é que trocamos os lugares do laser e do sensor. Ficando nosso laser incidindo de cima pra baixo, e nosso sensor capturando a luz refletida pela lateral.
Note também que para controlar o laser fiz uma ligação direta (cuidado para não queimar seu laser, verifique os limites dele). Onde usei um segundo Arduino só para servir de Power Supply.
Antes de tudo tenhamos em mente que estamos controlando exatamente estas coisas:
- A bobina do eixo Y
- A bobina do eixo X
- O sinal lido pelo sensor LDR
É bem sabido que para variar um sinal no Arduino basta fazer uso da função analogWrite, e utilizar algum pino para enviar o sinal. Logo, tudo que precisamos é de um simples circuito eletrônico para realizar amplificação de sinal, coisa que fazemos com o uso de transistores, resistores e capacitores (existem muitos tutoriais na internet a respeito disso). Tendo isto em mente, tudo que você precisa fazer é criar um circuito que controle (e varie) o sinal enviado para suas bobinas, para assim fazê-las movimentar.
No Arduino teremos o seguinte código (arduino.c):
#define PIN_X 9
#define PIN_Y 3
#define PIN_LDR A0
void setup()
{
pinMode(PIN_X, OUTPUT);
pinMode(PIN_Y, OUTPUT);
pinMode(PIN_LDR, INPUT);
Serial.begin(115200);
delay(100);
Serial.println("Jesus Amor");
}
int delayTime = 23;
int limit = 256;
int increment = 1;
void loop()
{
if (Serial.available() > 0)
{
String command = Serial.readStringUntil('\n');
command.trim();
char receivedChars[256];
memset(receivedChars, '\0', 256);
command.toCharArray(receivedChars, 256);
// Read line.
if (strstr(receivedChars, "read:"))
{
char *ptr = &receivedChars[ strlen("read:") ];
char currentYCh[256];
int currentY = 0;
memset(currentYCh, '\0', 256);
for (int a=0; ptr[a]!='\0' && ptr[a]!='\n'; a++)
{
if (ptr[a] == '-')
{
currentY = atoi(currentYCh);
break;
}
currentYCh[a] = ptr[a];
}
// Control: X, Y.
Serial.print("startline");
analogWrite(PIN_Y, currentY);
delay(50);
for (int x=0; x<limit; x+=increment)
{
analogWrite(PIN_X, x);
delay(delayTime);
int LDR = analogRead(PIN_LDR) / 4;
Serial.print(LDR, DEC);
Serial.print(",");
}
Serial.print("endline");
delay(100);
}
}
}
Tenha em mente que o código acima recebe uma entrada de dados pelo cabo USB, no caso o texto "read:Y-", onde o valor de Y equivale a linha que está sendo processada. Em seguida o mesmo faz a bobina movimentar-se para a devida posição, para em seguida começar a leitura. Ou seja, a bobina do eixo X irá movimentar-se de 0 a 256, onde a cada incremento é realizada a leitura do sensor de luminosidade. Tudo é enviado para o programa que está recebendo estes dados.
No computador executamos o programa read-data.php, onde o papel dele é simplesmente realizar essa comunicação com o Arduino, iniciar e controlar a leitura, armazenar os dados localmente para com eles gerar uma imagem em grayscale.
Na imagem abaixo você pode ver um protótipo operando. Observe que a luz do quarto está desligada, pois como todo o dispositivo está exposto, não é legal que exista interferência luminosa.
Para utilizar como amostra eu dei um jeito de retirar uma lâmina de silício de dentro de um microchip convencional (isso deu trabalho). Dê uma olhada nas imagens abaixo.
Utilizando lentes ópticas eu consegui um zoom grande para assim ter uma fotografia optica de minha amostra, para que eu pudesse ver como são meus microchip.
ITEM 1 | ITEM 2 | ITEM 3 |
Os itens 1 e 2 são apenas para dar uma noção de proporção e tamanho.
O item 3 é a fotografia óptica que consegui (para ela usei uma lente também de driver de DVD, mas acoplada na câmera do celular). O bom de termos uma fotografia óptica é para confirmar se nossa imagem gerada pelo dispositivo está correta.
O erro mais comum de quem tenta reproduzir este experimento é não conseguir ajustar o foco devidamente, quando isso ocorre sua imagem de saída ficará semelhante a esta. Ou seja, um lixo. |
Quando você começa a conseguir corrigir o foco, já começa aparecer algumas formas legais, como esta, onde já começa a aparecer alguns terminais de contato do microchip. |
Em resumo, você deve ir ajustando seu dispositivo para ficar o melhor possível, pois qualquer coisinha torta, ruído nas leituras, interferências luminosas, travamentos das peças (caso os driver de DVD forem velhos demais), tremores (um carro passando lá na esquina da sua casa irá afetar os seus resultados), e coisas semelhantes afetam em seu resultado final.
Observe que na parte de cima das imagens geradas há sempre uma distorção, pelo que entendi isso se deve ao meu mecanismo estar meio duro no começo da leitura. Depois ele fica normal e segue até o fim. Como eu disse, qualquer coisinha torta já afeta no seu resultado. No entanto já começam a aparecer imagens legais.
Retirando a parte distorcida de nossa leitura, as imagens ficam assim:
Colocando nossa lâmina de silício ao lado das nossas imagens, conseguimos ter melhor uma noção de proporção. Se fosse encontrar um número para nos dar uma aproximação satisfatória do tamanho da imagem que conseguimos capturar, chegaremos ao valor de mais ou menos 200 micrômetros.
Como você pode notar, tudo isso é apenas uma diversão. Logo, é claro que há pontos e coisas que podem ser melhoradas (sempre há). Em todo caso, espero que tenha gostado 😀
Fique com Jesus e nossa Mãe Maria Santíssima 💜
Até a próxima!
http://www.gaudi.ch/GaudiLabs/?page_id=652
https://www.instructables.com/Laser-Scanning-Microscope/
https://www.instructables.com/Scanning-Laser-Microscope-With-Arduino/
https://bitesizebio.com/19958/what-is-confocal-laser-scanning-microscopy/
https://ibidi.com/content/216-confocal-microscopy
https://bitesizebio.com/19958/what-is-confocal-laser-scanning-microscopy/
Patrocinar: melchisedech333
Twitter: Melchisedech333
LinkedIn: Melchisedech Rex
Blog: melchisedech333.github.io