Monthly Archives: October 2011

Função C para múltiplos e submúltiplos (REVISADO)

O Caio Alarcon me notificou de algumas coisas sobre minha função de múltiplos e submúltiplos, por exemplo, o tratamento de números negativos. Resolvi então revisar e otimizar a função em C. O Resultado está abaixo:

#include <stdio.h>
#include <math.h>
char toNotationUnit(double value,float *out) {
        double val;
        char notacoes[] = {'y','z','a','f','p','n','u','m',' ',

                                   'k','M','G','T','P','E','Z','Y'};
        int counter=8;
        char unit;
        val = value>0?value:-value;
        if(val < 1) {
                while( (val < 1.00) & (counter != 0)) {
                        counter--;
                        val=val*(double)1000;
                }
        }else{
                while((val >= 1000) & (counter != 16)) {
                        counter++;
                        val=val/(double)1000;
                }
        }
        unit = notacoes[counter];
        val = round(val*(double)100)/(double)100;
        *out = (float) value>0?val:-val;
        return unit;
}
 
int main() {
  double x = -1230000;
  float res;
  char t;
  t = toNotationUnit(x,&res);
  printf("%.2F%c",res,t);
  return 0;
}

Quem preferir, tem um link no ideone com este código funcionando 😀

http://ideone.com/wpvZo

Bom uso!

Interruptor MIDI Polifônico com PIC 16F628A (Interface)

Neste tópico colocarei apenas como é a interface do interruptor descrito anteriormente.

image

Para um interruptor monofônico, ligamos o Enable em Vcc e ignoramos o BUSY. Para polifônicos, colocamos o Enable do primeiro no Vcc, e nos seguintes ligamos no BUSY do anterior. Nas saídas fazemos uma operação OR, e as entradas MIDI são ligadas todas juntas.

Continue reading

Interruptor MIDI Polifônico com PIC 16F628A

– Introdução

Bom, muitos sabem que eu fiz um Interruptor MIDI (ou sintetizador como preferir) com um FPGA. Porém poucos tem acesso a um FPGA principalmente para fazer algo tão *simples*, então resolvi fazer um com PIC 16F628A.

No começo queria fazer com um PIC menor, mas os menores não tem Receptor Serial via hardware, então ficaria mais complicado implementar. Outro ponto, é que o preço dos PIC’s menores são praticamente os mesmos, então era só uma questão de espaço mesmo. Usando um PIC maior, fica mais espaço livre para futuras modificações caso seja necessário.

O PIC 16F628A tem 2KB de memoria flash, 224 Bytes de RAM, 128 Bytes de EEPROM, um Comparador, 3 Timers, e um Receptor Serial Universal. Está no pacote DIP de 18 Pinos, e ele tem 2 portas de 8 bits (dependendo da configuração, a porta A pode *perder* 3 bits.

Datasheet dele: http://ww1.microchip.com/downloads/en/DeviceDoc/40044F.pdf

Ele tem um oscilador RC Interno de 4MHz calibrado de fábrica para +/- 1%, então podemos fazer uso dele tranquilamente.

Continue reading

Amostra de Memória MRAM da Everspin

A muito tempo atrás pedi amostras de uma memória magnética da Everspin para fazer testes aqui, porém depois me deparei com o problema de que ela é 3.3V.

De qualquer maneira agora tenho um FPGA para brincar com ela.

O modelo de amostra é a MR2A16AYS35, uma MRAM de 1M de endereço e 16 Bits de “palavra”, totalizando 16Mbit ou 2 Mbytes.

MRAM é um acrônimo para Magneto-resistive Random Access Memory, que é uma memória RAM não-volátil (não perde os dados quando se desliga). Ela é considerada a chave para o futuro da computação, principalmente portátil. Com ela vem o conceito de “boot-instantâneo” onde seu computador ao apertar o botão de ligar, estará já pronto para uso.

O por que disso? É bem simples na realidade. Os armazenamentos não-volateis (por exemplo cartões de memória, HD’s, pendrives) são muito lentos para se trabalhar diretamente neles, e devido a isso se usa a Memória RAM, que é muito mais rápida, porém perde seu conteúdo ao se remover a energia. E até pior no caso das atuais DDR que são baseadas na DRAM, onde seu conteúdo precisa ser “refrescado” de tempos em tempos (a memória precisa de um pulso pra recarregar os valores 1 dentro dela, se não ela perde. Isso é devido ao dado propriamente dito ser armazenado em um capacitor, que perde sua energia com o tempo)

Continue reading

Fonte 3v3 do FPGA

Bom, alguns talvez lembrem que um pouco antes do Flisol de Salto uma das minhas placas de Desenvolvimento Xilinx Spartan 3A Evaluation Kit parou de funcionar. Descobri que era o regulador de 3.3V da placa que havia queimado (bom, eu meti em curto várias vezes sem querer, apesar de ele ter proteção, nunca é a prova de falhas). Por sorte eu tinha outra e pude apresentar o projeto.

Mas ontem resolvi arrumar a placa de algum jeito. Infelizmente o regulador 3.3V apesar de não ser caro, tem algo em torno de 2mm²  e é em QFN, um SMD que os pinos dele são em baixo do chip.

Ou seja, era um mísero quadrado minúsculo que mesmo que tivesse seus pinos para o lado seria quase humanamente impossível de soldar. Então resolvi apelar. Tinha um Regulador de 3.3V 3A aqui num canto, uma placa boa e bem feita (vinda da China) e resolvi ligar no lugar do regulador 3.3V.

Não ficou tão bonito, mas está funcionando perfeitamente, e agora tenho um regulador mais robusto também de 3.3V para o que eu precisar:

image

Electronics Hacking

Bom, decidi postar hacks de eletrônica aqui também. Até por que são mais frequentes que os meus hacks. Ai vai umas fotos de um sensor CMOS que soldei numa placa pra facilitar, e verei um dia de brincar com ela:

image

image

É um Sensor CMOS VGA Colorido, que roda em 3.3V. A sua interface também é CMOS (muitas vezes o sensor é cmos, mas a interface é analógica) e como o nível de tensão é 3v3 é fácil de eu trabalhar com um FPGA. Devo ter tirado isso de uma webcam ou câmera de vigilância, não lembro.

A resolução é 644×484 pixels, porém ela tem uma área morta como qualquer câmera, logo não é tudo isso que é aproveitável. Outro ponto positivo, diz o datasheet que ela é capaz de chegar a 30FPS de taxa de amostragem, o que me leva a pensar que não foi uma webcam, e sim uma câmera de vigilância.

De qualquer maneira não irei brincar com ela hoje, e não tenho previsões. Preciso estudar muito ainda como funciona os sensores. A unica coisa que sei até agora é que ela trabalha com varredura dos sub-pixels, a cada clock tenho 10 Bits que demonstram a intensidade do sub-pixel.

Porém o datasheet é meio confuso, em alguns lugares parece que eu tenho o dado do pixel, e em outros parece o dado do sub-pixel. De qualquer maneira, não é apenas tacar numa tela o dado, é preciso processar ele antes. Esse sensor usa um filtro bayer padrão o que nos dá para cada pixel, dois sub-pixels verde, um vermelho e um azul. Num estudo rápido que fiz, o motivo de ter dois sub-pixels verdes e apenas um das outras cores, é o fato do olho humano ser mais sensível a cor verde devido ao numero de cones (mais sensíveis a cor verde) ser o dobro do numero de bastonetes. Então precisarei ver o que vou fazer.

De qualquer maneira, se alguém quiser o datasheet (não são muitos sites que tem o detalhado, então upei o detalhado no Project Source) ele está nesta pasta:

http://www.energylabs.com.br/project/?dir=Outros/Datasheets

É isso ae!

Função Javascript para Múltiplos e Submúltiplos

Bom, vocês devem ter visto meu tópico anterior sobre Função Javascript para Submúltiplos e eu resolvi fazer uma função mais completa. Agora abrangendo mais submúltiplos e também abrangendo múltiplos. O conceito é o mesmo do anterior, gerar o valor com múltiplo ou submúltiplo e arredondar para duas casas decimais apenas. A função fica assim:

function toNotationUnit(v) {
	var unit;
	var submultiplo = ["","m","&micro;","n","p","f","a","z","y"];
	var multiplo 	= ["","k","M","G","T","P","E","Z","Y"]
	var counter= 0;
	var value = v;
	if(value &lt; 1) {
		while(value &lt; 1) {
			counter++;
			value=value*1e3;
			if(counter==8) break;
		}
		unit = submultiplo[counter];
	}else{
		while(value &gt;= 1000) {
			counter++;
			value=value/1e3;
			if(counter==8) break;
		}
		unit = multiplo[counter];
	}
	value = Math.round(value*1e2)/1e2;
	return [value,unit];
}

Como podem ver, eu coloquei para retornar uma array contendo na sua posição 0 o valor arredondado em duas casas, e na posição 1 a unidade, assim você poderá tratar da maneira que bem entender o resultado. Para usá-la é bem simples, vamos a um exemplo em HTML:

<script type="text/javascript">
function toNotationUnit(v) {
	var unit;
	var submultiplo = ["","m","µ","n","p","f","a","z","y"];
	var multiplo 	= ["","k","M","G","T","P","E","Z","Y"]
	var counter= 0;
	var value = v;
	if(value < 1) {
		while(value < 1) {
			counter++;
			value=value*1e3;
			if(counter==8) break;
		}
		unit = submultiplo[counter];
	}else{
		while(value >= 1000) {
			counter++;
			value=value/1e3;
			if(counter==8) break;
		}
		unit = multiplo[counter];
	}
	value = Math.round(value*1e2)/1e2;
	return [value,unit];
}

function pegarvalor() {
	var i = parseFloat(document.getElementById('valor').value);
	var t = toNotationUnit(i);
	document.getElementById('resultado').innerHTML = t[0]+t[1];
}
</script>

Insira um valor: <input type="text" id="valor" name="valor">
<input type="button" onClick="pegarvalor();" value="Pegar"><BR>
Resultado: <div id="resultado"></div>

Ou se preferir no Codepad: http://codepad.org/TSn8wtA1

Façam bom uso 😀

Função Javascript para Multiplos e Submultiplos

Bom, estava montando uma outra calculadora aqui para a EnergyLabs Brasil, e quis fazer algo mais legalzinho. Fiz uma função em javascript que concatena o valor com o submúltiplo, e já faz as multiplicações necessárias além de arrendondar para duas casas decimais.

Não entendeu? Bom vou exemplificar.

Em física se usa muito múltiplos e submúltiplos para ajudar a escrever unidades. Por exemplo, estamos habituados com a unidade segundo no nosso dia a dia. Para representarmos 0,1 segundo, podemos representar como 100ms (100 milissegundos), para 0,0001 segundo, podemos representar como 100us (100 microssegundos), e assim por diante. Isso são os submúltiplos. Ao invés de escrevermos 0,0001 escrevemos 100 * 10^-6 (100 * 0,000001 que é 0,0001) ou 100us. Os mais comuns submúltiplos são:

  1. mili – m  – 10^-3
  2. micro – µ – 10^-6
  3. nano – n – 10^-9
  4. pico – p – 10^-12

Então vamos lá para a função:

function putunit(v,unit) {
	var lastunit = '';
	var units = ["m","µ","n","p"];
	var counter= 0;
	var value = v;
	while(value < 1) {
		lastunit = units[counter];
		counter++;
		value=value*1e3;
		if(counter==5) break;
	}
	value = Math.round(value*1e2)/1e2;
	return "<B>"+value+"</B> "+lastunit+unit;
}

Como usar? Bem simples:

	var i = 0.015;
	var resultado = putunit(i,"s");

Quer um exemplo mais prático? Vamos lá então, uma página HTML 😀

function putunit(v,unit) {
	var lastunit = '';
	var units = ["m","µ","n","p"];
	var counter= 0;
	var value = v;
	while(value < 1) {
		lastunit = units[counter];
		counter++;
		value=value*1e3;
		if(counter==5) break;
	}
	value = Math.round(value*1e2)/1e2;
	return "<B>"+value+"</B> "+lastunit+unit;
}

function pegarvalor() {
	var i = parseFloat(document.getElementById('valor').value);
	document.getElementById('resultado').innerHTML = putunit(i,"s");
}
Insira um valor: <input type="text" id="valor" name="valor">
<input type="button" onClick="pegarvalor();" value="Pegar"><BR>
Resultado: <div id="resultado"></div>

Ou se preferir ver no Codepad: http://codepad.org/hGDQsbT1

Faça o teste e terá resultados assim:

image

image

image

Viu como é prático? Você pode usar a mesma ideia da função para os múltiplos também!