Arquivo de setembro \28\UTC 2009

Darlington Transistor Array

Um problema comum de quem pretende usar um motor de passo em algum projeto com microcontrolador ou com uma FPGA, é o modo que ele funciona.

Para fazer um motor de passo girar, você precisa fazer um excitamento de bobinas na ordem em que elas devem atuar para girar o motor no tamanho do passo e no sentido certos.

Até aí, nada demais, só que um motor desses, mesmo um pequeno, precisa de 200 a 400mA de corrente para funcionar, o que pode fazer você queimar seu microcontrolador que, normalmente, fornece de 30 a 60mA em cada saída.

Na Wikipedia e pelo Google é possível encontrar informações sobre os motores de passo, tanto bipolares como unipolares, o que não é o assunto dessa postagem. Dê uma olhada, se não sabe como eles funcionam ou pra que servem.

Continuando sobre o problema da corrente máxima que o seu aparato produz, existe uma solução simples: Usar um circuito que forneça mais corrente, apenas mantendo o nível lógico da entrada.

Para fazer esse trabalho, os circuitos integrados mais usados são os que contém matrizes de pares de Darlington. Os mais fáceis de se encontrar são os da família ULN2000 e ULN2800, sendo que o ULN2003 e o ULN2803 são os mais comuns e são compatíveis com a família TTL.

Cada um desses integrados pode fornecer até 500mA em cada uma de suas saídas, que são formadas por apenas um transístor de Darlington. Eles podem enviar até 50V para a saída, também sendo útil em aparelhos que nescessitem de tensões mais altas.

A única diferença visível é que o ULN2003 usa um encapsulamento de 16 pinos, onde um pino é usado para Vcc (que será repassado ao motor ou outro aparelho), um para terra, além das 7 entradas de dados e 7 saídas. Já o ULN2803 usa um encapsulamento de 18 pinos, onde é possível adicionar mais uma entrada e uma saída, resultando em 8 de cada.

uln2003a

Particularmente, acho mais vantajoso, para controlar motores de passo, ter um ULN2803 já que seriam precisos 8 entradas e 8 saídas para controlar um segundo motor, algo que não seria possível no ULN2003. No entanto, isso depende do projeto de cada um.

Osciloscópio grátis

Bem, não é tão grátis assim, já que ele está dentro do seu computador.

Como a placa de som de um computador pode amostrar sinais, ela é um osciloscópio, só faltando um software para isso.

Fiquei com essa idéia na cabeça, mas não pensei (n00b) que esse software já existisse. Foi quando, assistindo um vídeo de um cara que precisava olhar o sinal de um controle remoto de um carrinho de brinquedo e disse que ia comprar um osciloscópio.

Estava pensando como osciloscópios são caros e que já tinha a placa de som do computador para isso, quando o sujeito fala que entrou no Google e encontrou um programa que exibia o sinal da placa de som. Aposto que ele não levou mais de 2 minutos pesquisando e acabou com um problema de meses que eu tinha.

Ah, você quer saber qual o programa?

Ele se chama “Xoscope” e pode ser instalado no Ubuntu via apt-get ou pode ser compilado e instalado em qualquer distribuição Linux e possivelmente Mac OSX.

xoscope

Xoscope - Até 8 canais

A amostragem vai depender da placa de audio usada, podendo fazer com que a onda não fique tão boa quanto com um osciloscópio “de verdade” (como se esse não fosse), mas, de graça, até injeção na testa. 🙂

Além disso, o programa poderia ter funções matemáticas, ajuste automático e outras facilidades que qualquer osciloscópio digital de laboratório de eletrônica de faculdade tem, mas deixa pra lá.

Para usá-lo, pegue um plugue de 3,5mm, solde duas pontas de prova ou garras de jacaré, coloque na entrada de microfone do seu computador e pronto.

Para Windows, dei uma procurada e achei um tal de Pcscope 1.0. Não testei e parece que é pago. Se encontrarem um programa melhor, avisem!

Arduino

Como no Brasil os eletrônicos chegam com preços abusivos, então temos que nos virar com o que tem por aqui.

Nessa filosofia DIY, estou montando meu primeiro (talvez de muitos) Arduino, na versão com porta serial e trilhas de um lado apenas da placa, para facilitar a montagem.

O Arduino Severino pode ser equipado com um ATmega8 ou um ATmega168, sendo que irei usar o primeiro, por ser mais fácil de encontrar.

image-0

Esse microcontrolador de 8bits tem 8KB de memória Flash, 1KB de RAM, 14 pinos para entrada e saída digital (sendo que 3 podem ser usados para PWM e 2 podem ser usados para transmissão e recebimento serial), 6 pinos de entrada analógica e roda à 16MHz.

No mundo de hoje, 8KB de armazenamento pode parecer pouco, mas dá para fazer bastante coisa com isso. Se realmente for preciso mais que isso, o microcontrolador desse Arduino pode ser trocado sem problemas pelo ATmega168, que, basicamente, possui 16KB de memória Flash. Fora isso, ele tem mais 3 portas que podem ser usadas com PWM.

Até agora, já pensei em alguns projetos para usar no Arduino, mas acho que vou precisar de mais placas!

Agora só preciso encontrar alguém que vá aos EUA para trazer a versão mais nova do Arduino, o Duemilanove.

Para programar qualquer modelo do Arduino, somente é necessário baixar o programa homônimo e sair escrevendo em uma linguagem chamada de Wiring, mas que é extremamente parecida com C/C++. Além disso, ela tem várias bibliotecas para controle de LCDs, motores de passo, servos, EEPROM e etc.

Vale a pena conferir e, se gostar, montar o seu próprio Arduino.

Tempo de processamento – Funções muito rápidas

Medir o tempo que uma função gasta para ser executada parece ser bem simples, olhando superficialmente.

Teoricamente, só seria necessário gravar o tempo de início e subtrair do tempo do fim.

O problema nesse tipo de medição é que, nos PCs só temos acesso à milisegundos (10⁻³ s) no relógio e uma instrução que seja processada em poucos ciclos de clock dura alguns nanosegundos (10⁻⁹ s).

O que fazer para medir esses nanosegundos?

A primeira solução é usar probabilidade:

pulso

Olhando a imagem, podemos perceber que a medição de tempo pode ser tanto zero ou um, dependendo se a função começou a ser executada próximo do início da borda de subida do pulso de clock.

Assim, mandamos a função ser executada centenas ou milhares de vezes e teremos como encontrar sua duração, com um erro que diminui com o aumento do número de execuções.

Note que o processador conta ciclos de clock, que na função clock() duram 1 milisegundo cada. Por isso, em alguns lugares teremos divisões por 1000.

Exemplo:

#define N 1000000
tempo_inicial = clock() / 1000;
for (i =0; i < N; i++) {
    funcao();
}
tempo_final = clock() / 1000;
duracao = (tempo_final - tempo_inicial)/N;

Essa solução funciona muito bem, mas na medida que você vai aumentando a complexidade ou os dados de entrada vai ser preciso ficar ajustando o número de execuções, para que não demore tempo demais para dar precisão de nanosegundos à uma função que demore microsegundos ou até alguns milisegundos.

Assim, é aconselhado usar um medidor de tempo máximo para executar instruções. Ou seja, antes de executar a função novamente, deve-se conferir se o tempo de execução de esgotou ou não, garantindo um número mais alto de execuções para funções mais rápidas e um número menor (com erro maior) para funções mais demoradas.

Exemplo:

#define tTotal 1000
numExecs = 0;
t1 = clock();
limite = t1 + tTotal;
while ( clock() < limite ) {
    funcao();
    numExecs++;
}
t2 = clock();
duracao = (t2-t1) / (numExecs*1000);

Como o Sistema Operacional está quase sempre realizando operações leves, podemos ter erros de medidas caso a função fosse rodada apenas uma vez, como inicialmente proposto. Com o uso de probabilidade, podemos diluir esse gasto entre todas as medidas, tornando-o desprezível.

Alguns erros de medida podem ser gerados por causa do “warm-up” de cache, entre outras coisas, sendo aconselhado repetir o teste algumas vezes. O valor medido será quase constante após algumas medidas.

Uma Observação:

Caso a função a ser medida seja muito rápida, esse segundo método pode criar um overhead, fazendo com que o tempo total para entradas com poucos dados seja confundido com o gasto de processamento do código do nosso cronômetro.

Para amenizar isso, é possível repetir o bloco sem chamar a função e depois subtrair o tempo gasto do tempo total anterior.

Note que isso só será necessário em funções que durem menos de microsegundos.

Loops em C

A discussão do dia foi sobre o loop while em C, no sentido de diminuir o tempo de processamento.

A ideia que me foi proposta era:


while (condicao1 && condicao2) {
//instrucoes
}


A condição com mais probabilidade de dar zero (olhando as características do programa) deveria ser escrita primeiro ou não faria diferença?

Para nós, seres pensantes, olharíamos o primeiro caso e, se fosse falso, o AND também seria, então não seria preciso olhar o segundo.

Mas, como a linguagem C, além de outras, permite que você atribua valor a uma variável ou execute uma função dentro do WHILE, do FOR e do IF, o processador seria obrigado a processar as duas condições.

No entanto, isso acaba não acontecendo, o que pode ser perigoso se você precisa do valor de uma variável ou que uma função apresente algum dado específico!

Portanto, sim, é válido escolher a melhor ordem para fazer um AND num loop em C e na maioria das linguagens dessa derivada, como C++ e Java. Claro que isso também pode depender do compilador usado, mas esse é o “comportamento padrão”. Isso também não pode ser dito como verdade para todas as linguagens, então é bom prestar atenção

Isso tudo que eu falei também vale par o OR, quando a primeira condição é verdadeira.

VHDL

Very complicated Hardware Description Language.

Pessoa sobre VHDL

Claro que não significa isso, mas bem que poderia.

Aprendendo VHDL para programar uma CPLD a fazer um simples circuito para criar um pulso ao clique de um botão me custou 3 dias.

E o projeto era simples: Criar um divisor de frequência para o conseguir 100Hz ao invés de 250MHz, esperar 3 ciclos do novo clock após o botão ser pressionado (evita ruído) e depois gerar um pulso para a saída.

Placa UP1 da Altera

Placa UP1 da Altera

Coisas que podem ser feitas em outras linguagens de programação dão problemas em VHDL, como mudar o valor de uma das variáveis duas vezes no processo.

Acho melhor começar a ler mais sobre VHDL.

Fui.

Tiras

De um tempo para cá, comecei a salvar coisas interessantes que encontrava na internet, apenas pelo fato de nunca conseguir lembrar novamente o site onde vi a tal coisa.

Essa tirinha do Dilbert (Dogbert, para ser mais preciso) é uma delas:

dilbert_dogbert_techsupport

Como dá para imaginar, não sei onde encontrei… se um dia achar, coloco aqui o link. Se quiser, pode entrar no site do Dilbert que todo dia tem uma tirinha nova.