Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/melchisedech333/transistor-simulator
:fire: This project performs a simulation of N and P-type MOSFET transistors. Next, the creation of logic gates is performed using the simulated transistors. Then, a Half-Adder mechanism is created with the logic gates, to later use it in a binary sum algorithm.
https://github.com/melchisedech333/transistor-simulator
binary-calculations binary-calculator circuit circuit-simulation circuit-simulator circuits circuits-simulator mosfet mosfet-transistor mosfets semiconductor semiconductors transistor transistor-level transistor-modeling transistor-switch transistor-tester transistors
Last synced: 26 days ago
JSON representation
:fire: This project performs a simulation of N and P-type MOSFET transistors. Next, the creation of logic gates is performed using the simulated transistors. Then, a Half-Adder mechanism is created with the logic gates, to later use it in a binary sum algorithm.
- Host: GitHub
- URL: https://github.com/melchisedech333/transistor-simulator
- Owner: melchisedech333
- License: bsd-3-clause
- Created: 2022-10-08T00:38:41.000Z (about 2 years ago)
- Default Branch: main
- Last Pushed: 2022-10-17T19:09:13.000Z (about 2 years ago)
- Last Synced: 2024-05-01T21:16:18.151Z (8 months ago)
- Topics: binary-calculations, binary-calculator, circuit, circuit-simulation, circuit-simulator, circuits, circuits-simulator, mosfet, mosfet-transistor, mosfets, semiconductor, semiconductors, transistor, transistor-level, transistor-modeling, transistor-switch, transistor-tester, transistors
- Language: C
- Homepage:
- Size: 376 KB
- Stars: 5
- Watchers: 2
- Forks: 3
- Open Issues: 0
-
Metadata Files:
- Readme: readme-pt.md
- License: license
Awesome Lists containing this project
README
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](source/gate-construction.c)).
```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](source/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](source/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](https://github.com/sponsors/melchisedech333) :blue_heart:**
Lembrando que para compilar o código, basta executar o script build.sh. Ele irá gerar o arquivo machine.
```bash
./build.sh
./machine
```
:smiley: Autor
---
Patrocinar: [melchisedech333](https://github.com/sponsors/melchisedech333)
Twitter: [Melchisedech333](https://twitter.com/Melchisedech333)
LinkedIn: [Melchisedech Rex](https://www.linkedin.com/in/melchisedech-rex-724152235/)
Blog: [melchisedech333.github.io](https://melchisedech333.github.io/)
:scroll: Licença
---
[ BSD-3-Clause license](./license)
## Lembre-se de deixar
uma linda estrelinha :star_struck: