alf de(con)struction

O MC14067bcp é um (de)multiplexador. Basicamente, um multiplexador é um circuito chaveador capaz de combinar vários canais de entrada em uma única via de saída. Um de-multiplexador tem a função contrária, através de um canal de entrada temos várias vias de saída.

Multiplexadores e de-multiplexadores são circuitos muito úteis quando estamos lidando com plataformas que possuem quantidades de pinos de entrada e saída limitados, como é o caso do Arduino, com apenas 6 pinos de entrada analógica. O 4067 possui 16 pinos que podem ser utilizados como entradas ou saídas, para realizar a transmissão ou recebimento de dados analógicos.

Seu funcionamento é simples. Através de 1 pino enviamos ou recebemos os dados, e energizando outros 4 pinos conseguimos indicar para qual canal queremos enviar os dados ou recebê-los.

Estive testando outro circuito lógico com as mesmas funções para o projeto Modular Synth, o 4051. Ao meu ver o 4067 tem algumas vantagens. Possui 16 pinos que podem ser utilizados como entradas ou saídas contra 8 do 4051, a organização dos pinos do 4067 é melhor, aparentemente ele é mais fácil de se encontrar em Joinville, Santa Catarina, por um preço menor comparado ao preço do 4051. Para ambos encontra-se alguma informação on-line, e para o 4067, o tutorial do ITP Physical Computing é uma boa documentação, esse post é baseado no que li por lá.

pinagem do 4067

Colocar esse circuito lógico para funcionar é simples. Para exemplificar seu uso, vou aproveitar o circuito que estou montando para o Modular Synth, um módulo com várias entradas analógicas. Nesse caso, o pino 1 (X), é o pino onde faremos a leitura dos dados. Os pinos de 2 à 9 (X0 até X7) e de 16 à 23 (X8 até X15) são os pinos de entrada, os pinos 12 (VSS, o terra) e 15 (INHIBIT) são ligados ao terra do circuito, e o pino 24 (VDD) deve ser ligado a uma fonte de alimentação de 5 volts. Para realizar o chaveamento entre os 16 canais de entrada, escolhendo um deles para fazer a leitura pelo pino 1 (X), usamos os pinos 10 (A), 11 (B), 14(C) e 13(D).

A tabela abaixo mostra a relação entre os pinos de controle A, B, C, D e o canal que será lido a partir do pino de entrada 1(X).

Para entender essa tabela é necessário entender um pouco sobre números binários:

Dado um número N, binário, para expressá-lo em decimal, deve-se escrever cada número que o compõe (bit), multiplicado pela base do sistema (base = 2), elevado à posição que ocupa. Uma posição à esquerda da vírgula representa uma potência positiva e à direita, uma potência negativa. A soma de cada multiplicação de cada dígito binário pelo valor das potências resulta no número real representado. Exemplo:

1011(binário)

1 × 2³ + 0 × 2² + 1 × 2¹ + 1 × 2⁰ = 11

Portanto, 1011 é 11 em decimal

(via wikipedia)

Então, escolhendo quais dos pinos A, B, C e D são energizados, selecionamos o canal do qual vamos realizar a leitura a partir do pino 1 (X).

A ligação do 4067 ao Arduino é simples, nesse exemplo vou utilizar os pinos digitais 2, 3, 4 e 5 para selecionar os canais e o pino analógico 0 para a leitura. No diagrama abaixo não consta a ligação dos pinos 12 e 15 ao terra e o pino 24 na fonte de alimentação, não esqueça deles!

Ligação do 4067 com o Arduino

Nos pinos de X0 até X15 estão ligados os potenciômetros. O código abaixo demonstra de forma simples como realizar a leitura de um determinado pino:

void setup() {
        Serial.begin(9600);
        pinMode(2, OUTPUT);
        pinMode(3, OUTPUT);
        pinMode(4, OUTPUT);
        pinMode(5, OUTPUT);
        digitalWrite(2, HIGH);
        digitalWrite(3, LOW);
        digitalWrite(4, LOW);
        digitalWrite(5, LOW);
}
 
void loop() {
        int valor = analogRead(0);
        Serial.print("Valor lido no canal: ");
        Serial.println(valor, DEC);
        delay(1000);
}

Veja que na função setup o único pino setado como HIGH é o pino dois, assim obtemos o valor em binário 0001, ou seja, 1 em decinal, selecionando então o canal X1 para realizar a leitura. No tutorial do ITP Physical Computing é apresentada a função setChannel que nos facilita a leitura de dados de um determinado canal. Reproduzo essa função abaixo com algumas modificações:

int pino_entrada = 0;
void setup() {
        Serial.begin(9600);
        pinMode(2, OUTPUT);
        pinMode(3, OUTPUT);
        pinMode(4, OUTPUT);
        pinMode(5, OUTPUT);
        digitalWrite(2, LOW);
        digitalWrite(3, HIGH);
        digitalWrite(4, LOW);
        digitalWrite(5, LOW);
}
 
void loop() {
        int valor_entrada;
        for (int canal = 0; canal < 16; canal++) {
                setChannel(canal);
                valor_entrada = analogRead(pino_entrada);
                Serial.print("Leitura do Canal ");
                Serial.print(canal);
                Serial.print(": ");
                Serial.println(valor_entrada, DEC);
                delay(1000);
        }
}
 
void setChannel(int canal) {
        for (int posicao_bit = 0; posicao_bit < 4; posicao_bit++) {
                // Realiza o deslocamento à direita (&gt;&gt;) e
                //a função bitwise AND (&amp;)
                int valor_bit = (canal >> posicao_bit) & 1;
                // Como o primeiro pino de controle é o pino 2,
                // soma-se posicao_bit a ele
                int pino = 2 + posicao_bit;
                // Escreve no pino indicando se ele está ligado
                // ou desligado
                digitalWrite(pino, valor_bit);
        }
}

A função setChannel realiza um shift (deslocamento à direita) para cada canal e realiza a função bitwise AND (&) para verificar se o canal deve ser colocado como ligado ou desligado. Ok, mas como assim? Por exemplo, se o canal selecionado for o canal 5, sua representação em binário é 0101. Assim, ao realizar o deslocamento à direita (>>) na primeira iteração do loop, obteremos 0101, na segunda iteração, 0010, na terceira, 0001 e na quarta, 0000.
Dessa forma, ao realizarmos a função de bitwite AND (&) comparando o número 1 com o resultado obtido com o deslocamento à direita, receberemos como retorno 1 ou 0, indicando se o pino de controle deve estar ligado ou desligado, e o setamos usando a função digitalWrite logo em seguida.

Pronto, 16 entradas ou saídas analógicas usando 5 pinos do Arduino.

Yah! Tenho que agradecer ao Pedro Rito pelos jumpers! Foram um presente muito giro, isso tem facilitado a vida imensamente, thks!

Nessa última quinta-feira realizamos o último encontro da oficina de prototipação com o Arduino, com o objetivo de introduzir conceitos de eletrônica e programação de microcontroladores para os participantes. Sentimos a necessidade de realizar essa oficina depois que iniciamos os projetos no grupo UDESC-PC, onde a maioria dos participantes estava tendo o primeiro contato com o mundo da eletrônica e com microcontroladores. Foram montadas 8 placas do Arduino Severino (muito obrigado pelo desenvolvimento desse projeto Adilson Akashi!), onde os participantes aprenderam desde o funcionamento dos componentes básicos, técnicas de laboratório, programação do microcontrolador e comunicação serial com o Computador.

O primeiro dia de oficina foi uma aula expositiva onde conceitos sobre eletrônica foram apresentados. Mostrou-se desde o que é tensão, corrente e resistência, o triângulo básico da elétrica, até o funcionamento de componentes básicos como transistores, diodos, capacitores, etc. Ao passo que cada componente ia sendo explicado, um circuito mostrando seu funcionamento era montado.

No segundo dia nos reunimos em uma sala para montar o Arduino Severino. Ficamos até 01:50 da manhã na universidade. Como o Vilson gosta de dizer “Esse tipo de coisa é para ser feito de madrugada”. Ao final desse dia tínhamos 8 plaquinhas montadas, quase todas funcionando corretamente. Infelizmente debugar circuitos eletrônicos é muito mais chato do que debugar código-fonte.

No terceiro dia,  o mais esperado, montamos circuitos básicos com o Arduino e escrevemos código para eles. Aprendemos como fazer input/output digitais e analógicos, como funciona o PWM e para que serve, como fazer a comunicação serial entre o microcontrolador e o computador e trabalhamos com a linguagem processing para enviar e obter dados.

Apresentação no slideshare.

Iniciamos ontem as atividades do nosso mais recente projeto, o Udesc Physical Computing. O projeto desenvolve-se a partir da interação entre acadêmicos e professores da Universidade do Estado de Santa Catarina. Nosso maior interesse é desenvolver projetos que envolvam os conceitos de Physical Computing, Live Coding e Computer Art.

Atualmente estamos trabalhando em uma mesa multi-toque baseada em projetos como o tbeta. Ja comentei sobre ele aqui no blog. O diferencial é que estamos usando um monitor LCD ao invés de um projetor. Outro projeto que está sendo estudado é a criação de um clone do monome usando o Arduino como base.

Você pode encontrar mais informações sobre o projeto na nossa wiki.

Physical Computing, ou “Computação Física”, significa construir sistemas interativos que consigam sentir e responder ao ser humano e/ou ao mundo analógico, analisando suas expressões e mudanças físicas como intensidade de luz, temperatura, vibração, pressão, etc. Em Physical Computing, vai-se muito além das tradicionais formas de comunicação por teclado, mouse, monitor, etc. Nessa abordagem leva-se em conta, para a obtenção de dados, todo o ambiente físico.

Primeiramente isso significa que temos que conhecer como o o mundo analógico funciona e como converter os dados obtidos em sinais elétricos digitais para que um computador seja capaz de compreender o que está acontecendo e crie a interação com o ambiente. Para tanto, faz-se uso de sensores que realizam a captura de dados e os enviam a uma interface computacional onde os dados são convertidos em sinal digital.

Na seqüencia, temos que aprender a usar a consciência que o computador toma dos acontecimentos no mundo real em formas de interações úteis e produtivas. O computador tem que criar eventos de interação para determinados dados captados, como por exemplo, a variação de luminosidade gerando som.

Apesar das habilidades necessárias para criar a interação entre o computador e o ambiente serem similares as necessárias para se construir robôs, os conceitos são bem diferentes. Gosto da maneira como Tom Igoe explica essa diferença no seu artigo What is Physical Computing:

[...] When you build robots, you’re usually focused on making something that’s autonomous, and can ignore people and navigate through the world on its own. That takes a lot of work. Physical computing applications tend to depend more on people for input, and amplify that input into another form, like an animation, a sound, or motion. Robotics tends towards duplicating what humans can do, replacing the human brain with a computer brain; physical computing tends to extend what they can do, leaving the human brain and body at the center of it all. [...]

Enquanto a Robótica se foca na criação de mecanismos autônomos, buscando substituir o cérebro humano e suas demais capacidades, Physical Computing pretende estender as capacidades humanas, tendo o cérebro e restante do corpo humano no centro de tudo isso.

O objetivo principal é fazer com que o computador se adapte a forma de interação humana, e não o contrário. É muito mais natural, por exemplo, para um cartunista desenhar em uma interface que lembre o uso de papel e caneta ao invés de usar o mouse para isso. Da mesma forma, é mais natural para um músico utilizar um dispositivo que lembre uma guitarra para criar músicas, ao invés do teclado.

Physical Computing está intimamente ligada com temas relacionados a artes, design de interação, arquitetura, etc. É a busca pela amplificação das nossas capacidades, tentando extrapolar algumas de nossas limitações mas sem nos excluir do processo na tentativa de termos novas experiências e sensações através da nossa interação com o ambiente.

Mais informações:

http://www.tigoe.net/pcomp/blog/archives/notes/000169.shtml

http://itp.nyu.edu/~dbo3/blog/

http://www.physicalcomputing.com/

http://oreilly.com/catalog/9780596510510/