Conquistas da Comunidade LibreOffice

Por: Jono Bacon

Tradução: Bruno Ferreira

Recentemente o Projeto LibreOffice liberou a versão 5.0 de sua suíte office multi-plataforma. A nova versão trás vários recursos típicos de uma suíte de escritório bem elaborada e que roda em ambientes Linux, Windows, Mac e em dispositivos móveis.

Falar LibreOffice ou OpenOffice para o público em geral pode levar a reações iteressantes. Para algumas pessoas, LibreOffice é o queridinho do mundo do software livre, e para outros, é a cópia mal feita do Microsoft Office que eles olham com desconfiança.

Eu acredito que o LibreOffice alcançou uma função importante no mundo, e que vai além da mera função de uma suíte de escritório. Mas, antes de chegarmos a isso, é importante que olhemos para trás através da imensa jornada que levou o Projeto LibreOffice ao que conhecemos hoje.

Voltando no Tempo

A história começa em 1985, quando Marco Börries criou o StarWriter para o Zilog Z80. Posteriormente ele fundou a StarDivision e começou a construir o que hoje é conhecido como suíte de escritório moderna. O fruto desse esforço foi o StarOffice, que unia funções de editor de textos, planilha eletrônica, gerador de apresentações, banco de dados, software de desenho, fórmulas e outras ferramentas.

Nos anos iniciais do Linux, o StarOffice era a única suite de escritório bem desenvolvida disponível para esse sistema. Era desajeitada e feia, mas funcionava bem e desempenhou uma função importante para os novos usuários Linux. Nunca esquecerei a possibilidade de criar um cartaz para meu grupo de usuários Linux e imprimí-lo, o que era na época um grande passo adiante para o Linux.

Em 1999, a Sun comprou a StarDivision por 73,5 milhões de dólares e, de acordo com a imprensa, comprar toda a companhia foi mais barato que pagar licenças do Microsoft Office para os funcionários da Sun. E isso veio naturalmente com uma vantagem: a Sun agora teria sua própria suíte de escritório.

A Sun seguiu fundo na filosofia software livre e liberou o código do StarOffice em 2000, e esta iniciativa se transformou no Projeto OpenOffice.org. Primeiramente foi apenas a liberação do código, mas logo uma comunidade formou-se ao redor do projeto e tentou evoluir como uma comunidade de software livre. Eu estava em contato próximo com ambas as comunidades, OpenOffice.org e Sun Community, e rapidamente vi as coisas complicarem.

Tempos Difíceis

Apesar de termos uma dívida de gratidão para com a Sun, por abrir o código do StarOffice, isso significou liberar um gigantesco bloco de código monolítico e rústico que poderia afugentar o mais impetuoso programador. As pessoas que se juntaram ao projeto OpenOffice.org nesses dias assumiram a tarefa complexa, ingrata e mentalmente desgastante de entender aquele enorme código espaguete e prepará-lo para futuro desenvolvimento. Eles foram verdadeiros heróis do mundo do software livre.

A Ximian foi uma das empresas envolvidas no projeto. Michael Meeks, um importante membro do projeto OpenOffice.org, criou um patch específico, chamado ooo-build, que tornava a gerência do código no Linux mais fácil. Isso resultou em um software chamado go-ooo, que incluía alguns recursos que não existiam no código original do OpenOffice.org.

Nesse tempo, a Sun estava contribuindo menos com o projeto, possivelmente porque os objetivos financeiros e administrativos mudaram. Para piorar as coisas os responsáveis pelo OpenOffice.org na Sun respondiam menos às contribuições de código externas. Isso criou um ambiente em que Michael Meeks e outros desenvolvedores trabalhavam duro para criar uma suíte de escritório que o mundo do software livre pudesse se orgulhar, mas esse esforço falhava por falta de resposta.

Lembro desses tempos claramente. Michael Meeks fazia tudo que podia para inspirar e encorajar a Sun a gerenciar o OpenOffice.org de forma que fosse mais de acordo com um projeto de software livre. Eu até passe algum tempo com Michael tentando conversando com pessoal da Sun, e tentando que a Canonical ajudasse. Infelizmente esse esforço não trouxe muito resultado. Para falar a verdade eu estava a par de várias das considerações internas na Sun, e sua relutância em se envolver pode ter sido resultado de grupos de gestão externos e recursos de engenharia limitados.

Em 2010, a Oracle adquiriu a Sun. Isso causou ondas de choque pela comunidade de software livre e pode ter sido o que colocou a locomotiva novamente nos trilhos. Ainda nesse ano a organização Document Foundation foi anunciada como novo hospedeiro do trabalho derivado do OpenOffice.org, o LibreOffice. Esse seria o novo projeto de software livre pelo qual Meeks e companhia tanto haviam lutado.

Uma Nova Era

Desde esses dias, o LibreOffice tem se fortalecido mais e mais. Aquele enorme código monolítico foi modularizado, atualizado e refinado. O suporte multiplataforma foi expandido, novos recursos adicionados, redundâncias removidas, e uma visão de simplicidade e usabilidade aplicada. Além disso, uma nova comunidade nasceu, cenferências e encontros de desenvolvedores foram fundados, patrocinadores surgiram, e outras comunidades – como de documentadores, escritores, tradutores, artistas, designers – criadas.

Olhar para o LibreOffice e compará-lo com o Microsoft Office pode ser tentador. Certamente, o LibreOffice não provê o mesmo nível de recursos e finesse, que o segundo apresenta, mas quando pensamos no “antes e depois” desde os anos 1999 até hoje, o que a comunidade alcançou é fenomenal. Desenvolver o LibreOffice tem sido um trabalho difícil, tecnicamente desafiador, e algumas vezes desmotivante, e contribuições tem sido feitas por milhões de usuários ao redor do mundo.

Mais que uma Suíte

Além das tremendas realizações técnicas da comunidade LibreOffice, o projeto desempenha uma grande missão além mundo do software livre. Estamos vendo uma grande renascença do espírito de comunidade no mundo. Pessoas estão se unindo para criar, compartilhar e colaborar de novas e interessantes formas. Uma coisa que aprendi em minha carreira é que qualquer missão ou visão é possível quando temos o conjunto correto de ferramentas, conhecimento e pessoas. O conjunto “ferramentas” é onde se encontra o LibreOffice.

Nos dias iniciais do surgimento do Linux e do software livre, um conjunto de ferramentas permitiu que muito do que temos hoje fosse possível. Entre essas ferramentas estão o gcc, make, binutils, e outras peças do sistema GNU. Sem elas, disponíveis livremente, desenvolvedores não teriam como realizar muitas coisas.

Comunidades de software livre não trabalham apenas desenvolvendo software. Elas são grupos locais, esforços de ativismo, escrita colaborativa, modelagem de dados e mais. Como era nos dias iniciais dos projetos de software livre, ferramentas abertas, disponíveis livremente e conteúdo hackeável são imprescindíveis. O LibreOffice está fornecendo a ferramente livre que pode inspirar uma geração a criar conteúdo aberto em formatos abertos.

Por exemplo, para auxiliar a criar grupos locais cordenados ao redor do mundo, devemos ter kits de materias, disponíveis livremente por download, que esses grupos possam usar para criar cartazes, documentos, crachás, autocolantes etc. Prover material é uma coisa, mas prover material num formato que possa ser utilizado, editado e customizado com uma ferramenta livre significa que comunidades não precisarão se preocupar em comprar uma suíte de escritório proprietária.

Uma combinação de formatos e ferramentas abertos levou à revolução colaborativa que vemos hoje. Apesar de ser tentador ver o LibreOffice como mero substituto livre do Microsoft Office, essa linha de pensamento subestima a incrível missão que aquele pode desempenhar na revolução do desenvolvimento de software.

Ao terminar essa coluna hoje à noite, estarei saudando meus amigos do Projeto LibreOffice. Vocês são a esência do que amo no código livre: a gentileza, experiência, e senso de comunidade que faz isso tão especial. Obrigado pela sua devoção e esforço.

Artigo Original por Jono Bacon: http://opensource.com/life/15/8/libreoffice-community-achievements

Tradução livre: Bruno Ferreira.

This work is licensed under a Creative Commons Attribution-ShareAlike 4.0 International License.

Arduino: Sensor de Cores RGB

1. Introdução

Esse projeto visa construir um detector de cores usando componentes baratos e fáceis de encontrar e uma placa Arduino. Eu usarei o Mega nesse projeto, porque é o que tenho disponível, mas o Uno já atende perfeitamente.

2. Teoria

Talvez a idéia de detectar cores com um LDR possa parecer estranha a uma primeira vista, mas veremos que é algo possível e relativamente fácil. Ao final, teremos um detector com um bom nível de precisão e a um preço bastante acessível.

2.1 Foto-resistores

Um foto-resistor - também chamado de LDR (Light Dependent Resistor) - é um tipo de resistor que varia sua resistência de acordo com a quantidade de luz que chega a ele. A resistência é inversamente proporcional a quantidade de luz, ou seja, quanto mais luz, menor a resistência elétrica. Os foto-resistores são muito usados em células fotoelétricas para a automatização de postes de iluminação pública e luzes de emergência. Abaixo a imagem real de um LDR e sua representação simbólica.

2.2 O Sistema de Cores RGB

RGB é a abreviatura de Red/Green/Blue. Esse sistema se baseia no fato que todas as cores podem ser formadas a partir dessas três cores básicas e é usado em inúmeros dispositivos atuais como monitores, televisores, projetores multimídia, máquinas fotográficas etc.

Sistema de Cores RGB

2.3 Um pouco de Ótica

Sabemos que o que forma as cores para a nossa percepção é a reflexão de certas ondas luminosas. Um objeto verde reflete as frequências de onda correspondentes ao verde. Os tons de vermelho também tem sua faixa de frequência específica, bem como o azul. A faixa visível varia da frequência 400THz (tons vermelhos) até 790THz (tons violeta).

A idéia básica do tipo de detector que buscamos construir é associar a emissão de luz no sistema RGB, feita pelos LED's e a reflexão da mesma por amostras de cor. Por exemplo, se acionarmos um LED vermelho próximo a uma amostra vermelha, a quantidade de luz refletida será razoavelmente grande. Se a amostra for azul ou verde, a luz refletida será bem menor. Se colocarmos um LDR para "sentir" a luz refletida, poderemos detectar quando a amostra vermelha é testada.

Por fim, se conseguirmos associar três LED's, sendo um vermelho, um verde e um azul, poderemos detectar qualquer das cores básicas do RGB. E se armazenarmos cada valor RGB, poderemos até replicar a exata cor da amostra, bastando reunir os valores detectados de vermelho, verde e azul!

3. Montagem do Detector

Vamos partir agora para a construçao do sistema em uma protoboard ou PCB.

3.1 Componentes Necessários

• 1 protoboard (ou se preferir soldar, uma PCB)
• 1 sensor LDR
• 3 LED's: Um azul, um verde e um vermelho (preferencialmente pode-se usar um único LED RGB)
• 1 pushbutton
• 1 buzzer
• 4 resistores de 350 Ohms
• 1 resistor de 10KOhms

3.2 Esquema de Montagem

Usei o Fritzing para desenhar o modelo abaixo. Trata-se de um excelente software livre. Pode ser baixado gratuitamente em http://fritzing.org.

Recomendamos fortemente que seja montada uma pequena câmara escura que proteja o detector (o conjunto dos três LED's + LDR) das emissões de luz do ambiente externo. Se não for usada essa câmara, haverá muita interferência de luz externa. Abaixo o sistema real já montado. Note a câmara escura com os três LED's e o LDR dentro.

4. Codificação

O código a seguir não foi totalmente criado por mim. Encontrei diversas referências e trechos na Internet e montei o meu fazendo as adaptações que achei pertinentes e que melhor serviam a mim. Na sessão de referências há links para os sites de onde me baseei.

Agora abra a IDE do Arduino e digite isso.

/* RGB SENSOR */ const int LDR = 0; // ldr sensor on analog pin 0 const int redLed = 2; const int greenLed = 3; const int blueLed = 4; int ledArray[] = {redLed, greenLed, blueLed}; const int buzzer = 8; int buzzTone=200; const int button = 7; int buttonState = 0; float colorArray[] = {0,0,0}; float whiteArray[] = {0,0,0}; float blackArray[] = {0,0,0}; //int avgRead; int ldrvalue = 0; // Values for detected colors int redval = 0; int greenval = 0; int blueval = 0; boolean balanced = false; void setup () {   Serial.begin (9600);   pinMode (redLed, OUTPUT);   pinMode (greenLed, OUTPUT);   pinMode (blueLed, OUTPUT);   pinMode (button, INPUT);   pinMode (buzzer, OUTPUT);   Serial.println ("Press button to start");   beepBuzzer (1); } void loop () {   waitButton();   //buttonState = digitalRead (button);   //if (buttonState == HIGH) {     if (!balanced) {       blinkLeds (3);       Serial.println ("Performing Balance...");       rgbBalance();     }     else {       rgbSense();       printColors();       beepColor();   } } void rgbBalance() {   // White Balance: operador deve colocar amostra branca sobre o sensor.   Serial.println ("White balance [press button to start] ...");   waitButton();   delay(500);   // Le os valores red/green/blue para a amostra branca.   Serial.print ("White Array: [");   for (int i=0;i<3;i++) {     digitalWrite (ledArray[i], HIGH);     delay(100);     whiteArray[i] = getAvgRead(5);     digitalWrite (ledArray[i], LOW);     Serial.print (whiteArray[i]);     delay(100);   }   Serial.println ("] OK");      // Black Balance: operador deve colocar amostra preta sobre o sensor.   Serial.println ("Black balance [press button to start] ...");   waitButton();   delay(500);  // Espera oito segundoa para usuario posicionar a amostra negra.   //  Le os valores red/green/blue para a amostra negra.   Serial.print ("Black Array: [");   for (int i=0;i<3;i++) {     digitalWrite (ledArray[i], HIGH);     delay(100);     blackArray[i] = getAvgRead(5);     digitalWrite (ledArray[i], LOW);     Serial.print (blackArray[i]);     delay(100);   }   Serial.println ("] OK");   balanced = true;   delay(2000); } void rgbSense () {   float greyDiff=0;   for (int i=0; i<3;i++) {     digitalWrite (ledArray[i], HIGH);     delay(100);     colorArray[i] = getAvgRead(5);     greyDiff = whiteArray[i] - blackArray[i];     colorArray[i] = (colorArray[i] - blackArray[i]) / greyDiff*255;     digitalWrite (ledArray[i], LOW);     delay(100);   } } int getAvgRead (int times) {   int value=0;   int summ=0;   int avg=0;   for (int i=0;i<times;i++) {     value = analogRead(LDR);     summ = value + summ;     delay(10);   }   avg = summ/times;   return avg; } void blinkLeds (int times) {   for (int i=0;i<times;i++) {     digitalWrite (redLed, HIGH);     digitalWrite (greenLed, HIGH);     digitalWrite (blueLed, HIGH);     delay(500);     digitalWrite (redLed, LOW);     digitalWrite (greenLed, LOW);     digitalWrite (blueLed, LOW);     delay(500);   } } void beepBuzzer (int times) {   for (int i=0;i<times;i++) {     tone (buzzer, 2000);     delay(100);     noTone (buzzer);     delay(100);   } } void printColors () {   Serial.print ("R: ");   Serial.println(int(colorArray[0]));   Serial.print("G = ");   Serial.println(int(colorArray[1]));   Serial.print("B = ");   Serial.println(int(colorArray[2]));   Serial.println(); } void beepColor ( ) {   // Red: 1 beep; Green: 2 beeps; Blue: 3 beeps   int beeps=0;   int color;        if (colorArray[0]>colorArray[1])   {     color = colorArray[0];     beeps=1;   }   else {     color = colorArray[1];     beeps=2;   }      if (color<colorArray[2]) {     beeps=3;   }   beepBuzzer(beeps); } void waitButton () {   while (true) {     buttonState = digitalRead (button);     if (buttonState == HIGH) {       beepBuzzer(1);       break;     }   } }

5. Operação

Para que o sistema funcione adequadamente é necessário realizar o balanço inicial de luz para amostras brancas e pretas. Será necessário usar a interface serial da IDE do Arduino para se familiarizar com o funcionamento. Através da interface serial, o sistema dará as instruções básicas de operação, que consistem no que está descrito abaixo.

Após ligar, o sistema solicitará que o operador coloque a amostra branca sobre o detector (o conjunto dos LED's + o LDR) e pressione o botao. Após isso ele deverá colocar a amostra preta sobre o detector e pressionar novamente o boato. Nesse momento o balanceamento foi feito e o sistema está pronto para uso.

Coloque qualquer amostra de cor sobre o detector e pressione o botao. O sistema lerá a a cor predominante (vermelho, verde ou azul) da amostra e emitirá bips da seguinte forma:

• 1 bip: vermelho
• 2 bips: verde
• 3 bips: azul

Nos testes que fiz, o sistema se mostrou bem eficiente. Muitas melhorias podem ainda ser feitas. Pode-se trocar o conjunto de três LED's por  um único LED RGB. Outra melhoria é colocar ainda outro LED RGB e tentar "imitar" a cor lida.

Caso você faça melhorias nesse sistema, peço que mantenha vivo o espírito do software/hardware livre e compartilhe o que foi feito com o público em geral.

6. Referências

http://www.instructables.com/id/Using-an-RGB-LED-to-Detect-Colours/?ALLSTEPS
http://www.georgegardner.info/arduino/photoresistor-color-sensing-with-the-arduino.html

Instalando o plugin do Java no Ubuntu 14.04

Esse micro-tutorial mostra o passo a passo para a instalação do Plugin do Java no Ubuntu 14.04. Usei a versão 64 bits.

1. Baixe a versão mais atualizada da JRE em http://java.com.
Obs: Eu prefiro sempre baixar o arquivo .tgz.
Após o download você terá o arquivo da JRE no diretório Downloads, e o nome dele será algo como jre-7u60-linux-x64.tar.gz.

2. Descompacte no diretório /usr/lib/jvm
Surgirá um subdiretório com o nome similar a jre1.7.0_60.
Obs.: Naturalmente, você precisará de permissão de root para isso.

$ sudo su -
# cd /usr/lib/jvm
# tar -zxvf /home/<usuario>/Download/jre-7u60-linux-x64.tar.gz

3. Inicie o Firefox e desabilite as extensões do Ubuntu: clique no menu "Ferramentas->Complementos" (ou use Ctrl-Shift-A), clique em "Extensões" e desabilite todas as que estejam relacionadas com Unity. No meu caso:

• Ubuntu Firefox Modifications
• Ubuntu Online Accounts
• Unity Desktop Integration
• Unity Websites Integration

4. Feche o Firefox e verifique se existe o diretório /usr/lib/mozilla/plugins. Se não existir, crie-o:

# mkdir -p /usr/lib/mozilla/plugins

5. Entre no diretório e crie o link para a biblioteca dos plugins:

# cd /usr/lib/mozilla/plugins
# ln -s /usr/lib/jvm/jre1.7.0_60/lib/amd64/libnpjp2.so

6. Inicie novamente o firefox e veja se o plugin está ativo. Para isso, clique na caixa de endereços e digite "about:plugins" (sem as aspas) e tecle enter. Deverá aparecer na página a referência ao plugin do Java:

Java(TM) Plug-in 10.60.2

Arquivo: libnpjp2.so

Caminho: /usr/lib/jvm/jre1.7.0_60/lib/amd64/libnpjp2.so

Versão: 10.60.2

Status: Ativo

Next Generation Java Plug-in 10.60.2 for Mozilla browsers

Ok, o plugin foi instalado. Ao acessar qualquer página que exija o uso do plugin, o Firefox por segurança perguntará se você deseja executá-lo. Basta permitir a execução e o plugin faz o resto.

Arduino: Gerenciando Bibliotecas (parte 1)

Uma das tarefas de quem programa para Arduino é gerenciar suas bibliotecas. Normalmente é uma tarefa simples, mas nem sempre intuitiva.

Nesse mini-artigo, listo algumas tarefas e o passo-a-passo relacionado a elas.

1. Criar uma biblioteca.

Em minha opinião, a melhor forma de se criar uma biblioteca para o Arduino é usar seu editor de programas preferido. O ambiente de desenvolvimento do Arduino foi projetado para criar Sketches, e não bibliotecas.

1.1 Crie um diretório com o nome da biblioteca, por exemplo Testlib.

$ mkdir Testlib

1.2 Crie os arquivos da biblioteca dentro do diretório criado. Nomeie os arquivos como Testlib.h e Testlib.cpp.

1.3 Abra o ambiente de desenvolvimento do Arduino e importe a biblioteca recém criada: Acesse o menu Sketch -> Import Library, e escolha a sua biblioteca. Caso não a visualize, verifique se os nomes foram criados corretamente (somente arquivos .h e .cpp). Numa inclusão correta, surgirá a linha abaixo no sketch:

#include "testlib.h"

1.4 Usando o ambiente de desenvolvimento, compile a biblioteca. Caso surjam erros, volte a editar os arquivos da biblioteca com seu editor de programas.

Para maiores detalhes, ver referência abaixo.

Referência: Writing a Library for Arduino

2. Adicionar uma biblioteca de terceiros

Muitas vezes, temos de baixar e instalar bibliotecas de terceiros para certos projetos. Recentemente adquiri um sensor DHT11 (humidade e temperatura) e tive de baixar a biblioteca que o gerencia.

2.1 Baixando os fontes:

Acesse o link http://playground.arduino.cc/main/DHT11Lib, copie os fontes dht11.h e dht11.cpp, salvando como arquivos texto.

2.2 Crie um diretório chamado DHT11 e copie os arquivos para ele.

2.3 Mova o diretório DHT11 (e os arquivos internos) para a pasta das bibliotecas do Arduino.

2.4 Abra o ambiente de desenvolvimento do Arduino e importe a DHT11: Acesse o menu Sketch -> Import Library.

Se tudo foi feito corretamente, surgirá a linha #include <dht11.h> no sketch automaticamente.

Esse é o método manual de instalar bibliotecas. O link a seguir detalha o método automatizado de instalação: http://arduino.cc/en/Guide/Libraries.

3. Incluindo uma biblioteca dentro de outra

Falamos até agora um pouco sobre a criação e instalação de bibliotecas para o Arduino. Agora descreveremos um "arremedo técnico" para que possamos referenciar elementos de uma certa biblioteca dentro de outra.

Esclarecendo o problema: recentemente, trabalhando num projeto de hexápode, tentei incluir a biblioteca "Servo" dentro de uma biblioteca que criei. Minha surpresa foi verificar que não era possível fazer isso. O ambiente de desenvolvimento do Arduino não traz facilidades para incluir uma biblioteca para dentro de outra. Tentei várias formas de include: referenciamento global, local etc. Nada deu jeito.

Então, pesquisando um pouco nos fóruns, encontrei uma dica que resolvel facilmente o problema. Basta escrever a biblioteca conforme o item 1. No Sketch criado, apenas inclua ambas as bibliotecas criadas, tendo o cuidado de colocar primeiro a biblioteca base. Por exemplo, se a biblioteca Testlib que criamos precisa acessar elementos da biblioteca Servo e da DHT11, nós simplesmente incluímos no sketch, na seguinte ordem:

# include <servo.h> # include <dht11.h> # include <testlib.h>

Arduino + Servo + Fonte Externa

Faz cerca de um mês que estou lidando com o Arduino. Adquiri um adquiri um Mega 2560 e, desde então tenho realizado algumas experiências. Hoje completei uma que acho digna de colocar nesse blog, pois poderá ajudar outras pessoas que estejam iniciando. Trata-se de um controlador de servo motor que usa um Arduino e uma fonte externa.

Por que usar uma fonte externa?

Alguns projetos utilizam servos que estão acima da capacidade dos pinos de força do Arduino e este fica resetando. Pode ocorrer também de seu projeto precisar de mais de um servo e o arduino não conseguirá gerar energia a todos.

Dessa forma, muitas vezes existe a necessidade de usar fontes externas para a alimentação do(s) servo(s).

Bom. Antes de seguirmos adiante, um aviso importante:

ATENÇÃO: Esse projeto não tem qualquer garantia de funcionar corretamente. Lembre-se que qualquer erro poderá levar a queimar os componentes usados, e até mesmo a placa Arduino. Eu faço meus projetos correndo esse risco. O que mostro aqui, é o que eu fiz e deu certo comigo, mas não posso dar garantias que funcionará com você.

No meu caso, comprei um servo que é potente demais para ser controlado sem fonte externa. É um servo um pouco maior que os comuns que se usam para robótica e o arduino ficava resetando direto. Ao usar a fonte, o sistema funcionou perfeitamente.

O servo usado foi um motorsat, normalmente usado em antenas parabólicas para alterar a polarização. Segundo o site, as especificações desse motor são:

Frequência de sinal: 60HZ(20ms)

Controle de pulso: 0.8 to 2.2ms

Voltagem: DC 5.0v

Ângulo de operação: 180 +10

Corrente: 180 to 200 mA

Velocidade: 0.3 (60/sec.)

Saída máxima de torque: 2.2 to 2.8 kg/cm

Corrente máxima: 580 to 600ma

Funciona com PWM, (modulação por largura de pulso).

Fio vermelho: alimentação 5 v DC.

Fio branco: Pulso

Fio preto: GND terra

Rotação do servo= 40 Rpm.

PESO: 500 Gramas

Dica: Um servo adequado a pequenos projetos em robótica é menor e pode ser alimentado direto pelo Arduino. Esse que utilizei não é o ideal, mas foi o que pude encontrar no mercado local em minha cidade.

Segue abaixo figura mostrando as ligações realizadas:

Nota: Essa figura foi feita com o Fritzing.

Basicamente:

1. Ligamos os pinos GND e 5V (nesse caso, 4,8V) da fonte externa no servo;
2. O GND (ground) do Arquino está interligado ao GND da fonte. Isso é necessário para permitir o controle do servo;
3. Ligamos o pino 9 do Arduino no cabo de controle do motor. É importante usar um pino que tenha capacidade PWM (Pulse Wave Modulation).

Segue abaixo o código utilizado:

#include <Servo.h>

Servo servo1;

int pos = 0;

void setup() {

  servo1.attach (9);

}

void loop() {

  for (pos=0; pos<180; pos++) {

    servo1.write (pos);

    delay(15);

  }

  for (pos=180; pos>=1; pos--) {

    servo1.write (pos);

    delay(15);

  }

}

Esse código implementa apenas uma rotina de Sweep (gira o eixo do servo em 180 graus e retorna 180 graus, indefinidamente). O mesmo foi descaradamente copiado de: http://arduino.cc/en/Tutorial/Sweep

Ligue a fonte externa e carregue o código de teste no arduino. O servo começará a girar 180 graus, em ida e volta.

Os servo-motores são um dos componentes essenciais a inúmeros projetos em robótica. O que foi exposto nesse texto é uma forma extremamente simples de iniciar os estudos com servo-motores e Arduino.

Bons estudos :)

Um Linuxer sobre o OSX parte 1

Dia 06/06/2014

Recentemente surgiu-me a oportunidade ímpar de adquirir um Mac Mini usado que um colega estava vendendo: um i7 quad core com 6GB de RAM e 500GB de HD. Fazia algum tempo que eu cogitava comprar um Mac Mini para substituir meu desktop, que mais lembrava um KingKong em meu escritório: gabinete de excelente qualidade, mas absolutamente enorme.

O Mac veio com o RedHat instalado. Esse meu amigo trabalha para a RedHat com virtualização e havia comprado-o para esse fim. Ele disse que esquecera de colocar o HD de 500GB e ficou de trazer na semana seguinte (era uma sexta feira). Assim que cheguei em casa, liguei o MAC e percebi que a interface gráfica não estava instalada. Para poder começar a testar adequadamente, instalei o Ubuntu 14.04 64 bits Desktop. A instalação fluiu de forma absolutamente tranquila, e o sistema operacional detectou todo o hardware, inclusive a interface de rede sem fio, que não funcionava com o RedHat.

Passei o fim de semana usando o pequeno e eficiente hardware: excelente aquisição.

Dia 09/06/2014

Na segunda-feira seguinte, recebi o HD de 500GB e decidi instalar o Mavericks, pois queria ter suporte fácil ao iTunes e Netflix, e começar a testar efetivamente o uso de um MAC OS. Meus pequenos problemas começaram aí...

Round 1: Criar pendrive de boot.

Acostumado com o procedimento fácil e trivial de criar pendrives de boot no Linux, fiquei perplexo com o procedimento muito mais complexo para criar um do Mavericks. Para ter uma idéia, no Ubuntu, normalmente basta baixar a imagem (ISO), abrir o "Criador de Discos de Inicialização", inserir o pendrive e clicar OK. O sistema faz o resto.

Para o MAC, segue esse tutorial.  Esse outro confirma o mesmo procedimento.  O processo no Linux é inegavelmente muito mais tranquilo.

Após finalizar a criação do pendrive de boot, espetei-o no Mac e iniciei. O Mavericks deu boot corretamente. Após aceitar o contrato de licença, o sistema me mostra uma tela perguntando em que disco eu quero instalar... mas não mostra qualquer disco! Que houve? Na minha personalidade acostumada com a Lei de Murphy imaginei logo que meu colega havia cometido algum erro ao conectar o HD de 500G. Desligo o Mac, abro-o, removo o HD, limpo os contatos, monto-o novamente (após uma longa luta para encaixar a pequena grade metálica que segura o HD e interface wifi). Quando tento novamente a instalação, o mesmo problema: o sistema não encontra o disco.

Para ter certeza, coloco novamente o pendrive de boot do Ubuntu, e magicamente ele reconhece o HD: estava lá, em toda a sua glória o dispositivo /dev/sda.

Antes de continuar essa saga, cabe um pequeno parágrafo de elogios: O Mac Mini é uma pequena obra de arte da engenharia, belíssimamente montada de forma a utilizar cada espaço. Além disso, o hardware consome muito pouco e a carga térmica é extremamente baixa. Inegavelmente a Apple merece os melhores elogios nesse aspecto. Para se ter uma idéia, e deleito dos leitores, segue link para um tutorial do iFixIt, que trata da instalação de um HD no Mac Mini, cheio de imagens deslumbrantes.

Mas voltemos à narrativa..

Novamente fiquei sem entender: por que o Mac não detectava o HD? Achando que eu havia cometido algum erro na criação do pedrive, recorri à instalação via rede: reboot, tecla alt (uso o teclado ABNT), conecto à wifi e inicio a instalação. Nesse caso o Mac força a instalação do Mountain Lion. Sem problemas, se der certo, atualizo para o Mavericks depois. Mas após aceitar o contrato de licença novamente deparo-me com o mesmo problema. Cadê a #$%! do disco ?!?

Tenho de dizer que é um sofrimento ser noob num sistema operacional. Eu, acostumado com as facilidades do mundo Linux, não fazia ideia que era necessário explicitamente recorrer ao utilitário de discos para fazer um particionamento prévio no disco antes de iniciar a instalação (o Linux sugere isso automaticamente). Terminei descobrindo esse detalhe por tentativa e erro. Após isso, a instalação e posterior atualização seguiu tranquilamente. Deixei o sistema atualizando, e como já era quase 2 da madrugada, fui dormir.

Continua ...

-x-x-x-

Dicas do dia:

1. Não crie pendrives de boot. Use o netinstall;
2. Sempre particione o disco antes da instalação.

Minha opinião após essa experiência: Caso não precise de algo proprietário, como iTunes ou Netflix, continue com o Linux ;)

Nos próximos capítulos: a mudança do idioma default e batalha pelo teclado ABNT.

Seu Roteador nos Pertence

Alguns usuários de roteadores ASUS tem sido surpreendidos nas últimas semanas por um estranho arquivo texto em suas pastas. O arquivo tem o título "WARNING_YOU_ARE_VUNERABLE.txt" abaixo seguem trechos do conteúdo (em inglês):

"Essa é uma mensagem automatizada que está sendo enviada a todos os afetados. Seu roteador Asus (e todos os seus arquivos) podem ser acessados por qualquer pessoa no mundo que tenha uma conexão com a Internet. 
(…)
Se você está lendo isso, VOCÊ ESTÁ VULNERÁVEL TAMBÉM.
(…)
Solução: DESABILITE COMPLETAMENTE O FTP E O AICLOUD, IMEDIATAMENTE!

Espero ter ajudado.

Atenciosamente,

/g/"

Essa mensagem está sendo adicionada a dispositivos de armazenamento USB conectados a roteadores ASUS, sem qualquer necessidade de login e senha, explorando-se uma vulnerabilidade que foi descoberta a cerca de oito meses. Tudo indica se tratar de um grupo Hacker tentando alertar sobre o problema, pois não há qualquer relato ou indicativo de roubo de dados ou injeção de malwares.

A falha é extremamente preocupante, pois como demonstrado, todos os arquivos ficam abertos ao público. E já existem listas com milhares de IP's vulneráveis disponíveis na Internet.

A solução parcial é desabilitar os recursos FTP e Aicloud desses roteadores. A solução ideal é a atualização do Firmware, que foram disponibilizadas pela Asus na semana passada.

Alguns modelos de roteadores afetados são: RT-AC66R, RT-AC66U, RT-N66R, RT-N66U, RT-AC56U, RT-N56R, RT-N56U, RT-N14U, RT-N16, e RT-N16R.

Essa notícia foi dada apenas uma semana após a descoberta de outra vulnerabilidade, relacionada a roteadores Lynksys, que permite a instalação de malwares no próprio roteador. Nesse caso, o malware afeta modelos E1000, E1200, e E2400.

Fonte: Arstechnica