Language: EN-US
Primeiramente é importante deixar claro que fiz este código para me divertir. Eu tenho muita vontade de desenvolver coisas utilizando transistores, por isso fiz este código. E também simplesmente me deu uma vontade muito grande de criar um código que fizesse soma binária utilizando portas lógicas, mas também que essas portas lógicas fossem construídas com transistores (o mais próximo possível do funcionamento de transistores reais).
No código eu crio os 2 tipos conhecidos de transistores MOSFET (N e P). Importante deixar claro que os transistores trabalham apenas com dois níveis de tensão, representados por 0 e 1, onde 0 significa nenhuma tensão aplicada (e nenhuma corrente elétrica passando pelos canais de Drain e Source), e 1 significa que há um valor X de tensão ou corrente elétrica aplicada nos respectivos canais.
Vale lembrar que o funcionamento básico de um transistor MOSFET é definido pela tensão (Volts) que se aplica no Gate, fazendo com que a corrente elétrica flua nos canais de Drain e Source.
N-TYPE:
Em um transistor do tipo N, a corrente elétrica flui do Drain em direção ao Source. A tabela abaixo explica o funcionamento do transistor conforme ocorra alteração no Gate.
------------->
GATE | DRAIN | SOURCE
---------------------
0 | 0 | 0
1 | 0 | 0
0 | 1 | 0
1 | 1 | 1
Em relação ao Gate, quando o mesmo possui o valor 0 (zero), significa que não há tensão aplicada nele. Seguindo a mesma lógica, quando há o valor 1, significa que há tensão suficiente aplicada no Gate, fazendo com que ele venha a funcionar como uma chave eletrônica, ou seja, permitindo que flua corrente elétrica do Drain ao Source.
Em relação ao Drain e Source, quando o valor está como 0 (zero), significa que não há tensão e nem corrente elétrica. E quando há o valor 1, significa que há tensão e/ou corrente elétrica aplicada neles.
P-TYPE:
Em um transistor do tipo P, a corrente elétrica flui do Source em direção ao Drain.
------------->
GATE | SOURCE | DRAIN
---------------------
0 | 0 | 0
1 | 0 | 0
0 | 1 | 1
1 | 1 | 0
Utilizando os transistores com a lógica acima, é criado canais de comunicação entre eles, para que assim sejam criadas as portas lógicas. Ou seja, para realizar a comunicação eu criei os equivalentes aos fios que conectam os canais dos transistores, como demonstra o código abaixo na criação da porta lógica NOT (para ver o código completo acesse gate-construction.c).
// Cria dois transistores, um do tipo P, outro do tipo N.
// O primeiro da lista é o transistor do tipo P.
gate->transistors = get_transistors(1, 1);
// Adiciona os fios para realizar a comunicação
// entre os canais dos transistores.
add_wire(GATE_PIN_VDD, 0, first_p(), PIN_TRANSISTOR_SOURCE);
add_wire(GATE_PIN_INPUT1, 0, first_p(), PIN_TRANSISTOR_GATE);
add_wire(first_p(), PIN_TRANSISTOR_DRAIN, GATE_PIN_OUTPUT, 0);
add_wire(GATE_PIN_INPUT1, 0, first_n(), PIN_TRANSISTOR_GATE);
add_wire(first_n(), PIN_TRANSISTOR_DRAIN, GATE_PIN_OUTPUT, 0);
add_wire(first_n(), PIN_TRANSISTOR_SOURCE, GATE_PIN_GROUND, 0);Observe que o Vdd (que representa o positivo) é a origem do primeiro fio conectado, e o Ground é o último.
O código acima realiza o seguinte esquema lógico:
Chave desligada
|
Chave ligada
|
Obs: o transistor do tipo N colocado na saída do CMOS (P e N) é apenas para demonstrar o funcionamento da porta lógica, fazendo com que ela acione um transistor que controla um LED. Como se pode notar, o LED liga e desliga conforme o estado de ligado/desligado da porta lógica.
Utilizando as noções expostas acima, foi construído as seguintes portas:
NOT
|
NAND
|
AND (NAND + NOT)
|
XOR (utilizando portas NAND)
|
OR (utilizando portas NAND)
|
O código responsável por realizar o processamento das portas lógicas e dos transistores é o gate-machine.c.
Utilizando todas estas coisas foi possível construir um mecanismo Half Adder, semelhante a este demonstrado na imagem ao lado. Com a diferença que não foi utilizado apenas as portas XOR e AND, mas também as portas OR e NOT.
Para maiores detalhes você pode analisar o algoritmo no arquivo device-arithmetic.c, onde ali foi feito o mecanismo do Half Adder para ser utilizado no algoritmo da soma binária implementado na função process_sum().
Aqui está a saída do programa:
Operation: SUM (+)
BINARY | DEC
----------------
|
0000000101 | 5
0000000011 | 3
----------------
0000001000 | 8
Enfim, resumindo tudo, foi simulado os transistores MOSFET do tipo P e N, e com eles foi implementado portas lógicas, como AND, NOT, NAND e outras. Com as portas lógicas foi implementado o mecanismo Half Adder, e com ele foi desenvolvido um algoritmo de soma binária (para simular uma máquina de calcular).
Se você gostou deste código, ou ele te ajudou em algo, considere ser um patrocinador 💙
Lembrando que para compilar o código, basta executar o script build.sh. Ele irá gerar o arquivo machine.
./build.sh
./machinePatrocinar: melchisedech333
Twitter: Melchisedech333
LinkedIn: Melchisedech Rex
Blog: melchisedech333.github.io
