|
|
| (23 edições intermediárias de um usuário não apresentadas) |
| Linha 1: |
Linha 1: |
| − | = Introdução =
| + | O projeto ABaCo tem como objetivo fornecer uma estrutura básica de eletrônica e softwares relacionados, de modo que qualquer pessoa interessada em aprender ou desenvolver projetos interativos, mídias tangíveis entre outros, seja capaz de executá-lo de um modo mais fácil. As ferramentas e softwares utilizados estão diretamente correlacionados com a filosofia de software livre e da liberdade de uso, execução, distribuição e modificação. |
| | | | |
| − | Um dos entraves enfrentados pelos professores e estudantes das áreas de Engenharia que têm como disciplina eletricidade, é o ensino e entendimento, este por parte dos alunos, de circuitos elétricos. Como cita [1] há uma dificuldade na construção da ponte que liga o embasamento teórico, este adquirido desde as disciplinas básicas tais como física e matemática, e as disciplinas que envolvem a prática em laboratório, o que faz com que o aproveitamento esperado seja prejudicado.
| + | Esta wiki divide o projeto ABaCo em tópicos didáticos que buscam explicar de um modo simples cada parte que o compõe. |
| | | | |
| − | O foco deste projeto é a criação de um arcabouço para auxiliar no entendimento do aluno para com as aulas de laboratório mesclado as artes envolvendo processing e a familiarização com circuitos elétricos.
| |
| − | Um dos pontos-chave do projeto é a importância do baixo custo na construção do arcabouço, uma vez que toda a arquitetura , a princípio almejada, segue a filosofia livre.
| |
| | | | |
| − | O diagrama abaixo ilustra de forma ampla as ferramentas livres mais utilizadas para se trabalhar com eletrônica, entretanto o projeto focará apenas em algumas de modo a não estender o conteúdo do manual, deixando as outras como forma de auxílio no caso de uma necessidade. | + | = O ABaCo = |
| | | | |
| − | [[Imagem:Toolchain.png|870px]] | + | O projeto ABaCo segue uma [[cadeia de desenvolvimento]] elaborada com base em Software livre. |
| | | | |
| − | = O que é =
| + | Para se trabalhar com circuitos elétricos e projetos interativos usando o ABaCo são necessários componentes eletrônicos como [[Resistores]], chaves de contato entre outros, bem como de um [[Protoboard]] no qual o [[Protótipo]] será montado. Com o protótipo montado no protoboard, o controle do circuito será feito pelo [[Arduino]] que estará conectado a um [[Computador]] no qual roda o código de controle do protótipo na [[linguagem de programação do Arduino]]. Entretanto antes de se ligar o protótipo no arduino é importante simular se tudo está ocorrerá como esperado em um [[software de simulação]] e é também importante manter o diagrama do circuito para que possa ser explicado de forma simples o seu funcionamento e mostrar quais componentes foram usados usando um programa de [[diagramação(Layout do circuito)]]. |
| | | | |
| − | Em termos práticos o projeto é uma bancada computacional de baixo custo que irá auxiliar, a quem interessar, no entendimento e desenvolvimento de projetos utilizando hardware e interface hardware-software. A arquitetura básica da bancada, além do computador para coleta e envio de dados ao hardware em desenvolvimento, será composta por tecnologias livres, utilizando na parte de interação com o hardware base o ambiente de programação Arduíno [2] e na simulação, anterior a montagem do circuito, será usado o QUCS [3] para que haja certeza de que o que se espera irá ocorrer. Outros simuladores de circuitos pesquisados: KLogic [4] e XCircuit [5].
| + | Para visualização dos dados, pode-se optar pelo [[interfaceamento com processing]] de modo a ter uma interação gráfica e de fácil manipulação. Bem como o custo do projeto a ser construído, o [[ABaCo também tem seu custo]]. |
| | + | Com todo o projeto simulado e montado, já funcionando, é possivel, caso se queira, criar um [[diagrama para impressão]] em placa condutora e assim construir o projeto final numa placa independente do protoboard com o tamanho requisitado pelo circuito ao contrário do protoboard que sempre possui as mesmas dimensões. |
| | | | |
| − | Programas relacionados a circuitos podem ser encontrados em opencollector.org. O projeto ABaCo será usado em conjunto com outro em elaboração, que é criar aulas de laboratório de mídias e hardware para que os alunos tenham um melhor entendimento dos conteúdos que serão cobrados posteriormente em outras disciplinas de circuítos e desenvolvam a capacidade de criar sistemas interativos.
| + | O projeto incentiva a criação de [[mídias tangíveis]] bem como em paralelo o uso da [[filosofia de software livre]]. |
| | | | |
| − | == Computador ==
| + | Alguns [[Exemplos Práticos]] estão disponíveis para que se possa esclarecer o uso do ABaCo para construção de mídias tangíveis. |
| − | | + | |
| − | O componente da bancada no qual todos os estudos serão realizados tais como simulações, programação do software a ser embarcado no hardware(Arduino) quando necessário, a partir de uma interface(Arduino). O sistema operacional a ser utilizado será baseado no GNU/Linux afim de que se estimule o aluno ao uso e criação de soluções livres para que haja total entendimento e acesso no projeto em desenvolvimento ou já desenvolvido por parte de outros estudantes ou interessados no assunto.
| + | |
| − | | + | |
| − | == Arduino ==
| + | |
| − | | + | |
| − | Arduino é um protótipo eletrônico open-source que implementa um ambiente de fácil relacionamento entre o hardware e o software para programadores, designers, artistas ou quem quer que esteja interessado em utilizá-lo para algum fim. Com ele é possível capturar eventos em ambientes através de sensores, não inclusos, por meio da porta de entrada de sinais, e também controlar dispositivos eletrônicos de diversos tipos como luzes, motores et cetera, de um modo simples quando comparado às linguagens usadas que permitem esse tipo de comunicação. O Freeduino ou similares ao Arduino pode ser utilizado.
| + | |
| − | | + | |
| − | [[Imagem:Arduino.jpg]] | + | |
| − | | + | |
| − | O Arduino tem três regiões principais que estão em torno de um quadrado com bordas vermelhas na imagem acima.
| + | |
| − | # No canto esquerdo da imagem há duas portas e um pino (jumper) selecionável que diz se a alimentação do arduino será via USB ou por uma fonte externa ou bateria de 9 Volts.
| + | |
| − | # No topo da imagem há 16 portas sendo que os pinos de 0 a 13 são usados pra entrada e saída digital. Desses 13 pinos, os pinos rotulados 0(RX, Recebe) e 1(TX, Transmite) podem ser usados para comunicação serial, os pinos 3,5,6,9,10 e 11 suportam pwm (Pulse-width modulation) em que é possível especificar o tempo que o sinal ficará ligado em um periodo, a porta GND(Ground) é o terra do circuito e a porta AREF é a referência de entrada para as entradas analógicas, ou seja, quando a tensão lida é igual a tensão aplicada em AREF, então 1023 é retornado, caso contrario um valor proporcional de 0 a 1023 é retornado. O valor máximo aplicado na porta AREF deve ser de 5 volts, entretanto esse é o valor padrão considerado como 1023 nas leituras analógicas, logo o uso de AREF deve-se a necessidade de leitura de tensões máximas menores que 5 volts.
| + | |
| − | # Na base da imagem há 12 portas sendo 6 rotuladas de 0 a 5 para a entrada analógica de tensão, sendo a máxima 5 volts; na esquerda há 6 portas rotuladas da esquerda para a direita como porta RESET usada para resetar o arduino quando aplicado o terra sobre ela, a porta 3V3 que fornece 3.3 Volts com corrente máxima de 50mA, a porta 5V que fornece 5 volts de tensão, a porta GND que é ligada ao terra do circuito e a porta Vin que também fornece 5 Volts quando alimentado por USB ou a tensão da fonte de tensão ou da bateria quando alimentado por estas.
| + | |
| − | | + | |
| − | O botão na região central direita do arduino serve para resetá-lo.
| + | |
| − | | + | |
| − | == Ambiente de programação Arduino ==
| + | |
| − | | + | |
| − | O ambiente de programação Arduíno é baseado na IDE do processing e a linguagem de programação do arduino é baseada no Wiring. Para os programadores de C/C++ e java não há diferenças significativas na sintaxe.
| + | |
| − | | + | |
| − | == Interfaceamento Processing - Arduino ==
| + | |
| − | | + | |
| − | É possível fazer comunicação com o Arduino através do Processing, assim aproveitando as vantagens em se trabalhar com processing em Mídias e Artes. O que o Processing fará então é ler toda a saída do Arduino, aplicando uma computação mais elaborada às respostas dele como efeitos 3D, musicas et cetera.
| + | |
| − | Nos exemplos que se seguem será abordado a maneira de realizar tal comunicação.
| + | |
| − | | + | |
| − | == Fonte de alimentação ==
| + | |
| − | | + | |
| − | A fonte de alimentação será construída de modo que tenha saídas padrões com relação aos componentes avançados que podem vir a ser usados, tais como transistores, amplificadores operacionais entre outros. A fonte precisa ser construída por uma pessoa experiente, utilizando o circuito que for conveniente de modo que apenas saiam as tensões +5V, -5V, +12V, -12V e terra(GND-Ground).
| + | |
| − | | + | |
| − | == QUCS (Quite Universal Circuit Simulator) ==
| + | |
| − | | + | |
| − | QUCS é um diagramador de circuitos open-source fácil de usar e foi escolhido para compor o arcabouço, pelo fato de que permite a simulação fácil de circuitos e terá como finalidade sanar possíveis dúvidas de funcionalidade, antes da construção de um determinado circuito. Ele permite uma quantidade razoável de simulações dentre elas de corrente alternada, contínua e circuitos digitais.
| + | |
| − | | + | |
| − | == Hardware Base ==
| + | |
| − | | + | |
| − | O hardware base para a elaboração de circuitos será composto por resistores, um multimetro para a verificação das grandezas reais associadas ao circuito e aos componentes. A captura de dados e a alimentação do hardware será através da porta USB utilizando o Arduino, entrentanto para circuitos sem a necessidade da captura de dados uma fonte de tensão pode ser usada e por fim um protoboard, ou matriz de contatos, que é uma placa que contém dezenas de pequenas entradas nas quais os componentes eletrônicos são encaixados e o circuito é montado, evitando a necessidade inicial de placas condutoras e soldagem.
| + | |
| − | | + | |
| − | === Leitura de Resistores ===
| + | |
| − | | + | |
| − | Cada resistor tem uma identificação única que o caracteriza, ou seja, que informa a sua resistência. São três anéis coloridos em que cada cor representa um número e a partir da combinação se tem então a resistência.
| + | |
| − | | + | |
| − | Geralmente os resistores possuem quatro faixas sendo que a última faixa a ser lida é dourada ou prata, ou seja, a orientação que deve-se seguir é com base na posição da faixa dourada ou prata. A faixa vermelha representa que o resistor tem um erro de 1%, a dourada um erro de 5% e a prata 10%. A leitura será explicada em base ao resistor de 5%.
| + | |
| − | | + | |
| − | Posicionando a faixa de erro para a direita, da esquerda para a direita a primeira faixa representa o primeiro digito, a segunda faixa o segundo digito e a terceira faixa o multiplicador dos dois primeiros. A tabela abaixo relaciona as cores com os valores a serem associados.
| + | |
| − | | + | |
| − | [[Imagem:Resistores.png]]
| + | |
| − | | + | |
| − | Como exemplo, se um resistor tem as cores Amarelo-Violeta-Marrom-Dourado, então pode-se dizer que ele tem um erro de 5%, ou seja, varia para mais ou menos 5% do valor nominal e mais:
| + | |
| − | | + | |
| − | # Amarelo no primeiro anel representa 4
| + | |
| − | # Violeta no segundo anel representa 7
| + | |
| − | # Marrom no terceiro anel representa 10
| + | |
| − | | + | |
| − | Logo o resistor é determinado com a seguinte relação: ABxM em que A é o primeiro digito, B é o segundo digito e M é o multiplicador, do exemplo acima tem-se que A=4, B=7 e M=10 então a resistência desse resistor vale 47x10 = 470 Ohms
| + | |
| − | Essa tabela é importante para se ter as resistências, entretanto há outras melhores e mais didáticas para facilitar na leitura e obtenção do valor.
| + | |
| − | | + | |
| − | É recomendado que se compre a série de 10 a 10k Ohms.
| + | |
| − | | + | |
| − | === Protoboard ===
| + | |
| − | | + | |
| − | [[Imagem:Protoboard2.jpg]]
| + | |
| − | [[Imagem:Protoboard.jpg]]
| + | |
| − | | + | |
| − | De maneira simples o protoboard pode ser explicado como se segue:
| + | |
| − | | + | |
| − | Cada conjunto de 5 furos numa mesma vertical estão ligados eletricamente como um nó, como mostra a figura acima e toda a linha horizontal nos extremos são ligadas eletricamente.
| + | |
| − | Por exemplo, para se ligar uma bateria no protoboard, é necessário apenas plugar um terminal em um furo de qualquer das linhas nos extremos e o outro terminal na outra linha, então todos os furos da linha com o terminal positivo tera +V e toda a linha com o terra terá GND(Terra).
| + | |
| − | Um resistor por exemplo deve ter cada terminal em uma linha vertical (coluna) diferente. Caso seus terminais estejam na mesma coluna, não funcionará corretamente o circuito pois os dois terminais estarão num mesmo potencial e não fluirá corrente através do resistor.
| + | |
| − | | + | |
| − | == Software para criar o layout do projeto ==
| + | |
| − | | + | |
| − | Se o interesse for apenas em construir o layout do projeto, com os componentes, pode-se usar:
| + | |
| − | | + | |
| − | * gEDA - GPL’d suite of electronic design automation [6]
| + | |
| − | | + | |
| − | Uma vez montado o circuito no protoboard, todo o esquema então pode ser passado a um programa para que, caso haja interesse, o circuito possa ser construído para a versão definitiva, ou seja, impresso e construído em uma placa condutora. Um software para GNU/Linux encontrado que possibilita o desenho de circuitos para impressão no formato sem componentes:
| + | |
| − | | + | |
| − | * PCB - Printed Circuit Board Layout Tool [7]
| + | |
| − | | + | |
| − | == Componentes físicos do projeto ABaCo ==
| + | |
| − | | + | |
| − | [[Imagem:Abaco.jpg]]
| + | |
| − | | + | |
| − | A imagem acima ilustra a parte física necessária para o projeto ABaCo, a maioria dos itens já foram explicados anteriormente e os que ainda não foram, serão melhor explicados no manual junto aos exemplos.
| + | |
| − | | + | |
| − | # Arduino e cabo USB para conexão com computador
| + | |
| − | # Multimetro Digital para medir as grandezas associadas aos circuitos
| + | |
| − | # Protoboard para a montagem física do circuito sem a necessidade de uma placa impressa
| + | |
| − | # Ferramentas: Cabo de rede para construção de cabos para interligar os componentes no protoboard
| + | |
| − | # Ferramentas: Alicate para auxiliar na construção dos fios que interligarão o circuito
| + | |
| − | # Ferramentas: Pinça para retirar resistores do protoboard e/ou manipulação de pequenos componentes
| + | |
| − | # Componentes: Resistores
| + | |
| − | # Fonte de alimentação para alimentar o circuito
| + | |
| − | | + | |
| − | === Custo dos componentes ===
| + | |
| − | | + | |
| − | Abaixo segue a especificação dos componentes recomendados para o uso no projeto ABaCo junto ao preço aproximado de cada elemento:
| + | |
| − | Observação: A fonte de alimentação para o projeto deve ser construída por uma pessoa experiente.
| + | |
| − | | + | |
| − | * Arduino Duemilaenove R$ 150,00
| + | |
| − | * Freeduíno R$ 85,00
| + | |
| − | * Alicate de corte diagonal 4 1/2'' (4,5 polegadas) R$ 6,00
| + | |
| − | * Protoboard ICEL 840 furos com Bornes (terminais para fontes) R$ 31,00
| + | |
| − | * Mutimetro digital Minipa ET1002 R$ 24,00
| + | |
| − | * Pinça reta TS-14, ponta fina, anti-estática R$ 6,00
| + | |
| − | * Resistores(10 unidades) R$ 0,30
| + | |
| − | * Fonte de alimentação (Retificação-Transformador) R$ 25,00
| + | |
| − | | + | |
| − | Para o Arduino deve-se buscar online para comprá-lo, ou também adquirir um mais barato (Freeduino), que pode ser encontrado no Mercado Livre ou nos buscadores online.
| + | |
| − | | + | |
| − | = Fundamentos de Software Livre =
| + | |
| − | | + | |
| − | Como o projeto vai se manter sobre a filosofia de software livre, é de grande importância esclarecer alguns pontos que dizem respeito ao software livre. Segundo a cartilha de Software Livre do Projeto Software Livre Bahia [8], software livre não é uma questão de preço, mas sim de liberdade, que segue as seguintes liberdades definidas pela Free Software Fundation [9]:
| + | |
| − | | + | |
| − | # A liberdade de executar o programa, para qualquer propósito;
| + | |
| − | # A liberdade de estudar como o programa funciona, e adaptá-lo para as suas necessidades. Acesso ao código-fonte é um pré-requisito para esta liberdade;
| + | |
| − | # A liberdade de redistribuir cópias de modo que você possa beneficiar o próximo;
| + | |
| − | # A liberdade de aperfeiçoar o programa, e liberar os seus aperfeiçoamentos, de modo que toda a comunidade se beneficie. Acesso ao código-fonte é um pré-requisito para esta liberdade.
| + | |
| − | | + | |
| − | Um programa que segue essas quatro liberdades pode ser condiderado livre. Entretanto não impede que o programa custe um valor que muitos não possam pagar. No caso de um hardware em conjunto com o software, algumas mudanças baseadas nessas quatro liberdades são suficientes para que o hardware seja livre Hardware Aberto. Algo interessante que poucas vezes é citado quando explicado o porquê do software livre é o fato de que todo o conhecimento usado pelo programador para se contruir um software/hardware, pode ser obtido por ele sem custo algum. Desde as teorias matemáticas, físicas, químicas et cetera até a própria escrita que ele tem com as quatro liberdades acima citadas (com algumas adaptações). Entretanto o produto produzido pelo programador de software proprietário é fechado de modo que ninguém saiba como funciona? Mas e se tudo que ele usou como fundamento para seu projeto fosse também restrito? O que seria do projeto?
| + | |
| − | Um texto escrito por Pedro Antonio Dourado de Rezende explica melhor a linha de raciocínio:
| + | |
| − | | + | |
| − | "No software proprietário, o programador abdica da liberdade de controlar sua obra, em troca de salário e compromisso de sigilo. O distribuidor, fantasiado de 'fabricante', torna-se proprietário de tudo. Desde o código fonte, tido como segredo de negócio, até as cópias executáveis, licenciadas ao usuário sob custódia e regime draconiano. Enquanto no software livre o programador abdica de um dos canais de receita pelo seu trabalho, em troca da preservação do controle dos termos de uso da sua obra. Em contrapartida, se a obra tiver qualidades, agregará eficiência aos empreendimentos em torno dela. Seu valor semiológico, conversível em receita com serviços, será proporcional à magnitude do esforço colaborativo onde se insere. O código fonte é livre sob licença que preserva esta liberdade, enquanto a cópia executável é tida como propriedade do usuário. (...) Só tem a perder com ele (Software Livre) quem consegue galgar posições monopolistas no modelo proprietário. O problema é que a ganância faz muitos acreditarem que serão os eleitos pelo deus mercado, enquanto seguem correndo atrás da cenoura amarrada na ponta da vara que pende das suas carroças digitais, não se importando com os efeitos colaterais de se tratar conhecimento como bem escasso, ao considerarem software como mercadoria."
| + | |
| − | | + | |
| − | = Fundamentos em Mídias Tangíveis =
| + | |
| − | | + | |
| − | Segundo a definição de Ullmer e Ishi(2000) [10], interfaces tangíveis relacionam o uso de um sistema de artefatos físicos para o controle de informações digitais. Ou seja, a informação a ser manipulada não fica restrita apenas a comandos e ações realizadas por meio de dispositivos genéricos, mas sim por dispositivos específicos. Isso faz com que se torne mais fácil e eficiente a manipulação dessas informações. O projeto ABaCo tem por foco o apoio ao desenvolvimento de interfaces tangíveis. Com isso agregar melhor entendimento de circuitos eletro-eletrônicos bem como em design de interação, atingindo a meta do projeto que é fornecer uma base de circuitos elétricos em conjunto com programação embarcada para que haja o interesse do aprendiz no desenvolvimento de tecnologias pensando no usuário, aplicando os princípios de design de interação.
| + | |
| − | | + | |
| − | = Montagem e configuração do ABaCo =
| + | |
| − | | + | |
| − | Antes de se começar com os exemplos é de grande importância estar com todos os componentes do projeto ABaCo prontos. Todos os componentes já foram citados anteriormente, entretanto a parte teórica que não foi abordada anteriormente será explicada em cada exemplo.
| + | |
| − | | + | |
| − | # Arduino (Software) Uma vez com o sistema operacional GNU/Linux instalado, o software que manipulará o Arduino pode ser instalado. Baixe o software Arduino do site oficial http://www.arduino.cc na seção Download e escolha a arquitetura Linux(32bits) que é a usada nesse manual. Extraia o pacote e então abra a pasta que foi gerada através do terminal (Shell) e execute o executável arduino. Os detalhes são mostrados no apêndice A.
| + | |
| − | # É recomendável que a fonte de tensão, quando for usada, esteja ligada em um filtro de linha ou que a saida da fonte para o circuito sempre esteja acompanhada de um fusível de baixa corrente para que se tenha maior segurança na manipulação do circuito.
| + | |
| − | # QUCS A instalação do QUCS pode ser feita na maioria das vezes por gerenciadores de pacotes, consulte no gerenciador de pacotes da sua distribuição como o QUCS é referenciado e o instale. No apêndice A o QUCS é instalado em duas distrbuições diferentes. Para mudar a linguagem siga para File > Application Settings e escolha Portuguese, entretanto nem todo o programa ficará em português.
| + | |
| − | # gEDA A instalação do gEDA segue em algumas distribuições GNU/Linux o mesmo estilo de instalação do pacote QUCS, ou seja, por gerenciador de pacotes, entretanto em algumas distribuições esse pacote pode não existir nos espelhos de pacote e neste caso deve-se usar o método da compilação do pacote baixando os códigos fonte do site oficial do projeto em http://www.gpleda.org/. Na página de download do projeto gEDA tem quais distribuições já possuem nos espelhos o pacote. Para detalhes consulte o apêndice A.
| + | |
| − | | + | |
| − | Realizado esses passos a montagem e configuração do ABaCo está quase completa, ficando então para o restante os componentes eletrônicos e o protoboard que não precisam ser montados e nem configurados. A explicação destes últimos se dará com o desenvolver dos exemplos junto com a do funcionamento do Arduino.
| + | |
| − | | + | |
| − | = Exemplos =
| + | |
| − | | + | |
| − | == Lousa mágica ==
| + | |
| − | | + | |
| − | === O que é ===
| + | |
| − | | + | |
| − | Um exemplo básico de mídia tangível utilizando Arduino e Processing em que cinco botões irão representar esquerda, direita, cima, baixo e reset que de acordo com quais botões estiverem pressionados, uma linha seja desenhada na tela na direção respectiva ao botão e a tecla reset servirá para apagar a tela de modo que se possa fazer um desenho contínuo na tela.
| + | |
| − | A posição dos botões na montagem fica a critério de que montar, entretanto no código deve-se tomar o cuidado de que a sequência escrita pelo arduino na porta serial e lida pelo processing é a seguinte: EDCBR (Esquerda, Direita, Cima, Baixo, Reset).
| + | |
| − | | + | |
| − | === Problemas ===
| + | |
| − | | + | |
| − | Caso haja mal contato na montagem devido a fios soltos e contatos mal ligados, poderá haver mal funcionamento do programa fazendo com que o ponto ande sozinho ou que a tela apague sem a vontade do usuário.
| + | |
| − | Se estiver tudo montado e não houver resposta na tela ao pressionar os botões, é recomendado que se encerre a execução do programa e desligue da alimentação o arduino e verifique se não há curto-circuito ou algum problema associado ao circuito.
| + | |
| − | | + | |
| − | === Exercício de aprendizagem (Resolver após concluir esse exemplo) ===
| + | |
| − | | + | |
| − | Implemente um botão que ao ser pressionado faça com que a cor alterne entre Branco e Preto, ou seja, ora é branco ora é preto, sendo controlado por um toque, de modo que se possa locomover pela tela com os outros botões sem rabiscá-la. Desse modo é possível escrever letras separadas uma das outras na tela simulando um espaço.
| + | |
| − | | + | |
| − | === Requisitos ===
| + | |
| − | | + | |
| − | * 5 Resistores de 100 Ohms
| + | |
| − | * 5 Chaves tac (PushButton)
| + | |
| − | * Fios para se fazerem as ligações
| + | |
| − | | + | |
| − | === Cadeia de ferramentas utilizada ===
| + | |
| − | | + | |
| − | [[Imagem:LousaToolchain.png|700px]]
| + | |
| − | | + | |
| − | === Usando os componentes do ABaCo ===
| + | |
| − | | + | |
| − | Com base na cadeia de ferramentas mostrada no diagrama no item Introdução, o primeiro passo é construir o '''Projeto Teórico''' com a '''Montagem Virtual do Circuito''' e utilizando o QUCS.
| + | |
| − | Na aba Componentes no QUCS e Componentes Soltos os items utilizados para montagem são: Porta do subcircuito, Resistor e Switch. E em Fontes foi escolhido Fonte de Tensão CC. E foi usado o Ground(Terra) que está na barra superior do programa. Para mudar o desenho de um componente é necessário clicar com o botão direito sobre o componente e ir em Edit Properties (Editar Propriedades). Os switchs são as chaves tac (PushButton)
| + | |
| − | | + | |
| − | O circuito está mostrado abaixo:
| + | |
| − | | + | |
| − | [[Imagem:LousaCirc.png]]
| + | |
| − | | + | |
| − | O principio do circuito é : Caso a chave esteja ligada, a porta irá receber tensão, caso contrário não e os resistores de 1K servem para que o nível de tensão na entrada das portas de 8 a 12 seja o mais próximo possível de 0 volts, caso contrário quando não tiver tensão nas portas de 8 a 12, como não há terra conectado a ela dizendo que o nível é 0 volts, é muito provavel que ela responda de maneira errada. Desde que o princípio seja simples como explicado, não há necessidade de simulação, pois os erros que podem acontecer são devido a erro na montagem, entretanto é sempre bom ter o diagrama do circuito.
| + | |
| − | | + | |
| − | Agora que o diagrama está montado, pode-se então partir para a '''Montagem Real do Circuito''' no '''Protoboard''' tomando o devido cuidado para não haver curto-circuitos e eliminação de um componente por estar com seus terminais no mesmo potencial (mesma coluna).
| + | |
| − | será necessário apenas o Arduino e o Protoboard, a fonte de tensão não será necessária, pois o Arduino possui uma alimentação que supre a demanda do circuito.
| + | |
| − | | + | |
| − | A imagem abaixo ilustra o circuito montado no protoboard, o circuito não precisa estar montado exatamente da mesma forma, existem N formas de se montar.
| + | |
| − | | + | |
| − | [[Imagem:LousaReal.jpg]]
| + | |
| − | | + | |
| − | | + | |
| − | A '''Alimentação''' agora se torna necessária e será usada a alimentação do Arduino de 5 Volts e o programa será feito no '''Ambiente de Programação (IDE)''' '''Arduino Programming Language''' e '''Processing Interfaceamento'''.
| + | |
| − | | + | |
| − | O código do programa para ser embarcado no '''Arduino''' está separado em seções:
| + | |
| − | | + | |
| − | A seção abaixo declara variáveis que conterão inteiros representando as portas do Arduino as quais receberão as entradas das chaves liga-desliga.
| + | |
| − | | + | |
| − | int Esq=12;
| + | |
| − | int Dir=9;
| + | |
| − | int Cim=11;
| + | |
| − | int Bai=10;
| + | |
| − | int Res=8;
| + | |
| − | int var;
| + | |
| − | | + | |
| − | A seção abaixo diz que essas portas irão exercer a função de Entrada(INPUT), ou seja, as portas vão estar prontas pra dizer se há tensão nelas ou não. E a função Serial.begin(9600) abre uma comunicação serial, para que o processing possa ler depois, a uma velocidade de 9600 bits por segundo. Tudo que está dentro de void setup(){ } só será executado na primeira vez que o programa for iniciado, geralmente funções de configuração.
| + | |
| − | | + | |
| − | void setup(){
| + | |
| − | pinMode(Esq,INPUT);
| + | |
| − | pinMode(Dir,INPUT);
| + | |
| − | pinMode(Cim,INPUT);
| + | |
| − | pinMode(Bai,INPUT);
| + | |
| − | pinMode(Res,INPUT);
| + | |
| − | Serial.begin(9600);
| + | |
| − | }
| + | |
| − | | + | |
| − | A seção abaixo diz que a cada loop (iteração ou passagem) é para o programa aguardar 150 milisegundos antes de ler as portas verificando se há tensão ou não. A função Serial.print escreve na saída serial se a porta está com tensão (1) ou está sem tensão (0).
| + | |
| − | A função Serial.print não pula uma linha quando é executada, ao contrário da Serial.println, portanto as 5 leituras serão feitas e na saída serial o padrão será (NNNNN) em que N representa 0 ou 1. O ultimo Serial.print com um "\n" diz que assim que escrever os 5 digitos, pule uma linha, para que o processing possa ler de 5 em 5 digitos.
| + | |
| − | | + | |
| − | void loop(){
| + | |
| − | delay(150);
| + | |
| − | Serial.print(digitalRead(Esq));
| + | |
| − | Serial.print(digitalRead(Dir));
| + | |
| − | Serial.print(digitalRead(Cim));
| + | |
| − | Serial.print(digitalRead(Bai));
| + | |
| − | Serial.print(digitalRead(Res));
| + | |
| − | Serial.print("\n");
| + | |
| − | }
| + | |
| − | | + | |
| − | Agora basta compilar clicando no botão Play - Verify do Arduino e então File > Upload to I/O Board.
| + | |
| − | | + | |
| − | | + | |
| − | O código a ser usado no processing para que esse exemplo de mídia tangível seja finalizado é o que se segue dividido em seções explicadas:
| + | |
| − | | + | |
| − | Essa declaração importa as ferramentas necessárias para que se possa ler a porta serial na qual o Arduino está escrevendo.
| + | |
| − | | + | |
| − | import processing.serial.*;
| + | |
| − | | + | |
| − | Essas declarações criam uma variável porta para que se saiba em qual porta o arduino está escrevendo, uma variável dados que vai conter os 5 digitos que o Arduino enviou através da porta serial e por fim x,y,xant,yant que é a posição atual (x,y) do ponto a ser desenhado e a posição anterior (xant,yant) para que se possa desenhar uma reta entre esses dois pontos.
| + | |
| − | | + | |
| − | Serial porta;
| + | |
| − | String dados;
| + | |
| − | int x,y,xant,yant;
| + | |
| − | | + | |
| − | Novamente tudo que estiver dentro de void setup(){} será executado uma única vez, geralmente funções de configuração, e o que está sendo feito dentro de setup é mostrar com a função println todas as portas disponíveis para comunicação, assim é possível ver se a que você está usando no Arduino está listada pelo processing, feito isso e sabido a porta usada então é criada a comunicação dizendo que quem cria é o próprio programa (this, este mesmo), a porta é a segunda da lista, caso fosse a primeira então deveria ser Serial.list()[0] e com velocidade 9600 bits por segundo.
| + | |
| − | Size diz o tamanho da tela, stroke a cor da linha, strokeWeight a espessura da linha, strokeCap a forma com que a linha terá, background o fundo da tela e x,y,xant,yant as posições iniciais do ponto a ser movido pelas chaves liga-desliga.
| + | |
| − | Para mais detalhes das funções consulte a referência da linguagem processing http://processing.org/reference/.
| + | |
| − | | + | |
| − | void setup(){
| + | |
| − | println(Serial.list());
| + | |
| − | porta = new Serial(this, Serial.list()[1], 9600);
| + | |
| − | size(500,500);
| + | |
| − | stroke(255);
| + | |
| − | strokeWeight(1.5);
| + | |
| − | strokeCap(SQUARE);
| + | |
| − | background(0);
| + | |
| − | x= width/2;
| + | |
| − | xant = x;
| + | |
| − | y= height/2;
| + | |
| − | yant = y;
| + | |
| − | }
| + | |
| − | | + | |
| − | O método( onde funções são executadas ) draw serve para desenhar na tela, ou seja, se há um desenho a ser feito, ele deve ser declarado no método draw. Nele então lê-se serialmente o que o arduino está dizendo em forma de String(texto) e imprime na tela o que foi lido, verifica-se com if se o que foi lido existe (caso não exista é null) e caso exista verifica letra por letra se é 1 ou 0. Caso for 1 então o botão foi pressionado, caso contrário não. Por exemplo se o botão esquerdo for pressionado então dados.charAt(0) será 1 e a variável x será decrementada (subtraída) de 5 unidades fazendo o ponto se deslocar pra esquerda na tela.
| + | |
| − | A função stroke garante que a linha continue branca e então desenha a linha com coordenadas iniciais (xant,yant) e coordenadas finais (x,y). E então pega-se o ponto que foi modificado e diz que ele é anterior de modo que na próxima passagem ele seja usado como ponto inicial para se construir a linha. delay(180) diz para aguardar 180 milisegundos a cada desenho.
| + | |
| − | | + | |
| − | void draw(){
| + | |
| − | dados = porta.readString();
| + | |
| − | println(dados);
| + | |
| − | if( dados != null ){
| + | |
| − | if( dados.charAt(0) == '1' ) x-=5;
| + | |
| − | if( dados.charAt(1) == '1' ) x+=5;
| + | |
| − | if( dados.charAt(2) == '1' ) y-=5;
| + | |
| − | if( dados.charAt(3) == '1' ) y+=5;
| + | |
| − | if( dados.charAt(4) == '1' ) background(255,0,0);
| + | |
| − | stroke(255,255,255);
| + | |
| − | line(xant,yant,x,y);
| + | |
| − | xant = x;
| + | |
| − | yant = y;
| + | |
| − | }
| + | |
| − | delay(180);
| + | |
| − | }
| + | |
| − | | + | |
| − | Agora basta clicar em Play-Run no processing e pressionar os botões para ver o funcionamento na tela.
| + | |
| − | | + | |
| − | = Apêndice A =
| + | |
| − | | + | |
| − | == Instalação do arduino no GNU/Linux (Terminal) ==
| + | |
| − | | + | |
| − | Após baixar o pacote do ambiente Arduino descompacte-o em uma pasta dedicada a códigos-fontes para uma melhor organização. O pacote usado nesse manual é o arduino-0013-linux2.tgz. Para a instalação os seguintes passos foram seguidos:
| + | |
| − | | + | |
| − | # $ tar xvf arduino-0013-linux2.tgz
| + | |
| − | # $ cd arduino-0013
| + | |
| − | # # chmod 666 /dev/ttyUSB0
| + | |
| − | | + | |
| − | No passo 1 o pacote foi extraído e o no passo 2 foi acessado o diretório que contém o executável do arduino. O passo 3 é necessário para que seu usuário comum tenha acesso ao arduino através da porta USB, caso você não faça esse passo não será possível estabelecer no arduíno qual porta usar para se comunicar. O cifrão($) detona usuário comum e a cerquilha(#) usuário root.
| + | |
| − | Se o arduino estiver desconectado ou a porta não for a /dev/ttyUSB0 o seguinte erro será mostrado:
| + | |
| − | | + | |
| − | ''chmod: impossível acessar /dev/ttyUSB0: Arquivo ou diretório não encontrado''
| + | |
| − | | + | |
| − | Caso isso ocorra e o Arduino esteja plugado, abra o programa arduino como root:
| + | |
| − | | + | |
| − | # $ su
| + | |
| − | # # ./arduino
| + | |
| − | | + | |
| − | E busque pela porta adequada no menu como indica a imagem abaixo, após isso seu arduino deve estar configurado. Para maiores problemas consulte a busca na internet.
| + | |
| − | | + | |
| − | [[Imagem:apendice1.jpg]]
| + | |
| − | | + | |
| − | Observação: Não insira os caracteres $ ou # no terminal, eles apenas denotam o nível de usuário a ser utilizado para realizar o comando, no caso $ denota usuário comum e # usuário root.
| + | |
| − | | + | |
| − | == Instalação do software QUCS no ambiente GNU/Linux ==
| + | |
| − | | + | |
| − | A instalação se dará por meio de gerenciador de pacotes afim de resolver as dependências. No caso 1 a instalação é feita no debian com o gerenciador apt, no caso dois no ArchLinux com o gerenciador pacman e no caso 3 no fedora com o gerenciador yum.
| + | |
| − | \begin{enumerate}
| + | |
| − | # apt-get install qucs
| + | |
| − | # pacman -S qucs
| + | |
| − | # yum install qucs
| + | |
| − | | + | |
| − | == Instalação do gEDA no ambiente GNU/Linux ==
| + | |
| − | | + | |
| − | Para o ArchLinux o pacote deve ser obtido do AUR, entretanto fedora e debian possuem o pacote nos espelhos e a instalação é de acordo com a explicada no site do projeto gEDA na parte de downloads http://www.gpleda.org/download.html.
| + | |
| − | | + | |
| − | = Referências Bibliográficas =
| + | |
| − | | + | |
| − | # O Desafio do Ensino de Circuitos Elétricos na Formação Básica em Engenharia Elétrica na UERJ.http://www.del.ufms.br/desafio_CE.pdf. Acesso em 29 de agosto de 2008.
| + | |
| − | # Arduino. http://www.arduino.cc/. Acesso em 01 de setembro de 2008.
| + | |
| − | # Quite Universal Circuit Simulator - QUCS.http://qucs.sourceforge.net/. Acesso em 5 de setembro de 2008.
| + | |
| − | # KLogic. http://www.a-rostin.de/. Acesso em 15 de setembro de 2008.
| + | |
| − | # XCircuit. http://opencircuitdesign.com/xcircuit/. Acesso em 15 de setembro de 2008.
| + | |
| − | # gEDA. http://www.geda.seul.org/. Acesso em 26 de setembro de 2008.
| + | |
| − | # PCB. http://sourceforge.net/projects/pcb/. Acesso em 26 de setembro de 2008.
| + | |
| − | # Projeto Software Livre Bahia. http://twiki.dcc.ufba.br/bin/view/PSL. Acesso em 7 de novembro de 2008.
| + | |
| − | # Free Software Foundation. http://www.fsf.org/. Acesso em 7 de novembro de 2008.
| + | |
| − | # ULLMER, Brygg; ISHI, Hiroshi. Emerging frameworks for tangible user interfaces. http://www.research.ibm.com/journal/sj/393/part3/ullmer.html. Acesso em 5 de novembro de 2008.
| + | |
O projeto ABaCo tem como objetivo fornecer uma estrutura básica de eletrônica e softwares relacionados, de modo que qualquer pessoa interessada em aprender ou desenvolver projetos interativos, mídias tangíveis entre outros, seja capaz de executá-lo de um modo mais fácil. As ferramentas e softwares utilizados estão diretamente correlacionados com a filosofia de software livre e da liberdade de uso, execução, distribuição e modificação.
Esta wiki divide o projeto ABaCo em tópicos didáticos que buscam explicar de um modo simples cada parte que o compõe.
Para se trabalhar com circuitos elétricos e projetos interativos usando o ABaCo são necessários componentes eletrônicos como Resistores, chaves de contato entre outros, bem como de um Protoboard no qual o Protótipo será montado. Com o protótipo montado no protoboard, o controle do circuito será feito pelo Arduino que estará conectado a um Computador no qual roda o código de controle do protótipo na linguagem de programação do Arduino. Entretanto antes de se ligar o protótipo no arduino é importante simular se tudo está ocorrerá como esperado em um software de simulação e é também importante manter o diagrama do circuito para que possa ser explicado de forma simples o seu funcionamento e mostrar quais componentes foram usados usando um programa de diagramação(Layout do circuito).
