LTSpice: Primeiros passos
O software LTSpice
O LTSpice é um software produzido pela Linear Tehcnology e que agora é parte da Analog Devices cuja finalidade é a simulação e análise do comportamento de circuitos elétricos contendo os mais variados componentes: resistores, capacitores, diodos, amplificadores operacionais e outros. Neste tutorial iremos aprender como montar e simular circuitos práticos utilizando esta ferramenta. Com isso, podemos estimar os valores de tensão e corrente, bem como de resposta em frequência de nossos circuitos antes mesmo de executá-los na prática.
Para se realizar uma simulação no LTSpice, podemos inserir as informações de entrada de duas formas: através de uma sequência de linhas de descrição, ou através de sua interface gráfica que nos possibilita desenhar o circuito e selecionar a representação desejada dos resultados. Aqui, iremos focar na segunda maneira, ou seja, selecionando os componentes desejados e criando o desenho.
Neste tutorial usaremos o LTSpice XVII em sua versão mais atual.
[toc]
Mãos à obra - Como utilizar o LTSpice
Instalação
A primeira coisa que faremos será a instalação do software. Para isso, basta entrarmos no site da Analog Devices ->Design Center -> LTSpice e clicar na opção de download que corresponde ao seu sistema operacional. O link para o download é o seguinte:
https://www.analog.com/en/design-center/design-tools-and-calculators/ltspice-simulator.html
Para instalarmos o LTSpice, basta clicarmos no arquivo de extensão .exe que foi baixado. Com isso a janela abaixo será aberta e se você concordar com os termos de instalação, basta clicar em ACCEPT:
Com isso, o botão INSTALL NOW será liberado e a instalação poderá ser iniciada clicando nele.
Depois de alguns minutos a instalação será concluída, clique em OK e depois de alguns segundos o software estará pronto para uso.
Criando o primeiro esquemático
Depois que o programa for aberto nosso primeiro passo será criar um novo esquemático a partir do qual poderemos desenhar o nosso circuito, para isso, basta apertar Ctrl+N ou clicar no local indicado de acordo com a figura abaixo:
Primeiramente, desenharemos um circuito RLC, selecionando um resistor, um capacitor e um indutor, como indicado abaixo através da barra de ferramentas ou apertando R para resistor, C para capacitor e L para indutor. Uma vez selecionado um tipo de componente, você poderá inserir quantos desejar e se quiser trocar de componente basta apertar ESC e selecionar o próximo.
Usando MOVE, podemos selecionar e mover os componentes que já escolhemos e com ROTATE e MIRROR podemos rotacioná-los e espelhá-los para que assim possamos representar-los de uma melhor maneira em nosso circuito. O botão WIRE serve para desenharmos as conexões entre nossos componentes.
Clicando com o botão direito do mouse nos componentes selecionados, podemos inserir seus valores de resistência, capacitância ou indutância, lembrando que podemos inserir diretamente as letras k para multiplicar o valor por 1000, m para multiplicar por 0,001, u para multiplicar por 0,000001 e assim por diante. De forma semelhante, se você clicar com o botão direito em cima do nome do componente é possível alterá-lo, no entanto, basta tomar cuidado para não atribuir o mesmo nome a dois componentes diferentes.
O próximo passo será inserirmos nossa fonte de sinal de entrada. Para isso clicamos em COMPONENT , escrevemos VOLTAGE e depois clicamos no botão OK.
O botão COMPONENT nos permite selecionar uma grande variedade de componentes eletrônicos mais específicos para aplicações mais avançadas.
Selecionada a fonte de sinal, basta clicarmos com o botão direito para atribuirmos um valor de tensão a ela. Entretanto, se você deseja que o sinal de sua fonte seja alternado ou que simplesmente varie com o tempo, temos que selecionar a opção ADVANCED, a partir da qual poderemos selecionar um sinal de tensão em forma de pulso, senoidal, exponencial e outros. Uma vez escolhido o tipo de sinal de entrada, basta preencher os campos correspondentes aos parâmetros do sinal, como amplitude, frequência, etc. Para o nosso exemplo usaremos um fonte senoidal com uma tensão de offset de 0V, uma amplitude de 2V e uma frequência de 100Hz.
Com isso, ligamos nossa fonte ao circuito e selecionamos GROUND para indicar onde será a referência de nosso circuito, que neste caso será na ligação inferior entre todos os componentes. Com isso, estaremos prontos para avaliarmos os valores de tensão e corrente em todos os pontos que desejarmos.
- Análise do circuito
Para analisarmos o circuito precisamos clicar em RUN, de modo que será aberta uma janela onde nós devemos inserir o intervalo de tempo em segundos no qual o programa analisará nossa montagem. No nosso exemplo colocamos 0.1s.
Sendo assim, quando clicamos em cima de um dos componentes do circuito, o programa irá plotar o gráfico da corrente que passa por esse dispositivo durante o intervalo de tempo determinado. Se clicarmos em cima de uma das ligações ou nós o programa nos dará o gráfico da tensão correspondente àquele ponto em relação ao Ground. Vale lembrar que para o nosso exemplo, o gráfico da tensão em cada componente será igual ao da fonte, visto que eles se encontram em paralelo com ela.
- Imprimindo ou salvando o projeto
Podemos ainda imprimir ou salvar o nosso projeto através do menu FILE, selecionando a opção PRINT para imprimir ou SAVE AS para salvar em algum lugar desejado. Uma vez salvo, você pode abrir o arquivo sempre que desejar clicando nele ou escolhendo a opção OPEN do menu FILE.
Simulação e análise de um circuito mais complexo
- Utilizando um amplificador operacional
Um componente bastante usado em circuitos práticos é o amplificador operacional. Para usá-lo em um circuito é preciso selecioná-lo da mesma forma que a fonte de tensão. Clicando em COMPONENT e depois em OPAMPS. Será aberta uma janela com vários modelos de amplificadores, alguns baseados em CIs reais de mercado e outros que simulam o funcionamento ideal do dispositivo.
Para o próximo exemplo selecionamos o UniversalOpAmp2.
Uma maneira prática de ligar a alimentação do amplificador é usando a opção NET NAME (F4), pois com ela, podemos igualar a tensão em um ponto com a tensão de outro sem necessitar de escrever ligações. Para isso, basta apertar F4 e escrever o nome da tensão de ponto e colocar o símbolo que surgir nos locais em que se deseja igualar as tensões, como está exemplificado na figura abaixo.
Agora estamos prontos para simular um circuito mais avançado. O circuito que analisaremos é o Filtro Notch, um circuito famoso em projetos eletrônicos de baixíssima tensão cujo objetivo na maioria das vezes é eliminar o ruído de 60Hz da rede elétrica. Para isso, é necessário que você faça no seu LTSpice o seguinte desenho:
O circuito acima é chamado de Rejeita Faixa e seus valores de capacitores e resistores fazem com que essa rejeição seja de 60Hz (Fc = 1/2piRC). A análise desse circuito pode ser feita de forma mais apropriada através de sua resposta em frequência. Para isso, nas configurações da fonte, selecione apenas a amplitude AC, que pode ser de 1V:
Depois disso, no menu SIMULATE selecione a opção EDIT SIMULATION CMD e vá para a aba AC ANALYSIS. Nesta janela você poderá escolher a opção de representação do eixo das frequências, além da frequência de início e a de fim, bem como do número de pontos para análise no intervalo. Depois de preencher as opções com os dados adequados, clicamos em OK e colocamos a linha de comando em algum lugar perto do circuito.
Feito isso, colocamos para executar mais uma vez (RUN) e clicamos no ponto de tensão referente a saída, o gráfico gerado está na imagem abaixo:
Neste gráfico, podemos ver o que acontece com a amplitude do sinal para diferentes frequências de entrada e também o que acontece com a fase. É fácil ver que o sinal é bastante atenuado para uma frequência próxima de 60Hz. Os resistores de 10k e 1k controlam o quanto é atenuado o sinal para frequências próximas a frequência de corte, você pode alterá-los e verificar o que acontece com a resposta do circuito para diferentes pares de valores.
Considerações finais
Com isso, concluímos nosso estudo sobre as funções básicas do software LTSpice. O programa é uma ferramenta muito poderosa e muito usada em disciplinas dos cursos de engenharia elétrica e eletrônica. Além disso, pode lhe poupar muito tempo no projeto de circuitos práticos que você se propor a fazer.
Software Timer - ESP8266
Software Timer
Em várias situações, é necessário de certa forma, a manipulação do tempo em micro controladores. O jeito mais fácil é pelas funções básicas (delay e derivados), porém, normalmente, estas funções travam o micro controlador, e com isto, você é incapaz de ler botões ou algo do tipo enquanto o delay não acabar. Isto além de gerar terríveis problemas nos mais variados projetos, não é uma pratica saudável. Neste tutorial, vamos aprender sobre o OS_TIMER do ESP8266, este timer é baseado no software do ESP8266 e o limite inferior é 1mS e máximo de ~2 horas. Este software timer não é aconselhado para projetos em que o tempo é crítico. Apesar de nossos testes darem certa confiança, por ele ser baseado em software, alguns fatores podem atrasa-lo em alguns mS, tome cuidado.
Demonstrando a diferença
Neste exemplo apenas para comparação do Software Timer, usaremos um exemplo que acende 3 LEDs a cada 1 segundo e enquanto isso, ficaremos enviando dados na Serial para mostrar o funcionamento do código. Antes de ir para o software timer, testem este código abaixo no ESP8266 e veja no Serial Monitor como é o recebimento de informações.
Neste código, estamos usando Delay para fazer o acionamento simples dos LEDs. Você perceberá que só irá aparecer mensagens a cada 4 Segundos.
long x;//Variavel para mostrar o desenvolvimento do codigo no Serial Monitor.
void setup()
{
pinMode(D1, OUTPUT);//Define D1 como Saida.
pinMode(D2, OUTPUT);//Define D2 como Saida.
pinMode(D3, OUTPUT);//Define D3 como Saida.
Serial.begin(9600);//Inicia a comunicaçao Serial para provar que o codigo nao trava.
}
void loop()
{
led();//Sub rotina para acender os LED`s.
Serial.println(x++);//Mostra no serial monitor o desenvolvimento do codigo.
}
void led()//Sub rotina para acender os LED`s.
{
digitalWrite(D1, 1);//Acende o led 1.
delay(1000);//Aguarda 1 segundo.
digitalWrite(D2, 1);//Acende o led 2.
delay(1000);//Aguarda 1 segundo.
digitalWrite(D3, 1);//Acende o led 3.
delay(1000);//Aguarda 1 segundo.
digitalWrite(D1, 0);//-
digitalWrite(D2, 0);//-
digitalWrite(D3, 0);//-Apaga os 3 leds.
delay(1000);//Aguarda 1 segundo.
}
Após ver que o ESP só pula para a linha debaixo da função led() a cada 4 segundos, percebe-se que o ESP fica travado durante 4 segundos apenas para acender os LEDs, inutilizando totalmente o seu uso para outras coisas.
Agora chega de papo e vamos ao Software Timer.
Normalmente, na maioria dos casos, as funções de delay travam o código até que o delay se acabe. Ao usar delay(60000), o micro controlador ficará travado por 1 Minuto nesta linha até que o tempo acabe e não fara mais nada. Se desejarmos acender um LED a cada 30 segundos, isto irá gerar muitos problemas usando delay, então, usaremos os Timer’s. O Timer gera uma interrupção no sistema a cada intervalo de tempo e voltara a fazer a sua rotina padrão após terminar suas instruções.
Lembre-se, A rotina de um timer (Interrupção) não pode conter comandos de Delay, Serial e vários outros. A rotina do ISR deve ser a mais breve possível e normalmente usamos flag’s armazenadas na RAM para agilizar o processo e evitar erros internos.
Mãos à obra
Componentes necessários
- 1 – ESP8266 (Usaremos o NodeMCU).
- 3 – LED's.
- 3 - Resistores de 220 Ω.
- Fios Jumpers.
Montando o projeto
Veja como ficou nossa montagem:
Código do projeto
#include <user_interface.h>;//Biblioteca necessaria para acessar os Timer`s.
os_timer_t tmr0;//Cria o Timer. Maximo de 7 Timer's.
volatile byte status;//Variavel armazenada na RAM para Status do LED.
long x;//Variavel para mostrar o funcionamento do Codigo.
void setup()
{
os_timer_setfn(&tmr0, led, NULL); //Indica ao Timer qual sera sua Sub rotina.
os_timer_arm(&tmr0, 1000, true); //Inidica ao Timer seu Tempo em mS e se sera repetido ou apenas uma vez (loop = true)
//Neste caso, queremos que o processo seja repetido, entao usaremos TRUE.
pinMode(D1, OUTPUT);//Define D1 como Saida.
pinMode(D2, OUTPUT);//Define D2 como Saida.
pinMode(D3, OUTPUT);//Define D3 como Saida.
Serial.begin(9600);//Inicia a comunicaçao Serial.
}
void loop()
{
leitura();//Sub rotina para processar os LED`s.
//O codigo irá funcionar normalmente sem que haja delays e acendendo os LED`s no intervalo definido.
//Para demonstraçao, abra o Serial monitor e voce vera que o codigo continua normalmente.
Serial.println(x++);//Print para provar que o codigo nao trava. Abra o Serial monitor e veja
//que o codigo continua rodando enquanto os LED`s piscam a cada 1 Segundo.
}
void leitura()//Sub rotina para processar os LED`s.
{
switch (status)
{
case(1)://Caso status seja 1, acenda o led 1.
digitalWrite(D1, 1);
break;
case(2)://Caso status seja 2, acenda o led 2.
digitalWrite(D2, 1);
break;
case(3)://Caso status seja 3, acenda o led 3.
digitalWrite(D3, 1);
break;
case(4)://Caso status seja 4, Apague os 3 LED`s.
digitalWrite(D1, 0);
digitalWrite(D2, 0);
digitalWrite(D3, 0);
break;
}
}
void led(void*z)//Sub rotina ISR do Timer sera acessada a cada 1 Segundo e mudara o status do LED.
{
if (status == 4)//Verifica se o maximo foi alcançado para resetar a contagem.
{
status = 0;
}
status++;
}
Entendendo a fundo
Hardware
As ligações são simples, apenas sendo necessário ligar o pino de cada LED em sua correspondente porta, não esquecendo o uso de resistores para limitar a corrente/tensão e também não queimar o LED. O outro pino do LED no GND. Este é o básico para um LED funcionar.
Software
-Função os_timer_setfn()
os_timer_setfn(&tmr0, led, NULL);
Esta função atribui uma função sua à rotina do Timer. Neste caso, definimos a nossa função led() ao timer tmr0, que criamos anteriormente.
-Função os_timer_arm()
os_timer_arm(&tmr0, 1000, true);
Com esta outra, é definido o tempo do timer e também se irá se repetir (loop). Neste caso, definimos ao timer tmr0, que entre na função anteriormente atribuída, a cada 1000mS. Se você não precisa que isso seja repetido, troque true por false, desativando o loop.
Finalizando
Comparando os dois códigos, podemos perceber claramente a diferença entre fazer tarefas com um Timer ou Delay. Enquanto o primeiro código só mostra a mensagem a cada 4 Segundos, o segundo mostra a mensagem diversas vezes ao mesmo tempo que gerencia os LEDs. Você pode usar isso em vários projetos em que é preciso fazer tarefas em tempos definidos, sem travar o resto do sistema com Delay. Dúvidas? Sugestões? Críticas? Comente abaixo!
