Há um díodo Schottky ali no meio; este tipo de díodo tem uma queda de tensão mais baixa (0.3V – 0.4V). Para díodos de germânio os valores são ainda outros: 0.2V a 0.3V.

De qualquer forma vemos que não há um valor “exacto” para a queda de tensão. No entanto convencionou-se que seriam estes valores porque nos dá jeito para fazer contas em aplicações não críticas – que são a maior parte das aplicações.

Para saber detalhes e descarregar, visitem a página do AVIC:
Projecto: Aplicação de gestão fiscal simplificada

O fabricante de semiconductores Linear Technology disponibiliza gratuitamente uma aplicação SPICE chamada LTspice, que é um simulador SPICE de circuitos electrónicos e capturador gráfico de esquemas, muito fácil de usar. Download aqui: LT spice. Faz download, instala, e continua a ler!

O que é que podemos fazer com isto? Um circuito electrónico é regido pelas Leis da Física, e as Leis da Física têm descrições matemáticas. Como os computadores são bons em matemática (isto é, são bons a fazer contas!), podemos introduzir no computador uma descrição de um circuito electrónico e obter a simulação do seu comportamento, ou seja, saber as tensões e correntes que ocorrem em qualquer ponto do circuito, e como variam ao longo do tempo. Dito de outra forma, testar um circuito sem o ter montado! Podemos ainda facilmente analizá-lo e efectuar algumas medidas que na prática seriam muito dificeis de efectuar, como por exemplo medir a potência dissipada por um componente num certo periodo de tempo.

Eu uso muito simulação para testar só pequenas partes de um esquema mais complexo ou para entender melhor como funciona um circuito. É uma ferramenta com um potencial muito grande…

A simulação bate sempre certo com a realidade? Não! É preciso ter algum bom senso ao utilizar a simulação. Existem alguns aspectos que influenciam a fidelidade da simulação, tais como:

• a temperatura é constante
• os modelos dos componentes não são totalmente fiéis à realidade ou não cobrem situações limite de funcionamento
• o circuito foi construído assumindo um funcionamento ideal dos componentes e ligações

Basicamente a simulação é tão real quão real for a definição do circuito, dos modelos dos componentes usados e de temperatura.

No entanto, ainda assim a simulação pode ser uma tremenda ajuda, pois ainda que possa não ser exactamente fiel ao que se passa na realidade,

• dá-nos um “feeling” sobre o comportamento do circuito;
• permite-nos testar algumas ideias sem ter que construir o circuito;
• e ajuda-nos a compreender o funcionamento sem ter que montar o circuito e/ou efectuar medidas muito difícieis de fazer na prática!

Com o tempo e a experiência vamos aprendendo a avaliar as respostas que a simulação nos dá.

Em resumo, fica a regra de ouro:

funcionar na simulação não é garantia de funcionar na realidade, o circuito tem sempre que ser prototipado para se confirmar o seu comportamento!

Vamos a um exemplo prático! Vou fazer aqui um pequeno exemplo em que vou tentar passar pelos aspectos que considero mais relevantes.

O circuito que vamos montar e simular é… tadaaaaa, uma resistência mágica! E que raio é uma “resistência mágica”? perguntam vocês, e perguntam muito bem: uma resistência mágica é um circuito que substitui a tipica resistência limitadora de corrente que se usa para acender um LED normal. Este circuito funciona como uma resistência que ajusta automaticamente o seu valor à tensão de alimentação, e mesmo à própria cor do LED! Nesta resistência nós só definimos qual é a corrente que ela deve deixar passar, que é exactamente o que nós queremos para um LED. Desta forma libertamo-nos de ter que calcular uma resistência diferente para cada cor de LED, e para cada tensão que quisermos usar para alimentar o LED.

Em termos mais formais este circuito designa-se “fonte de corrente”. Tal como temos fontes de tensão que fornecem uma tensão constante, também temos fontes de corrente que fornecem uma corrente constante, e que é exactamente o que nós necessitamos para acender um LED. O circuito é este:

Vamos começar por desenhar este circuito no LTspice, que é muito fácil de fazer. Eu gosto de usar o teclado para algumas funções pois é muito mais rápido e prático, e é o que vos aconselho.

A interface do LTspice funciona por “modos” que são selecionados na barra de ferramentas; existe um modo de “apagar”, um modo de “adicionar”, um modo de “copiar”, um modo de “aumentar”, um modo de “fazer ligações”, um modo para “arrastar parte do circuito”, etc. Para voltarmos ao modo “sem modo”, carregamos na tecla ESC ou no botão direito (esquerdo para os esquerdinos) do rato. Existem outros botões para operações como abrir ou gravar o esquema.

A interface é bastante intuitiva e vou falar apenas de alguns modos, que vamos usar; os restantes depois vocês experimentam.

Aos vários desenhos que fazem parte de um esquema chamamos símbolos. Um símbolo é tipicamente um componente electrónico, mas não só; pode ser também um “ground”, um comentário nosso, uma directiva de simulação ou um sub-circuito.

Para adicionar um símbolo ao esquema temos várias formas. Para alguns símbolos de componentes básicos temos logo um botão da barra de ferramentas para entrar no modo de “adicionar esse símbolo”; uma vez nesse modo, basta clicar no(s) sítio(s) do esquema onde queremos adicionar o símbolo (não esquecer; para sair do modo, carregar em ESC ou no botão menos usado do rato).
Para os símbolos que não aparecem na barra de ferramentas, usamos o botão que abre a janela selectora de símbolos. Aí podemos ver e navegar nas várias bibliotecas (directórios) de símbolos existentes, seleccionar o símbolo desejado e clicar “OK”.

Como alguns símbolos são muito usados, existem teclas de atalho que aceleram a sua adição. Para adicionar…

• um ground (em Português diz-se “massa”), tecla G
• uma resistência, tecla R
• um condensador, tecla C
• uma bobina, tecla L
• um díodo, tecla D

Sabendo agora como se adiciona um símbolo, já podemos adicionar ao esquema os símbolos dos vários componentes que o compõem, colocando-os mais ou menos nas suas posições tal como no esquema de todo o circuito que está mais acima.

Um componente pode ser apagado entrando no modo “apagar”, tecla F5; o cursor do rato transforma-se numa sugestiva tesourinha . Aí é só cortar (clicar), cortar (clicar), cortar (clicar)… que também funciona para apagar ligações (já vamos falar delas mais à frente) e qualquer outro elemento gráfico do esquema.
Se for preciso mudar um símbolo de sítio, temos o modo “mover”, tecla F7; o cursor do rato transforma-se numa mão e com ela podemos escolher um símbolo (clicando) para mover, movimentá-lo com o rato para a nova posição e clicar novamente para “largar” o símbolo na nova posição. O símbolo pode ser re-orientado enquanto está seleccionado neste modo, carregando em CTRL+R para Rodar ou CTRL+E para o Espelhar horizontalmente.
Para fazer UNDO (desfazer), F9 é a tecla.

Para adicionar o transístor e a fonte de alimentação, temos que recorrer à janela selectora de símbolos (). Para o transístor procuramos o símbolo npn e para a fonte de alimentação procuramos o símbolo voltage. Não se esqueçam de adicionar a massa (G). Todos os circuitos têm um ponto de referência, um nó, em relação ao qual são feitas as medidas de tensão em todos os nós do circuito; esse ponto é a massa. Sem ele o LTspice dá-vos um erro e não simula.

Depois de adicionar a resistência, o díodo e o LED (para já, símbolos de díodos normais), o transistor e todos os restantes símbolos, ficamos com o esquema assim:

Reparem como a cor dos traços dos símbolos é um azul muito escuro. Isto vai contrastar com a cor das ligações, que é um azul claro. E por falar em ligações, vamos a elas, é muito fácil também: tecla F3 e entramos em modo “fazer ligações” (vejam lá se adivinham qual é o botão correspondente na barra de ferramentas :p ). Cliquem no esquema para iniciar uma ligação e sempre que quiserem mudar de direcção; para finalizar, cliquem no botão direito do rato. Quando unem mais do que 2 pinos de símbolos, automaticamente surge um quadradinho mais grosso, que indica que todos os traços que passam nesse ponto estão unidos num único nó. Comecem então a efectuar todas as ligações entre os símbolos do circuito até ficarmos com o desenho do esquema:

O LTspice já escolheu referências para os componentes, R1, D1, etc, e só falta agora darmos-lhes valores para o esquema ficar completamente capturado – é assim que se designa a acção de desenhar numa aplicação informática o equema de um circuito, “capturar o esquema”.

Vamos agora editar as propriedades dos símbolos, começando pela resistência que é o mais simples. Parem com o rato em cima dela e reparem como o cursor do rato muda para uma mão indicadora; clicando agora com o botão direito, vai aparecer a janela de propriedades. Isto acontece para todos os símbolos. Diferentes tipos de símbolos têm diferentes janelas de propriedades. O LTspice é um programa bastante completo e aparecem imensos parâmetros para introduzir, mas felizmente já existem valores por omissão para todos excepto os “essenciais” – no caso da resistência é essencial introduzir o valor em Ohm, sem o qual nenhuma simulação pode ser feita. Sendo assim vamos introduzir o valor de acordo com o esquema do inicio do tutorial, e clicar “OK”. O valor aparece agora no esquema.

Passando agora ao díodo que era suposto ser um díodo zener, a coisa fica mais interessante. A janela de propriedades não permite alterar nenhum valor, mas podemos clicar no botão “Pick New Diode” (em Português, escolher novo díodo) e ser-nos-á apresentada uma lista de díodos da qual podemos escolher um. Vamos escolher o 1N750 que é um díodo zener de 4.7V, tal como está no esquema do inicio do tutorial. Uma vez escolhido este díodo, o símbolo muda para o símbolo do díodo zener.
Para o LED o procedimento é similar, mas escolhemos o modelo NSCW100 que é de um LED. O seu símbolo também muda para o de um LED, ganhando 2 setinhas onduladas que representam a luz a saír.
Para o transístor escolhemos o 2N2222, e nas propriedades da fonte de tensão basta introduzir a tensão DC em Volt, 9.
O esquema está agora completamente capturado e estamos prontos para começar a pensar e simulação!!

Existem vários tipos de simulação para obtermos vistas de diferentes “ângulos” sobre o circuito mas vou falar apenas numa, talvez a mais “útil”, que é a análise temporal. A análise temporal é uma simulação do que acontece às tensões e correntes em todos os pontos do circuito ao longo do tempo, ou seja, é como estarmos a olhar para o circuito com um osciloscópio que é capaz de ver não só as tensões mas também as correntes. Para esta análise só temos que definir 1 parâmetro: quanto tempo queremos simular. Para escolher a simulação de análise temporal e definir quanto tempo queremos simular, temos que editar o comando de simulação, acedendo ao menu Simulate -> Edit Simulation Cmd. Este menu dá acesso a um quadro com várias tabs que correspondem aos vários tipos de simulação, tendo cada quadro os respectivos parâmetros. Quando este quadro abre, já está activa a tab respectiva à simulação de análise temporal (Transient), e só temos que preencher o Stop Time, que define exactamente quanto tempo é simulado.

O tempo de simulação começa em zero e termina no valor que configurarmos e que será 1, que corresponde a 1 segundo. Este tempo é o tempo do circuito, ou seja, não é o tempo que demora a simulação em si mas sim o tempo de funcionamento do circuito. Se tivessemos o circuito real, montado à nossa frente, este 1 segundo corresponde a ligar o interruptor e deixar passar 1s.
O tempo que demora a simular este 1 segundo depende da complexidade do circuito, de quão rápido é o nosso PC e de alguns parâmetros em que não vamos mexer (porque afectam a precisão da simulação – só para experts!). Para o nosso circuito simples, qualquer PC já com vários anos irá simular este segundo quase instantaneamente.

Depois de clicar em OK no quadro acima vai aparecer um rectangulo “agarrado” ao cursor do rato; o LTspice preparou uma directiva especial e espera agora que nós cliquemos algures no esquema para deixar lá essa directiva. A directiva é .tran 1, e podem ver que ela está no esquema do inicio do tutorial. Quando colocarmos a simulação a correr, o simulador vai à procura desta directiva para decidir como vai simular o nosso circuito.
Agora estamos a 1 clique da simulação… vai, força, clica em !… Num passe de magia (hehehe) aparece uma nova janela, que é um gráfico com uma escala temporal no eixo horizontal, escala de 0.0s a 1.0s, o intervalo de tempo que dissemos ao LTspice para simular:

NOTA: fui ao menu Window -> Tile Vertically para dispôr as janelas verticalmente

Mas como devem ter reparado o gráfico está vazio! Bom, está vazio porque ainda não indicámos que tensão ou que corrente do circuito queremos ver; para isso basta clicar em pontos do esquema. Seleccionem a janela do esquema, coloquem o rato em cima da ligação no topo e reparem como o cursor muda para uma ponta de prova vermelha – isto indica um ponto em que podemos medir uma tensão. Clicando nesse ponto eis que aparece então um gráfico da tensão:

Agora já temos uma escala vertical, e um gráfico. No topo, com a mesma cor do gráfico, temos indicado o nó correspondente – V(n001) quer dizer literalmente função da tensão no nó n001 (em ordem ao tempo). n001 foi o nome que o simulador atribuiu aquele nó do circuito, porque todos os nós têm que ter um nome para nos podermos referir a eles. Pelo gráfico vemos que o nó tem 9V, o que está certo, pois é o valor que a fonte de tensão está a impôr naquele nó.

Vamos agora medir a corrente no LED, que é afinal o valor em que estamos mais interessados neste circuito. Para medir corrente temos que aproximar o rato de um pino de um dos símbolos (neste caso, do LED), e vemos o cursor mudar para uma pinça amperimétrica. É nesse ponto que podemos clicar e ver surgir um novo gráfico:

O LTspice é “esperto” e cria uma nova escala vertical do lado direito do gráfico, para medir corrente. O novo gráfico, a azul, designa-se I(D2), que quer dizer literalmente função da corrente em D2 (em ordem ao tempo). E está indicada como cerca de 21mA constantes. Os valores dos componentes deste circuito foram escolhidos para serem valores comerciais, e isso resulta em cerca de 21mA em vez dos tipicos 20mA para acender um LED – uma diferença muito pequena para causar problemas ao LED.

Está demonstrado como desenhar um circuito e medir tensão e corrente!

Então mas… Até agora nada nos mostra que este circuito realmente faz “a magia” de manter constante a corrente no LED independentemente da tensão de alimentação. Como é que poderemos ver isso? Alterando o valor da tensão e voltando a simular para ver a corrente, claro ! Nas propriedades da fonte de tensão alterem os 9V para 12V e corram a simulação de novo. Desta vez já não aparece o gráfico vazio, pois o LTspice mostra logo as mesmas medidas que já escolhemos anteriormente. No novo gráfico já se vê a tensão nos 12V e a corrente aproximadamente nos mesmos 21mA.

Se re-simularem para uma tensão de 15V ou 20V, verão que a corrente continua aproximadamente nos 21mA. Magia !…

Agora quero ensinar-vos a traçar um gráfico que nos mostra de uma forma simples e clara que a corrente no LED se mantém constante para uma gama alargada de tensões. E quero ensinar isto porque usa funcionalidades da fonte de tensão que são extremamente úteis.

Voltem à janela de propriedades da fonte de tensão (clique com o botão direito do rato, para quem já não se lembrar). Cliquem no botão Advanced e terão acesso a um quadro de configuração mais complexo. Estas configurações permitem-nos definir uma fonte de tensão cuja tensão varia no tempo, e o que vamos fazer é criar uma que começa com 0V e vai crescendo linearmente até atingir 20V ao fim de 1s, ou seja, no final do nosso tempo de simulação:

No lado esquerdo temos várias funções que podem ser usadas para modelar o comportamento da tensão da fonte. A PULSE é uma forma fácil de gerar impulsos, e os parametros que se lá vêm introduzidos são suficientes para gerar a nossa rampa de tensão: começando com 0V (Vinitial), finalizando com 20V (Von), com zero segundos de atraso inicial (Tdelay) e demorando 1s a ir do inicio ao fim (Trise – tempo de subida da tensão). Depois de clicado OK, o esquema mostra as novas propriedades junto à fonte de tensão, e correndo a simulação novamente obtemos o gráfico mais interessante deste tutorial :

Aqui vemos que este circuito só “funciona” a partir de cerca de 8V, e que desde os 8V até aos 20V a corrente no LED mantém-se praticamente constante em torno dos 21mA. É ou não é lindo ?!

Uma última nota. Quem não estiver habituado a “ver” o comportamento de circuitos electrónicos talvez esteja a achar muito estranho eu dizer “corrente constante” quando na realidade ela não é propriamente constante; mas a verdade é que a electrónica funciona mesmo assim, nada é constante até um certo grau, e “aproximadamente constante” é muitas vezes o mesmo que “constante”. Trabalha-se muito com aproximações, porque a Física do mundo real impede a precisão exacta dos nossos modelos matemáticos puros, e então o objectivo é chegar ao “suficientemente bom” para cada aplicação – para acender um LED, a variação de menos de 1mA é mais do que suficientemente bom; não notaremos nenhuma diferença no brilho dele.

Podem ainda alterar a fonte de tensão para efectuar uma rampa que termine em 100V. Verão que a corrente no LED mal passará dos 22mA. Mas… se montassem este circuito e o alimentassem a 100V, ele esfumar-se-ia num abrir e fechar de olhos! Aqui está um limite que a simulação não tem em conta. Estejam atentos e avaliem os resultados também à luz de algum bom senso e conhecendo os limites de tensão, corrente e potência dos componentes que usam.

Agora é mesmo para finalizar… Muito há ainda para mostrar sobre deste circuito e sobre simulação, mas este tutorial já vai longo e tem apenas a intenção de introduzir o tema e criar apetite. Muitas coisas vocês vão descobrir se andarem a explorar um bocadinho o LTspice, e se souberem Inglês leiam o Help que está lá tudo. Vamos ver que discussão se gera em torno disto e não ponho de parte novos episódios. Até lá… boas simulações!

Mesmo assim acho que só pela nova página frontal já vale a pena; agora mostra os valores mais relevantes a preencher na declaração de IVA no site das finanças, e com os mesmos nomes e números dos campos pelo que não há que enganar!

Para saber detalhes do que há de novo e descarregar, visitem a página do AVIC:
Projecto: Aplicação de gestão fiscal simplificada

Um sistema “multithreading” é complexo para máquinas de recursos limitados como um Arduino e complexo para iniciantes, e por isso eu recomendo (e pessoalmente é o que uso) o modelo “por eventos” (também chamado “multitarefa cooperativa”). O modelo por eventos funciona bem se não houver operações “atómicas” que demorem muito tempo.

No modelo por eventos, cada tarefa é executada numa função mas essa função não pode bloquear. O ciclo principal do programa chama repetidamente todas as tarefas sem parar, por exemplo em round-robin (em sequência, uma a seguir à outra, no fim volta à primeira e repete tudo). Depois é uma questão de “truques” para impedir que as funções bloqueiem, geralmente usando uma máquina de estados.

Vamos pegar num problema que vi no LusoRobotica.com e que deu origem a este meu artigo: ter 2 LEDs a piscar a velocidades diferentes e ao mesmo tempo enviar números para a consola. Isto são 3 tarefas.

O ciclo principal invoca as 3 tarefas em sequência, e no final faz uma pausa de 10ms. Esta pausa serve para termos uma unidade de tempo conhecida, caso contrário o ciclo é executado a toda a velocidade e não poderemos controlar a cadência a que, por exemplo, os LEDs piscam:

int loop ()
{
    piscaLed1();
    piscaLed2();
    enviaNumeros();
    delayMs(10);
}

Agora sabemos que cada tarefa é invocada a intervalos de 10ms. Se queremos o nosso LED1 a piscar 1 vez a cada segundo, temos que o inverter de estado a cada 500ms. Como sabemos que a tarefa é invocada de 10ms em 10ms, temos que inverter o estado do LED a cada 500ms / 10ms = 50, 50 invocações (50 x 10ms = 500ms), e para isso usamos uma variável para contar o número de invocações:

void piscaLed1 ()
{
    static int contador = 0;

    contador = contador + 1;
    if (contador == 50)
    {
        togglePin(...);
        contador = 0;
    }
}

Uma variável declarada com static quer dizer que é uma variável global mas que só é “visível” dentro do bloco onde está declarada (“bloco” é o conteúdo de um conjunto de chavetas). Eu podia tê-la declarado fora das funções, mas como ela só diz respeito e só é usada dentro da função, resolvi declará-la como static para a casa ficar mais organizada e arrumada. Ainda outra razão para declarar as variáveis como static sempre que possível é que desta forma podemos ter variáveis “globais” com o mesmo nome. A função da tarefa piscaLed2 pode usar exactamente o mesmo nome para a variável, “contador”, uma vez que as variáveis só são “visíveis” dentro do bloco onde são declaradas.
A variável tem que ser global pois a execução vai entrar e sair da função mas o valor da variável tem que ser preservado, pois vamos usá-la e queremos manter o seu valor de umas invocações para outras.

A tarefa piscaLed2() é similar à piscaLed1(), mudando apenas o número 50 para estar de acordo com a cadência que se desejar.

Agora vamos fazer a tarefa enviaNumeros(), que pode parecer complicada mas não é. Basta ter uma variável que guarda o último número que foi enviado, e enviar um número a cada invocação:

void enviaNumeros ()
{
    static int numero = 0;

    numero = numero + 1;
    Serial.write(numero);
}

Esta tarefa vai tentar enviar 1 número a cada 10ms, o que pode ser demasiado rápido para o que queremos ou até mesmo para a velocidade de transmissão que foi escolhida para a porta série (os bps). Nesse caso podiamos querer enviar apenas, vamos supôr, 1 número por segundo. Isto é fácil de fazer, pois é o que já fazem as tarefas dos LEDs e podemos usar o mesmo mecanismo! Para 1 segundo o nosso contador tem que contar 1000ms / 10ms = 100, 100 vezes antes de fazermos alguma coisa (enviar um numero).

void enviaNumeros ()
{
    static int contador =  0;

    contador = contador + 1;
    if (contador == 100)
    {
        static int numero = 0;

        numero = numero + 1;
        Serial.write(numero);

        contador = 0;
    }
}

Reparem que o código original da função está lá todo inalterado, mas agora dentro do “if (contador == …” de modo a que só é executado 1 vez de 100 em 100 invocações da função.

Há alguns detalhes que não mencionei mas em geral a técnica é esta, e isto permite fazer bastantes coisas “em simultâneo” de uma forma simples. O importante é não deixar que as tarefas demorem muito tempo ou bloqueiem. Por exemplo, não podem fazer pausas dentro das funções. Se precisam de uma pausa, têm que usar um contador para esperar o tempo desejado, tal como fiz nos exemplos. As funções têm que entrar, fazer qualquer coisa “rápida” e sair.

Esta estrutura já serve para começarem e fazer imensas coisas e é uma forma simples e segura de conseguir fazer alguma multi-tarefa.

Enjoy

p.s. O código não compila, é essencialmente apenas ilustrativo.

Isto ainda é trabalho em desenvolvimento mas já faz o básico para quem está no Regime Simplificado de IRS e é sujeito passivo de IVA. Num futuro próximo quero adicionar a possibilidade de gerar ficheiros com a declaração trimestral, prontinhos para carregar no software do site da DGI.

O projecto está alojado aqui nesta página do blog, também e sempre acessível ali ao lado na lateral direita; sugestões, bugs, etc, podem ser dados nos comentários da mesma página. Se subscreverem o RSS do blog serão avisados quando houver novidades.

Então bom proveito!

Bom, mas há uma história “engraçada”.

Um dia prái com 12 ou 13 anos arranjei um alto-falante de um aparelho velho, o 1º que me passou pelas mãos. Eu não tinha dinheiro próprio e portanto comprá-los não podia, e chegar ao pé dos meus Pais e dizer “quero um alto-falante para o Natal!” foi coisa que, mesmo não sabendo qual seria a reacção deles, nunca senti que valia a pena experimentar. De qualquer forma eu também não saberia “que” alto-falante pedir se fosse à loja…

Na altura não fazia ideia de como fazer aquilo dar sons, mas soldei-lhe um pedaço de cabo duplo e descobri que se o ligasse a um transformador de parede daqueles baratuchos ele emitia um som (o transformador não era rectficado e o som que eu ouvia eram os 50Hz da rede). Depois comecei a brincar, punha condensadores em paralelo e em série e isso modificava ligeiramente o som. Achava alguma piada áquilo, apesar de não sair nenhum som como eu gostaria de ouvir. Algum tempo depois o alto-falante deixou de funcionar e nunca percebi porquê…

… até anos mais tarde, quando o meu irmão que na altura devia ter uns 6 anitos me contou (confessou, hehehe) que me tinha visto a mexer no alto-falante e um dia quis experimentar, só que ele pensou que o som vinha de se ligar o dito à tomada da parede… sim, aos 230V… quando ele o fez o alto-falante deu um “estalo” valente e nunca mais emitiu nada. Ele arrumou logo aquilo onde eu o tinha deixado e claro que nunca me contou com medo das consequências, hehehe…

Mas a moral da história é que a história podia ter acabado muito mal… tenham cuidado a mexer em electrónica à frente de crianças. Elas têm um poder dedutivo extremamente apurado…

Circuito fácil e divertido para iniciantes, no ElectronicaPT.com

Micro-tutorial sobre AVR, no ElectronicaPT.com

Feliz codificação! (porque será que não soa tão bem como “happy coding” ?)

Actualização: O tutorial agora também se encontra em PDF, aqui.