Registro cronológico de idéias e atividades

Mensagem inauguradora dos trabalhos, contendo o embrião inicial da proposta. Primeiro contato com o orientador, através do professor Artur Rozestraten e do professor Norberto Moura:

Partindo do tema inicial (prototipagem rápida), explorei desdobramentos possíveis com leituras de alguns materiais na rede. Me parece que para o arquiteto um dos potenciais importantes dessa técnica é poder usá-la como ferramenta para auxiliar na modelagem (pensar/fazer) o projeto. As perguntas que surgiram: Que situações justificam o emprego da impressão 3D, já que é complexa e demorada, se comparada com o fazer manual direto? Objetos impressos precisam ser antes criados virtualmente. Quais softwares/interfaces disponíveis atualmente (se houver algum) são: a. intuitivos o suficiente a ponto de permitir que se crie mais livremente (se aproximando do fazer manual) ou b. completamente legítimos, de forma a fazer uso próprio da linguagem da máquina para criar um método alternativo, ao invés de simular o original precária e incompletamente?

Esboços de respostas:
1. Os geradores de formas complexas justificam a necessidade de prototipagem rápida em alguns casos, desde que estejam inseridos como ferramenta para conceber o projeto (do contrário seria só imprimir um projeto concebido no computador).

Ramificações:
A. Integração híbrida. Combinando impressão e métodos tradicionais, como uma cobertura complexa gerada por dados e impressa, onde haja a necessidade de mudar a relação dos espaços que serão abrigados manualmente.

B. Elementos permutáveis. Em alguns casos em que o foco do estudo está em analisar a relação entre elementos modulares complexos, se forem difíceis de se construir manualmente, a impressora também pode ter um papel positivo. Por exemplo: superfícies com curvatura sutil, como os triângulos isósceles de uma cúpula geodésica ou experimentos abstratos com módulos complexos.

C. Peças fragilizadas por escala/emendas. É o caso de elementos estruturais que, mesmo no processo de criação, precisam sustentar cargas com alguma eficiência mas que acabam fragilizados pela necessidade de emendas em ângulos desfavoráveis e/ou pelo tamanho reduzido das peças. Essas peças – mesmo sem ser tão complexas – podem ser impressas, dependendo do grau de necessidade. Um exemplo que encontrei na rede é um espaço batizado de “tote” – um salão de festas projetado como extensão de um conjunto de prédios coloniais em Mumbai.

Esses geradores de formas complexas são softwares de design paramétrico – como o CATIA, o Rhino + o plug-in Grasshopper, o Revit Architecture e o Digital Project de Frank Ghery e, me parece, têm o potencial de criação autêntico a que me referi no primeiro parágrafo. Por ser uma linguagem criativa autêntica, o arquiteto passa a ter que orquestrar seus resultados usando uma linguagem bastante diferente do fazer arquitetônico tradicional, moldando espaços e relações através de parâmetros (dimensões, áreas, volumes, numero de pavimentos, dados do terreno, curvas complexas, etc.) Se por um lado esta nova linguagem é mais abstrata e numérica, por outro produz soluções que extrapolam o que é possível fazer diretamente com nossos cérebros. Infelizmente ainda não compreendo o processo plenamente, porque até o momento não achei nenhum software paramétrico que pudesse testar gratuitamente.

Exemplos de software e abordagens do design paramétrico:

• http://www.youtube.com/watch?v=EhjUli4cYEg
• http://www.dysturb.net/2007/associative-design-berlage/

2. Interfaces digitais intuitivas, que podem se equiparar (ao menos parcialmente) ao fazer manual. No campo da arquitetura os melhores exemplos que pude encontrar foram softwares como o Google Sketchup e similares, que de fato são intuitivos mas também extremamente limitados, incapazes de produzir formas que justificassem serem impressas. Ou seja: até agora não consegui encontrar exemplos suficientemente bons no campo da arquitetura. Fora do meio arquitetônico, temos softwares intuitivos mas menos limitados como o MudBox ou o Zbrush. São capazes de aproximar o fazer/pensar digital do esculpir manual com materiais deformáveis. Mas não são muito úteis para este caso.

Exemplo (Z-brush):

• http://www.youtube.com/watch?v=3tz7na7Y75o

Em preparação para a feira USPiTec, para explorar a tecnologia de fresagem, hoje visitamos a empresa/residência do Sr. Antônio, dono da Easy Drill. Foi meu primeiro contato com uma fresadora, motores, perfis metálicos, placas controladoras, composites e uma porção de outras coisas.

Atualmente o Sr. Antônio é a empresa, ou seja, além de ser o proprietário, é também o responsável por criar e aperfeiçoar o design das máquinas que, segundo ele, são ideais para trabalhos de alta precisão, como por exemplo a criação de circuitos em chapas de fenolite cobreadas.

As máquinas trabalham com um formato de dados proprietário e quem compra uma máquina da EasyDrill recebe um aplicativo CAM próprio, desenvolvido pelo Sr. Antônio.

Panfletos: EasyDrill e CadTec (empresa que faz os circuitos para a EasyDrill)

Hardware

Aplicativo

Fotos do hardware e do aplicativo retiradas da página da empresa (atualmente fora do ar)

Conversando com ele sobre o nosso projeto de robô, descobrimos algumas peças que podem ser potencialmente usadas no desenvolvimento da pesquisa:

• Placa controladora de motores, vendida pelo Sr, Antônio; e nesse caso usaríamos também o software que ele provê para suas fresadoras, que é gratuito.
• Motores de passo talvez sejam mais indicados que os servos (usados braço desenvolvido para o doutorado), já que têm maior torque. Por outro lado são muito lentos e não são capazes de informar em que ponto do giro se encontram. Teremos que testá-los no futuro, quando já tivermos algo mais sólido.
• Pinças da marca Dremel para pequenas ferramentas de fresagem, como escovas ou mesmo fresas.
• Uma peça chamada acoplamento flexível, que faz a ponte entre o motor que já temos e a pinça.

Pela primeira vez conversei presencialmente com o orientador sobre o tema escolhido no caminho para a reunião com o proprietário da empresa EasyDrill. Foi uma discussão mais séria e o orientador me explicou que a técnica de impressão 3D aditiva é um assunto já bastante explorado (para a minha surpresa, já que é um assunto que eu decidi explorar por desconhecê-lo quase que completamente). Fui introduzido à um possível novo tema: o uso de braços robóticos na arquitetura e no design.

O tema era derivado de um ramo da tese de doutorado em andamento de Leandro Yanaze (Poli USP), desenvolvido com a participação do orientador. Apesar de imediatamente ter achado interessantíssimo, salientei novamente que meu conhecimento em eletrônica era limitado e que eu tinha receio de comprometer com um projeto de pesquisa que exigiria aquisição de conhecimentos completamente inusitados.

O orientador garantiu que eu não estaria desamparado e listou recursos já existentes, sua experiência prévia com o doutorado de Yanaze e pessoas que poderiam contribuir com informações faltantes.
Aceitei o desafio.

As primeiras perguntas que surgiram:

• Em que contexto braços robóticos – que associei imediatamente às linhas de montagem industriais – podem ser usados por arquitetos?
• Será que eu seria capaz de lidar com um tema tão novo, que saia tanto do meu universo de conhecimentos existentes? O tema original seria uma exploração de impressão 3D como ferramenta criativa, mas usando um equipamento existente.

+23/08/2012

Minha busca inicial revelou algumas informações interessantes:

1. A Robots in architecture association (da universidade de tecnologia de Viena). Uma entidade que “está engajada em pesquisa aplicada, desenvolvimento de soft/hardware, “pedagogia robótica” – e na questão: em quanto tempo robôs revolucionarão a arquitetura?” (traduzido da página em 23/08/12).
• Usam um braço robótico Kuka nas demonstrações disponíveis da página eletrônica.
• Desenvolveram o que parece ser um plugin para Rhinoceros/Grasshopper que controla o braço.
2. Um braço robótico de design aberto que usa sete servomotores. Talvez sirva como referência para a pesquisa.
3. Uma esfera a vácuo, desenvolvida pela universidade de Cornell, que instalada num robô permite uma manipulação precisa de objetos.

Estou longe de compreender o que se pode fazer com este tipo de máquina na arquitetura, mas, pelo pouco que li até agora, percebo que existe uma relevância na técnica que atualmente está sendo investigada por grupos de vanguarda e minha pesquisa irá ao encontro de ajudar nesse processo exploratório, de descoberta.

Avante!

Fui convidado pelo orientador a participar da disciplina de mestrado ministrada por ele, neste semestre:

Disciplina AUT5834
Novas Tecnologias de Simulação e Modelagem da Arquitetura

Docente Responsável:
Arthur Hunold Lara

Objetivos:
Apresentar e discutir as novas metodologias de simulações, modelagem digitais relacionadas ao processo projetual de concepção espacial arquitetônico. Entender e compreender os novos métodos de ensaios e simulações virtuais utilizando máquinas máquinas PR (prototipagem rápida). Dar ao aluno embasamento téorico e crítico para aplicação destes métodos na área dos trabalhos programados ou na dissertação de mestrado.

Justificativa:
Desde a década de 70, o desenho auxíliado pelo computador vem desenvolvendo tecnologias que estão revolucionando a forma de conceber e construir a arquitetura. O curso -com aulas expositivas, seminários e estudos programados- dará um panorama histórico de seus principais autores e seus métodos de projetar com o auxílio da automação e fabricação digital. A disciplina apresenta a evolução da modelagem explicitando suas lógicas e métodos de concepção espaciais. Os alunos poderão ter acesso às possibilidades dessa tecnologia e como elas podem ser inseridas nas pesquisas, com simulações e modelagens concebidas em ambientes virtuais mas executadas em impressoras 3D ou fresas CNC (controle por comando numérico).

(retirado da página do sistema Janus)

O conteúdo parece extremamente relevante e pode me ajudar muito com a pesquisa, porque vai inseri-la num contexto mais amplo da fabricação digital: histórico e prático. Outro ponto interessante é que fui informado de que haverá uma introdução ao aplicativo Grasshopper, que eu desconheço quase que por completo, apesar de modelagem paramétrica ser um dos temas que justificam a existência do meu trabalho.

Fui convidado a participar do estande da FAU na USPiTec 2012. No site do evento, uma breve descrição:

(…) tem por objetivo apresentar aos estudantes, empresários e autoridades o grande potencial tecnológico existente no meio acadêmico. Criar um ambiente para a troca de experiências, motivar novas parcerias com empresas e divulgar de forma ampla as inovações tecnológicas desenvolvidas pela USP.

O evento acontecerá na Escola de Artes e Ciências Humanas – EACH (USP Leste), à Av. Arlindo Bettio, 1000 – Ermelino Matarazzo – São Paulo, nos dias 23, 24 e 25 de agosto

Comparecemos apenas no primeiro dia e não ficamos até o fim, mas foi uma experiência – junto com a reunião do dia 18 – inauguradora do meu contato com a fabricação digital.

No estande da FAU, o Prof. Arthur inicialmente propôs um experimento envolvendo digitalização 3D e fabricação do objeto capturado e se inspirou na intervenção urbana Be Your Own Souvenir!, desenvolvida nas ruas de Barcelona em 2011 pelo grupo de artistas do blablabLAB (vídeo ao lado).

Assim como no vídeo o digitalizador usado no experimento do Prof. Arthur foi o Kinect, que vem equipado com um sensor de profundidade e é capaz de determinar a distância de objetos e construir imagens 3D a partir desse dado; aliado ao aplicativo ReconstructMe – que inclui em um só pacote os drivers e funcionalidades necessários para a captura. Ao mesmo tempo que é um equipamento revolucionário, o Kinect é também acessível – amplamente disponível no mercado por um custo reduzido -, graças à parceria da empresa desenvolvedora Prime Sense com a Microsoft, que passou a fabricá-lo em massa como periférico para o seu próprio console, o XBox.

O equipamento para a fabricação foi a fresadora da EasyDrill, que me pareceu ser voltada para uso de entusiastas, estudantes e pequenos comércios. É possível ler mais sobre esse equipamento em outro post.

Além de esse ter sido meu primeiro contato com a fabricação digital, também adquiri noções iniciais sobre os problemas de compatibilidade do fluxo de informações entre diversos padrões de arquivos necessários nas diferentes etapas do processo. Abaixo descrevo as etapas resumidamente:

etapaentradasaída

¹inspeção e limpeza manual da malha necessárias!

Infelizmente os problemas aos quais me referi no parágrafo anterior, prejudicaram a execução completa do experimento.
Um mês antes da feira, o Prof. Arthur já havia dominado o processo de captura do modelo 3D eletrônicos com o Kinect.  O conhecimento necessário para o tratamento da malha poligonal no aplicativo Rhinoceros – para eliminar imperfeições nas bordas eliminar polígonos sobrepostos, que o Kinect tem dificuldades de definir com exatidão – também já existia no dia da feira.
Abaixo, vemos o primeiro objeto-teste – o rosto do Prof. Arthur em *.3ds – que teria as coordenadas Z de seus pontos comprimidas, pronto para ser fresado em baixo relevo em um pequeno bloco de celeron ou fenolite (não lembro bem!) de um ou dois centímetros de altura.

Só faltava conhecer o restante do processo e nos reunimos na sede da empresa EasyDrill com uma semana de antecedência para fazê-lo. Como descrito na tabela acima, compreendemos na teoria o funcionamento do equipamento, segundo o fluxo de trabalho preestabelecido pelo Sr. Antônio: usar uma versão antiga e gratuita do aplicativo KCam para transformar o sólido 3D em uma série de instruções CNC que, traduzidas para o formato nativo pelo software autoral da EasyDrill, pudessem ser finalmente transformados na peça.
O Sr. Antônio nos advertiu que as peças que ele havia produzido até então eram sempre planas e altamente precisas: fotos gravadas em peças finas de fenolite, circuitos impressos, recortes em placas de compensado e polímeros. Ele nunca havia tentado criar nada que envolvesse tantas variações no eixo Z. Mas nada disso nos pareceu um empecilho à execução do experimento. Aproveitamos também para esclarecer dúvidas sobre outros aspectos da minha pesquisa, mas infelizmente o tempo acabou e precisamos ir embora.

No dia da feira, quando tentamos executar o teste, alguns problemas ocorreram:

1. O aplicativo KCam, estava com dificuldades de lidar com a complexidade do arquivo com muitas coordenadas e produzir a visualização correta do objeto convertido em sua interface visual. Talvez por ser uma versão muito antiga?
2. O arquivo em G-code gerado, aparentava estar estar corrompido, com alguns valores de coordenadas extremamente grandes, incompatíveis com a escala de outros valores-padrão;
3. Quando tentamos abrir o arquivo no programa da fresadora, o easyDrill, fomos barrados por um erro.
4. Abrindo o arquivo no Rhinoceros, percebemos que o objeto estava planificado, com linhas que cruzavam o objeto de uma borda a outra. Já vi problemas parecidos, que ocorreram quando a sequência dos pontos

Do meu ponto de vista, foi uma experiência extremamente enriquecedora – incluindo as dificuldades, que permitiram que eu conhecesse o problema da falta de padronização de formatos de dados -, porque me pôs em contato com o que seria o novo tema central da minha pesquisa: fabricação digital e que até então eu desconhecia quase completamente.

Fotos e vídeos do evento de autoria do Prof. Arthur Lara:

Outros contatos interessantes:

• Primeiro contato presencial com impressão 3D, através do estande vizinho da metamáquina.
• Conheci o Warthog Robotics, um grupo interdisciplinar de robótica da USP São Carlos, que desenvolvem robôs para competições pacíficas e destrutivas.

Não pude parar de pensar em como ficamos próximos de executar o rosto em 3D na fresa. Me pareceu que o problema talvez estivesse na conversão de dxf para g-code porque:

1. O programa usado pelo Sr. Antônio – dono da EasyDrill -, o KCam, estava com dificuldades de lidar com a complexidade do arquivo com muitas coordenadas e produzir a visualização correta do objeto convertido em sua interface visual;
2. O arquivo em g-code parecia estar corrompido, com alguns valores de coordenadas extremamente grandes, incompatíveis com a escala de outros valores;
3. Quando tentamos abrir o arquivo no programa da fresadora, o easyDrill, fomos barrados por um erro.
4. Abrindo o arquivo no Rhinoceros (não lembro como fizemos!), percebemos que o objeto estava planificado, com linhas que cruzavam o objeto de uma borda a outra. Já vi problemas parecidos, que ocorreram quando

Ao chegar em casa, intrigado pelo problema, tentei baixar o programa EasyDrill – que, segundo o Sr. Antônio, está livremente disponível na página da empresa, porque como output usa um formato de dados proprietário que só é compreendido pelas máquinas EasyDrill – mas o arquivo não estava disponível, por alguma razão.

Decidi investigar outros softwares.

Encontrei um programa gratuito da empresa MecSoft, que gera o g-code a partir de um arquivo DXF: o FreeMILL. O interessante é que ele tem a capacidade de gerar uma simulação 3D do processo de desbaste no bloco de material, mostrando inclusive o percurso da ferramenta (imagem à esquerda).

A imagem à direita mostra a interface para a determinação de dados da máquina e da ferramenta – que afinal precisam ser contabilizados para que a estratégia de corte possa ser traçada -, mas eu não soube preenchê-los por não ter pensado em anotar nenhum dado tão específico durante a feira.

O código gerado pareceu livre dos problemas mencionados a cima. Só falta testar!

Por recomendação do orientador, visitei duas mostras relevantes à minha pesquisa, que acontecem no instituto Tomie Ohtake.

A primeira foi a 3ª mostra 3M de arte digital: Tecnofagias.

A curadora Giselle Beiguelman, escreve:

A exposição reúne artistas que se destacam pelo uso crítico e criativo das tecnologias e mídias. Em suas abordagens, evidenciam a combinação entre o high e low tech e as novas acomodações entre saberes imemoriais e de última geração. Em uma frase, as relações entre a ciência de ponta e a ciência de garagem.

Confesso que há algum tempo eu não visitava nenhuma exposição não-virtual, apesar de me a experiência ter me agradado muito. Minha intenção durante a visita foi tentar desvendar aspectos das obras que dialogassem diretamente com a pesquisa e assim, analisando a exposição segundo os meus filtros – que infelizmente se tornaram demasiadamente técnicos de uns dois ou três anos pra cá em resposta à constatação involuntária de que pouco compreendo a arte e que portanto não devo emitir opiniões sobre o assunto -, foquei me no fato de que muitas das obras, equipadas com placas controladoras e sensores, enfatizam a interação com o visitante e reagem à sua presença: ao peso, ao toque, ao movimento, a presença de seus celulares.

Segundo esse critério, entre as instalações e peças mais marcantes, ficaram destacadas na minha memória:

• A obra XYZ, de Raquel Kogan. O visitante está num ambiente escuro, enquanto caixas de som são destacadas com uma iluminação dramática, descendente. O visitante é convidado a ficar em pé em uma área do pisto, com um dos dedos sobre um sensor. A obra então reage: usando o peso, a altura e o ritmo dos batimentos cardíacos, uma placa controladora sintetiza uma harmonia sonora que de alguma forma reflete esses dados. Não sei se são sons pré-gravados ou se os dados passam por algum tipo de modelagem paramétrica e participam de fato da construção do som.
• Usando um Arduino UNO, Lucas Bambozzi montou a instalação das coisas quebradas que, ao detectar um certo número de campos eletromagnéticos emitidos pelos celulares dos frequentadores que se aproximam, responde ao estímulo acionando (o que parece ser) um mecanismo de correias de bicicleta, engrenagens e um prensa elétrica que destrói um celular antigo. Me pareceu uma crítica ao ritmo forçado de consumo, descrito pelo ciclo de aquisição por impulso e obsolescência prematura. O discurso do artista elabora questões mais abstratas e complexas, como o elo entre as redes (o fluxo de informação) que nos circundam e controlam. A obra em si é a “simulação física de um mecanismo contínuo, que opera entre as redes e o mundo real, onde a autonomia eventualmente caduca, os princípios se mostram obsoletos e percebemos que estamos na era da Internet das coisas quebradas.” (citação retirada da página do artista)
• A escultura in_existences-out do argentino Rafael Marchetti, apresenta-se como um conjunto de seis estruturas com um cabo central, ligados a motores; e duas hastes flexíveis laterais. Não pude vê-la em movimento porque provavelmente as adaptações ocorrem lentamente, ao longo do dia, mas lendo sobre a obra descobri que reage a variações no ambiente: circulação do público, do ar e mudanças na temperatura, portanto deve coletar dados com sensores de movimento ou câmeras e um sensor de temperatura. Os seis elementos têm movimentos independentes e imprevisíveis: tensionam e relaxam-se usando os estímulos coletados do entorno mas a transcrição do estímulo ao estado formal é regida por caminhos imprevisíveis, algo que o artista chama de “indeterminismo de estados”.
• Mirror é a obra da dupla Rejane Cantoni e Leonardo Crescenti. Trate-se de uma superfície espelhada flexível que reage à distância do observador, tornando-se côncavo com a aproximação e convexo com o distanciamento.

A segunda foi a exposição dos projetos do arquiteto americano Thom Mayne – Morphosis, formas combinatórias:

Pra mim um dos aspectos mais impressionantes da obra de Mayne – um arquiteto que até então eu desconhecia – é a aparente fragmentação heterogênea com que os elementos parecem se articular nas diversas dimensões das construções documentadas sob diversas óticas na exposição em fotos, desenhos, maquetes e modelos virtuais.

É natural que eu não tenha conseguido absorver questões muito profundas do seu discurso num contato tão casual, então ao chegar em casa procurei fontes de informação que pudessem dar sentido ao que eu tinha visto, que recheassem o primeiro impacto formal com percepções mais completas. Encontrei um vídeo de uma palestra que o arquiteto deu para a organização sem fins lucrativos TED: Ideas worth spreading (ao lado) e percebi que minha impressão sobre a obra de Mayne, que descrevi no paragrafo anterior como visualmente fragmentada, não estava completamente equivocada, mas incompletas: determinadas camadas do discurso não podem ser deduzidas através de mera observação desinformada.

São conceitos chave, repetidos ao longo da palestra, a arquitetura como processo, concebida durante o processo de detecção e organização de variáveis, cujo fim não pode ser antecipado; e a arquitetura como uma negociação entre o plano do imaginário – das ideias, das intenções – e do real – do ‘mineral’, como chama o arquiteto; do espaço disponível e suas idiossincrasias, da relação entre construção e solo, dos materiais e das possibilidades de respostas espaciais trazidas pelas ferramentas eletrônicas criativas.

Para Mayne lidar com a confluência de forças, discutir suas sobreposições e definir soluções que acomodem-nas, são passos generativos da forma. Os sistemas distintos que compõe a construção são citados com frequência, acompanhados de exemplos como a eliminação do ar condicionado, as necessidades de iluminação, a transparência reveladora da estrutura (e portanto do processo construtivo do edifício), a pele que se destaca da estrutura como elemento independente, a comunicação com tipologias significativas do entorno e a preocupação com as complexidades do tecido urbano e da cultura local – o arquiteto julga ser importante que a obra possa inserir-se num local específico ao mesmo tempo refletindo esse contexto e costurando-o, tornando-o mais significativo.

No vídeo ele aponta os recursos de prototipagem rápida e modelagem paramétrica como ferramentas cruciais para que uma resposta a altura possa ser dada aos seus anseios teóricos. Foram justamente as maquetes que revelaram aspectos de maior interesse para esta pesquisa. Prototipadas com impressão 3D aditiva – mais especificamente uma técnica precisa, que envolve a deposição simultânea de pó e resina, que juntos formam um material resistente e de aparência superficial homogênea -, as maquetes de Mayne não são apenas objetos de apresentação de uma forma final, mas objetos de estudo, representação dos estágios de uma ideia, feitas para serem rabiscadas, modificados, debatidas e assim serem parte do processo criativo.

Nos reunimos hoje no QG do Lab de garagem, que é um espaço voltado para atender demandas de desenvolvedores independentes. Comercializam peças e kits de eletrônica e robótica e oferecem infraestrutura de apoio para projetos.

Na página da empresa, descrevem-se:

O Laboratório de Garagem é uma iniciativa voltada para a integração, colaboração e apoio aos desenvolvedores independentes de ciência e tecnologia, ou como gostamos de ser chamados: garagistas.

Somos uma rede social, um laboratório comunitário localizado em São Paulo, uma incubadora, uma loja virtual e um grupo de pessoas que acreditam que a próxima revolução pode (e vai) sair de uma garagem, ainda mais se ela estiver conectada a muitas outras garagens.

Há algum tempo atrás o orientador havia me dito que a empresa oferecia um curso de Arduino, mas foi só há alguns dias atrás que eu lembrei de entrar na página da empresa. Não vi nenhum curso, mas descobri que eles disponibilizam uma série de videoaulas excelentes e abrangentes, que cobrem desde os aspectos físicos mais básicos – lei de Ohm, instruções sobre como usar um multímetro – até tópicos mais avançados, como por exemplo fazer funcionar um motor de passo usando uma ponte H.

Estou pensando pensando em comprar – apesar de o orientador já ter me dito que me emprestará o dele – o starter kit do Lab de garagem, porque:

• estou angustiado para começar a lidar com a parte eletrônica, afinal vai ser meu maior desafio!.
• eu gostaria de ter material próprio pra poder continuar desenvolvendo projetos mesmo depois de terminado o TFG.
• para o caso de, durante minha curva de aprendizado inicial eu “precisar” queimar um Arduino.

Veremos! Preciso pensar melhor sobre o assunto.

Para a reunião de hoje, o orientador disse que talvez trouxesse o material que foi usado no desenvolvimento do robô original – e que me explicaria mais detalhadamente o projeto para que eu já possa começar a estudá-lo e pensar no problema -, mas ele acabou não conseguindo vir de carro e só pode trazer um motor: o que será usado como parte da ferramenta de fresagem. Esse motor tem 12V, alcança 20.000rpm e foi retirado de uma motocicleta infantil(?) onde funcionava com um sistema de engrenagens de redução para transformação de velocidade de giro em torque.
Foi comprado com uso e veio com um adesivo identificador do modelo:

Alguns caracteres estão ilegíveis, mas achei importante identificar o motor por modelo, porque dessa forma poderíamos obter outras especificações diretamente do fabricante. Pude deduzir: RS ***50SH, T0022621 ou TD022521, CHINA.

Isso foi suficiente para começar a busca. Como eu sei que foi fabricado na China, entrei no portal de compras Alibaba e encontrei um fabricante chinês que faz motores cujas nomenclaturas identificadoras e a aparência externa se assemelham às do nosso.
Encontrei também um fabricante japonês – que pode ter fábricas na China -, com modelos ainda mais parecidos. Na página desse fabricante, encontrei duas informações importantes: um aplicativo que explica o que representam as diferentes partes da nomenclatura de identificação; alguns compradores encomendam motores customizados, cujas nomenclaturas não estão no catálogo padrão do fabricante – como no caso do nosso motor.
A busca não foi bem sucedida e por enquanto vou deixá-la de lado, já que o orientador disse que existem equipamentos especializados capazes de fazer medições e deduzir outros dados sobre o motor.

O orientador me mostrou um dos motores à venda (um mini servomotor) e disse motores idênticos tinham sido usados no projeto do robô que deu origem à pesquisa. Disse também que esses motores não sustentavam a posição depois de movidos (torque estático?) e esse foi o motivo de o robô original não ter dado certo.

Preciso voltar a estudar as propriedades dos motores de passo e dos servomotores para tentar dar uma resposta melhor à essa questão. Por um lado os motores de passo tem mais torque e os servos mais velocidade de giro, mas todos os projetos de braços robóticos que encontrei usam servos. Preciso compreender o porquê!

Retomamos também a conversa sobre como acoplar a pinça que segura as ferramentas de fresagem ao motor. Segundo o Sr. Antônio da empresa EasyDrill suas fresadoras usavam uma peça comum, fácil de encontrar em lojas especializadas, que dava uma solução simples para o problema da fixação.

Infelizmente não lembramos de anotar o nome, mesmo procurando na internet e precisaremos contactar o Sr. Antônio mais uma vez para recuperar essa informação.

Uma alternativa que pode ser usada como material para fresagem no projeto: a espuma fenólica de células abertas, que também conhecida como espuma para ikebana ou espuma para hidroponia. É um material

Trata-se de um material bastante mole (O vídeo ao lado mostra um artesão esculpindo um bloco da espuma sem o auxílio de nenhuma ferramenta.), usada por mim como material para confecção de maquetes no início do curso. Um artigo científico encontrado na rede ajuda a compreender melhor o material:

Espumas Fenólicas

A partir de resinas fenólicas obtidas por policondensação sob catálise alcalina (resol, o pré-polímero), se produz a espuma, fazendo-se a reticulação na presença de um ácido. A evaporação do agente de expansão, normalmente um hidrocarboneto halogenado, adicionado ao pré-polímero, ocorre em função do calor liberado pela reação de reticulação. A presença de um surfactante na formulação é necessária a fim de promover a emulsificação do agente de expansão e estabilização da espuma formada. A cura da espuma é feita na presença de um ácido, sendo que a reação se completa e a espuma endurece totalmente com o tratamento térmico à temperatura em torno de 70 ^oC, ou superior em alguns casos.

A espuma fenólica tem a mesma característica da resina: dura e frágil, propriedades essas que são acentuadas em espumas com reduzido tamanho de células (< 80 mm) ou com elevado número de células abertas.

A pedido do orientador, fui à FAU registrar a nova fresadora do LAME, além das fresas e dos materiais usados nos testes iniciais. Na mensagem de e-mail, o Prof. Arthur passou informações interessantes, que registro aqui para poder compreendê-las mais a fundo no futuro:

• Para fresar de peças dos dois lados constroem-se galhos que estruturam a peça para que ela possa ser girada em 180 sem sair do esquadro. Ao fim da fresagem, um drill remove essas peças de apoio e dá o acabamento final com fresas.
• Para fresar materiais mais rígidos (como o MDF) é necessário ter uma compreensão profunda sobre as propriedades de cada tipo de fresa, sobre as velocidades de giro adequadas e sobre o acabamento que proporcionam.
• Fresas são ferramentas caras que quebram, queimam e se desgastam, principalmente se mal utilizadas.
• O método de usinagem rápida HSC (ou high speed cuting) transfere a energia da fresagem para o cavaco do material, possibilitando um bom acabamento.
• As fresas para HSC têm forma e o ângulo de corte específicos, adaptados para as demandas das altas velocidades de trabalho.
• A nova fresadora da DS4 não trabalha com HSC, logo peças fabricadas por ela precisarão de  um processamento extra para dar acabamento.

Além disso sugeriu abordagens paralelas para a minha pesquisa:

• Uma pesquisa sobre técnicas de fresagem e sobre acabamentos em materiais baratos e moles.
• Com as novas máquinas chegando na FAU, criar um tipo de site explicativo e direto, com informações práticas sobre como escolher dentre os diversos tipos de máquina e ferramentas disponíveis.

Trata-se de uma máquina da empresa DS4:

Já que a segunda parte prática da pesquisa incluirá a construção de um dispositivo com capacidades de fresadora, poder ter contato com um equipamento profissional pode ser de grande valia. Com a permissão do responsável pelo LAME, o Sr. Emílio, peguei duas amostras de da espuma de poliuretano de 60 e 100Kg/cm³, para testar se é possível desbastá-los com escovas de polimento da minha mini-retífica, já que pensamos em uma solução similar para o robô que será construido na pesquisa.

É uma pena que a máquina ainda está em fase de testes e, pelo que eu entendi, continuará assim por um bom tempo.

Neste fim de semana fiz o curso de Arduino oferecido pelo SESC Vila Mariana. Eu já tinha algum conhecimento básico sobre o assunto por ter lido a HQ introdutória da Jodie Culkin, mas mesmo assim achei prudente adquirir conhecimento prático pra me livrar de medos adubados pela minha falta de conhecimento de eletrônica.

Foi a primeira turma e o curso ainda não está muito bem lapidado e isso gerou algumas inconsistências na escolha do conteúdo. Por exemplo, achei que foram extremamente moderados e cuidadosos nos exercícios práticos, mas por outro lado os conceitos e siglas necessários para a compreensão da arquitetura da placa; e a introdução à linguagem de programação e à IDE foram passados com extrema rapidez, como se alguma experiência preexistente fosse exigida.

Paguei a entrada inteira (R$20,00), porque estou sem a carteirinha da USP e esqueci de levar um comprovante de matrícula, mas mesmo assim foi muito barato se comparado com cursos de tecnologia que se vê por aí, mas por outro lado, foi a primeira vez que a instituição ofereceu um curso sobre o assunto e fomos as cobaias do formato de aulas proposto.

Descrição profundamente genérica e pouco esclarecedora na página do SESC:

Conhecimento dos conceitos básicos e do uso da plataforma de hardware livre Arduíno, apresentados com exercícios práticos.

As duas aulas de quatro horas foram ministradas pelo Vítor Fernandes, que é membro do Garoa Hacker Club. Acabei descobrindo que o curso é uma versão reduzida do curso Arduino 100 noção, oferecido gratuitamente na sede do clube.

Importante! A corrente máxima suportada por qualquer um dos pinos é de no máximo 40mA.

No sábado tivemos uma introdução técnica sobre a arquitetura da placa e do circuito integrado controlador. Na lista baixo e na imagem ao lado, reproduzo com as minhas palavras o que foi dito conteúdo da aula, complementado com pesquisas digitais – já que o tempo das aulas foi curto e minha falta de conhecimento formal de eletrônica fez com que eu me perdesse em algumas explicações e siglas (no sentido anti-horário, partindo botão reset):

• Botão reset: faz com que o firmware atualmente instalado no circuito volte ao início da execução.
• Conexão USB: é uma entrada USB do tipo B por onde se dá a troca de dados com um computador. Serve também para alimentar a placa com uma
• Oscilador de cristal: um componente eletrônico que serve para contagem interna de tempo da placa. Usa a oscilação de ressonância de um cristal no seu interior para criar um sinal elétrico com uma frequência constante que pode servir de referência cronológica.
• Entrada de alimentação: permite o uso de uma fonte de energia externa, que pode variar de 6 a 12V ou até 20V se houver uma forma de refrigerar a placa.
• pino de referência de tensão: Identificado na placa com a sigla IOREF, é usado por shields. Informa a tensão de referência de funcionamento dos pinos I/O da placa (no caso do Arduino UNO, 5V), para que o shield possa funcionar na mesma tensão.
• pino reset: faz o mesmo que o botão reset, mas eletronicamente. Basta que mudar o valor do pino para LOW ou 0.
• pino 3.3V e 5V: pinos capazes de fornecer as tensões (previamente reguladas) indicadas em seus nomes, a componentes externos à placa.
• pino VIN: este pino – cuja sigla significa Voltage INput – tem dupla função: 1. nos casos onde uma fonte de energia alternativa (ver entrada de alimentação) está sendo usada é possível acessar uma tensão DC alimentada através do pino VIN; 2. também é possível fornecer energia para a placa através deste pino. Basta ligar o polo positivo da fonte de energia diretamente no VIN e o polo negativo em um dos pinos GND.
• pinos analógicos: o chip controlador têm um conversor capaz de traduzir entradas de dados analógicas para digitais. Esse conversor tem 10 bits de resolução e isso quer dizer que uma escala com 1024 valores diferentes (de 0 a 1023) pode ser usada para simular digitalmente as medições do componente que está produzindo dados analógicos. Os seis pinos analógicos também podem ser usados como pinos digitais.
• controlador ATMega328: por ser mais complexo, comentarei a arquitetura do chip mais adiante, para não poluir esta lista de explicações mais sucintas.
• ICSP headers: O circuito controlador do Arduino tem um pequeno aplicativo chamado bootloader que já vem instalado na sua memória e administra a instalação de novos firmwares (programas escritos na IDE do Arduino e enviados pela conexão USB) através da interface do ICSP header (que quer dizer In-circuit Serial Programming) é possível instalar programas um pouco maiores com a ajuda de um programador externo, diretamente no circuito. A conexão USB também tem uma interface similar, mas infelizmente não sei como funciona!
• LEDS dos pinos seriais e do pino 13: O Arduino R3 tem três LEDs integrados na própria placa, associados aos pinos 0, 1 e 13. O pino 13 é um pino de teste, logo é útil poder averiguar seu funcionamento sem que partes extras (jumpers, breadboards, etc) sejam necessárias. O mesmo é válido para os pinos seriais: sinalizam os bits estão saindo de TX e sendo recebidos por TR. Os LEDs ascendem se um sinal elétrico for aplicado nos respectivos pinos e apagam quando o sinal deixa de existir.
• pinos digitais: são os pinos mais básicos da placa. A informação que representam tem dois estados: 0 (ou LOW) ou 1 (ou HIGH) e podem ser configurados para servirem como entrada ou saída de dados. Funcionam com uma tensão padrão da placa (5V) e suportam uma corrente de até 40mA.
• pinos seriais: O par de pinos seriais TX (Transmissor) e RX (Receptor) – que também podem ser usados como pinos digitais comuns – compõem uma interface de comunicação serial assíncrona que permite que o Arduino se comunique serialmente com outros dispositivos  que apresentem interfaces similares.
• pinos PMW~: Pulse-Width Modulation ou em português modulação por largura de pulso é uma forma de adaptar o sinal digital comum – que só pode ser 0 ou 1 – para que ele possa simular uma escala de valores de sinal analógico. Essa simulação envolve criar padrões de ondas reconhecíveis formados pela relação do tempo ocupado por 0 e 1 num módulo de tempo pré determinado – o ciclo de trabalho. No exemplo retirado da página do fabricante, percebe-se o tempo ocupado por 1 no ciclo de trabalho variando em 0, 25, 50, 75 e 100% e os valores da escala analógica associados: 0, 24, 127, 191 e 255.
• pino AREF: este pino pode receber um tensão de referência que serve para modificar a escala da resolução dos pinos analógicos. Explicando: a tensão de referência da placa determina a relação entre variação máxima e mínima possíveis e a escala de conversão de 10 bits (1024 valores possíveis) mencionada anteriormente. O valor de AREF padrão é a própria tensão da placa (5V), logo 5V/1024, temos uma variação de 0,0049V por unidade da escala. No entanto, com um AREF de 5V, se o componente acoplado à placa fosse capaz de produzir sinais com menos variação (de 0 a 1V, por exemplo) o número de valores da escala seria só 1/5 dos valores disponíveis originalmente: de 0 a 205. Neste caso, se aplicarmos uma tensão de 1V em AREF, a relação entre variação de tensão máxima e mínima possíveis e a escala de conversão de 10 bits seria alterada: 0V equivaleria ao digito 0 e 1V, corresponderia a 1023. A resolução (quantidade de valores da escala por volt) ficaria maior: 1V/1024 corresponde a uma variação de 0,0009V por unidade da escala.

Arquitetura do ATMega328

Por ter tido dificuldades com as siglas e conceitos de eletrônica na primeira aula, decidi me preparar um pouco melhor para a segunda. Na figura à direita está o rascunho que montei mostrando: 1. desenho do circuito em escala, com todos os terminais enumerados. 2. o diagrama de bloco do circuito, com o funcionamento interno esquematizado (que foi explicado muito rapidamente).

Mas o assunto não foi aprofundado e para entender os dois desenhos esquemáticos eu teria que pesquisar e ler muito mais para compreender o que todas as siglas significam, mas acho que isso sai demais do escopo da pesquisa. Por hora basta que eu saiba usar a interface do Arduino, que intermedia e expande as funções do circuito controlador sem que eu precise ter um entendimento integral de seu funcionamento interno.

Houve também nessa segunda aula uma breve introdução à IDE do Arduino mas, como já apontei no  dessa vez priorizaram a abrangência do público alvo e a profundidade do que foi ensinado não foi muito grande. Aprendemos sobre as funções básicas (o construtor start() e o loop())e estudamos o Blink, que é o exemplo mais básico disponível na IDE:

• /*
    Blink
    Turns on an LED on for one second, then off for one second, repeatedly.
  
    This example code is in the public domain.
   */
  
  // Pin 13 has an LED connected on most Arduino boards.
  // give it a name:
  int led = 13;
  
  // the setup routine runs once when you press reset:
  void setup() {                
    // initialize the digital pin as an output.
    pinMode(led, OUTPUT);     
  }
  
  // the loop routine runs over and over again forever:
  void loop() {
    digitalWrite(led, HIGH);   // turn the LED on (HIGH is the voltage level)
    delay(1000);               // wait for a second
    digitalWrite(led, LOW);    // turn the LED off by making the voltage LOW
    delay(1000);               // wait for a second
  }

Exercícios feitos em aula:

• Acendemos um led, copiando um esquema de um circuito da lousa, usando um circuito ATMega ligado diretamente à breadboard.
• Fazer os sete segmentos de um dígito de display LCD piscar em sequência. Ao invés de criar um comando para cada pino, o instrutor sugeriu que acessássemos os pinos desejados através de um valor numérico em uma variável que é incrementada a cada iteração do loop. Nesse mesmo experimento também fomos estimulados (aqueles com conhecimento suficiente em programação) a acrescentar algum tipo de identificação para que soubéssemos em qual sequência os pinos estavam enumerados no circuito do display. Implementei a seguinte solução: o primeiro segmento pisca uma vez, o segundo duas e assim sucessivamente.

Demonstrações, informações e vídeos interessantes, trazidos pelo instrutor:

• Usando o último exercício como base, o instrutor demonstrou como usar um dimmer, para transmitir um sinal analógico ao Arduino e traduzi-lo para controlar a velocidade dos intervalos entre o ascendimento dos segmentos do dígito do display. Ou seja, quando mais o dimmer é girado, menor o tempo das piscadas e da transição entre um segmento e outro.
• Mostrou um cubo de 4x4x4 LEDs que desenha imagens animadas. Mostrou um vídeo de um cubo maior e explicou que a partir de um certo ponto, o Arduino não tem pinos o suficiente para uma estabelecer uma relação de um LED por pino.
• um helicóptero de 6 hélices controlado por Arduino,
• Um circuito expansor de portas que, usando o protocolo I2C do Arduino, é capaz de divide o sinal de duas portas em 8. É usado inclusive na construção de versões maiores do cubo mencionado acima.

Também fomos apresentados à página Dealer Extreme para aquisição de peças para projetos de eletrônica – sensores, LEDs, componentes eletrônicos, placas, shields, etc. – a um baixo custo.

Hoje finalmente comprei-o e posso começar a brincar! Yay!
Por R$165,00, vem com um com:

• 1 Arduino UNO R3
• 1 cabo USB
• 1 breadboard
• 1 display LCD 16×2
• 1 buzzer contínuo
• 1 sensor de temperatura LM35
• 1 potenciômetro de 10K
• 8 botões push buttons de 4 terminais
• 24 LEDs (amarelos, verdes e vermelhos)
• 20 jumpers (fios com pontas rígidas que encaixam-se no Arduino e na protoboard)
• 16 resistores (8 de 1K e 8 de 330R)

Hoje, na aula da disciplina de pós-graduação fomos introduzidos ao novo pacote de suporte à fabricação digital da Autodesk, o 123D. Em troca de – e aqui especulo – tráfego virtual, fortalecimento da marca e expansão da base de dados de usuários, empresa disponibilizou 4 produtos gratuitos e fáceis de usar – e portanto com poucos recursos -, voltados para a fabricação digital pessoal:

• 123D Catch, que converte uma série de imagens tiradas de vários ângulos de um objeto ou ambiente em um modelo 3D com textura já aplicada.
• 123D Design é um programa de modelagem 3D convencional como o Blender, mas extremamente simplificado e acessível.
• O 123D Sculpt é uma versão – também simplificada – do método de modelagem tátil, implementada pelo aplicativo comercial ZBrush. A interface adota uma abordagem intuitiva onde, como na escultura com argila, o usuário pode acrescentar, subtrair, inchar, achatar, etc. Além de pintar a textura diretamente no modelo.
• O 123D Make foi o mais comentado, já que fomos informados de que o usaríamos na aula. É um aplicativo que usa a malha poligonal ou de NURBs de um modelo preconcebido para criar uma estrutura dividida em várias partes intertravadas, fabricadas a partir de materiais bidimensionais, como MDF e papelão.

A imagem acima ilustra a interface do 123D Make com um dos exemplos padrão, que vêm com o aplicativo. Na direita, o menu de opções construtivas, sendo as mais importantes:

• Model, onde o objeto 3D pode ser importado.
• Construction technique, que pode ser na forma de curvas de nível horizontais para serem coladas ou na forma de planos com espaçamento intertravados.
• Manufacturing settings diz respeito ao tamanho do material a ser cortado.
• Object size permite que usuário determine o tamanho real do objeto, independentemente do tamanho original do objeto importado.
• Slice distribution tem os parâmetros para determinar em quantos planos o objeto deve ser dividido.

No centro está a área de visualização do objeto, onde as mudanças efetuadas nos parâmetros do menu da esquerda são refletidas em tempo real e onde o objeto pode ser manipulado com o mouse, para que possa ser melhor visualizado.

Na coluna da direita, o aplicativo mostra uma pré-visualização da organização dos planos criados a partir do objeto nas placas de material, com tamanho definido pelo usuário.

O exercício proposto será montar um objeto usando as técnicas aprendidas na disciplina: gerá-lo parametricamente usando o aplicativo Rhinoceros e a extensão Grasshopper, para em seguida fabricá-lo no 123D Make e cortadora laser.

Como parte da disciplina de pós-graduação que participo como ouvinte nesse semestre, teremos a oportunidade de criar um objeto real – uma luminária! -, modelado parametricamente no Grasshopper. O ponto de partida foram dois exercícios usados pelo professor durante o curso: um sobre MetaBalls e outro sobre sólidos em revolução.

Os arquivos *.gh mencionados nessa entrada:

• exercício sobre MetaBalls
• exercício sobre sólido em revolução
• luminária completa

Origem: exercício sobre MetaBalls

O intuito desse exercício foi criar uma visualização mais realista de uma forma complexa na viewport do Rhinoceros, ou seja, é um artifício de representação que não produz objeto sólido composto por polígonos ou planos NURBS. Como descreverei mais adiante, convertê-lo em uma malha de polígonos foi um dos passos mais complicados do exercício. As duas imagens na direita mostrando  os componentes usados no Grasshopper e o resultado produzido na viewport do Rhino.

Se repararmos bem, na verdade o volume é composto por três componentes MetaBall(t) separados, mas que refletem o mesmo volume. Esse volume é determinado pelos elementos na área lilás superior:

1. O elemento Pt cria uma série de pontos (em verde) no eixo X, a partir de um simples elemento Series.
2. Os dois elementos Move, deslocam os pontos criados: o primeiro no eixo Y e o segundo no eixo Z. Repare que o primeiro conecta-se ao segundo para que o resultado seja um conjunto de pontos deslocados em Y e em Z.
3. Para que esses os deslocamentos não sejam regulares, números gerados com o elemento Random são multiplicados (AxB) por um fator (Num) e salvos num elemento que armazena valores de vetores em Y. Os mesmos valores são passados para o elemento que armazena valores de vetores em Z, mas antes um componente Jitter – cujo nome é traduzido como tremulamento – acrescenta um novo fator de aleatoriedade, para que os valores em Y e Z não sejam idênticos.

O slider numérico identificado como isocurves, localizado entre as duas áreas lilás, é responsável por determinar o raio básico das esferas formadas a partir dos pontos gerados no elemento acima.

Os componentes MetaBall também precisam de uma lista de planos espaçados, cujas intersecções com a forma completa, desenharão as curvas de nível (splines) vistas na imagem da direita. Cada um dos três componentes é responsável por exibir curvas de nível perpendiculares a cada um dos três eixos.

As amplas possibilidades formais das MetaBalls me pareceram ser um bom ponto de partida para resolver meu objeto.

Origem: exercício sobre sólido em revolução

Do segundo exercício, só peguei emprestado um elemento: a curva senoidal vertical que, em revolução a partir de um eixo central, produz o sólido ilustrado na segunda figura à direita.

Explicando os componentes geradores da forma da primeira imagem:

1. O elemento chave, RevSurf gera o sólido em revolução a partir de dois parâmetros básicos: a curva a ser revolucionada, o eixo central.
2. A curva para revolução – desenhada pelo componente Move – é uma cópia de uma curva criada no centro do objeto de acordo com o que o usuário deseja que  seja o raio da base.
3. A curva original – desenhada pelo componente Interpolate – é gerada a partir de um componente Sine que, alimentado por um uma sequência de valores sucessivos (Range), gera valores senoidais.
4. Esses valores, que por hora são apenas números, são multiplicados (Multiplication) por um fator para que a amplitude do intervalo ocupado seja maior.
5. Em seguida passam a ser atribuídos à componente Y do conjunto de vetores Vector XYZ. e assim temos vetores representáveis no espaço (ligando um componente PLine na saída vector de VectorXYZ, por exemplo, é possível ver os vetores desenhados na tela).
6. Por último um elemento Interpolate reconstrói a curva senoidal, calcula e introduz novos pontos entre os pontos já existentes, para que a curva fique mais sinuosa.

Criação da luminária

Acima estão as imagens dos componentes geradores da forma no Grasshopper (divididos em dois, para melhorar a legibilidade, já que o sistema WordPress comprime todas as imagens cujas larguras ultrapassem o valor permitido) e das etapas de finalização da forma, que serão explicadas nos parágrafos a seguir.

A ideia principal foi: produzir uma MetaBall a partir de uma espiral de pontos para que a forma resultante tivesse um aspecto de montanha. Para tanto, a curva senoidal do exercício 2 foi adaptada para que pudesse sair do plano Y, com valores de senos sendo aplicados também à componente X dos pontos.

A grande área lilás na primeira imagem cerca o mecanismo responsável por produzir a espiral. Explicando-a:

1. Para o valor em Z dos pontos, uma progressão simples de dados.
2. Para os valores nos eixos X e Y, o resultado é dado por um sistema que envolve multiplicar cada valor de uma série numérica (AxB) greada pelo componente Series, por um fator.
3. Esse fator é obtido pelo cálculo do seno (Sin) dos valores de uma segunda série numérica (o segundo Series), com o mesmo número de elementos da primeira. A segunda série é uma progressão aritmética cujo valor da constante pode ser mudado para produzir mais ou menos variação (por exemplo no eixo X, o valor é 1; e no eixo Y, 5.
4. A espiral produzida tinha uma base estreita e um topo largo. O componente Rev foi usado para inverter a relação.

Cria-se assim uma espiral virtual, na forma de dados, que não aparecem na viewport do Rhinoceros. Na segunda imagem, os pontos (Pt) geradores da MetaBall são criados:

1. Os valores de Z são fornecidos diretamente para Pt.
2. Na tentativa de introduzir um mecanismo que permitisse controlar a espessura do topo da espiral, tentei criar uma etapa extra, descrita no arquivo como valor do modificador de ponto, mas não fui bem sucedido. O raciocínio: os índices da lista que contém os pontos da espiral são uma progressão aritmética. Os valores que eu gostaria de mudar (os do topo da espiral) estão no fim dessa lista, logo têm os maiores índices.
   Então multiplicando os índices por um fator e somando-os aos valores de coordenadas correspondentes, quanto maior for o valor do índice, maior o valor do modificador somado à coordenada.
   Por exemplo: na lista de valores do eixo Y, o valor de indice 2 é 1,091892 e o de índice 40, 0,697304. Se o fator de multiplicação for 2, o valor de índice 2 mudará para 1,091892+(2*2) que é 5,091892; já o de índice 40, mudará para 0,697304+(40*2) que é 80,69730, ou seja uma variação bem maior.

Diferente to exercício, apenas uma MetaBall (imagem 3) foi suficiente neste caso, porque o produto final desejado é um sólido poligonal. A justificativa está na técnica empregada, que transforma as splines das curvas de nível em polígonos:

1. Os planos de divisão do MetaBall são criados no grupo planos metaball.
2. Subdivide-se os segmentos splines resultantes, usando um componente DivLength (resultado na imagem 4).
3. A opção bake é usada nesse componente do Grasshopper, para transformar os as divisões em objetos do Rhinoceros (imagem 5).
4. No Rhinoceros, todos os pontos obtidos são selecionados e, usando-se o comando MeshFromPoints – disponibilizado pelo plugin homônimo, que talvez precise ser instalado – a nuvem de pontos é transformada numa malha poligonal (imagem 6).

Hoje me aventurei pelas lojas que vendem peças usadas dos desmanches, na Av. Dr. Ricardo Jafet, à procura de motores atuadores lineares de farol para montar o primeiro dispositivo eletrônico da pesquisa, baseado no design aberto e simples do armbot. Os desenhos não são muito claros e não existem fotos do braço completo, o que me leva a crer que o autor não chegou a concluí-lo, mas é possível deduzir que cada articulação demanda um motor e um terceiro ainda é necessário para controlar a garra.

Dada a minha falta de experiência com eletrônica, para o meu experimento decidi comprar um motor a mais, para o caso de haver algum acidente durante o processo de aprendizado.

O Primeiro passo foi encontrar a avenida no Google maps e delimitar a região com o maior número de lojas, buscando pela expressão ‘auto peça’. A pesquisa listou resultados próximos à estação santos-imigrantes do metrô, concentrados na direção sul (1a. imagem).

Nem foi preciso caminhar muito: logo encontrei uma revenda especializada em faróis e lanternas, a Rod Car, onde fui atendido pelo proprietário, o senhor Carlos (2a. e 3a. imagens). Em um canto da loja estava uma caixa com diversos motores atuadores de modelos e marcas diferentes, que foram apanhados aleatoriamente e testados um a um, numa bateria de automóvel.

Inicialmente, ofereceu-os por R$40,00, mas com um pouco de negociação o valor caiu para R$25,00.

Os motores adquiridos:

Na reunião de hoje sentei-me com o Prof. Arthur pela primeira vez para conversarmos com mais detalhes sobre o braço robótico que começou a ser desenvolvido no doutorado de outro aluno e que deu origem à ideia para o tema deste TFG. Também recebi todo o material que necessário para que o desenvolvimento do projeto pudesse ser iniciado.

Avaliamos também nossas opções para o início do desenvolvimento do primeiro braço. Achamos vantajoso começarmos com um pré-projeto: um braço mais simples – baseado no design do Armbot – que usará motores atuadores de farol de automóveis e terá uma estrutura prototipada a partir de um kit de robótica infantil, emprestado por um dos filhos do orientador.

O material recebido:

Kit de robótica Robota

O que restou do braço antecessor, do doutorado de outro aluno.

Engrenagens e articulações em acrílico, potencialmente empregáveis ou que podem servir como modelo.

Caixa de transmissão, com dois motores – que podem girar em dois sentidos, independentes – com sistemas de engrenagens redutoras.

Eletrônicos: Arduino, shield para motores, display LCD, resistores, jumpers, cabo USB, etc.

Hoje, durante a aula da disciplina de mestrado, aconteceu uma palestra aberta sobre fabricação digital, modelagem paramétrica, com enfoque na obra do arquiteto Kas Oosterhuis.

Os palestrantes:
Affonso Orciuoli, professor da Escola Tècnica Superior d’Arquitectura da Universitat Internacional de Catalunya, onde coordena o Taller de Arquitectura Digital.

Doutor pela Escola Tècnica Superior d’Arquitectura (ESARQ), na Universitat Internacional de Catalunya (UIC).

Leciona e coordena uma série de cursos, dentre eles o de Computação Aplicada à Arquitetura e o programa de Mestrado em Arquitetura Biodigital, onde é co-responsável pelo Workshop de Arquitetura Digital.

É diretor do Toolingroup, um grupo de pesquisa interdisciplinar que investiga as aplicações da informática na arquitetura, com ênfase nos processos da fabricação digital.

Apuesta por vías “cloud”, open source, código abierto, sistemas emergentes, horizontales, con compromiso en la efectividad del uso del material a nivel local, apostando por medios de producción también locales. De las misma manera el uso de las TICs a nivel global, en sus consecuencias en el impacto de la acción constructiva en su entorno más inmediato.

(fonte: página do grupo Toolingroup)

Durante a palestra mostrou exemplos interessantes que desenvolveu junto ao Toolingroup:

1. Workshop Introdicción a la Fabricación Digital Aplicada a la Arquitectura, para os alunos da Universidad Simón Bolívar, em Caracas na Venezuela, em parceria com os designers do grupo Mediodesign, em 2012.

Propôs a fabricação de peças – geradas através da introdução de variações a um módulo embrionário – que, através das conexões e encaixes, permitissem ao aluno explorar possibilidades de proliferação espacial.

(Crédito das imagens e do vídeo: página do grupo Toolingroup)

2. Instalação GoTo, criada para a 5a edição da exposição EmE3 em 2010, em parceria com os estúdios Mediodesign e LaN Architecture Network, no Centro de Cultura Contemporánea de Barcelona.

Trata-se de um experimento, onde o público participa como protagonista, catalizador da edificação da obra.

(…)proporcionar una aproximación a los procesos de diseño y fabricación digital, intentando, de manera lúdica, subrayar una nueva relación entre ambos. Si el proceso clásico es el de diseñar para luego construir, deberíamos estar atentos a una nueva posibilidad. La retroalimentación (feedback) entre diseñador / interfaz de medios / realidad – se hace de manera concomitante – (idea / registro de idea / hacer realidad la idea). Estas 3 diferentes fases ahora se solapan. La instalación trata de experimentar este proceso, donde la tecnología podría ser entendida como una extensión no solo de las capacidades creativas, sino también constructivas. En cierto sentido, este modelo se acerca más a la artesanía que a la industria convencional.
Los participantes del Festival son los protagonistas de la instalación, donde el resultado, a priori, es impredecible.

(fonte: página pessoal do autor)

(Crédito das imagens: página do grupo Toolingroup)

Ernesto Bueno, arquiteto formado pela Escola Central de Venezuela em Caracas e mestre em Arquiteturas Genéticas pala Universitat Internacional de Catalunya, com experência em design paramétrico, scripting e fabricação digital em arquitetura. Atualmente estudando no Programa de Pós-Graduação em Design e Tecnologia da UFRGS, através de sua pesquisa no SimmLab.

Mostrou exemplos de seu trabalho junto à equipe do Atelier Um+D, como por exemplo:

1. O painel modelado parametricamente, do projeto Ligações Urbanas – de 2011 -, criado para o Instituto Municipal de Turismo em Curitiba.

We start from a Delaunay triangulation of a pseudo-random network differentially extruded following a set of attractor curves and we extend the connecting nodes’ geometry to stabilize the structural parts in the direction perpendicular thereto. This extension changed the secondary status of the connectors, turning them the main pieces. The whole parametric process consists of five Grasshopper definitions and one RhinoScript separated in stages to allow team work. As a result, 540 unique pieces of polystyrene were CNC cut and assembled with screws.

(fonte: página pessoal do autor)

(Crédito das imagens e vídeo: página do atelier Um+D)

2. Uma intervenção intitulada [Des]Dobrar, construída em 2012 nas proximidades do prédio do curso de Arquitetura e Urbanismo da Universidade positivo de Curitiba. Trata-se de um espaço de passagem, cercado por laminas verticais espelhadas que reagem à presença de transeuntes, segundo um mecanismo: cada uma das lâminas está associada a um sensor de movimentos, que os transmite dados à uma placa controladora, que está no comando de um motor. Quando a presença de alguém é detectada, a lamina gira em um eixo vertical, de forma a não refletir a imagem da própria pessoa, mas ângulos diferentes do entorno.

Um espaço composto por elementos refletivos é (…) um espaço de limites nublados(…)

No campus universitário, cuja configuração busca a otimização e legibilidade a partir da repetição de respostas e signos pré-estabelecidos, surge a possibilidade de um espaço singular onde esta mesma repetição multiplica-se exponencialmente de maneira a materializar-se como objeto que ao mesmo tempo influencia e é influenciado por um local específico. (…)

Ao contrário de um mero espectador passivo, é o observador quem compõe a obra, através de seu posicionamento e de seu movimento no espaço. Tal movimento é, ainda, ‘refletido’ por objetos que “dançam” conforme a passagem dos transeuntes e os acusa de serem eles, também, atores em uma realidade múltipla, dinâmica e interconectada.

(fonte: página do atelier Um+D)

(Crédito das imagens: página do atelier Um+D Toolingroup)

Para encerrar a palestra, o Prof. Bueno criou, passo a passo no Grasshopper, sistema paramétrico de construção de uma cúpula, apoiada por quatro pontos (representados por Breps).

• O arquivo *.gh pode ser baixado neste link: http://www.stefanomega.com.br/tfg/regCron/wp-content/themes/bare/files/bueno_cupula.gh
• As instruções para montagem, foram anotadas pelo Prof. Arthur Lara: http://www.stefanomega.com.br/tfg/regCron/wp-content/themes/bare/files/arthur_cupula_gh.pdf

Depois de muitas considerações sobre como funcionam os três terminais dos atuadores lineares de farol, de muitos testes com engenharia reversa, de tentar fazê-lo funcionar diretamente com o Arduino, de tentar montar um circuito auxiliar, resolvi fazer um teste mais básico: controlar o motor com um potenciômetro, como a apostila do Armbot sugere que seja feito. E funcionou!

Por hora vou deixar de lado os circuitos e o Arduino. Vou usar essa combinação pra testar a solução estrutural; observar o impacto do peso dos motores se movimentando eletronicamente.

Essa solução expõe mais uma variável: variando a resistência (e, portanto, também a corrente) no pino do meio, o braço para em posições diferentes. Ou seja, a cada grau de giro, a haste do atuador para numa posição diferente até estar totalmente extendida/contraída nos limites máximos de giro.

Se houver um componente que equivale à um potenciômetro controlável por corrente, dá pra montar um circuito mais simples do que o que eu estava fazendo.

Hoje fui à região da Santa Ifigênia para comprar o material elétrico necessário para a conclusão da primeira etapa do dispositivo 01. O motivo foi tornar o dispositivo funcional o suficiente para ser mostrado na apresentação pré-banca 1.

Na lista à direita, fui anotando ao longo do semestre, todos os itens que julguei necessários:

• Jumpers fêmea, para que os jumpers macho que eu já tenho pudessem ser ligados uns nos outros, formando fios compridos reversíveis.
• Terminais de compressão são materiais elétricos que encontrei na internet cuja função eu deduzi: dar acabamento à fios elétricos. Tem um com área de secção redonda de 1mm2 que devem encaixar bem nos terminais dos motores atuadores lineares da Bosch. Para os outros motores, que têm terminal achatados, vou ter que procurar uma solução na hora.
• Alicates para crimpagem, feitos para comprimir e fixar nas pontas dos fios os terminais descritos acima.
• Um kit de resistores que, somados aos do starter kit do Lab de Garagem, cubram um maio numero de intervalos. Escolhidos segundo a série numérica E2, seguem o seguinte padrão: 1, 3.3, 10, 33, 100, 330, 1000, 3k3, 10k, 33k, etc.
• Uma caixa organizadora para armazenar todas essas peças pequenas.
• Uma ponta de ferro de solda,
• Dois potenciômetros (na lista a palavra está errada) de 10K, um para controlar cada um dos motores do dispositivo 1.
• Uma pinça de heat sink é uma ferramenta que, posicionada no terminal metálico do componente absorve o calor do ferro de solda, evitando que os componentes eletrônicos sejam danificados.

As primeiras paradas foram nas lojas Mult Comercial (street view) e Santil (street view), pré-localizadas pelo Google, para que houvesse algum tipo de ponto de partida, já que essa foi minha primeira vez comprando material elétrico.

Na Mult encontrei boa parte do que precisava, com exceção dos terminais de fios elétricos. Por recomendação de um vendedor, depois de pular de loja em loja, cheguei à Casa dos Relês (street view) onde o dono, muito gentil, me explicou que os terminais não eram para ser usados daquela maneira e me ofereceu um outro tipo de material alternativo que resolveu meu problema: um terminal metálico que testamos nos motores que levei como exemplo.

Um outro material interessante que o dono recomendou que eu usasse para proteger os terminais metálicos de encostarem uns nos outros foi um tubo flexível, com propriedades isolantes feito por um tipo de borracha que, quando em contato com o fogo, encolhe, amoldando-se ao material que estiver em seu interior, dando um ótimo acabamento.

A imagem ao lado mostra o material organizado na caixa (1) adquirida na Mult, numerados, misturado com os materiais que acompanharam meu starter kit do Lab de Garagem.

• (2) resistores
• (3) tubo isolante elétrico, que encolhe quando exposto ao fogo.
• (4) pontas para ferro de solda
• (5) terminais alternativos, adquiridos na Casa dos Relês.
• (6) potenciômetros
• (7) base para solda

Os alcances das articulações ainda não estão ajustados, ou seja, a extensão máxima e a contração mínima da haste do motor não correspondem às posições finais que o próximo segmento precisa assumir para cobrir uma porção útil equilibrara da área de trabalho à frente do robô – ou seja, traçando uma linha horizontal no eixo da articulação, o segmento cobre uma área muito maior abaixo da linha.

Uma peça experimental de durepoxi e arame, concebida para fazer a ponte entre a ponta da haste do motor e a peça plástica que deve ser puxada ou empurrada para que o segmento seguinte mova-se para cima ou para baixo. O desajuste descrito acima aconteceu porque essa peça está muito comprida, concentrando a amplitude de movimentos desse segmento na parte inferior da linha horizontal descrita.

Mas pelo menos funcionou bem!

Como parte da disciplina de mestrado que participo como ouvinte, desenvolvemos uma luminária usando modelagem paramétrica.

A seguir, como relatado em outra entrada, um aplicativo gratuito oferecido pela empresa Autodesk – o 123D Make – foi usado para decompor o sólido original em elementos planificados intertraváveis. As imagens abaixo ilustram a configuração final do processo:

123D Make: menu lateral e área de visualização do sólido, com as configurações usadas na luminária. Repare nos parâmetros do item selecionado Material Size, que aparecem na parte inferiror da tela: Thickness é a espessura do material e Kerf, o valor da compensação da perda de material a ser aplicado nos encaixes, para que não fiquem muito soltos.

Elementos planos organizados automaticamente no tamanho de prancha especificado: o algoritmo não é muito eficiente no aproveitamento do espaço.

A seguir, usando o software DraftSight, a distribuição das peças na prancha foi otimizada manualmente e os layers foram configurados para o corte a laser, na máquina DS4. A imagem abaixo mostra o resultado.

Sobre a configuração do arquivo para impressão:

• Aceita arquivos no formato *.dxf e *.eps
• Layers diferentes podem ser configurados para executar funções diferentes. Na imagem acima, por exemplo, a cor azul foi reservada para indicar corte; e a cor vermelha, gravação (processo em que o laser apenas queima a superfície do material).
• Cada uma das peças são compostas por um conjunto de linhas. É importante que todas as linhas relacionadas sejam convertidas em polylines contínuas para que a máquina corte cada uma das peças de uma só vez. Do contrário a máquina cortará cada um dos segmentos de acordo com a ordem em que foram criados. Com isso o laser é desligado e reposicionado para cada um dos segmentos, acrescentando ao tempo de execução; e a sequência de corte entre elementos é imprevisível e, se o material se mover minimamente, o resultado pode ser peças cortadas com distorções graves.

Sobre o funcionamento e configuração da máquina de corte a laser DS4:
Software:
Configuração de layers, da velocidade e potência dos lasers.
Hardware
Processo de centralização da cabeça de corte e processo de reconhecimento do tamanho da placa.
Sequência de corte: polylines fechadas x abertas.

Peças cortadas

Processo de montagem

Luminária completa

: espaço deixado muito pequeno

Felizmente a primeira apresentação aconteceu sem maiores imprevistos. O incentivo do nervosismo da apresentação foi aproveitado para acelerar o desenvolvimento do dispositivo 01 e com isso foi possível alcançar o marco mais importante até o momento: a versão 1.3.1, a primeira com um dispositivo totalmente funcional.
Mesmo sem  havido tempo de apresentar esses avanços formalmente, o orientador foi mantido atualizado de todos os passos por e-mail.
Por essa razão, os três vídeos abaixo foram gravados, mostrando:

1. o funcionamento dos motores instalados na estrutura, comandados por potenciômetros (leia mais sobre a interface de controle em outra entrada);
2. a primeira versão da garra de MDF fora da estrutura, logo após sua fabricação e montagem.
3. o funcionamento completo da versão 1.3.1.

Assista-os a seguir:

São aspectos importantes dessa versão, consultáveis na página do registro do dispositivo 01:

1. peças conectivas, ligando a haste dos motores à estrutura (explicado abaixo).
2. a garra fabricada em MDF.
3. interface de controle com potenciômetros.

Peças conectivas

São peças de durepoxi e arame e fita veda rosca (para aumentar o atrito), concebidas para fazer a ponte entre a ponta da haste do motor e a peça plástica que deve ser puxada ou empurrada para que o segmento seguinte mova-se para cima ou para baixo.

Conclusões

Aspectos técnicos da pesquisa consumiram muito tempo – pela complexidade do tema e pela falta de experiência com eletrônicos. Com isso o desenvolvimento do dispositivo teve um avanço maior do que o esperado e as leituras ficaram em segundo plano.

Ao fim da apresentação, a professora responsável pelo acompanhamento metodoógico disse que a evolução foi satisfatória, mas que seria importante adotar uma postura mais crítica em relação às descobertas no fim da pesquisa.

Conversando sobre a apresentação de ontem e planejando os próximos passos  do trabalho, estabelecemos o seguinte conjunto de afazeres e metas:

Aspectos digitais:

• Ver com mais calma os vídeos be your own souvenir e sobre o workshop de robôs fabricando fachadas.
• Refazer o exercício de planificação da palestra do Prof. Ernesto, pra não esquecer o que foi ensinado.
• Aprender a mexer no Firefly e no Wavebird.
• Fuçar na IDE do Processing.
• Dar uma olhada na engine física para Grasshopper, Kangaroo.

Aspectos eletro-físico-eletrônicos:

• Criar um usuário no Thingiverse para disponibilizar à comunidade minha versão da garra de um robô de design aberto produzido por outro usuário.
• Estudar se é possível mudar o funcionamento do atuador: remover a placa controladora, usando o motor DC direto, para que a haste possa se mover mais do que 8mm.
• Procurar saber se um dimmer de ventilador (?), porque pode ajudar a controlar o braço eletronicamente.

Frequentei o primeiro dia do Workshop sobre os novos processos de projeto e fabricação digital na arquitetura.

Objetivos Gerais

• Difundir e refletir a respeito da aplicação das tecnologias digitais de fabricação à produção do Design e Arquitetura Contemporâneos.
• Ampliar a percepção de alunos de graduação e pós-graduação sobre a tecnologia de fabricação digital, além de possibilitar o intercâmbio de informações entre os palestrantes convidados, os professores e pesquisadores da FAUUSP e a comunidade técnica em geral.

(fonte: convite para o evento)

Palestrantes e temas debatidos nesse dia:

Através de uma vista programada pela disciplina de mestrado visitei a FEIPLAR – a feira internacional de composites, poliuretano e plásticos de engenharia – que aconteceu no pavilhão do expo centernorte.

O intuito da minha presença foi obter informações sobre novas técnicas e materiais que pudessem contribuir diretamente no experimento com o segundo dispositivo, ou seja:

• materiais e processos de fabricação aplicáveis diretamente à construção do robô;
• ou materiais macios que pudessem ser usados como matéria prima para a criação de estudos fresados pelo robô.

Meu conhecimento sobre os materiais que dão o nome à feira era bem pequeno e a publicação distribuída na recepção do evento deu uma boa noção básica sobre os materiais que dão nome à feira. Abaixo transcrevo os trechos mais importantes:

Composites:

(…) também chamados de compósitos, plástico reforçado, fiber glass ou simplesmente fibra de vidro, são materiais que unem uma matriz, normalmente polimérica (…), com reforços, sendo fibra de vidro, carbono, aramida ou naturais as mais comuns. Fabricadas manualmente ou por processos de moldagem aberta ou fechada, as peças em composites combinam as melhores propriedades mecânicas, químicas, térmicas e dielétricas das resinas usadas com as excelentes propriedades (…) dos reforços com fibras, permitindo fabricar peças de extrema leveza e resistência.

(…) As resinas utilizadas na fabricação (…) são geralmente termofixas (…). Os reforços, (…) fios contínuos fios picados, mantas de fios picados e tecidos (…).

Alguns dos mercados que mais utilizam composites são o automobilístico, náutico, aeroespacial, eólico, anticorrosivo, elétrico, construção civil, industrial (…), esportivo, e moveleiro (…). (…) são conhecidos por substituírem (…) o aço e o alumínio em aplicações onde a leveza e a liberdade de design exigem a utilização de materiais plásticos.

Poliuretano:

Polímero temofixo (cuja reação não pode ser revertida aos componentes iniciais), (…) é um dos polímeros mais versáteis (…). Utilizado em grande escala em diversos mercados. (…) Quimicamente, o poliuretano é o resultado da reação de um ou vários polióis com um ou vários isocianatos, numa polimerização que envolve catalizadores amínicos e organo-metálicos, surfactantes em grande parte siliconados, cargas, pigmentos e outros aditivos. O sprincipais tipos de polióis existentes são base poliéter e poliéster. A depender das matérias-primas iniciais, a reação pode originar espuma flexível ou moldada, espuma rígida, rígida moldada, integral skin, elastômero, adesivo ou tinta, dentre outras.

Setor moveleiro – (…) o poliuretano aparece como espuma flexível (para colchôes, travesseiros, cobertores (…) )e modlada (em travesseiros com espuma viscoelástica, por exemplo). (…) por volta de 60% do poliuretano produzido no país vai para móveis. (…)

Isolamento térmico – (…) origina espumas rígidas com o maior potencial de isolamento térmico dentre os materiais conhecidos (…)

Elastômero – Moldado a quente (…) o poliuretano origina peças elastoméricas com excelente resistência à abrasão e elevada rigidez, indicadas para uso em rodas de skate (…) rodas de móveis, peças técnicas para o mercado de mineração (…) é o material mais indicado em relação aos vários concorrentes, como aço, borracha(…)

Adesivo – (…) Existente em versões mono ou bicomponente (…) mostra excelentes propriedades de resistência a tração e ao cisalhamento. (…)

Tintas – (…) e vernizes de poliurtetano são (…) melhores produtos para proteção e pintura de superfícies de madeira, metais e composites (…) desempenho superior a tintas de origem acrílica ou alquídica (…).

Plásticos de engenharia:

(…) são plásticos especificados e utilizados em função de necessidades (…) mecânicas, químicas, térmicas, ergonômicas, de design, dentre muitas outras. (…) Uma infinidade de plásticos de engenharia está à disposição dos transformadores de peças plásticas. (…) podem estar na forma de blendas que utilizam o que há de melhor nos polímeros que entram na mistura.

No setor automotivo, por exemplo, a poliamida (PA), o polibutileno tereftalato (PBT), o poliacetal (POM), a acrilonitrila-butadieno-estireno (ABS), a acrilonitrila estireno acrilato (ASA) (…) Em bens de consumo geral (…) são utilizados em aparelhos eletrônicos, eletrodomésticos e microcomputadores, aparelhos celulates, brinquedos, móveis, etc.
Contrariamente aos plásticos tradicionais, vendidos e transformados em commodities, os plásticos de engenharia obedecem (…) parâmetros técnicos que os tornam inficados para aplicações tradicionalmente indicadas para ligas metálicas ou plásticos de pior rendimento. (…) quanto mais a tecnologia avança e os requisitos de engenharia se tornam cada vez mais difíceis de atender, mais o mercado cresce (…).

Abaixo alguns exemplos dos catálogos mais interessantes obtidos durante a visita:

Fabricação

Wacker: Fabricação de bolsas de vácuo.

Materiais

Texiglass: tecidos para aplicação na fabricação de compósitos.

Ao chegar em casa, fiz um balanço mental da experiência. Apesar de ter visto e conhecido muitas coisas novas, porque o contato foi breve e porque meu conhecimento sobre o assunto era quase nulo no momento da visita, não foi possível determinar se de fato encontrei novos materiais imediatamente aplicáveis diretamente à construção do robô. Em relação à materiais para serem fresados, não nos deparamos com nenhum produto que correspondesse às características procuradas.

De forma alguma a visita foi sem importância. Tudo o que conheci ampliou meu vocabulário técnico e agora integram minha biblioteca mental de opções, ou seja, agora eu sei onde buscar soluções quando, durante o trajeto de desenvolvimento encontrarmos problemas que demandem o uso de um material com alguma propriedades específicas, como por exemplo resistência ao calor, mecânica ou química.

Em substituição à primeira garra do dispositivo 01 – estruturalmente instável, por limitações impostas pelo kit de robótica Robota – construí uma nova versão da peça, baseada no braço robótico de design aberto desenvolvido pelo usuário Jan-Jaap –  disponível no site Thingverse sob a licença CC BY-NC 3.0 -, usando as técnicas de corte à laser recém aprendidas na disciplina de mestrado AUT5834, que frequento como ouvinte.

Minha entrada na página do Thingverse, inclui um manual de instruções para auxiliar na montagem e um artigo escrito por mim em Inglês, sobre como criar engrenagens de dentes arredondados, ambos em inglês, em respeito à internacionalidade da comunidade.

CMS (content management system ou sistema de gerenciamento de conteúdo) é um aplicativo que permite a publicação, edição e manutenção de conteúdo, através de uma interface administrativa centralizada. No caso de páginas e portais eletrônicos, o aplicativo – escrito em ASP, PHP ou qualquer outra linguagem server-side – deve ser instalado em um servidor com suporte à linguagem em que foi escrito o aplicativo.

Especificamente no caso desta pesquisa, um sistema desse tipo torna mais simples o trabalho de registro de ideias e atividades durante os períodos mais tumultuados de trabalho ao longo do semestre letivo, ainda que sua implementação tenha consumido um tempo considerável no período vago das férias acadêmicas.

A instalação e customização do sistema foi relativamente simples, mas o processo de seleção envolveu aprender sobre o funcionamento de cada CMS e sobre seus temas e extensões disponíveis; além de diagramá-lo, editando todos os elementos do tema numa folha de estilo. À seguir descrevo cada elemento desse processo:

1. Processo de seleção

As únicas exigências iniciais a orientarem a seleção foram: 1. o sistema escolhido deveria poder ser instalado em um servidor próprio (alguns sistemas oferecem o CMS só como parte de um serviço hospedado no servidor da empresa), exatamente para que pudesse ser customizado no nível do código, se necessário. 2. o sistema deveria ser de código aberto e gratuito. 3. O sistema deveria ser simples de customizar, para que pudesse ser moldado na estrutura vista nesta página – estradas de dados datadas em ordem crescente e em uma só página; e um cabeçalho com um índice de títulos que dão acesso às respectivas entradas quando clicados. Os sistemas avaliados no processo:

O sistema da WordPress – que oferece tanto o sistema quanto o serviço e é um CMS com ênfase em blogs – apareceu em primeiro lugar nas buscas, junto com os igualmente famosos Joomla! e Drupal – com capacidade para criar e gerir portais inteiros. Depois de uma breve avaliação inicial os três aparentaram ser mais complexos do que o necessário, o dificultaria a tarefa de customizá-los já que supostamente eu teria que compreender um grande volume de código PHP/SQL, incluindo interações as complexas entre as muitas partes.

A seguir encontrei o sistema de publicação de notícias SNews que, em si, é simples e elegante. Tem poucos arquivos (2, salvo engano) e é fácil de instalar. No entanto,  após perder algum tempo investigando os arquivos do sistema descobri que customizá-lo seria uma tarefa custosa já que o código, empilhado nos poucos arquivos existentes, não é muito autoexplicativo e as dependências entre as funções não ficam claras como deveriam em um código bem escrito e comentado. Quando tentei customizá-lo de acordo com minha compreensão, erros completamente imprevisíveis surgiam na visualização da página. Piorando a situação, a documentação oficial é escassa e a comunidade de suporte (fórum, comentários em blogs de terceiros, etc) não é desenvolvida e o sistema não é atualizado desde 2011.

Com a preocupação da customização em mente e sem achar substitutos viáveis para o SNews, descobri os frameworks de desenvolvimento rápido de aplicativos para web em PHP. Descobri que o Yii e o CodeIgniter eram indicados para usuários com conhecimento médio e achei que esta combinação de flexibilidade e relativa simplicidade pudesse resolver a questão da customização. Imaginei que houvessem bibliotecas extras, escritas por usuários, que implementassem funcionalidades extras sem que muitas linhas de código tivesse que ser escritas.
Depois de investir um bom tempo tentando instalá-los e de escrever (na verdade copiar) os primeiros programas simples sugeridos como exemplos na documentação, descobri que não haviam bibliotecas escritas por usuários e que eu teria que investir muito tempo inventando funcionalidades necessárias a partir do zero. Conclui que meu conhecimento sobre PHP e MYSQL está abaixo de do que é considerado médio e desisti dos tais frameworks também.

2. Escolha

Depois da trajetória tortuosa de aprendizado e eliminação de opções, voltei ao início da minha busca e tentei uma instalação do sistema WordPress. O resultado impressionou bastante. Apesar de ser um sistema altamente complexo, é extremamente bem escrito, e tem todas as funcionalidades bem compartimentadas. Tem uma documentação online farta, uma comunidade ativa e vasta, muitas extensões escritas por usuários e adicionam funcionalidades importantes com extrema facilidade.
Meu tempo pôde ser bem gasto apenas com as customizações necessárias: no tema – ou seja, na estrutura PHP das páginas (principal e a que mostra imagens individuais) e na folha de estilo – nas extensões – que precisaram ser escolhidas, testadas e também precisaram de algumas modificações. Mesmo assim, a abundância de fontes de informação e exemplos foram grandes facilitadores da tarefa.

Na imagem à esquerda detalho o funcionamento da página principal modificada (o original pode ser visto na página do desenvolvedor). A página principal organiza a ordem de execução dos arquivos PHP, criando a estrutura básica da página: cabeçalho, corpo e rodapé.
O cabeçalho é carregado pelo arquivo header.php, que visualmente é responsável apenas por carregar o título da página, lendo-o do banco de dados e desenhando-o no navegador. Mas estruturalmente é responsável por outros passos estruturais importantes, como criar o cabeçalho HTML <head> e abrir a tag <body>, além de carregar a folha de estilo e parte dos scripts necessários para o funcionamento da página.
O arquivo loop.php é responsável por ler do banco de dados o título, o conteúdo e a data de publicação de cada uma das entradas e desenhá-las numa ordem pré-determinada (que pode ser alterada, como discutirei adiante.). No caso desta página, acrescentei ainda um loop menor no mesmo arquivo, que é executado antes do principal e serve para criar a tabela índice, a partir dos títulos e datas de publicações das entradas.
Por último, footer.php exibe um texto com créditos e licenças do próprio CMS e dos scripts e extensões de terceiros usados. Também é responsável por fechar a tag <body> e por carregar os scripts de fim de página.

Além da página visível, gerada para a interação do conteúdo com o usuário, o sistema conta com uma interface administrativa com muitos recursos (imagem à direita), onde um administrador pode expandir gerir e criar conteúdos intuitivamente, enriquecido-os com textos, imagens, galerias de imagens, vídeos e aplicativos em flash.

3. Aplicação em outras áreas do projeto?

O resultado do investimento foi bastante satisfatório, com uma redução drástica no tempo necessário para atualização do conteúdo. Com a experiência adquirida, é possível adequar a solução à outra área do site cuja atualização é problemática: os registros de desenvolvimento dos dispositivos. Atualmente, cada uma das sub páginas – exibidas quando um qualquer um dos links da página principal são acessados – ou precisa ser montada manualmente, com diagramação via HTML, no caso de serem poucas imagens; ou é uma cópia de um sistema PHP open source de exibição de fotos – que é eficiente e simples se a intenção for montar uma galeria, mas começa a ficar complexo, se você precisar mudar o título da página ou acrescentar informações em cada uma das imagens ou mesmo outros tipos de mídias, como vídeos por exemplo.

Hoje executei os dois primeiros testes envolvendo comunicação entre um computador e um Arduino, usando a combinação de aplicativos e extensões Rhinoceros + Grasshopper + Firefly.

Antes de tudo, é necessário instalar o firmware na placa, de acordo com as instruções oferecidas na página do desenvolvedor.

Foram testes simples, desenhados para me familiarizar com o processo:

1. Básico

No primeiro experimento, a o objetivo foi piscar um LED, comandado pela interface do Grasshopper. Para tornar o problema mais interessante, resolvi criar um ritmo visual baseado no instrumento que marca o andamento do bolero de Ravel. O vídeo ao lado foi usado como referência, já que traduz o som do instrumento em elementos visuais, divididos em curtos (C) e longos (L), formando o seguinte padrão repetitivo:  L,C,C,C,L,C,C,C,L,L,L,C,C,C,L,C,C,C,C,C,C,C,C,C.

A imagem à direita mostra o arranjo de componentes usado na solução do problema descrito acima, com explicações sobre como usá-los no canto superior esquerdo da própria imagem ou do arquivo *.gh. Sobre o funcionamento da solução, a variável DPin13 do componente Uno Write recebe os valores controlados por um componente Blink que ao receber uma sequência de valores em milissegundos, alterna-os desligando (0) e ligando (1) o sinal nos tempos predeterminados. Essa sequência é gerada da seguinte maneira: o componente responsável por gerar os tempos de desligamento da sequência é o primeiro Weave. Nele estão ligadas listas com valores em milissegundos, a partir dos quais o usuário pode escolher. Notem também que um componente Panel – transformado numa lista de números inteiros pelo componente Split – pode ser modificado para customizar a ordem do padrão representados pelos nomes de variáveis em Weave. O segundo Weave, serve apenas para intercalar valores de tempos de acionamento do LED – também determinados por escolha do usuário a partir de uma lista –  com cada um dos valores de desligamento selecionados no primeiro Weave.

Uma variação interessante desse teste, poderia incluir a exploração os elementos no menu de audio do Firefly, que aparentemente disponibiliza ferramentas para capturar dados diretamente de fontes sonoras.

• Baixe o arquivo *.GH!

2. Detecção programática de sincronia entre três leds.

O experimento consiste em controlar três LEDs vermelhos, que recebem instruções de três temporizadores binários no Grasshopper. Esses temporizadores são acionados e desligados em intervalos regulares, mas diferentes entre si. Por exemplo, o primeiro LED é acendido a cada 200 milissegundos, o segundo a cada 100 e o terceiro a cada 300.

Quando, ao longo do tempo, os três intervalos se sincronizarem – e os três LEDs acendem ao mesmo tempo – um quarto LED verde também acende, refletindo a congruência dos sinais. O vídeo ao lado mostra o sistema em funcionamento no monitor e no circuito construído na protoboard. As imagens abaixo também representam as mesmas duas partes do sistema. Repare que há uma equivalência espacial e de cores entre os elementos digitais responsáveis pelos LEDs e a disposição dos LEDs na protoboard. No parágrafo seguinte explico cada uma das etapas com mais detalhe.

Foram usados os pinos digitais 12, 9, 8 e 3 do Arduino, além de um pino GND (terra). É possível vê-los tanto na imagem da tela do Grasshopper (ver elemento Uno Write) quanto na imagem do circuito.

Elementos Blink recebem um único intervalo de tempo equivalente à um ciclo de acendimento e apagamento. O valor do intervalo é selecionado pelo usuário em uma das Value Lists e então é dividido por dois pelo elemento A/B, já que o valor escolhido é a duração de um ciclo inteiro e depois da divisão obtemos a duração do ascendimento ou apagamento.

O elemento Eval é responsável por determinar as regras de acendimento do LED verde. Para fazer isso, esse componente precisa de:

• dois ou mais monômios que receberão valores de outros componentes.
• uma expressão condicional que avalie os valores dos monômios e determine uma resposta .

A expressão condicional pode ser fornecida de duas maneiras: digitada num elemento Panel e fornecida através de F ou digitada diretamente no elemento, através do item Expression Editor, acessível com um clique do segundo botão do mouse em F.

A expressão usada:

If((x=1) And (y=1) And (z=1), 1, 0)

Na linguagem VB.NET (adotada pelo Rhino e pelo Grasshopper), o If statement requer três variáveis para funcionar:

If(condição, ação se verdadeiro, ação se falso)

Ou seja, quando todos os valores dos LEDs fornecendo dados às variáveis 1, 2 e 3 do componente Eval for forem simultaneamente 1 (HIGH ou ligado), 1 é a resposta retornada. Do contrário, se uma ou todas as variáveis forem 0 (LOW ou desligado), o LED verde permanece desligado, porque a resposta retornada por Eval é 0.

• Baixe o arquivo *.GH!

Depois da conversa com o orientador (registrada em outra entrada), decidimos que aumentar a amplitude dos movimentos do dispositivo 01 seria uma das modificações necessárias para que o experimento pudesse ser considerado completo.

Para isso, será necessário:

• Determinar, para cada um dos motores, qual a distância necessária que as hastes precisariam percorrer para que cada um dos segmentos do dispositivo possam alcançar as posições máximas e mínimas desejadas.
• Identificar se os motores têm mecanismos de trava – físicas ou eletrônicas – e determinar uma estratégia para removê-las – modificando os chassis, circuitos controladores e engrenagens.
• Observar como os motores DC transmitem os giros até as hastes, para que novas hastes possam ser criadas e substituir o sistema de movimentos limitados das hastes originais.

Documentei os diversos aspectos internos observáveis dos três motores na página de registro de versões do dispositivo:

À partir desses dados, é possível tentar traçar estratégias para alcançar o resultado desejado.

Depois de criar esta página – o registro de ideias e atividades – a partir do sistema de gerenciamento de conteúdo da WordPress, percebi que seri um ótimo investimento desenvolver um sistema semelhante para substituir a página antiga de registro de desenvolvimento dos dispositivos.

O requerimento para o sistema de registro de dispositivos é:

• uma página principal que exibe:
  • informações básicas, comum à todas as versões do dispositivo (material base, motores, etc.)
  • um diagrama de árvore de versões, que divida o dispositivo em partes e que permita identificar alterações da versão com facilidade.
• sub páginas, contendo informações sobre cada um dos elementos separados em cada uma das versões do dispositivo, acessíveis pelos elementos do diagrama de árvore.

A página antiga rapidamente se tornou difícil demais para atualizar, depois de apenas algumas versões do dispositivo.

Primeiro porque, para atualizá-la, era necessário editar ou criar o código HTML da página manualmente. Na página principal, por exemplo, as atualizações incluíam escrever o código dos espaçamentos iniciais, de cada um dos ramos do novo diagrama e dos módulos contendo as partes do dispositivo – que inclui orquestrar o nome de imagem e do link para a sub-página. Com o volume de código crescente, esse sistema estava sujeito à muitos erros e desperdício de tempo.

Segundo porque descobriu-se que o número de partes mostradas em cada um dos elementos de versão precisavam variar, logo, novamente, um método mais flexível e menos trabalhoso de atualizar traria grandes vantagens.

Desenvolvimento da nova página

O ponto de partida para o desenvolvimento do novo sistema foi um clone do que já havia sido desenvolvido para esta página.

Na página principal, no entanto, ao invés de exibir a tabela com os índices das entradas seguido de todas as entradas enfileiradas em ordem cronológica. Para isso foi necessário customizar o sistema, acrescentando funções que gerassem um diagrama de árvore na tela automaticamente, a partir de dados estruturados em um XML. O diagrama abaixo mostra como funciona a implementação dessas características (no fim desta entrada, todo o código está disponível na íntegra):

1. A função customizada  buildVersionTree(), de functions.php, é chamada na página principal index.php.
2. Em functions.php o arquivo *.xml é importado na variável $xml.
3. function.php também importa as funções do arquivo treeBuilder.js, responsável por gerenciar o sistema de anotações das versões, que é basicamente uma caixa de texto que pode ser expandida e novamente escondida.
4. Usando os dados importados do *.xml e o conteúdo de treeBuilder.js, a função interna printTree(), o arquivo gera toda a estrutura do que deve ser desenhado na tela, incluindo imagens, links e funcionalidades implementadas em JavaScript; e passa a informação à index.php para que tudo possa ser desenhado na tela.

Mas o processo que foi realmente beneficiado pelas vantagens nativas do sistema WordPress foi a criação de sub-páginas – ou seja, das páginas individuais, que contêm informação específica de cada uma das partes de uma versão específica do dispositivo. Com a interface administrativa amigável, os inúmeros documentos que deverão ser criados podem ser facilmente diagramados, armazenados e atualizados com rapidez.

Abaixo estão os as linhas de código escritas por mim no processo de customização da página principal. O código é livre e pode ser usado sem nenhum tipo de permissão:

<?php buildVersionTree(); ?>

/**
 * ...
 * @author Stefano Mega
 */

/*TRACE: acrescentar o parágrafo <p id="inner"></p> em <body></body>
usar no javascript: document.getElementById('inner').innerHTML = WHATEVS;*/

//Armazena o comprimento do elemento 'versao' sendo atualmente manipulado.
var divVersaoWidth = 0;
// valor da altura minima das linhas que conectam elementos 'versao'.
var divShrunkHeight = '10px';
// largura dos divs contendo linhas conectoras de elementos 'versao'.
var divsWidth = '20px';

var endereco = 'http://www.stefanomega.com.br/tfg/regDisp01/wp-content/themes/bare/';

// usada na criação da página, para controlar o tamanho da div 'notas'.
function changeNotasWidth(divVersionID) {
	/*calculando o novo comprimento da div 'notas': comprimento total da div 'versao', menos o espaço ocupado
	  pelas divs com linhas de concção à esquerda.*/
	var newWidth = (divVersaoWidth - document.getElementById('downDiv_' + divVersionID).offsetWidth) + 'px';
	document.getElementById('notas_'.concat(divVersionID)).style.width = newWidth;
}

function changeNotasLink(divVersionID, maisOuMenos) {
	var divNotasLink = document.getElementById('notasLink_' + divVersionID);
	var divContentMais = String('<a href="javascript:switchVisibility(\'' + divVersionID + '\');"><img src="' + endereco + 'images/mais.gif"> notas</a>');
	var divContentMenos = String('<a href="javascript:switchVisibility(\'' + divVersionID + '\');"><img src="' + endereco + 'images/menos.gif"/> notas</a>');
	if(maisOuMenos == 'mais') { divNotasLink.innerHTML = divContentMais; }
	else if (maisOuMenos == 'menos') { divNotasLink.innerHTML = divContentMenos; }
}

//função usada pelos links 'notas', para fazer a div com as notas sumir/aparecer, além de ajustar as linhas de coneção.
function switchVisibility(divVersionID) {
	divVersaoWidth = document.getElementById('versao_' + divVersionID).offsetWidth;
	// localizando a div 'notas' em questão.
	var divNotas = document.getElementById('notas_'.concat(divVersionID));
	// localizando a div contenedora de todas as divs que precisam ser alongadas quando o texto 'notas' aparecer.
	var downDiv = document.getElementById('downDiv_'.concat(divVersionID));
	if (divNotas) {
		// a cada clique, trocar o fragmento do nome da classe do div 'notas' para o oposto (hidden <-> unhidden)
		divNotas.className=(divNotas.className=='notas hidden')?'notas unhidden':'notas hidden';
		// ajustar a largura da div de notas.
		if( divNotas.className=='notas unhidden') { changeNotasWidth(divVersionID); changeNotasLink(divVersionID, 'menos'); }
		else if (divNotas.className=='notas hidden') { changeNotasLink(divVersionID, 'mais'); }
	}
	if (downDiv) {
		/*calculando a altura necessária das novas linhas, com base na altura da div 'notas'.
		  15 é o valor das margens, não computadas por 'offsetWidth.*/
		var newHeight = (divNotas.offsetHeight + 14)+'px';
		// a cada clique, trocar o fragmento do nome da classe do div 'downDiv' para o oposto (shrunk <-> unhidden)
		downDiv.className=(downDiv.className=='downDiv shrunk')?'downDiv extended':'downDiv shrunk';
		// atribuindo a altura correta a cada um dos estados.
		if(downDiv.className == 'downDiv shrunk') { downDiv.style.height = divShrunkHeight; }
		else if(downDiv.className == 'downDiv extended') { downDiv.style.height = newHeight; }
	}
}

<?xml version="1.0" encoding="utf-8" ?>
<dispositivo>
	<!-- 1.0-->
	<versao	numero="1.0" cor="#333">
		<notas><![CDATA[
		
		Lista descrevendo as modificações da versão. Aceita tags HTML, graças à marcação CDATA usada.
		
		]]></notas>
		<modulos>
			<modulo cor="#000000">
				<parte id="string_identificadora_da_parte" usarVersao=""> <!-- quando uma parte está sendo reutilizada, é necessário preencher o 'id' da parte original e informar em que versão foi originalmente usada -->
					<nome>Nome da parte, formatado para leitura humana.</nome>
					<link>http://www.endereco.eletrônico.da.sub-pagina.da.parte.com.br</link> <!-- se sub-página tiver a mesma string identificadora, basta escreve 'id', sem as aspas -->
				</parte>
				<!-- acrescentar quantas <parte></parte>s forem necessárias -->
			</modulo>
			<!-- acrescentar quantos <modulo></modulo>s forem necessários -->
	</versao>
	<!-- acrescentar quantas <versao></versao>s forem necessárias -->
</dispositivo>

# MINHAS FUNÇÕES ! !----------------------------------

# endereço básico (exigido pelo folder da wordpress)
$endereco = 'http://www.stefanomega.com.br/tfg/regDisp01/wp-content/themes/bare/';
# carregando o arquivo XML.
$xml = simplexml_load_file("http://www.stefanomega.com.br/tfg/regDisp01/wp-content/themes/bare/disp01.xml");
# array associando as versões com os índices no XML
$xmlIndex = array();
# array contendo nomes das partes como índice e um array multidimensional dos índices de parte e módulo.
$namesIndex = array();

function setHierarchy() {
	global $xml;
	
	# array com elementos XML convertidos no formato $child => $parent.
	$return;
	# [ACRESCENTAR UMA FUNÇÃO DE SORT, PARA O CASO DE AS VERSÕES NÃO ESTAREM EM ORDEM]
	foreach($xml as $xmlVersao) {
		# valor local da versão.
		$versao = (string) $xmlVersao['numero'];
		# elimina zeros à direita
		if ((int) substr($versao, -1) == 0) { $versao = substr($versao, 0, -2); }
		# criando um valor para child e parent.
		$child = $versao;
		if (strlen($child) == 1) { echo $parent = null; }
		else if (strlen($child) > 1) { $parent = substr($xmlVersao['numero'], 0, -2); };
		# acomodando child e parent no array para retorno.
		$return[$child] = $parent;
	}
	return $return;
}

# associa o número das versões com um índice no XML
function getXMLIndex() {
	global $xml;
	global $xmlIndex;
	
	# indice, incrementado a cada iteração do loop.
	$i = 0;
	
	foreach($xml as $xmlVersao) {
		# valor local da versão.
		$versao = (string) $xmlVersao['numero'];
		# acomodando child e parent no array para retorno.
		$xmlIndex[$versao] = $i;
		$i++;
	}
}

# associa o nome das partes seus índices e com os índices do modulos contenedores
function getNamesIndex() {
	global $xml;
	global $namesIndex;
	
	foreach($xml as $versao) {
		$i = 0;
		foreach($versao->modulos->modulo as $modulo) {
			$j = 0;
			foreach($modulo->parte as $parte) {
				if ($parte['usarVersao'] == "") {
					$nomeParte = (string) $parte['id'];
					$namesIndex[$nomeParte] = array(
						'modulo' => $i,
						'parte' => $j
					);
				}
				$j++;
			}
			$i++;
		}
	}
}

function parseTree($tree, $root = null) {
	$return = array();
	# Traverse the tree and search for direct children of the root
	foreach($tree as $child => $parent) {
		# A direct child is found
		if ($parent == $root) {
			# Remove item from tree (we don't need to traverse this again)
			unset($tree[$child]);
			# Append the child into result array and parse its children
			$return[] = array(
				'name' => $child,
				'children' => parseTree($tree, $child)
			);
		}
	}
	return $return;    
}

# cria as divs necessárias para alinhar verticalmente elementos, já que a linguagem não tem suporte nativo.
function createVerticalAlignment($content)
{
	return '<div class="verticalFora"><div class="verticalDentro">' . $content . '</div></div>';
}

# adicionando as linhas principais que conectam os módulos de versões
function createUpDivs($versao) {
	global $xmlIndex;
	# declarando a string de retorno
	$return = "";
	# decompondo a versão em inteiros separados em um array
	$versionChars = explode('.', $versao);
	# determinando o número de espaços necessários para linhas conectoras
	$divs = count($versionChars) - 1;
	$i = 1;
	#garantindo que a versão X.0 não gere linhas de conecção.
	if (substr($versao, -1) != 0) {
		# avaliando a estrutura da árvore e criando as divs apropriadas
		while ($i <= $divs) {
			# string que conterá as versões hipotéticas sucessoras a serem procuradas.
			$versaoTeste = "";
			$j = 0;
			# criando as versões sucessoras hipotéticas para serem procuradas.
			while ($j <= $i) {
				if ($j < $i) {
					$versaoTeste .= $versionChars[$j] . '.';
				} else if ($j == $i) {
					$versaoTeste .= (string) ($versionChars[$j] + 1);
				}
				$j++;
			}
			/*desenhando tipos diferentes de linhas conectoras (entre versões antecessoras, a presente e
			  sucessoras), dependendo da existência ou não versões sucessoras. Se a ligação cogitada estiver
			  num ramo direto, a linha pode ser em L ou em T, dependendo da existência de versões sucessoras.
			  Se for de outros ramos, podem ser em I ou vazias.*/
			if ($i < $divs) {
				if (array_key_exists($versaoTeste, $xmlIndex)) { $return .= '<div class="I"></div>'; }
				else if (!array_key_exists($versaoTeste, $xmlIndex)) { $return .= '<div class="N"></div>'; }
			} else if ($i == $divs) {
				if (array_key_exists($versaoTeste, $xmlIndex)) { $return .= '<div class="T"></div>'; }
				else if (!array_key_exists($versaoTeste, $xmlIndex)) { $return .= '<div class="L"></div>'; }
			}
			$i++;
		}
	}
	
	return $return;
}

#adicionando as linhas secundárias (extensoras) que conectam os módulos de versões.
function createDownDivs($versao) {
	global $xml;
	global $xmlIndex;
	# declarando a string de retorno. Começa com a tag de abertura da div contenedora.
	$return = '<div><div class="downDiv shrunk" id="downDiv_' . str_replace(".", "_", $versao) . '" >';
	# decompondo a versão em inteiros separados em um array
	$versionChars = explode('.', $versao);
	# determinando o número de espaços necessários para linhas conectoras
	$divs = count($versionChars) - 1;
	
	$i = 1;
	
	#garantindo que a versão X.0 não gere linhas de conecção de passagem, com ascendentes e descendentes.
	if (substr($versao, -1) != 0) {
		# avaliando a estrutura da árvore e criando as divs apropriadas
		while ($i <= $divs) {
			# string que conterá as versões hipotéticas sucessoras a serem procuradas.
			$versaoTeste = "";
			$j = 0;
			# criando as versões sucessoras hipotéticas para serem procuradas.
			while ($j <= $i) {
				if ($j < $i) {
					$versaoTeste .= $versionChars[$j] . '.';
				} else if ($j == $i) {
					$versaoTeste .= (string) ($versionChars[$j] + 1);
				}
				$j++;
			}
			/*desenhando tipos diferentes de linhas conectoras entre módulos, que extendem as ligações
			  forjadas em createDownDivs(). Como só extendem linhas existentes, limitam - se a ligações do
			  tipo I ou vazias.*/
			if ($i <= $divs) {
				if (array_key_exists($versaoTeste, $xmlIndex)) { $return .= '<div class="I2" ></div>'; }
				else if (!array_key_exists($versaoTeste, $xmlIndex)) { $return .= '<div class="N2" ></div>'; }
			}
			$i++;
		}
	}
	
	# averiguando a existência de versões derivadas diretamente e criando as ligações, se necessário
	$versaoTeste = $versao . ".1";
	$zero = (int) substr($versao, -1);
	if ( $zero == 0 ) { $return .= '<div class="I2" ></div>'; }
	else if (array_key_exists($versaoTeste, $xmlIndex)) { $return .= '<div class="I2" ></div>'; }
	
	#fechando a div contenedora
	$return .= '</div></div>';
	
	#criando a div que receberá as notas da versão
	$return .= '<div class="notas hidden" id="notas_' . str_replace(".", "_", $versao) . '">' . $xml->versao[$xmlIndex[$versao]]->notas . '</div>';
	
	return $return;
}

function setParteLink($valorTagLink, $id="", $versao="")
{
	$return = "";
	$blogKey = str_replace("_", "-", $id) . "-" . str_replace(".", "-", $versao);
	if ($valorTagLink == 'id') { $return = 'href="http://www.stefanomega.com.br/tfg/regDisp01/'. $blogKey . '"'; }
	else if ($valorTagLink != 'id') {
		$isLocalServer = substr($valorTagLink, 0, 29);
		if ($isLocalServer == 'http://www.stefanomega.com.br') { $return = 'href="' . $valorTagLink . '"'; }
		else if ($isLocalServer != 'http://www.stefanomega.com.br') { $return = 'href="' . $valorTagLink . '" target="_blank"'; }
	}
	return $return;
}

function buildVersion($i) {
	global $xml;
	global $xmlIndex;
	global $namesIndex;
	global $endereco;
	
	# declarando a string de retorno
	$return = "";
	
	# abrir div geral e criar o módulo com a versão e o módulo com o dispositivo completo.
	$return .= 
	'<div class="parteVersao" style="background-color:'. $xml->versao[$i]['cor'] .';">'
		. createVerticalAlignment('v'. $xml->versao[$i]['numero']) .
		'<div class="notasLink" id="notasLink_' . str_replace(".", "_", $xml->versao[$i]['numero']) . '">
			<a href="javascript:switchVisibility(\'' . str_replace(".", "_", $xml->versao[$i]['numero']) . '\');"><img src="' . $endereco . 'images/mais.gif"/> notas</a>
		</div>
	</div><div class="parteFim" style="border-color:'. $xml->versao[$i]['cor'] .';"> <a '. setParteLink('id', 'dispositivo', $xml->versao[$i]['numero']) .'> <img src="' . $endereco . 'images/thumbs/' . $xml->versao[$i]['numero'] . '_dispositivo.jpg" title="dispositivo ' . $xml->versao[$i]['numero'] . '"/></a></div>';
	
	# criar o restante dos módulos.
	foreach($xml->versao[$i]->modulos->modulo as $modulo) {
		# total de partes no atual módulo.
		$partes = count($modulo);
		$j = 0;
		$jSemDivisor = 0;
		
		while ($j < $partes) {
			# se houver apenas uma parte
			if ($partes == 1) { $tipoModulo = "parteCompleta"; }
			# se for a primeira parte de uma série
			else if ($j == 0) { $tipoModulo = "parteInicio"; }
			# se for a última parte de uma série
			else if ($j == ($partes -1)) { $tipoModulo = "parteFim"; }
			# se forem partes intermediárias de uma série
			else { $tipoModulo = "parteMeio"; }
			
			# desenhando a parte do módulo.
			$moduloChildren = $modulo->children();
			if ($moduloChildren[$j]->getName() == 'divisor') {
				$return .= '<div class="parteDivisora" style="border-color:'. $modulo['cor'] .'; background-color:'. $modulo['cor'] .'; " >'. createVerticalAlignment($moduloChildren[$j]) .'</div>';
			} else {
				# averiguar se há instruções para usar parte de versões anteriores
				if ($modulo->parte[$jSemDivisor]['usarVersao'] == "") {
					$return .= '<div class="'. $tipoModulo .'" style="border-color:'.  $modulo['cor'] .';" ><a '. setParteLink($modulo->parte[$jSemDivisor]->link, $modulo->parte[$jSemDivisor]['id'], $xml->versao[$i]['numero']) .'><img src="' . $endereco . 'images/thumbs/' . $xml->versao[$i]['numero'] . '_' . $modulo->parte[$jSemDivisor]['id'] . '.jpg" title="' . $modulo->parte[$jSemDivisor]->nome . '" /></a></div>';
					
				} else if ($modulo->parte[$jSemDivisor]['usarVersao'] != "") {
					$versaoAntiga = (string) $modulo->parte[$jSemDivisor]['usarVersao'];
					$iVersaoAntiga = $xmlIndex[$versaoAntiga];
					$idAntigo = (string) $modulo->parte[$jSemDivisor]['id'];
					$iModuloAntigo = $namesIndex[$idAntigo]['modulo'];
					$iParteAntiga = $namesIndex[$idAntigo]['parte'];
					$moduloAntigo = $xml->versao[$iVersaoAntiga]->modulos->modulo[$iModuloAntigo];
					$parteAntiga = $moduloAntigo->parte[$iParteAntiga];
					$return .= '<div class="'. $tipoModulo .'" style="border-color:'.  $moduloAntigo['cor'] .';" ><a '. setParteLink($parteAntiga->link, $parteAntiga['id'], $versaoAntiga) .'><img class="transparente" src="' . $endereco . 'images/thumbs/' . $versaoAntiga . '_' . $parteAntiga['id'] . '.jpg" title="' . $parteAntiga->nome . ' (v.' . $versaoAntiga . ')" /></a></div>';
				}
				$jSemDivisor++;
			}
			$j++;
		}
	}
	return $return;
}

function printTree($tree) {
	global $xmlIndex;
	
	foreach($tree as $node) {
		$versao = (string) $node['name'];
		
		# se é o primeiro elemento, re-acrescentar o .0 a direita. Recuperando o índice da versão no XML.
		if (strlen($node['name']) == 1) {
			$versao .= ".0";
			$indiceVersao = (int) $xmlIndex[$versao];
		}
		# 
		else {
			$indiceVersao = (int) $xmlIndex[$node['name']];
		}
		
		# criando o código HTML
		echo 
		'<div class="versao" id="versao_' . str_replace(".", "_", $versao) . '">'
			. createUpDivs($versao) . buildVersion($indiceVersao) . 
			'<div class="breaker"></div>'
			. createDownDivs($versao) . 
		'</div>
		<div class="breaker"></div>';
		printTree($node['children'], $xmlIndex);
	}
}

function buildVersionTree() {
	global $xmlIndex;
	# array contendo todos os pares de relações, no formato child (key) => parent (value). 
	$treeXML = setHierarchy();
	# array associando as versões com os índices no XML
	getXMLIndex();
	# array contendo nomes das partes como índice e um array multidimensional dos índices de parte e módulo.
	getNamesIndex();
	# array multidimensional, contendo a árvore em si.
	$tree = parseTree($treeXML);
	# desenha a árvore na tela.
	printTree($tree);
}

Apenas os dois motores que controlam o antebraço (Bosch) e o punho (Mes) precisarão de ajustes na haste. A evolução da compreensão sobre o funcionamento de ambos os motores está registrada nas respectivas entradas da página sobre o registro de desenvolvimento do dispositivo 01 , como já citado em outra entrada.

Determinação da amplitude de movimento:

Os estudos abaixo foram feitos para determinar o comprimento necessário da nova haste (as atuais deslocam-se apenas 8mm), baseado na projeção da amplitude angular máxima de movimento.

Desenvolvimento das novas hastes e engrenagens auxiliares:

Estudando o funcionamento das engrenagens de redução dos atuadores, foi possível compreender o mecanismo de expansão e contração dos motores, como mostram as duas imagens abaixo, elaboradas para a página do registro de versões do dispositivo 01:

Bosch	Mes

Apenas as engrenagens que estão em contato imediato com as hastes (além das próprias hastes) precisarão ser fabricadas, já que são responsáveis pelo deslocamento da haste e precisam ser maiores.
No caso do motor Bosch, a engrenagem externa gira ao redor da haste, arrastando-a para frente e para trás. A haste não gira.
No motor Mes a engrenagem externa não gira (vista acompanhando a haste na imagem acima) e nesse sentido é como se fosse parte da haste, ou seja, podem ser fabricadas em uma só peça.

Seguindo a orientação do Prof. Arthur, as novas hastes e engrenagens serão fabricadas a partir de barras de polímero (nylon) desbastadas no torno e, em casos onde houver a necessidade de uma rosca interna as peças serão fabricadas em duas metades, na fresadora ou na router – com o auxílio de um funcionário, já que são máquinas que ainda não domino.

Os desenhos abaixo mostram as diferentes etapas do projeto, desde as primeiras medições, até uma simulação de funcionamento que mostra que a amplitude determinada como ideal no primeiro estudo foi implementada.

Motor	Original	Projeto	Partes	Simulação

Assim como a primeira pré-banca, a segunda também transcorreu surpreendentemente bem, contrariando todas as previsões catastrofistas do meu nervosismo característico.

O arquivo PDF da apresentação está disponível no servidor: http://www.stefanomega.com.br/tfg/preBancaTFG2.pdf

Dentre os tópicos mais importantes debatidos, estão:

1. O desenvolvimento das páginas de registro, a partir do sistema de gerenciamento de conteúdo da WordPress.:
   • Registro cronológico de ideias e atividades
   • Registro do dispositivo 01
2. A lentificação temporária do desenvolvimento de dispositivos por causada pela implementação dos sistemas citados acima e pelo tempo gasto com o registro do material acumulado no primeiro semestre de trabalho, que estava na forma de fragmentos (e-mails, memórias, vídeos e imagens em lugares diferentes).
3. O atraso que os itens acima provocaram na leitura da bibliografia proposta no início do TFG.
4. O grande progresso pessoal no entendimento de eletrônica.
5. A dificuldade de terminar o dispositivo 01. Razões:
   • atuadores de farol tinham documentação escassa
   • falta de conhecimento em eletrônica
   • pelas razões descritas acima, houve dificuldades para usar os motores com o Arduino. Foram feitos projetos de circuitos auxiliares – que no fim das contas foram descartados -, quando finalmente decidimos adaptar o motor, mas foi necessário criar hastes mais longas, de projeto e execução extremamente complexos.
6. O início do dispositivo 02: se deve ou não ser iniciado.

Segundo a programação o mês de maio deve ser usado para concluir a monografia, já que será necessário imprimi-la para que os membros da banca possam lê-la com algumas semanas de antecedência. Abaixo, o calendário com o tempo restante e a programação.

Ao final da apresentação Prof. Camila D’Ottaviano – responsável pelo atendimento metodológico do meu trabalho na disciplina de TFG – ressaltou que, apesar de não ter muito como avaliar o trabalho, por falta de conhecimento técnico, ficou satisfeita com o progresso e novamente recomendou que uma postura crítica em relação ao uso da tecnologia fosse adotada ao final do experimento, na monografia.
Recomendou também que:

• não iniciássemos o desenvolvimento do dispositivo 2, já que o primeiro consumiu tanto tempo para chegar a esse patamar;
• o dispositivo 1 fosse concluído e que, caso sobrasse tempo, concordou que alguns experimentos poderiam ser feitos.

Respondi que o impasse seria resolvido em conversa com o orientador, mas concordei que precisávamos rapidamente traçar uma estratégia de aproveitamento do tempo restante.

Quando desenvolvi a garra para o dispositivo 01 e a luminária paramétrica, percebi que o processo de corte à laser consome parte do material. Apesar de não ter uma ferramenta física – uma fresa, broca, etc. – atuando, essa técnica trabalha com a queima controlada do material através de um feixe de laser concentrado e é inevitável que algum material se perca.

A garra foi cortada sem qualquer tipo de compensação dimensional e por isso ficou ligeiramente menor do que o necessário. Em modelos de arquitetura isso não seria um problema já que, mesmo que tenha partes articuladas, seu propósito é de mera visualização. A garra, no entanto, é o produto final e deve funcionar sem folgas entre as partes.

No caso da luminária já houve uma tentativa de compensar a queima do material, baseado no dado fornecido pelo técnico do laboratório: perde-se .03 mm na dimensão total, ou seja, .015mm em cada borda. No entanto as leituras dimensionais feitas depois do corte não corresponderam ao desejado, havendo inclusive variações na perda de material entre as diversas geometrias de corte: ortogonal, diagonal e curvo. As partes da luminária precisaram ser encaixadas com golpes de uma marreta de borracha.

Surgiu a ideia de desenhar um ensaio que permitisse determinar com precisão qual a quantidade de material perdida para cada uma das geometrias de corte.

Infelizmente a máquina DS4 que me habituei a usar antes das férias não está operacional, graças a um alagamento que houve no laboratório em janeiro e inutilizou o sistema de refrigeração hidráulica. Até o momento,  não há previsões de concerto. A solução é usar a cortadora a laser menor, da marca Universal Laser Systems.

A imagem abaixo mostra o desenho feito no DraftSight. Repare nas linhas diagonais, curvas e ortogonais, correspondentes às geometrias de corte a serem testadas. Cada um dos números observados nas peças representa o ajuste feito em suas bordas para compensar o desbaste da máquina. Se o dado inicial era .03cm, 7 peças no intervalo entre 0 e .15cm me pareceram um bom grupo de teste.

Abaixo estão as imagens dos testes possíveis entre as duplas de peças. A ideia, além de obter a medida exata da perda de material, foi obter a melhor solução de encaixe empiricamente, que pode não coincidir com as peças de maior exatidão.

Por hora não houve tempo de executar o teste adequadamente e o exemplo acima corresponde à peça 0, sem qualquer tipo de compensação dimensional. Quando o teste for feito, esta entrada será atualizada.

Registrando a estratégia para o término do TFG discutida na reunião com o orientador.

Como o tempo restante é de aproximadamente 1 mês para concluir os experimentos práticos e terminar a monografia para que possa ser enviada para impressão com certa antecedência – já que é justo que os outros membros da banca tenham tempo suficiente para ler tudo -, decidimos que:

• Os experimentos com o dispositivo 01 estão oficialmente encerrados, já que executar as engrenagens com o nível de detalhe necessário consumiria mais tempo do que temos disponível. Além disso, uma base giratória precisaria ser desenvolvida e o novo controle dos motores existente – com firefly, arduino e shield – precisaria ser melhor elaborado.
• A melhor opção é começar o dispositivo 02, montado usando soluções prontas. Ou seja: com um bom kit de robótica e partes eletrônicas e motores adquiridos da empresa XBot, que fornece partes e robôs completos para as áreas de educação e entretenimento.
• Seguindo o a recomendação recebida durante a apresentação da pré-banca 2, decidimos começar a desenvolver a conclusão crítica da pesquisa, explorando projetos relevantes construídos com braços robóticos industriais. Se no final do trabalho o dispositivo 02 estiver pronto e se houver tempo para desenvolver experimentos que testam suas possibilidades, poderemos integrar o novo material à conclusão crítica preexistente.

Fui convidado pelo Prof. Arthur a fazer uma demonstração técnica sobre minha experiência com a operação digital de motores – através da interface do aplicativo Firefly (Uma extensão para o Grasshopper) intermediada por uma placa controladora Arduino -, para os alunos da disciplina optativa que o Prof. leciona (AUT2501) neste semestre.

Primeiro houve uma breve introdução sobre a interface e os componentes do Firefly e sobre o funcionamento das placas Arduino que seriam utilizadas. Na sequência uma pequena introdução ao funcionamento dos motores – um servo de 5V e um atuador linear de 12V – seguida da demonstração prática sobre a articulação entre o hardware e o controle digital – ou seja, a construção do sistema paramétrico no Firefly/Grasshopper.

Abaixo está o texto produzido para consulta dos alunos, contendo o registro detalhado da demonstração.

http://www.stefanomega.com.br/tfg/regCron/wp-content/themes/bare/files/firefly_stefano.pdf

O video abaixo foi gravado para mostrar para o Prof. Arthur o progresso do funcionamento do atuador linear no dia anterior à apresentação:

Hoje foi necessário escolher o material que viabilizará o desenvolvimento do segundo dispositivo no pouco tempo que temos disponível até o fim do semestre.
No início a ideia foi escolhermos um novo kit de robótica e criar um robô a partir da estrutura montada, escolhendo motores e fabricando quaisquer adaptações que fossem necessárias (como a garra do dispositivo 01).

O Prof. Arthur enviou por e-mail alguns links interessantes para que traçássemos uma estratégia.

Kits de Robótica

XBot – http://www.xbot.com.br/catalogo-educacional/
Fabrica e revende peças para montagem de robôs para competições escolares (luta, futebol, etc). Do catálogo, uma variedade de itens de interesse, como motores com redução, placas controladoras, drivers de motor, chassis, sistemas de controle por rádio, etc. Com a vantagem que a interação entre as partes vendidas estaria toda documentada, evitando imprevistos que consumiriam tempo caso estivéssemos comprando partes de fontes diversas.

Lab de Garagem – http://www.labdegaragem.org/loja/
Uma loja que já conhecíamos, mas que recentemente passou a vender uma variedade incrível de motores. Além de uma garra, que poderia ou não ser útil, que guardamos como possibilidade.

LDR – http://www.ldrrobotica.com.br/produtos
Empresa que faz kits de robótica para ensino. Têm um kit genérico, mas é enorme e muitas peças ficariam sem uso; além de outros kits menores, mas específicos, como por exemplo o kit de energia solar, o kit de hidráulica e o de energia eólica. Novamente o problema de peças que não nos seriam úteis.

Modelix – http://www.modelix.cc/pt-br/produtos/educacional/kits-escolares-combo
Kits de robótica escolares. Além de vigas, plataformas, cantoneiras e outras peças estruturais, os kits dessa marca vem com geradores solares, motores, sensores e uma porção de coisas que não seriam úteis para desenvolver o dispositivo 02.

Robôs

A seguir surgiu a ideia de procurar robôs prontos (ou quase), que dispensassem a necessidade de desenvolver e testar as soluções estruturais, economizando tempo.

Clickplus – http://www.clickplus.pt/pt/product/show_details/22495/Kit-Braco-Robotico-com-comando
Essa empresa portuguesa fabrica um pequeno braço robótico que já vem com um joystick integrado (que nos seria inútil) e não sei qual seria a dificuldade de integrá-lo ao computador para que pudesse ser controlado de outras maneiras. Além do mais a importação tomaria tempo demais!
Encontramos um exemplar no Mercado Livre, mas era muito caro além de todas as incertezas citadas.

Sci-Arm – http://www.xbot.com.br/educacional/sci-arm/
Braço fabricado pela empresa XBot, já citada acima.

Braço robótico de 7 servos – http://produto.mercadolivre.com.br/MLB-482419755-kit-braco-robotico-6-articulacoes-_JM
Um braço robótico fabricado em acrílico por um usuário do Mercado Livre. Funciona com Arduino e servos.

Escolha do robô

Como economizar tempo é essencial, concordamos que comprar um robô com partes mais prontas seria importante. O único excluído de imediato foi o Clickplus, de fabricação portuguesa, que é muito custoso (encontramos um exemplar sendo vendido no Brasil) e aparentemente difícil de adaptar.

O site do Sci-Arm fornece poucos dados sobre o produto e restaram dúvidas:

Vantagens:

1. Vem com fonte de alimentação 12V e cabo USB.
2. Todo o hardware vem montado. Grande economia de tempo.
3. Boa documentação e suporte online.

Desvantagens:

1. Como o hardware é fechado. Não foi feito pra ser desmontado/adaptado e isso provavelmente dificultará os ajustes necessários para posicionar o motor de fresagem.
2. Capacidade de, no máximo, 300g com o braço estendido.
3. Aplicativo próprio para controlar as articulações, individualmente ou em conjunto. Não fica claro se o programa é versátil o suficiente para interagir com outros aplicativos – com os quais já temos experiência -, além dos listados (labview e matlab)que já temos experiência. Do contrário teríamos que adquirir e treinar um novo software.

Analisando o robô de 7 servos do mercado livre:

Encontramos mais dados sobre o projeto do robô:

Uma página com mais detalhes: http://www.projetoespecial.com.br/?p=197
E um vídeo do robô funcionando: http://www.youtube.com/watch?v=9ID93yxAI7c

Vantagens:

1. É feito pra usar com Arduino e, portanto, dá pra usar o conhecimento acumulado (Firefly, Grasshopper, Arduino).
2. Já vem com o código necessário para que o Arduino reconheça os servos. Será necessário apenas adaptar o código fornecido ao firmware do Firefly.
3. Os 6 servos que o fabricante recomenda usar (MG995) para as articulações do braço têm um bom torque (10Kg/cm) e 5V de tensão. Por isso podem ser usados diretamente pelo Arduino, sem o intermédio de shields.

Desvantagens:

1. Vem só a estrutura, desmontada
2. Precisaremos fabricar a peça que recebe o motor da fresagem.
3. Demora 15 dias pra ser fabricado e enviado.
4. Preço: R$210 dos motores + R$290 da estrutura.

Conclusão

Por hora o robô de 7 servos parece ser a melhor opção, com mais vantagens e flexibilidade de design.

O Sci-Arm também parece uma boa opção, mas muitos dados estão faltando, como por exemplo o preço do produto.

Para fazer uma melhor avaliação das opções resolvemos visitar a empresa XBot para conhecer o Sci-Arm pessoalmente, obter mais informações e então optar.

Os servos indicados pelo fabricante na estrutura de robô que adquirimos são da marca TowerPro MG995.

Os dados sobre esse motor estão disponíveis na página do fabricante, complementados por medições minhas (marcados com #) e transcritos abaixo:

Fuçando no meu lixo eletrônico, encontrei uma fonte de 5.4V e 1A, que pertencia a um PalmOne antigo.
Removi o encaixe da saída de energia e uni os dois terminais à jumpers com uma das extremidades cortadas, para que a fonte possa ser usada nos pinos da protoboard e do Arduino com facilidade.

Infelizmente, após usar a fonte para medir a Corrente de serviço máxima – anotada na tabela acima – descobri que, nos picos de consumo dos motores, seriam necessários 2.4A e não os 700mA – uma estimativa inicial baseada em dados encontrados em páginas de fornecedores.

Abaixo o vídeo de dois servos funcionando com a fonte adaptada.

A definição do sistema no Grasshopper é idêntica à definição montada e explicada na demonstração para a disciplina AUT2501, com exceção de dois detalhes:

• As posições finais e iniciais – que correspondem às posições angulares do eixo do servo – do Number Slider são 1 e 160, ao invés de 0 e 180. Por alguma razão que desconheço (provavelmente por causa dos 0.4V a mais na fonte), os valores originais estavam causando comportamentos estranhos nos servos. Na posição final giravam mais do que os 180° desejáveis e na posição inicial alguns dos motores apresentaram um tipo de movimento convulsivo, que foi solucionado quando o primeiro algarismo da escala foi removido – sem consequências visíveis para a amplitude do movimento.
• Para controlar o segundo motor, decidi que seria interessante inverter o sentido do movimento angular. Para isso, usei um componente Subtraction, que e subtrai o valor atual do Number Slider do valor máximo possível; e um componente Addition para que a escala termine em 1 e não em 0. As duas operações acima transformam o valor lido na escala do Number Slider no valor proporcional equivalente na escala contrária, ou seja, a escala A vai de 0 ~ 160 e a escala B, de 160 ~ 1 e os valores em B são obtidos através da fórmula B = 161 – A.

No entanto, depois da descoberta dos picos de correntes de 400mA, fica claro que o próximo passo para que os 6 motores possam ser ligados simultaneamente e com segurança, será comprar uma fonte de 3A.

Hoje foi necessário visitar novamente a região da Santa Ifigênia para comprar materiais complementares da montagem do segundo dispositivo. A lista ao lado mostra todos os itens necessários.

• No item isolante contrátil mais fino, refiro-me ao material cujo nome técnico acabo de descobrir: tubos isolantes termorretráteis. Substitutos da fita isolante, são feitos por um material que encolhe quando uma fonte de calor é aplicada, amoldando-se ao conteúdo com um excelente acabamento à emenda.
• Entrada de fonte para protoboard é uma entrada de alimentação com pinos na parte inferior, compatíveis com as furações da protoboard. Servem para adaptar a alimentação de fontes com conectores cilíndricos (as mais comuns no mercado) à protoboard sem precisar mutilá-las, como aconteceu anteriormente.
• Acabamentos: servo / protoboard são conectores machos que, acoplados aos cabos de energia, criar interfaces elétricas mais confiáveis com os componentes citados.  No caso dos servos, são peças com três pinos, que se encaixam perfeitamente às saídas fêmeas dos motores. No caso de Arduinos ou protoboards são pinos únicos, como os vistos nos jumpers, ou pinos triplos, que respeitam o espaçamento das furações dos respectivos componentes.

Em posse da lista, voltei à loja Mult, onde já comprei materiais durante o desenvolvimento do dispositivo 01. Infelizmente – como descobri hoje – é extremamente difícil ser atendido aos sábados. O lugar fica mais cheio do que outros estabelecimentos vizinhos e os vendedores, comissionados e sobreatarefados, ficam completamente inacessíveis, principalmente a pessoas com compras mais modestas como a minha. Será necessário retornar na segunda.

Foi possível, no entanto, adquirir a fonte de 5V e 3A (que acabou sendo de 4A), por R$ 40,00. À esquerda está o cartão com o endereço e à direita, a imagem do componente. A vantagem é que essa fonte não precisa ser adaptada, já que sua interface elétrica consiste em 5 terminais (a nomenclatura está impressa em um adesivo na fonte, ampliado na imagem da direita) parafusados, nos quais poderei acoplar os fios que forem mais convenientes:

Hoje testei mais a fundo dois recursos para o Firefly, que usam o Kinect para captura de dados do usuário: o Kinect Skeletal Tracker e o Kinect Depth Stream associado ao Kinect Depth to Point.

A ideia é controlar a ferramenta na ponta do braço com gestos do usuário. Para isso são necessários dois pontos:

• o primeiro, na base da ferramenta, estipula a coordenada básica na área de trabalho do robô.
• um segundo ponto cria uma linha no espaço, que determina

Kinect Skeletal Tracker

Esse primeiro método de captura de dados é bastante prático, pois desvantagem: imprecisão. Marcações nos braços ajudariam? como nos casos de captura de animação digital para filmes e jogos.
Se não houvesse a necessidade de tanta precisão talvez fosse uma alternativa viável. Por exemplo, usar a coordenada Y da articulação do punho para mudar o valor numérico do motor. Quando o usuário trouxesse a mão para a direita da tela mais próximo do ângulo máximo o servo estaria; quanto mais à esquerda, mais próximo de 0.

[Depth Stream]

Com o entendimento do funcionamento das partes já adquirido – ou seja, com o conhecimento básico sobre como funcionam os sub-sistemas com Kinect e Firefly; Firefly, motores e Arduinos; e articulação das peças da estrutura – faz-se necessário pensar com mais detalhe no sistema que terá que ser montado no Firefly para que os dados capturados pelo Kinect sejam traduzidos em movimentos coordenados do robô.

Captura de dados

Como já averiguei que a captura do esqueleto não é tão confiável [CITAR OUTRO POST QUANDO ESTIVER PRONTO], principalmente quando as articulações estão fora da pose esquemática, ou seja, quando um dos membros do corpo está perpendicular à câmera de profundidade gerando sobreposição de articulações (ver primeiro vídeo abaixo). O esqueleto é estimado por um algoritmo de reconhecimento que usa um pós-processamento dos dados primários de profundidade, nativos da tecnologia.

Por essa e outras razões citadas na entrada original, decidi usar a câmera de profundidade como base para criação da interface do usuário, já que fornece um tipo de dado mais direto e consistente, demonstrado no vídeo abaixo.

Algoritmos de cinemática inversa

O desenho acima mostra um estudo feito para compreender como funciona a cinemática reversa nas articulações da estrutura adquirida (ir até o final da entrada).

Encontrei a definição de um sistema para controle de cinemática inversa chamado Lobster (ver também o vídeo ao lado) na comunidade digital do Grasshopper. Infelizmente é um sistema de 2011 e já não funciona com os componentes de versões mais recentes, mas é um bom sistema e vale a pena estudá-lo para aproveitar os caminhos já desbravados por alguém com mais experiência.

Interface

A relação entre o gesto do usuário e os movimentos do robô tem que ser a mais intuitiva e direta possível – e esse foi um dos princípios orientadores do formato de controle criado para a interface -, já que este dispositivo ferramenta pretende ser um instrumento de criação e, portanto, deve permitir que o usuário expresse sua intenção através do robô, com o menor numero de barreiras possível.

Usando os dados de profundidade, controlar o robô com apenas uma mão é impossível, porque são necessários dois pontos no espaço para determinar a inclinação da ferramenta. Por essa razão, idealmente o sistema de captura de esqueleto seria muito mais simples de implementar.

A solução a ser adotada – ilustrada na animação abaixo – implementa um sistema de controle que leva em consideração todas as necessidades descritas acima:

• com a mão direita, o usuário controla a posição da base da ferramenta, que se deslocará no espaço graças ao algoritmo de cinemática inversa criado no Grasshopper. Também é determinado o primeiro ponto para traçar o vetor que determinará a inclinação da ferramenta.
• com a mão esquerda, a direção da ponta da ferramenta é determinada em relação à base da ferramenta, completando o vetor de inclinação com o segundo ponto necessário.

No início do desenvolvimento do dispositivo 02 achei que haveria um gasto significativo de tempo para fazer funcionar o motor DC da fresa que vai ser usado como ferramenta, na ponta do braço. Isso porque tive problemas para fazer funcionar um motor DC no dia da demonstração técnica da disciplina AUT-2501, porque continuei achando que teria que customizar o código fornecido pelo desenvolvedor do Firefly (um firmware) para que o aplicativo e Arduino se compreendam. Cheguei a pedir ajuda no fórum de discussão oficial do aplicativo, mas não obtive sucesso.

/* 
 Created by Andrew Payne
 Modified from original Firefly Firmata written by Jason Kelly Johnson and Andrew Payne
 Latest Update September 10th, 2012 
 Copyright 2012 | All Rights Reserved
 
 This Firmata allows you to control an Arduino board from Rhino/Grasshopper/Firefly.
 Updates, Questions, Suggestions visit: http://www.fireflyexperiments.com
 
 1. Plug Arduino boards into your USB port; confirm that your Arduino's green power LED in on
 2. Select your specific Arduino Board and Serial Port (Tools > Board; Tools > Serial Port) *Take note of your Serial Port COM #
 3. Verify (play button) and Upload (upload button) this program to your Arduino, close the Arduino program
 4. then open ... Rhino/Grasshopper/Firefly
 
 Note: The Firefly Firmata sets the following pins to perform these functions:
 
 *****ON STANDARD BOARDS (ie. Uno, Diecimila, Duemilanove, Lillypad, Mini, etc.)*****
 ANALOG IN pins 0-5 are set to return values (from 0 to 1023) for analog sensors
 DIGITAL IN pins 2,4,7 will return 0's or 1's; for 3 potential digital sensors (buttons, switches, on/off, true/false, etc.)
 DIGITAL/ANALOG OUT pins 3,5,6,11 (marked with a ~) can be used to digitalWrite, analogWrite, or Servo.write depending on the input status of that Firefly pin
 DIGITAL OUT pins 8,9,10,12,13 can be used to digitalWrite, Servo.write, or analogWrite depending on the input status of that Firefly pin
 
 *****ON MEGA BOARDS (ie. ATMEGA1280, ATMEGA2560)*****
 ANALOG IN pins 0-15 will return values (from 0 to 1023) for 16 potential analog sensors 
 DIGITAL IN pins 34-41 will return 0's or 1's; for 8 potential digital sensors (buttons, switches, on/off, true/false, etc.) 
 DIGITAL/ANALOG OUT pins 2-13 can be used to digitalWrite, analogWrite, or Servo.write depending on the input status of that Firefly pin
 DIGITAL OUT pins 22-33 can be used to digitalWrite, Servo.write, or analogWrite depending on the input status of that Firefly pin
 
 *****ON LEONARDO BOARDS*****
 ANALOG IN pins 0-5 are set to return values (from 0 to 1023) for analog sensors
 DIGITAL IN pins 2,4,7 will return 0's or 1's; for 3 potential digital sensors (buttons, switches, on/off, true/false, etc.)
 DIGITAL/ANALOG OUT pins 3,5,6,11 (marked with a ~) can be used to digitalWrite, analogWrite, or Servo.write depending on the input status of that Firefly pin
 DIGITAL OUT pins 8,9,10,12,13 can be used to digitalWrite, Servo.write, or analogWrite depending on the input status of that Firefly pin
 */

#include <Servo.h>            // attach Servo library (http://www.arduino.cc/playground/ComponentLib/Servo)
#include <S4Power.h>          // [[[MOD]]] inclui a biblioteca do shield 4Power
#include <pins_arduino.h>     // attach arduino pins header file to determine which board type is being used

#define BAUDRATE 115200       // Set the Baud Rate to an appropriate speed
#define BUFFSIZE 512          // buffer one command at a time, 12 bytes is longer than the max length

/*==============================================================================
 * GLOBAL VARIABLES
 *============================================================================*/

char buffer[BUFFSIZE];        // declare buffer
uint8_t bufferidx = 0;        // a type of unsigned integer of length 8 bits
char *parseptr;
char buffidx;

int counter = 0;
int numcycles = 1000;

#if defined(__AVR_ATmega328P__) || defined(__AVR_ATmega168__)                         // declare variables for STANDARD boards
  uint16_t APin0, APin1, APin2, APin3, APin4, APin5, DPin2, DPin4, DPin7;             // declare input variables
  uint16_t DPin3, DPin5, DPin6, DPin8, DPin9, DPin10, DPin11, DPin12, DPin13;         // declare output variables  
  Servo Servo3, Servo5, Servo6, Servo8, Servo9, Servo10, Servo11, Servo12, Servo13;   // declare Servo objects
  S4Power shield4Power;                                                                // [[[MOD]]] declarando objeto S4Power
#endif

#if defined(__AVR_ATmega32U4__) || defined(__AVR_ATmega16U4__)                        // declare variables for LEONARDO board
  uint16_t APin0, APin1, APin2, APin3, APin4, APin5, DPin2, DPin4, DPin7;             // declare input variables
  uint16_t DPin3, DPin5, DPin6, DPin8, DPin9, DPin10, DPin11, DPin12, DPin13;         // declare output variables  
  Servo Servo3, Servo5, Servo6, Servo8, Servo9, Servo10, Servo11, Servo12, Servo13;   // declare Servo objects
#endif

#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)                        // declare variables for MEGA boards
  uint16_t APin0, APin1, APin2, APin3, APin4, APin5, APin6, APin7, APin8, APin9, APin10, APin11, APin12, APin13, APin14, APin15, DPin22, DPin23, DPin24, DPin25, DPin26, DPin27, DPin28, DPin29, DPin30, DPin31;  // declare input variables
  uint16_t DPin2, DPin3, DPin4, DPin5, DPin6, DPin7, DPin8, DPin9, DPin10, DPin11, DPin12, DPin13, DPin32, DPin33, DPin34, DPin35, DPin36, DPin37, DPin38, DPin39, DPin40, DPin41, DPin42, DPin43, DPin44, DPin45, DPin46, DPin47, DPin48, DPin49, DPin50, DPin51, DPin52, DPin53;  // declare output variables  
  Servo Servo2, Servo3, Servo4, Servo5, Servo6, Servo7, Servo8, Servo9, Servo10, Servo11, Servo12, Servo13, Servo32, Servo33, Servo34, Servo35, Servo36, Servo37, Servo38, Servo39, Servo40, Servo41, Servo42, Servo43, Servo44, Servo45, Servo46, Servo47, Servo48, Servo49, Servo50, Servo51, Servo52, Servo53;  // declare Servo objects
#endif


/*==============================================================================
 * SETUP() This code runs once
 *============================================================================*/
void setup()
{ 
  shield4Power.Config();   //[[[MOD]]] "Contrutor" da biblioteca, que precisa ser chamado.
  Init();                  //set initial pinmodes
  Serial.begin(BAUDRATE);  // Start Serial communication
}

/*==============================================================================
 * LOOP() This code loops
 *============================================================================*/
void loop()
{
  if(Serial){
    ReadSerial();                       // read and parse string from serial port and write to pins
    if (counter >= numcycles){          // Wait every nth loop 
      ReadInputs();                     // get input data
      PrintToPort();                    // print data to serial port 
      counter = 0;                      // reset the counter
    }
    counter ++;                         // increment the writecounter
  }
}

/*==============================================================================
 * FUNCTIONS()
 *============================================================================*/

void Init(){
  #if defined(__AVR_ATmega328P__) || defined(__AVR_ATmega168__)    //set pin mode for STANDARD boards
    pinMode(2, INPUT); 
    pinMode(4, INPUT); 
    pinMode(7, INPUT);
  #endif
  
  #if defined(__AVR_ATmega32U4__) || defined(__AVR_ATmega16U4__)   //set pin mode for LEONARDO board
    pinMode(2, INPUT); 
    pinMode(4, INPUT); 
    pinMode(7, INPUT);
  #endif
  
  #if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)  //set pin mode for MEGA boards
    pinMode(22, INPUT); 
    pinMode(23, INPUT);
    pinMode(24, INPUT);
    pinMode(25, INPUT);
    pinMode(26, INPUT); 
    pinMode(27, INPUT);
    pinMode(28, INPUT); 
    pinMode(29, INPUT);
    pinMode(30, INPUT);
    pinMode(31, INPUT); 
  #endif
}

void ReadInputs(){ 
  #if defined(__AVR_ATmega328P__) || defined(__AVR_ATmega168__)    //read pins on STANDARD boards
    APin0 = analogRead(0);   
    APin1 = analogRead(1);  
    APin2 = analogRead(2); 
    APin3 = analogRead(3); 
    APin4 = analogRead(4); 
    APin5 = analogRead(5); 
    DPin2 = digitalRead(2);  
    DPin4 = digitalRead(4);  
    DPin7 = digitalRead(7); 
  #endif
  
  #if defined(__AVR_ATmega32U4__) || defined(__AVR_ATmega16U4__)   //read pins on LEONARDO board
    APin0 = analogRead(0);   
    APin1 = analogRead(1);  
    APin2 = analogRead(2); 
    APin3 = analogRead(3); 
    APin4 = analogRead(4); 
    APin5 = analogRead(5); 
    DPin2 = digitalRead(2);  
    DPin4 = digitalRead(4);  
    DPin7 = digitalRead(7); 
  #endif
  
  #if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)  //read pins on MEGA boards
    APin0 = analogRead(0); 
    APin1 = analogRead(1); 
    APin2 = analogRead(2); 
    APin3 = analogRead(3); 
    APin4 = analogRead(4); 
    APin5 = analogRead(5); 
    APin6 = analogRead(6); 
    APin7 = analogRead(7); 
    APin8 = analogRead(8); 
    APin9 = analogRead(9); 
    APin10 = analogRead(10); 
    APin11 = analogRead(11); 
    APin12 = analogRead(12); 
    APin13 = analogRead(13); 
    APin14 = analogRead(14); 
    APin15 = analogRead(15); 
    DPin22 = digitalRead(22);  
    DPin23 = digitalRead(23);  
    DPin24 = digitalRead(24);  
    DPin25 = digitalRead(25);  
    DPin26 = digitalRead(26); 
    DPin27 = digitalRead(27); 
    DPin28 = digitalRead(28);  
    DPin29 = digitalRead(29);  
    DPin30 = digitalRead(30);  
    DPin31 = digitalRead(31);
  #endif
}

void PrintToPort(){
  #if defined(__AVR_ATmega328P__) || defined(__AVR_ATmega168__)    //print formatted string for STANDARD boards
    Serial.print(APin0); Serial.print(",");  
    Serial.print(APin1); Serial.print(","); 
    Serial.print(APin2); Serial.print(","); 
    Serial.print(APin3); Serial.print(","); 
    Serial.print(APin4); Serial.print(","); 
    Serial.print(APin5); Serial.print(","); 
    Serial.print(DPin2); Serial.print(","); 
    Serial.print(DPin4); Serial.print(","); 
    Serial.print(DPin7); Serial.print(","); 
    Serial.println("eol");  //end of line marker
  #endif
  
  #if defined(__AVR_ATmega32U4__) || defined(__AVR_ATmega16U4__)   //print formatted string for LEONARDO boards
    Serial.print(APin0); Serial.print(",");  
    Serial.print(APin1); Serial.print(","); 
    Serial.print(APin2); Serial.print(","); 
    Serial.print(APin3); Serial.print(","); 
    Serial.print(APin4); Serial.print(","); 
    Serial.print(APin5); Serial.print(","); 
    Serial.print(DPin2); Serial.print(","); 
    Serial.print(DPin4); Serial.print(","); 
    Serial.print(DPin7); Serial.print(","); 
    Serial.println("eol");  //end of line marker
  #endif
  
  #if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)  //print formatted string for MEGA boards
    Serial.print(APin0); Serial.print(","); 
    Serial.print(APin1); Serial.print(","); 
    Serial.print(APin2); Serial.print(","); 
    Serial.print(APin3); Serial.print(",");   
    Serial.print(APin4); Serial.print(","); 
    Serial.print(APin5); Serial.print(",");   
    Serial.print(APin6); Serial.print(",");
    Serial.print(APin7); Serial.print(",");  
    Serial.print(APin8); Serial.print(",");  
    Serial.print(APin9); Serial.print(","); 
    Serial.print(APin10); Serial.print(",");  
    Serial.print(APin11); Serial.print(","); 
    Serial.print(APin12); Serial.print(","); 
    Serial.print(APin13); Serial.print(","); 
    Serial.print(APin14); Serial.print(",");  
    Serial.print(APin15); Serial.print(","); 
    Serial.print(DPin22); Serial.print(","); 
    Serial.print(DPin23); Serial.print(","); 
    Serial.print(DPin24); Serial.print(",");
    Serial.print(DPin25); Serial.print(",");   
    Serial.print(DPin26); Serial.print(","); 
    Serial.print(DPin27); Serial.print(",");  
    Serial.print(DPin28); Serial.print(","); 
    Serial.print(DPin29); Serial.print(","); 
    Serial.print(DPin30); Serial.print(","); 
    Serial.print(DPin31); Serial.print(",");  
    Serial.println("eol");  //end of line marker
  #endif
}

void ReadSerial(){

  char c;    // holds one character from the serial port
  if (Serial.available()) {
    c = Serial.read();         // read one character
    buffer[bufferidx] = c;     // add to buffer
    
    if (c == '\n') {  
      buffer[bufferidx+1] = 0; // terminate it
      parseptr = buffer;       // offload the buffer into temp variable

      #if defined(__AVR_ATmega328P__) || defined(__AVR_ATmega168__)  //parse string for STANDARD boards
        DPin13 = parsedecimal(parseptr);     // parse the first number
        parseptr = strchr(parseptr, ',')+1;  // move past the ","
        
        DPin12 = parsedecimal(parseptr);     // parse the second number
        parseptr = strchr(parseptr, ',')+1;  // move past the ","
  
        DPin11 = parsedecimal(parseptr);     // parse the third number
        parseptr = strchr(parseptr, ',')+1;  // move past the ","
  
        DPin10 = parsedecimal(parseptr);     // parse the fourth number
        parseptr = strchr(parseptr, ',')+1;  // move past the ","
  
        DPin9 = parsedecimal(parseptr);      // parse the fifth number
        parseptr = strchr(parseptr, ',')+1;  // move past the ","
  
        DPin8 = parsedecimal(parseptr);      // parse the sixth number
        parseptr = strchr(parseptr, ',')+1;  // move past the ","
  
        DPin6 = parsedecimal(parseptr);      // parse the seventh number
        parseptr = strchr(parseptr, ',')+1;  // move past the ","
  
        DPin5 = parsedecimal(parseptr);      // parse the eighth number
        parseptr = strchr(parseptr, ',')+1;  // move past the ","
  
        DPin3 = parsedecimal(parseptr);      // parse the ninth number
        
        WriteToPin(13, DPin13, Servo13);     //send value out to pin on arduino board
        WriteToPin(12, DPin12, Servo12);
        WriteToPin(11, DPin11, Servo11);
        WriteToPin(10, DPin10, Servo10);
        WriteToPin(9, DPin9, Servo9);
        WriteToPin(8, DPin8, Servo8);
        WriteToPin(6, DPin6, Servo6);
        WriteToPin(5, DPin5, Servo5);
        WriteToPin(3, DPin3, Servo3);
         
      #endif
      
      #if defined(__AVR_ATmega32U4__) || defined(__AVR_ATmega16U4__)  //parse string for LEONARDO boards
        DPin13 = parsedecimal(parseptr);     // parse the first number
        parseptr = strchr(parseptr, ',')+1;  // move past the ","
  
        DPin12 = parsedecimal(parseptr);     // parse the second number
        parseptr = strchr(parseptr, ',')+1;  // move past the ","
  
        DPin11 = parsedecimal(parseptr);     // parse the third number
        parseptr = strchr(parseptr, ',')+1;  // move past the ","
  
        DPin10 = parsedecimal(parseptr);     // parse the fourth number
        parseptr = strchr(parseptr, ',')+1;  // move past the ","
  
        DPin9 = parsedecimal(parseptr);      // parse the fifth number
        parseptr = strchr(parseptr, ',')+1;  // move past the ","
  
        DPin8 = parsedecimal(parseptr);      // parse the sixth number
        parseptr = strchr(parseptr, ',')+1;  // move past the ","
  
        DPin6 = parsedecimal(parseptr);      // parse the seventh number
        parseptr = strchr(parseptr, ',')+1;  // move past the ","
  
        DPin5 = parsedecimal(parseptr);      // parse the eighth number
        parseptr = strchr(parseptr, ',')+1;  // move past the ","
  
        DPin3 = parsedecimal(parseptr);      // parse the ninth number
        
        WriteToPin(13, DPin13, Servo13);     //send value out to pin on arduino board
        WriteToPin(12, DPin12, Servo12);
        WriteToPin(11, DPin11, Servo11);
        WriteToPin(10, DPin10, Servo10);
        WriteToPin(9, DPin9, Servo9);
        WriteToPin(8, DPin8, Servo8);
        WriteToPin(6, DPin6, Servo6);
        WriteToPin(5, DPin5, Servo5);
        WriteToPin(3, DPin3, Servo3);
        
      #endif
      
      #if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)  //parse string for MEGA boards
        DPin2 = parsedecimal(parseptr);       // parse the first number
        parseptr = strchr(parseptr, ',')+1;   // move past the ","
  
        DPin3 = parsedecimal(parseptr);       // parse the second number
        parseptr = strchr(parseptr, ',')+1;   // move past the ","
  
        DPin4 = parsedecimal(parseptr);       // parse the third number
        parseptr = strchr(parseptr, ',')+1;   // move past the ","
  
        DPin5 = parsedecimal(parseptr);       // parse the fourth number
        parseptr = strchr(parseptr, ',')+1;   // move past the ","
  
        DPin6 = parsedecimal(parseptr);       // parse the fifth number
        parseptr = strchr(parseptr, ',')+1;   // move past the ","
  
        DPin7 = parsedecimal(parseptr);       // parse the sixth number
        parseptr = strchr(parseptr, ',')+1;   // move past the ","
  
        DPin8 = parsedecimal(parseptr);       // parse the seventh number
        parseptr = strchr(parseptr, ',')+1;   // move past the ","
  
        DPin9 = parsedecimal(parseptr);       // parse the eighth number
        parseptr = strchr(parseptr, ',')+1;   // move past the ","
  
        DPin10 = parsedecimal(parseptr);      // parse the ninth number
        parseptr = strchr(parseptr, ',')+1;   // move past the ","
        
        DPin11 = parsedecimal(parseptr);      // parse the tenth number
        parseptr = strchr(parseptr, ',')+1;   // move past the ","
        
        DPin12 = parsedecimal(parseptr);      // parse the eleventh number
        parseptr = strchr(parseptr, ',')+1;   // move past the ","
        
        DPin13 = parsedecimal(parseptr);      // parse the twelvth number
        parseptr = strchr(parseptr, ',')+1;   // move past the ","
        
        DPin32 = parsedecimal(parseptr);      // parse the thirteenth number
        parseptr = strchr(parseptr, ',')+1;   // move past the ","
  
        DPin33 = parsedecimal(parseptr);      // parse the fourteenth number
        parseptr = strchr(parseptr, ',')+1;   // move past the ","
        
        DPin34 = parsedecimal(parseptr);      // parse the fifthteenth number
        parseptr = strchr(parseptr, ',')+1;   // move past the ","
        
        DPin35 = parsedecimal(parseptr);      // parse the sixteenth number
        parseptr = strchr(parseptr, ',')+1;   // move past the ","
        
        DPin36 = parsedecimal(parseptr);      // parse the seventeenth number
        parseptr = strchr(parseptr, ',')+1;   // move past the ","
        
        DPin37 = parsedecimal(parseptr);      // parse the eightteenth number
        parseptr = strchr(parseptr, ',')+1;   // move past the ","
        
        DPin38 = parsedecimal(parseptr);      // parse the nineteenth number
        parseptr = strchr(parseptr, ',')+1;   // move past the ","
        
        DPin39 = parsedecimal(parseptr);      // parse the twentieth number
        parseptr = strchr(parseptr, ',')+1;   // move past the ","
        
        DPin40 = parsedecimal(parseptr);      // parse the twenty first number
        parseptr = strchr(parseptr, ',')+1;   // move past the ","
        
        DPin41 = parsedecimal(parseptr);      // parse the twenty second number
        parseptr = strchr(parseptr, ',')+1;   // move past the ","
        
        DPin42 = parsedecimal(parseptr);      // parse the twenty third number
        parseptr = strchr(parseptr, ',')+1;   // move past the ","
        
        DPin43 = parsedecimal(parseptr);      // parse the twenty fourth number
        parseptr = strchr(parseptr, ',')+1;   // move past the ","
        
        DPin44 = parsedecimal(parseptr);      // parse the twenty fifth number
        parseptr = strchr(parseptr, ',')+1;   // move past the ","
        
        DPin45 = parsedecimal(parseptr);      // parse the twenty sixth number
        parseptr = strchr(parseptr, ',')+1;   // move past the ","
        
        DPin46 = parsedecimal(parseptr);      // parse the twenty seventh number
        parseptr = strchr(parseptr, ',')+1;   // move past the ","
        
        DPin47 = parsedecimal(parseptr);      // parse the twenty eigth number
        parseptr = strchr(parseptr, ',')+1;   // move past the ","
        
        DPin48 = parsedecimal(parseptr);      // parse the twenty ninth number
        parseptr = strchr(parseptr, ',')+1;   // move past the ","
        
        DPin49 = parsedecimal(parseptr);      // parse the thirtieth number
        parseptr = strchr(parseptr, ',')+1;   // move past the ","
        
        DPin50 = parsedecimal(parseptr);      // parse the thirty one number
        parseptr = strchr(parseptr, ',')+1;   // move past the ","
        
        DPin51 = parsedecimal(parseptr);      // parse the thirty second number
        parseptr = strchr(parseptr, ',')+1;   // move past the ","
        
        DPin52 = parsedecimal(parseptr);      // parse the thirty third number
        parseptr = strchr(parseptr, ',')+1;   // move past the ","
        
        DPin53 = parsedecimal(parseptr);      // parse the thirty fourth number
        
        WriteToPin(2, DPin2, Servo2);         //send value out to pin on arduino board
        WriteToPin(3, DPin3, Servo3);
        WriteToPin(4, DPin4, Servo4);
        WriteToPin(5, DPin5, Servo5);
        WriteToPin(6, DPin6, Servo6);
        WriteToPin(7, DPin7, Servo7);
        WriteToPin(8, DPin8, Servo8);
        WriteToPin(9, DPin9, Servo9);
        WriteToPin(10, DPin10, Servo10);
        WriteToPin(11, DPin11, Servo11);
        WriteToPin(12, DPin12, Servo12);
        WriteToPin(13, DPin13, Servo13);
        WriteToPin(32, DPin32, Servo32);
        WriteToPin(33, DPin33, Servo33);
        WriteToPin(34, DPin34, Servo34);
        WriteToPin(35, DPin35, Servo35);
        WriteToPin(36, DPin36, Servo36);
        WriteToPin(37, DPin37, Servo37);
        WriteToPin(38, DPin38, Servo38);
        WriteToPin(39, DPin39, Servo39);
        WriteToPin(40, DPin40, Servo40);
        WriteToPin(41, DPin41, Servo41);
        WriteToPin(42, DPin42, Servo42);
        WriteToPin(43, DPin43, Servo43);
        WriteToPin(44, DPin44, Servo44);
        WriteToPin(45, DPin45, Servo45);
        WriteToPin(46, DPin46, Servo46);
        WriteToPin(47, DPin47, Servo47);
        WriteToPin(48, DPin48, Servo48);
        WriteToPin(49, DPin49, Servo49);
        WriteToPin(50, DPin50, Servo50);
        WriteToPin(51, DPin51, Servo51);
        WriteToPin(52, DPin52, Servo52);
        WriteToPin(53, DPin53, Servo53);
        
      #endif
      
      bufferidx = 0;                             // reset the buffer for the next read
      return;                                    // return so that we don't trigger the index increment below
    }                                            // didn't get newline, need to read more from the buffer
    bufferidx++;                                 // increment the index for the next character
    if (bufferidx == BUFFSIZE-1) bufferidx = 0;  // if we get to the end of the buffer reset for safety
  }
}

void WriteToPin(int _pin, int _value, Servo _servo){
  if (_value >= 1000 && _value < 2000)             // check if value should be used for Digital Write (HIGH/LOW)
  {      
    if (_servo.attached()) _servo.detach();        // detach servo is one is attached to pin
    pinMode(_pin, OUTPUT);                         // sets the pin for output 
    _value -=1000;                                 // subtract 1000 from the value sent from Firefly 
    if (_value == 1) digitalWrite(_pin, HIGH);     // Digital Write to pin
    else digitalWrite(_pin, LOW);   
  }   
  else if (_value >= 2000 && _value < 3000)        // check if value should be used for Analog Write (0-255)
  {
    if (_servo.attached()) _servo.detach();        // detach servo is one is attached to pin
    pinMode(_pin, OUTPUT);                         // sets the pin for output 
    _value -= 2000;                                // subtract 2000 from the value sent from Firefly
    analogWrite(_pin, _value);                     // Analog Write to pin
  }
  else if (_value >= 3000 && _value < 4000)        // check if value should be used for Servo Write (0-180)
  {
    _value -= 3000;                                // subtract 3000 from the value sent from Firefly
    if (!_servo.attached())_servo.attach(_pin);  // attaches a Servo to the PWM pin (180 degree standard servos)                                    
    _servo.write(_value);                        // Servo Write to the pin
    
    int newValue = (_value/0.9)-100;               //[[[MOD]]] convertendo o valor de _value (0-180) do servo para a escala do motor
    
    if (_pin == 3){
      shield4Power.M1.speed = newValue;
    }else if(_pin == 5){
      shield4Power.M2.speed = newValue;
    }else if(_pin == 6){
      shield4Power.M3.speed = newValue;
    }else if(_pin == 8){
      shield4Power.M4.speed = newValue;
    }
  }
}

uint32_t parsedecimal(char *str){
  uint32_t d = 0;
  while (str[0] != 0) {
    if ((str[0] > '50') || (str[0] < '0'))
      return d;
    d *= 10;
    d += str[0] - '0';
    str++;
  }
  return d;
}

Felizmente hoje, enquanto testava o funcionamento de um dos motores me ocorreu tentar usar o componente que o componente Generic Serial Write, visto na parte de baixo do campo salientado em vermelho na imagem ao lado (O de cima é o Generic Serial Read, que pode ser usado para enviar informações do Arduino para o Firefly). Descobri que esses dois elementos, que funcionam independentemente do modelo do Arduino, comunicam-se diretamente com instruções Serial.read(), Serial.write() e Serial.print() da linguagem de programação do Arduino. Ou seja, basta que você escreva um programa básico usando essas instruções para que os componentes Generic Serial Read e Generic Serial Write consigam se comunicar com o Firefly.

O código abaixo, por exemplo, exibe a mensagem “Mensagem do Arduino para o Firefly” na variável Out do componente Generic Serial Read.

void setup() {
// initialize serial communications at 9600 bps:
Serial.begin(9600);
}
void loop() {
Serial.println(“Mensagem do Arduino para o Firefly.”);
delay(100);
}

A imagem abaixo mostra a disposição dos componentes que usei no teste bem sucedido do motor:

Em relação ao exercício construído na disciplina AUT-2501, algumas mudanças foram feitas:

• troca do componente  Uno Write pelo Generic Serial Write
• um botão de liga e desliga que envia o valor -100 via Serial.write() para o Arduino quando está pressionado e 0 quando não está ativo (valores explicados a seguir).

Por alguma razão que desconheço, o motor DC testado não comporta os recursos do shield: nem as variações de velocidade e nem a inversão de sentido de movimento (para mais informações ler o material preparado para a demonstração técnica na disciplina AUT-2501. Só reage quando a variável speed do objeto M1 (o equivalente digital dos terminais M1+ e M1- usados no shield) tem valor -100. Embora o motor fique parado com outros valores, elegi o valor original 0 para indicar o estado estacionário, pois não havia razão para mudá-lo.

Abaixo, o código escrito por mim (o mesmo usado na demonstração técnica da disciplina AUT-2501), que viabiliza o uso do Generic Serial Write para controlar um Arduino qualquer. É importante que o valor de Baud Rate seja o mesmo no Firefly – no componente Open Port, a variável Baud – e no código enviado para o Arduino – Procurar o comando Serial.begin() nas linhas de código abaixo.

/*
* ATENÇÃO: Mudar a opção 'No ending line' para 'Newline' no dropbox do Serial Monitor.
* Referência usada: < http://my.safaribooksonline.com/book/hobbies/9781449399368/serial-communications/receiving_serial_data_in_arduino >
* 
* Author: Stefano Mega - stefano.mega@gmail.com - < http://www.stefanomega.com.br >
*/

#include "S4Power.h"
S4Power s4power;//Instanciando um S4power.

int intensityValue = 0; //Atual valor de intensidade de giro do motor e brilho do led.
int sign = 1; //Inteiro usado para estabelecer se intensityValue é positivo ou negativo. Pode ser 1 ou -1.

void setup()
{
  s4power.Config(); //Inicializando configurações internas do pacote.
  Serial.begin(115200); //Inicializando a trasmissão de dados via porta USB.
}

void loop()
{
  //Só receber dados quando houver algum disponível.
  if (Serial.available() > 0) {
    
    char charTemp = Serial.read(); //Ler Serial e armazenar o primeiro caracter na variável.
    
    if(charTemp >= '0' && charTemp <= '9') // Garantindo que o char é um algarismo de 0 a 9.
    {
      intensityValue = (intensityValue * 10) + (charTemp - '0'); //Se sim, acrescentar o char ao fim da variável intensityValue.
    }
    else if( charTemp == '-') //Se o caractere '-' aparecer, assinalar um multiplicador negativo.
    {
       sign = -1;
    }
    else if (charTemp == 10)  //Se o enter for precionado (new line é o ASCII 10)
    {
      //Limitando os valores ao intervalo de -100 a 100.
      if ((intensityValue <= 100) && (intensityValue >= -100))
      {
        intensityValue = intensityValue * sign; //Aplicando o sinal, se cabível.
        changeIntensity(intensityValue); //Usando a função que informa a 4Power do valor da velocidade.
        
        Serial.print("Nova velocidade: ");
        Serial.println(intensityValue);
        
        intensityValue = 0; //Zerando o intensityValue, para que possa receber a nova sequência.
        sign = 1; //Positivando o sinal (default)
      }
      else { Serial.println("Valores de velocidade devem estar entre -100 e 100."); intensityValue = 0; sign = 1;}
    }
    else { Serial.println("Só são permitidos caracteres de 0 a 9 ou o sinal de -."); intensityValue = 0; sign = 1; }
  }
}

void changeIntensity(int newIntensity)
{
  s4power.M1.speed = newIntensity; //Mudando o valor da variável 'speed' para o motor M1.
  s4power.M1.Update(); //Mudando a velocidade com o valor de 'speed'.
  
  s4power.M2.speed = newIntensity; //Mudando o valor da variável 'speed' para o motor M2.
  s4power.M2.Update(); //Mudando a velocidade com o valor de 'speed'.
  
  s4power.light.intensity = newIntensity; //Mudando o valor da variável 'intensity' para o led.
  s4power.light.Update(); //Mudando o brilho com o valor de 'speed'.
}

O único problema que enfrentei foi que um dos componentes do shield (o Full-Bridge Motor Driver da direita) ficou extremamente quente depois de um tempo. É bem provável que eu precise de um dissipador de calor ou mesmo um ventilador para reduzir a temperatura.

Com o fim do semestre letivo, foi necessário também concluir o dispositivo da melhor forma possível. Abaixo, o vídeo com o resultado final: