Relé e gráficos sobrepostos no Simulink

Para obter dois gráficos numa mesma janela usando o Scope do Simulink, use um Mux, como na figura abaixo.

O funcionamento do relé é o seguinte. Quando a tensão de entrada for maior que o Von, a saída é V1; quando for menor, V2. Usando o Simulink, os parâmetros são:

Dica do mux: Fórum da Mathworks
Relés para ajuste PID: Projeto Final

Contador em LaTeX com referência cruzada

Quem usa LaTeX sabe que é possível referenciar figuras, tabelas e equações através de labels, porque usa contadores internos, como variáveis de programação mesmo. Então, é possível, sim, ter um contador ao longo do texto e fazer referência a esse contador.

Minha primeira tentativa foi usando os comandos \newcounter{foo} e \addtocounter{foo}{1}. O primeiro, que vai no preâmbulo, define uma variável foo que vai ser incrementada ao longo do texto através do segundo comando, onde o número entre chaves é o número a somar ao contador. Esse sistema funciona para referências diretas, por exemplo, se eu estiver falando Tabela 3 em vez de tabela a seguir, basta incrementar o contador e mostrar, no texto, quanto vale o contador (eu usei o \arabic{foo}). A referência que usei para essa tentativa foi o LaTeX Counters.

Então, percebi que, se precisasse referenciar ao tal foo mais à frente do texto, perderia a referência, pois só teria o valor atual de foo (se, por exemplo, forem colocados dois foo entre onde quero referenciar e onde estou referenciando, vou obter foo+2). Se acharam confuso, aposto que este tópico está ainda mais, vejam o exemplo abaixo para esclarecer.

A solução foi com os comandos \newenvironment e \refstepcounter. No primeiro, defino o nome do novo ambiente entre chaves e o número de argumentos a ser recebido entre colchetes. O segundo serve para guardar uma referência numa label a este número. (Mais sobre o \newenvironment em Wikibooks). A seguir está o código:

1. \documentclass{article}
2.  
3. \newcounter{tabela} \setcounter{tabela}{0}
4. \newcounter{subtabela}[tabela] \setcounter{subtabela}{0}
5.  
6. \newenvironment{tabela}[1]
7. {
8.    \refstepcounter{tabela} %contador
9.     \textbf{Tabela \thetabela} #1
10. }
11.  
12. \begin{document}
13.  
14. \tabela{Primeira Tabela}\label{um}\\
15. \tabela{Segunda Tabela}\label{dois}\\
16. \tabela{Terceira Tabela}\label{tres}\\
17. \tabela{Quarta Tabela}\label{quatro}\\
18.  
19. Tabela 1 = \ref{um}\\
20. Tabela 3 = \ref{tres}\\
21. Tabela 2 = \ref{dois}\\
22. Tabela 4 = \ref{quatro}\\
23. \end{document}

O comando \tabela recebe como entrada o texto da tabela e dá como saída em negrito seu número, seguido do texto. Abaixo a saída gerada:

Células ocupando mais de uma coluna (LaTeX)

Para fazer uma tabela em LaTeX com em que uma das linhas tenha menos colunas que o restante, por exemplo, duas subtabelas, utiliza-se o comando multicolumn. No exemplo, usamos uma tabela com 4 colunas e a primeira linha somente com duas colunas maiores:

O comando multicolumn requer 3 argumentos: o número de colunas a ser ocupado; o formato da coluna (|c| por exemplo, significa com borda direita e esquerda, e centralizado); o texto a ser escrito nesse espaço. A figura acima foi obtida usando o multicolumn duas vezes, separado pelo operador &.

Eis o código

\begin{tabular}{|c|c|c|c|}
   \hline

1.   \multicolumn{2}{|c|}{\textbf{Algoritmo 1}}&
2.   \multicolumn{2}{|c|}{\textbf{Algoritmo 2}}\\
3.   \hline
4.   Execuções & Resultado &Execuções & Resultado \\
5.   \hline
6. \end{tabular}

Fontes de Consulta:
Apostila de LaTeX (Professor Reginaldo Santos, UFMG) - Seção 7.8
texblog

Primeiros passos no Git

Vou escrever aqui  meus primeiros passos usando o Git. Os tutoriais pela internet mostram como fazer coisas mais avançadas, mas acredito que, como eu, tenha muitos usuários aí sem saber o que fazer com o básico.

Após instalar e criar um login, fazemos a configuração local. No terminal, digite:

git config --global user.name "Fulano de Tal"

git config --global user.email fulano@site.com.br

Essas informações sempre aparecerão no cabeçalho dos arquivos de log das alterações. Escolhemos uma pasta onde ficará o código, provavelmente uma pasta já com conteúdo. Vá então até essa pasta e digite:

git init

Este comando fará com que sua pasta esteja sendo monitorada LOCALMENTE pelo Git (mas nada está online ainda, no https://github.com/seu_nome_de_usuario). Para verificar a presença do Git, dê um ls .git

A pasta está sendo monitorada, mas os arquivos não. Se dermos um git status, veremos uma mensagem de aviso que os arquivos da pasta não estão sendo monitorados (Untracked files). Vamos, então, começar a separar os arquivos que devem ser monitorados e quais não. Para monitorar, dê:

git add arquivo(s)

É bom, também, ter um arquivo README, esse pode ser feito online, por sugestão do próprio github, ou ser feito localmente e ser enviado depois, como todos os outros arquivos do seu código. Para adicioná-lo, seria git add README. Para ignorar arquivos, edite o arquivo .gitignore, adicionando os nomes dos arquivos ou expressão regular.

Adicionados todos os arquivos, vamos fazer o commit, que significa, de grosso modo, avisar ao git que eu tenho uma nova versão pronta do arquivo. Em todo commit, você deve escrever um comentário sobre que alterações foram feitas. Como este é o primeiro commit, digite:

commit -m "Primeira versao crua, incompleta, bugada e sem tratamento de erros"

Ou algo menos exagerado que isso. Mas, o backup ainda está sendo local, nada na sua página no github. Agora, vem o pulo do gato. Vá à sua página no github - https://github.com/seu_nome_de_usuario - e crie um novo repositório. Lá, haverá uma instrução para você tornar seu repositório online através da linha de comando. A tela é como a seguinte:

Então, os comandos a serem dados nesse primeiro momento são:

git remote add origin https://github.com/seu_nome_de_usuário/nome_do_repositório.git git push -u origin master

Ele pedirá seu usuário e senha do github e voilà, seus arquivos estarão online.

Para adicionar novos arquivos e adicionar arquivos alterados, repita as operações de add, commit e, após isto, use o git push. Este comando submete o commit ao online. Lembre-se sempre de controlar seus arquivos com o git status. Para adicionar o log do git status ao seu commit, use a opção commit -v.

Qualquer informação que esteja errada, por favor, não avacalhem, apenas avisem amavelmente, estou apenas aprendendo e expondo meu aprendizado. Editarei o arquivo sempre que for preciso.

Referências:
Grande parte do conteúdo foi resumido do git-scm.com. Outra boa referência é o Guia Definitivo do Stack Overflow.

Colocar data automaticamente em arquivos de fotos (Linux)

Fiz um programa em bash para colocar aquela estampa de data (timestamp) em arquivos com base na última modificação do arquivo. Muitas vezes acontece de você ter a foto em si, mas não ter programado a câmera para gerar automaticamente esse carimbo na foto. Ou, como foi meu caso, achar que não tinha importância a data e, depois, começar a querer colocar, além de que os aplicativos padrão de Câmera de celular não terem essa funcionalidade (pelo menos eu nunca tive contato com um que tivesse, somente aplicativos instalados a mais, como o Camera360).

Para quem quiser pegar o programa, pode fazer o download, mas, aqui, vou explicar o que fiz, deixando o código   e que referências de consulta usei. É bom para aprender um pouquinho de Bash e alguns comandos de Linux e, para quem quiser, modificar o programa para outros propósitos (Filosofia do Código Aberto ;) ).

O primeiro passo do programa é testar a entrada do programa. Eu quero que o programa receba apenas uma entrada, portanto, se a chamada ao programa for diferente de 1 argumento, devo dar uma mensagem de erro e sair.

Para obter a data da última modificação do arquivo, usamos o comando stat. Consultando o manual, vemos que a opção -c corresponde a: "use the specified FORMAT instead of the default; output a newline after each use of FORMAT". Ou seja, se usarmos o stat sozinho, ele dará uma série de informações sobre o arquivo, mas só nos interessa a data da modificação, então usamos a opção -c e pedimos o formato que queremos, que é obtido usando %y.

    %y     Time of last modification, human-readable

Trecho do manual sobre a opção %y

Usando o comando stat -c %y [referência], obteremos algo do tipo:

2014-02-25 15:37:46.000000000 -0300

Mas só nos interessa a data, que vem no formato yyyy-mm-dd. Então, usando uma manipulação de string, localizamos o espaço e pegamos o conteúdo até onde ele ocorrer. Usamos o operador %% seguido do caracter desejado, no caso, o espaço e um asterisco ($string=${string%%-*} - substituí o espaço por um traço para ficar mais palpável). Note que o comando verificará a primeira ocorrência do marcador, mesmo que a string pode tenha o mesmo marcador depois. Entretanto, se usarmos o operador % (simples), ele localizará a última ocorrência, que é o que queremos nesse instante: separar a substring que vem antes do espaço. 

O operador ##, por outro lado obtém o que estiver depois do marcador, sendo que a ordem entre o marcador e o asterisco se inverte ($string=${string##*-}). Servirá para obter a extensão do arquivo, como será visto ao longo deste texto. Não quis me alongar muito nessa explicação para não perder o objetivo principal do post, mas tem exemplos aqui, aqui e o meu exemplo (link no GitHub).

Voltando à data, vamos usar o operador "%% *" para obter o pedaço "2014-02-25" da saída obtida com o comando stat. Segue o trecho do código responsável:

1. #obtem data de ultima modificacao do arquivo
2. data=$(stat -c %y $1)
3. data=${data%% *}

No programa, eu gerei um nome de saída para o arquivo com a data com base no nome de entrada, adicionando a ele a data e hora em que foi gerado. Para isso, temos que pegar o nome do arquivo (que é dado pelo usuário ao rodar o programa, ou seja, é o argumento 1 - $1 - da chamada via linha de comando, por exemplo ./datarFoto lago.jpg), obter todo o nome até o último ponto (usando o tratamento de substrings que eu expliquei acima) e também guardar a extensão, que usará o operador ## para guardar a substring depois do marcador. Para concatenar duas strings, basta colocá-las lado a lado depois do sinal de =, como na última linha do trecho abaixo:

1. #gerar nome do arquivo de saida
2. nomeSaida=$1
3. extensao=${nomeSaida##*.}
4. nomeSaida=${nomeSaida%.*}
5. nomeSaida=$nomeSaida$(date +"_%y%m%d_%H%M")

Faltou explicar o funcionamento do date [referência]. O sinal de + indica o formato que eu quero que a data seja exibido. O comando date sozinho dá a data atual, usando os operadores +"_%y%m%d_%H%M", a data será exibida no tipo _140131_1251, onde 14 é o ano (2014), 01, o mês e 31 o dia. Os sublinhados foram escolha minha, você podia botar outros caracteres para separar, mas , como estamos lidando com nome de arquivo, não seria legal colocar certos caracteres como barra e dois pontos.

Para mudar o formato da data (a ser carimbada na foto e não no nome do arquivo de saída) para o nosso formato tradicional (dd/mm/yyyy), também usamos o comando date. Mas, dessa vez, damos como entrada a data obtida pelo stat. Para isto, usamos a opção --date= que indica ao date que é para usar determinada data e não a do dia de hoje.

1. #converte o formato da data de yyyy-mm-dd para dd/mm/yyyy
2. texto=$(date --date=$data +"%d/%m/%y")

Por fim, vamos carimbar a foto. Usamos o comando convert. Como não consegui rodar o comando de uma vez, coloquei o comando numa string e mandei a string ser rodada, através do eval. As opções do convert que merecem destaque são a gravity (mais informações aqui), que serve para mudar a origem das coordenadas. A opção draw diz em que posições vertical e horizontal vai ser colocado o texto. Usando a opção gravity Southeast, essas posições são dadas com relação à ponta inferior direita, sendo assim, independente do tamanho, o carimbo sempre vai ser dado neste canto.

1. #usar o formato para usar o comando convert
2. executar="convert -pointsize 20 -fill yellow -gravity Southeast -draw 'text 20,20 \"$texto\"' $1 $nomeSaida.$extensao"
3. eval $executar

Referências:
http://www.instructables.com/id/Add-text-to-images-with-Linux-convert-command/2/?lang=pt
http://www.linuxquestions.org/questions/programming-9/get-file-modification-date-time-in-bash-script-163731/
http://www.cyberciti.biz/faq/linux-unix-formatting-dates-for-display/
http://www.win.tue.nl/~aeb/linux/misc/convert/convert-draw-text.html
http://tldp.org/LDP/abs/html/string-manipulation.html

Mudar TextView com aplicação em Android

No post anterior, vimos como obter um conteúdo da interface Android para dentro do processamento em Java. Agora, o objetivo é processar algo e retornar para a interface, alterando-a conforme o resultado.

3 - Processando a resposta
O processamento é um raciocínio meramente algorítmico. Temos que criar um número aleatório e verificar se é ímpar ou par.:

1. int numero = (new Random()).nextInt(50);
2. int resultado = numero % 2;

A variável "numero" recebe um número aleatório criado pelo método nextInt (cujo parâmetro é o número máximo somado de 1, desde 0, que poderá ser sorteado, ou seja, nextInt(50) é um número entre 0 e 50, excluindo o 50) e que precisa da importação de java.util.Random, a própria IDE deve reclamar disso, pondo um ponto de erro na linha e uma sugestão de correção com a importação.

1. import java.util.Random;

Este código vai na MainActivity.java, conforme explicado no post anterior.

4 - Exibindo a resposta modificando a interface
Usando uma interface simples, vamos alterar o texto "Hello World!" para "Cara" ou "Coroa", se a variável "resultado" for igual a 1 ou 0, respectivamente (ou vice-versa). Para alterar o conteúdo, é preciso armazenar o "ID" do elemento da interface usando o método findViewById. O código fica o seguinte:

1.     /** Chamado ao pressionar OK */
2.     public void processar(View view) {
3.         TextView editText = (TextView) findViewById(R.id.textView1);
4.         String mensagem = editText.getText().toString();
5.         int numero = (new Random()).nextInt(50);
6.         int resultado = numero % 2;
7.         if(resultado == 0){
8.                 mensagem = "Cara";
9.         }
10.         else{
11.                 mensagem = "Coroa";
12.         }
13.         editText.setText(mensagem);
14.     }

A variável "mensagem" é iniciada com o conteúdo "Hello World!" só para aproveitar o código do último post. Poderia ser vazia. A "editText" identifica o elemento (como um form) que contém o texto e possui um método para alterar o texto desse elemento, que é usado na última linha, o setText().

Vamos aprimorar a interface e, em vez de mostrar o resultado com texto, vamos mostrar uma moedinha mesmo (sem animações, só a figura mesmo, mais informações sobre figuras no site do Android Developer).

Primeiro, você deverá trazer suas figuras de cara e coroa para o acervo de imagens. Para isso, copie as imagens desejadas e, no Eclipse, na pasta res/drawable-hdpi (pode ser também mdpi ou ldpi, vi aqui), clique com o botão direito e cole. Atenção ao tamanho das figuras, que deve ser pequeno. Para mais informações, existe uma série de explicações no Android Developer. Quanto à extensão, consegui com .gif e com .png como pode ser visto na figura abaixo.

ic_action_cara.png foi uma tentativa frustrada de carregar
a imagem pelo Create New Icon do Eclipse.
Só consegui mesmo copiando e colando na pasta drawable

Volte ao activity_main.xml e escolha Graphical Layout. Clique na caixa suspensa "Image & Midia" e, em seguida, arraste para a tela do aplicativo o ImageView. Selecione uma imagem qualquer para ser a imagem inicial do programa (eu usei o ícone do programa). Conforme o resultado, essa imagem mudará para a imagem de cara ou de coroa seguindo os passos a seguir.

No MainActivity.java, antes do if que avalia o resultado, crie um objeto para receber a imagem padrão.

1. ImageView imagem = (ImageView) findViewById(R.id.imageView1);

Dentro do correspondente if/else, mude o conteúdo do objeto para a imagem de cara ou de coroa:

1. imagem.setImageResource(R.drawable.nome_arquivo_cara_ou_coroa); //OBS: Sem o .png

O método fica, então:

1.  /** Chamado ao pressionar OK */
2.     public void processar(View view) {
3.         TextView editText = (TextView) findViewById(R.id.textView1);
4.         String mensagem = editText.getText().toString();
5.         ImageView imagem = (ImageView) findViewById(R.id.imageView1);
6.         int numero = (new Random()).nextInt(50);
7.         int resultado = numero % 2;
8.         if(resultado == 0){
9.                 mensagem = "Cara";
10.                 imagem.setImageResource(R.drawable.cara);
11.         }
12.         else{
13.                 mensagem = "Coroa";
14.                 imagem.setImageResource(R.drawable.coroa);
15.         }
16.                 editText.setText(mensagem);
17.     }

Resultado:

Tela Inicial

Apresentação do resultado

5 - Instalando o aplicativo no celular
No Eclipse, na esquerda, onde ele mostra os diretórios, vá em bin/res e copie o caraCoroa.apk (ou o nome que você deu a seu projeto) para o celular. Abra-o no celular e instale.

Fontes de Consulta:
Stack Overflow
Mkyong.com

Criando meu primeiro aplicativo de Android

O primeiro passo é, naturalmente, a instalação. Na página do kit de desenvolvimento do Android (developer.android.com), baixe o pacote completo (Eclipse+Máquina Virtual+ambiente Android), é um arquivo bem grande (453 MB), então demora um pouco para baixar. No Linux, a instalação consistiu somente de dezipar o arquivo. Para abrir o kit de desenvolvimento, vá na subpasta eclipse e clique duas vezes sobre o programa eclipse.

Ao abrir, ele pergunta sobre a workspace. É nesse caminho que ficarão os arquivos de código gerados e o arquivo final para rodar seu programa (o .apk). Selecione o seu caminho de preferência (dica, se usa dropbox, use uma pasta dentro do seu diretório de sincronia).

Tudo instalado e configurado, vamos partir para o desenvolvimento de um aplicativo simples. A filosofia de programação em Android é similar à de .NET ou qualquer cliente-servidor. A parte de interação com o usuário é feita com um XML (com muitos dos componentes são gerados automaticamente pela IDE, ou seja, pelo Eclipse), fazendo o papel da página web analogamente, e os cálculos  são rodados em Java, através de requisições enviadas pelo XML. Isso vai ficar mais claro com o exemplo prático.

O aplicativo consiste em um "Cara ou Coroa", com basicamente duas interfaces:
- A interface inicial, onde o usuário pode tocar em um botão para ativar o programa
- A interface de resultado, que mostra uma moeda com a cara ou o número virado para cima e um botão para repetir o procedimento.

O cálculo não é complicado, basta fazer um programa que sorteie um número aleatório e obtenha o resto da divisão dele por 2. Se o resto for 0, o resultado é cara, se for 1, coroa (ou vice-versa).

Agora, mãos à massa. Os passos seguidos aqui são um resumo do guia presente no developer.android.com. Clique em New Android Application e preencha os espaços para decidir o nome da aplicação (pode deixar os outros campos com o padrão) e avance. Na segunda janela de configurações, também deixe tudo como está e avance. A terceira janela é para decidir o ícone que vai aparecer na lista de programas no celular.

 Para se localizar, aqui vai uma explicação sobre os principais dentre vários diretórios criados automaticamente ao criar uma nova aplicação (mais informações na página oficial).

• src: arquivos .java para a programação propriamente dita. Possui um arquivo MainActivity.java que cria a tela inicial do programa (o nome MainAcitivity pode mudar, se você alterar algumas das configurações padrão)
• gen: possui arquivos gerados, incluindo o importante R.java, que intermedeia algumas operações.
• res/layout: os XML que descrevem as telas do programa. Por padrão, tem um activity_main.xml. Ao abrir um dos arquivos dessa pasta, há as opções Graphical Layout e nome_do_arquivo.xml, o primeiro com uma visão gráfica, com possibilidade de arrastar e soltar forms e o segundo com o código gerado para mostrar esses forms. 

• res/values: para entrar com valores na interface (por exemplo, activity_main.xml), é preciso cumprir a burocracia de criar uma variável e definí-la dentro dessa pasta (por exemplo, strings.xml) ou então a IDE vai dar warning. Abra no activity_main.xml a parte de código e procure pela tag TextView e confira como o texto "Hello World!" está referenciado como uma string dentro da pasta string e não diretamente (android:text="@string/hello_world").

1 - Criação de um botão

Abra o arquivo activity_main e ative o Graphical Layout. Na janela Form Widgets (veja a figura anterior), clique em Button e arraste para a área em branco ao lado. Perceba que ele vai dar Warning, pois ao botão é automaticamente atribuído o text="Button". Vá em values/strings e adicione uma string, de nome botao_ok e valor "OK". Volte ao activity_main e troque android:text="Button" por android:text="@string/botao_ok". Se o Warning não desaparecer instantaneamente, clique no menu superior em Project e selecione Clean. 

[I18N] Hardcoded string "Button", should use @string resource:
Warning caso não use uma variável para o texto

2 - Resposta do botão ao toque

No activity_main, adicione o atributo android:onClick="processar" (sim, é sensível a maiúsculas). Vá em sec/MainActivity e adicione o seguinte trecho:

/** Chamado ao pressionar OK */
public void processar(View view) {
    // codigo sera inserido aqui
}

(adaptado de Android Developers)

Ele indicará erro, clique no apontador do erro e corrija importando a classe View. Alternativamente, pressione Ctrl+Shift+o para corrigir erros de importação.

Dentro do método processar, adicione 

Intent intent = new Intent(this, Sortear.class);

A IDE deve reclamar de dois erros, um da eportação do Intent, e a inexistência da classe Sortear (View cannot be resolved to a type).

OBS - Configurando o dispositivo de debug

Para fins de teste (e para configurar o dispositivo, real ou virtual, que vai rodar nossos programas), vamos rodar um programa muito simples. Esqueça, por enquanto, o Intent.

/** Chamado ao pressionar OK */
public void processar(View view) {
       //Intent intent = new Intent(this, Sorteio.class);
     TextView editText = (TextView) findViewById(R.id.textView1);
     String mensagem = editText.getText().toString();
}

Coloque um breakpoint na linha TextView editText = (TextView) findViewById(R.id.textView1) (para quem não sabe o que é um breakpoint, é só clicar ao lado da linha (na parte laranja). Quando rodar o programa em modo debug, o programa irá parar onde você marcou).

Eu, particularmente, não consegui rodar o dispositivo virtual. Usei um celular para rodar no dispositivo real. Para fazer isso, antes, você deve ir nas configurações do seu celular, em Aplicativos e, depois, em Desenvolvimento, e ativar a opção Depuração USB. Com essa opção marcada, ao conectar seu celular ao computador pelo cabo USB, deve aparecer na área de notificações. Então, quando você mandar rodar o programa (Run, Debug (F11)), o programa irá rodar no seu celular (cria automaticamente, um ícone no seu painel de aplicativos).

Voltando ao nosso teste, clique em Run e Debug e selecione o dispositivo. A tela da interface (um texto e um botão de OK) deve abrir no celular.

Aperte no OK e a execução do programa será pausada no breakpoint (veja a IDE). Aperte em Step Over duas vezes e posicione o mouse em cima da variável "mensagem" do MainActivity.java. Perceba como a variável recebeu o texto de um elemento da interface no Android. A partir dessa ideia, podemos operar entre a interface (XML) e o processamento (Java).

OBS - Criando um dispositivo virtual (Linux)
Ao rodar o dispositivo virtual (Window, Android Virtual Device Manager), tive o seguinte erro:

Failed to load libGL.so
error libGL.so: cannot open shared object file: No such file or directory

Solucionei com o comando sudo apt-get install libgl1-mesa-de (mais informações, clique aqui). O Arquivo libGL.so pôde ser encontrado em /usr/lib/i386-linux-gnu

Para o próximo post:
3 - Processando a resposta

4 - Exibindo a resposta