Bancada e fonte de energia

Esta é uma nova linha de trabalho baseada em hardware, arduíno e Linux, começando pela construção da bancada. Já vou avisando desde já que caso você se aventure por aqui, será por sua própria conta e risco - não deve me culpar caso o que você construiu (mesmo seguindo minhas instruções) não serviu para o que você quer, causou ou foi implicado em algum acidente envolvendo você ou terceiros,... enfim, não me responsabilize por danos de qualquer natureza.

...voltando à bancada....

Na minha opinião deve ser firme, suportar um bom peso (o seu, por exemplo), ter o tampo claro (ajuda a achar os componentes menores) e aceitar ser suja, manchada, queimada,... sem que você ou quem quer que seja ressinta-se por isso.

Qualquer mesa que estiver sem uso serve, desde que você tenha os devidos cuidados com cada uma:

1-) mesa de plástico (daquelas de bar) derretem - às vezes precisaremos de ferro de solda, ou simplesmente algo esquenta. Em geral não são muito firmes;
2-) mesa de metal (daquelas de bar) - conduzem eletricidade, sofrem corrosão (talvez usemos percloreto de ferro);
3-) mesa de vidro (geralmente o tampo) - ruim de enxergar o que está em cima, fácil de quebrar com certos impactos;

Pensando nisso, eu escolheria uma de madeira com fórmica branca, mas como você verá, uso uma de plástico. As de metal e vidro eu não usaria, na minha opinião é mais arriscado usá-las.

É bom que o local de trabalho esteja bem iluminado e tenha tomadas por perto.

Protótipos iniciais com arduíno podem aproveitar-se da energia da USB do computador mas se quisermos fazer algo que requeira mais energia (por exemplo use motores) uma boa fonte de alimentação é necessária.

Decidi usar uma fonte de computador pois é barata, fornece várias tensões, fornece muita corrente e tem proteção contra curtos. A que comprei por R$50 em janeiro/2015 tem na etiqueta:

3.3V x 28A
5V x 45A
12V x 18A
5V x 2.5A (pelo pino de stand by)
-12V x 1A

A idéia é fazer algo que funciona, assim, a montagem final ficou:

Eu não quis cortar os fios do conector da fonte (ATX de 20 pinos), então procurei um conector ATX fêmea. Problema: não achei o conector para comprar, assim, recuperei de uma placa-mãe velha que uma alma caridosa vendeu por R$10.

Deu um trabalhão para dessoldar o conector, e outro para montar o circuito pois ligar uma fonte ATX tem lá sua sofisticação. Para os componentes não ficarem "voando", usei uma placa de circuito impresso "padrão" (compra pronta em loja).

Fontes ATX são as que tem circuitos para ligar por soft button e permitem que seu computador fique em estado de suspensão. Para fazer isso, tem uma linha que fornece energia sem interrupção, geralmente codificada VSB (V stand-by) - pino 9 do conector, fio cor roxa. Ela fornece a energia para sustentar o computador em stand-by. Liguei um led nela.

A fonte liga as saídas 3.3V-laranja, 5V-vermelho, 12V-amarelo, -12V azul quando o pino PWR_ON (pino 14 do conector, fio cor verde) for ligado em 0V (qualquer pino COM - fio preto). Liguei um interruptor para fazer isso.

Pela especificação, quando a energia estabiliza nas saídas, o sinal PWR_OK (pino 8 fio cinza) vai de 0 para 5V. (Há considerações sobre fontes de boa ou má qualidade, mas ficarei fora disto). Liguei um led nela.

Pretendo usar mais as linhas de 5 e 12V, que podem ser usadas pelos conectores dos periféricos, apenas a linha de 3,3V está somente no conector da placa mãe.

Nota1: se fosse fazer outra fonte, eu cortaria PWR_ON, VSB, PWR_OK e um fio COM.
Nota2: no pino 11 são ligados dois fios - um é 3,3V, outro é um sensor de 3,3V (mede sobrecarga). Não testei, mas acho que se desconectar a fonte desliga.

informação sobre o padrão ATX e pinagem do conector em http://en.wikipedia.org/wiki/ATX

Exceções - criando a sua própria e "repassando"

01 /** 02    Lancando uma excecao criada por mim mesmo. 03    Aproveitei para mostrar como "repassar a excecao". 04    Ela eh lancada em c(), repassada (por isso o throws) 05    e depois main repassa para a JVM (por isso o throws) 06    Note que se retirar o throws, usando a assinatura como 07    nos comentarios das linhas 13 e 17, ocorre erro de 08    compilacao. 09 */ 10  11 class MinhaExcecao { 12    public static void main (String[] args) throws Exception {    13    //public static void main (String[] args){ 14       MinhaExcecao m=new MinhaExcecao(); 15       m.c(); 16    } 17    //void c() { 18    void c() throws Exception { 19       System.out.println ("lançando"); 20       throw (new ExException()); 21    } 22    // Esta eh otima: Java permite definir classes dentro de classes. 23    // Aqui usei apenas para mostrar que eh possivel. 24    class ExException extends Exception { 25       public String getMessage () {  // Sobrescreve getMessage 26          return toString(); 27       } 28       public String toString (){   // Sobrescreve toString 29          return "ExException Rules!"; 30       } 31    } 32 }

Java2html

Exceções - explicações

Java provê um mecanismo especifico para gerenciar eventos inesperados durante o ciclo de codificação e execução de programas. Neste mecanismo, a ocorrência desses eventos é transmitida através de objetos. A hierarquia de classes é apresentada abaixo:

Os objetos para gerenciar os eventos inesperados são Error e Exception. RunTimeException é subclasse de Exception. Todos são subclasse de Throwable (algo como Lançável). Nesta superclasse está implementada a maioria dos métodos.(https://docs.oracle.com/javase/8/docs/api/java/lang/RuntimeException.html)

As instâncias de Throwable, ou de suas subclasses, são lançadas pelo comando throw. Caso seja necessário marcar que determinado método lança exceções, sua assinatura é seguida pela declaração throws Exception. Exception requer essa marcação, ou seja, se um método lança (throw) uma instância de Exception então ele e todos os métodos que o invocam (numa sequência de chamadas) devem ou ser marcados (com isso eles repassam a exceção para o método que o invocou), ou tratar a exceção. O tratamento de uma exceção consiste em tentar executar o método que lança a exceção (para "tentar", coloca-se a invocação do método dentro de um bloco try), caso alguma exceção seja lançada, capturá-la (com o comando catch), tratá-la (num bloco de comandos associado ao comando catch) e fazer uma "limpeza" com o comando finally.

Exceção - código 9

01 /** Testando... 02 tratamento de exceção com todos os elementos (try catch finally). 03 O que motivou este teste Ã© verificar que elementos são executados mesmo 04 Qual a ordem de execução quando ocorre exceção e finally não tem return? 05 Neste código, o que vem depois do tratamento não Ã© executado por causa 06 do return dentro do try. 07 Este Ã© curioso - quando lança a exceção, executa o catch, antes do return salta para o finally, salta de volta para o finally e executa o return do catch. 08 Quando não lança, executa o finally e continua depois do try... 09  10 Para que serve finally? 11 O bloco finally existe para agregar todas as instruções que "precisam ser executadas para encerrar o método limpamente". Em geral contém comandos que liberam recursos compartilhados, por exemplo, fecham arquivos, pipes, sockets, liberam acesso a variáveis compartilhadas, ...  12  13 um exemplo do que acontece quando isso não Ã© feito direito: 14 Quando estamos editando um arquivo armazenado num pendrive e o editor aborta com o arquivo aberto, em geral não Ã© possível ejetar o pendrive. Explicação: o funcionamento normal do SO não permite ejetar o pendrive enquanto o arquivo estiver em uso - isso evita perda de dados. Quando abrimos o arquivo no editor de texto, este informa ao sistema operacional que o arquivo está em uso. Quando o editor aborta, não informa ao sistema operacional para fechar (e liberar) o arquivo, logo para o SO, o arquivo continua em uso. O que vemos Ã© o editor fechado e o pendrive que não ejeta.  15 */ 16 public class DivZero6 { 17    public static void main (String[] args) { 18       int a, b; 19       a=5; 20       b=0; 21       try { 22          a=a/b; 23          System.out.println ("depois do erro, dentro do try."); 24       } catch (Exception e) { 25          System.out.println ("catch " + e.getMessage()); 26          return; 27       } finally { 28          System.out.println ("finally"); 29       } 30       System.out.println ("continuou...depois do try, fora do catch e do finally"); 31    } 32 }

Java2html

Exceção - código 8

01 /** Testando... 02 tratamento de exceção com todos os elementos (try catch finally). 03 O que motivou este teste Ã© verificar que elementos são executados mesmo 04 Qual a ordem de execução quando ocorre exceção e finally não tem return? 05 Neste código, o que vem depois do tratamento não Ã© executado por causa 06 do return dentro do try. 07 */ 08 public class DivZero5 { 09    public static void main (String[] args) { 10       int a, b; 11       a=5; 12       b=0; 13       try { 14          a=a/b; 15          System.out.println ("depois do erro."); 16          return; 17       } catch (Exception e) { 18          System.out.println ("catch " + e.getMessage()); 19          return; 20       } finally { 21          System.out.println ("finally"); 22       } 23       System.out.println ("continuou..."); 24    } 25 }

Java2html

Exceção - código 7

01 /** Testando... 02 tratamento de exceção com todos os elementos (try catch finally). 03 O que motivou este teste Ã© verificar que elementos são executados mesmo 04 com return dentro dos tratamentos. 05 Obs. 1: a Exceção Ã© lançada (divisão por zero), capturada e tratada. Esperaria-se que programa encerrasse no return, entretanto o bloco finally Ã© executado. 06 */ 07 public class DivZero4 { 08    public static void main (String[] args) { 09       int a, b; 10       a=5; 11       b=0; 12       try { 13          a=a/b; 14          System.out.println ("depois do erro."); 15          return; 16       } catch (Exception e) { 17          System.out.println ("catch " + e.getMessage()); 18          System.exit (0); 19       } finally { 20          System.out.println ("finally"); 21          return; 22       } 23       // neste codigo o que for posto aqui não será executado. 24    } 25 }

Java2html

Exceção - código 6

01 /** Testando... 02 tratamento de exceção com todos os elementos (try catch finally). 03 O que motivou este teste Ã© verificar que elementos são executados mesmo 04 com return dentro dos tratamentos. 05 Obs. 1: a Exceção Ã© lançada (divisão por zero), capturada e tratada. Esperaria-se que programa encerrasse no return, entretanto o bloco finally Ã© executado. 06 */ 07 public class DivZero3 { 08    public static void main (String[] args) { 09       int a, b; 10       a=5; 11       b=0; 12       try { 13          a=a/b; 14          System.out.println ("depois do erro."); 15          return; 16       } catch (Exception e) { 17          System.out.println ("catch " + e.getMessage()); 18          return; 19       } finally { 20          System.out.println ("finally"); 21          return; 22       } 23       // neste codigo o que for posto aqui não será executado. 24    } 25 }

Java2html