Como Revisar seu Próprio Texto

Quando escrevemos um texto, é comum que o modifiquemos constantemente, até que as diversas estruturas estejam adequadas.

Primeiramente temos a estrutura do texto: os capítulos e as seções. Estes devem seguir uma hierarquia e uma ordem lógica, preferencialmente sequencial.

Em segundo lugar temos a estrutura dos parágrafos, dentro dos capítulos e das seções. Estes devem ser organizados de forma lógica e estritamente sequencial.

Em terceiro lugar temos a estrutura das frases dentro dos parágrafos. Neste ponto, expressamos uma ideia de forma clara, seguindo as regras gramaticais.

Em geral, a última estrutura sofre uma quantidade de modificações muito maior do que a primeira e, por isso, nela ocorrem a maioria dos erros. É comum que se reorganize uma frase, para escrevê-la melhor e de forma mais clara, e acabar por introduzir erros, por exemplo, artigos (o, a, os, as) discordantes com respeito ao gênero ou número e preposições inconsistentes.

No entanto, ao mesmo tempo que escrevemos e reorganizamos um parágrafo, nos acostumamos com sua estrutura e suas palavras-chave e acabamos por não avaliar com perícia diversos detalhes, como esses que acabamos de mencionar, os quais são extremamente importantes para uma leitura clara e prazerosa.

Diz-se que, ao escrever, estamos “viciados no texto”. Estamos tão acostumados com o ele que não o lemos mais com detalhe. Então, ao revisar o texto, mesmo quando focamos em ler cada palavra, com muita calma e analisando tudo, não é raro que algo passe despercebido.

No entanto, note que estamos “viciados” ao ler o texto, e não ao escutá-lo. É muito mais difícil enganar aos ouvidos do que aos olhos.

Então para revisar um texto, basta pedir que alguém o leia para você, em voz alta. Enquanto ouvimos o texto, fazemos sua leitura e anotamos as inconsistências. Dessa forma, é possível perceber muito mais do texto do que apenas lendo.

Mas quem faria um trabalho desses, de ler um texto em voz alta? Dez páginas, vinte paginas, cem páginas?

O Google Tradutor faria: selecione a língua, colote o texto e clique no botão “Ouvir”.

Linux: Áudio do computador em videoconferência

Para apresentar a defesa da minha dissertação de mestrado, eu precisava tocar executar um vídeo com áudio no computador e a audiência precisava escutá-lo.

Uma saída era, na hora do vídeo, colocar o meu fone de ouvido bem perto do microfone, de forma que fosse transmitido pela videoconferência. Fazendo isso, no entanto, perde-se muito na qualidade do áudio.

Com um pouco de pesquisa descobri que existe uma solução melhor:

  • Criar um canal de áudio Virtual-1, que recebe o áudio das aplicações compartilhadas com a videoconferência. Este canal é ouvido por mim e pela audiência.
  • Direcionar a saída de áudio Virtual-1 para meus fones de ouvido, de forma que eu possa ouvir os programas compartilhados.
  • Criar um canal de áudio Virtual-2, que recebe o Microfone no qual eu falo e a saída de áudio Virtual-1, com os áudios compartilhados. Este canal é transmitido para a audiência.
  • Direcionar a saída de áudio Virtual-2 para um microfone virtual, chamado Virtual-3, que pode ser utilizado pela plataforma de videoconferência Google Meet.

Dessa forma, em vez de enviar apenas o meu microfone para a videoconferência, envio a saída Virtual-3 que também contempla os programas compartilhados.

O sistema em uso

No meu caso, estava utilizando o Ubuntu Linux 18.04. Para configurar o computador dessa forma, fiz uso dos dois scripts a seguir:

  • O primeiro configura o Pulse Audio para criar esses dispositivos de entrada e saída de áudio; e
  • O segundo desfaz essa configuração.

pulse_setup.sh

#!/bin/bash
# This script sets up pulseaudio virtual devices
# The following variables must be set to the names of your own microphone and speakers devices
# You can find their names with the following commands :
# pacmd list-sources
# pacmd list-sinks
# Use pavucontrol to make tests for your setup and to make the runtime configuration
# Route your audio source to virtual1
# Record your sound (videoconference) from virtual2.monitor

# Unload
./pulse_unload.sh

set -e

MICROPHONE=${MICROPHONE:-"alsa_input.pci-0000_00_1b.0.analog-stereo"}
SPEAKERS=${SPEAKERS:-"alsa_output.pci-0000_00_1b.0.analog-stereo"}
#SPEAKERS=${SPEAKERS:-"alsa_output.pci-0000_00_03.0.hdmi-stereo"}

module_file="/tmp/pulseaudio_module_list.txt"

if ! pacmd list-sources | grep -P "^\s+name: <${MICROPHONE}>" >/dev/null; then
  echo "ERROR: Microphone (source) \"${MICROPHONE}\" was not found" >&2
  exit 1
fi

if ! pacmd list-sinks | grep -P "^\s+name: <${SPEAKERS}>" >/dev/null; then
  echo "ERROR: Speaker (sink) \"${SPEAKERS}\" was not found" >&2
  exit 1
fi

# Create the null sinks
# virtual1 gets your audio sources (mplayer ...) that you want to hear and share
# virtual2 gets all the audio you want to share (virtual1 + micro)
pactl load-module module-null-sink sink_name=virtual1 sink_properties=device.description="Compartilhar-Audio" | tee -a "${module_file}"
pactl load-module module-null-sink sink_name=virtual2 sink_properties=device.description="Intermediario" | tee -a "${module_file}"

# Now create the loopback devices, all arguments are optional and can be configured with pavucontrol
pactl load-module module-loopback source=virtual1.monitor sink="${SPEAKERS}" latency_msec=1 | tee -a "${module_file}"
pactl load-module module-loopback source=virtual1.monitor sink=virtual2 latency_msec=1 | tee -a "${module_file}"
pactl load-module module-remap-source source_name=virtual3 source_properties=device.description="Vmic" master=virtual2.monitor | tee -a "${module_file}"
pactl load-module module-loopback source="${MICROPHONE}" sink=virtual2 latency_msec=1 | tee -a "${module_file}"

# Make the default sink back to speakers
pactl set-default-sink "${SPEAKERS}"
pacmd set-default-source "virtual3"

pulse_unload.sh

#!/bin/bash
set -e
module_file="/tmp/pulseaudio_module_list.txt"
if [ ! -f "${module_file}" ]; then
  echo "ERROR: file ${module_file} doesn't exist" >&2
  exit 1
fi
while read -r module; do
  if [[ "${module}" =~ ^[0-9]+$ ]]; then
    pacmd unload-module "${module}"
  else
    echo "ERROR: file ${module_file} is not correctly formated" >&2
    exit 1
  fi
done < "${module_file}"
rm "${module_file}"

Usando OBS para apresentação em videoconferência

Para defender minha dissertação de mestrado, a banca foi realizada à distância, através de uma videoconferência pelo Google Meet.

Para dar mais flexibilidade para a apresentação, utilizei o software OBS para gerar a parte gráfica e para realizar a gravação da aprestação.

Vejamos a seguir os passos básicos para fazer isso.

O tamanho da tela

A primeira coisa a fazer é definir o tamanho da tela.

Entre em “Menu Arquivo > Configurações > Vídeo” e selecione a “Resolução de base (tela)”, ou seja, a resolução de onde será projetado, e a “Resolução de saída (escala)”, ou seja, a resolução da gravação. E clique OK.

É comum utilizar resoluções de proporção 16×9, por exemplo 1280×720 ou 1920×1080.

Existem várias outras configurações do OBS, mas vamos focar apenas no necessário para uma apresentação por videoconferência.

Criando a cena da apresentação

Com o OBS foi criada uma ‘cena’ que contem a apresentação de slides e a câmera.

A cena foi criada clicando no botão mais (+) da interface de cenas.

Capturando a câmera

Para capturar a câmera, clique no botão mais (+) da interface de fontes. No menu selecione “Dispositivo de captura de vídeo” e na janela da interface selecione “Criar nova > OK”. Então escolha a câmera e, se desejar, pode até ajustar sua resolução. Clique em OK e agora basta ajustar o tamanho e a posição da câmera.

Capturando a tela

Quando a apresentação é realizada em tela cheia, temos que capturar a tela em que ela é apresentada.

A tela teve ser capturada, clicando no botão mais (+) da interface de fontes. No menu selecione “Captura de tela” e na janela da interface selecione “Criar nova > OK”. Então selecione a tela da apresentação. É possível recortar bordas, se necessário. Clique em OK e agora basta ajustar o tamanho e a posição da captura de tela.

Capturando uma janela

No meu caso, em vez de capturar a tela, eu capturei apenas a janela da apresentação, porque eu precisava mexer ao mesmo em outras janelas e não queria que elas aparecessem para a audiência.

A apresentação de slides em PDF foi aberta maximizada, com opção de zoom para “ajustar à página”, de forma que fique com altura ou largura máxima, sem exceder a tela. Isso tem o objetivo de manter os slides com tamanho fixo, que será útil na hora de cortar a interface.

Então a apresentação foi adicionada à cena, clicando no botão (+) da interface de fontes. No menu foi selecionado “Captura de janela” e na janela da interface foi selecionado “Criar nova > OK”. Então foi selecionada a janela da apresentação de slides e foram recortadas as bordas desnecessárias. Então clica-se em OK. Agora basta ajustar o tamanho e a posição da janela da forma que desejar.

Projetando em uma janela

Agora que a cena está finalizada, precisamos projetar ela, de forma que possa ser compartilhada na videoconferência.

Quem não tem uma segunda tela, pode projetar em uma janela e compartilhá-la.

No OBS, abra a prévia em uma janela [Botão contrário > Projetor em janela (prévia)] e ajuste a prévia em um tamanho adequado.

Agora, no Google Meet, compartilhe a prévia [Apresentar Agora > Uma janela > Projetor em janela (prévia) > Compartilhar].

Ao compartilhar a janela, você tem a desvantagem de que, se a janela for fechada, seu compartilhamento é finalizado, tendo que ser reiniciado.

Projetando em uma segunda tela

Já quem tem uma segunda tela, pode projetar e compartilhar nesta. A vantagem é que se pode ver o resultado sem precisar ficar trocando de janelas.

No OBS, abra a prévia em tela cheia [Botão contrário > Projetor em tela cheia (prévia) > Monitor X].

Agora, no Google Meet, compartilhe a prévia, o que pode ser feito de duas formas: compartilhando a tela onde a prévia é projetada; ou compartilhando a janela invisível dessa prévia (semelhante acima).

Para compartilhar a tela use [Apresentar Agora > A tela inteira > Tela X > Compartilhar].

Para compartilhar a janela use [Botão contrário > Projetor em tela cheia (prévia) > Compartilhar].

Ao compartilhar a tela, você tem a vantagem de poder arrastar qualquer janela para esta segunda tela e exibi-la durante sua apresentação. Tudo o que estiver na segunda tela vai ser compartilhado.

Identicamente ao anterior, ao compartilhar a janela, você tem a desvantagem de que, se a janela for fechada, seu compartilhamento é finalizado, tendo que ser reiniciado.

Gravando a apresentação

Para gravar a apresentação, basta clicar em “Iniciar gravação” na interface de controles. Obviamente a resolução escolhida impactará no tamanho do arquivo da gravação.

Conclusão

Com isso tudo, agora sabemos como criar uma cena no OBS, gravá-la, projetá-la e compartilhá-la em uma videoconferência.

Foi dado exemplo com o Google Meet, porém imagino que fazer o mesmo com outras plataformas, como Zoom ou Teams, seja tão simples quanto nesse exemplo.

Gráficos vetoriais em PDF

Eu estava usando o LibreOffice Calc para criar gráficos para minha dissertação, porém não estava muito feliz com a conversão para imagem (PNG e JPEG). A solução é utilizar uma opção de exportação para e obter gráficos vetoriais em PDF, que pode ser aproximado sem perda de qualidade.

Criando os gráficos

A Planilha1 vamos deixar para os gráficos. As tabelas e cálculos ficam nas demais planilhas.

Na Planilha2 vamos criar duas tabelas: uma para o gráfico de uma reta e outra para parábola. Eixo X nos limites desejados e eixo Y calculado a partir do eixo X. A partir disso criamos dois gráficos: da reta e da parábola.

Veja que os gráficos possuem dimensão padrão de 16 cm x 9cm. No gráfico, clique com o botão contrário e selecione “Posição e Tamanho”.

Formatando a página

De volta à Planilha1, vamos formatar a página para que os gráficos caibam exatamente na página.

Selecione a Planilha1, entre em Menu Formatar > Página.

Na aba Página, configure Largura 16,1 cm, Altura 9,1 cm e as quatro margens 0 cm.

Na aba Cabeçalho, desative o cabeçalho. Na aba Rodapé, desative o rodapé.

Clique em OK para finalizar. O LibreOffice vai reclamar sobre as margens e impressão, aceite clicando em Sim.

Agora cada página possui tamanho 16,1 cm x 9,1 cm, um pouco maior que os gráficos, e não possui margens, cabeçalho ou rodapé para roubar espaço.

Organizando os gráficos

Agora recortamos os gráficos criados nas outras planilhas e colamos na Planilha1, um gráfico em cada página. Isso vai colocar um gráfico em cada página do PDF.

Para ver as divisões das páginas entre no menu Exibir > Quebras de página. É possível ajustar a altura e largura das células. Recomendo quatro colunas de 4 cm e três linhas de 3 cm.

Exportanto para PDF

Agora, para gerar o PDF com os gráficos, selecione a Planilha1, entre no menu Arquivo > Exportar como PDF, configure para imprimir seleção/planilhas selecionadas e clique em exportar.

Agora temos um arquivo com vários gráficos dentro dele. Ter menos arquivos é ótimo!

Importando no LaTeX

Agora basta importar os gráficos no seu documento LaTex:

\includegraphics[width=0.7\textwidth,page=1]{fig/Graficos.pdf}

Basta indicar qual a página que quer incluir com a opção page=?.

Também é possível recortar margens do gráfico importado usando as opções trim (ajustar as margens) e clip (recortar fora das margens):

\includegraphics[width=0.7\textwidth,page=2,trim=0.5cm 0.5cm 0.5cm 0.5cm,clip=true]{fig/Graficos.pdf}

Os comprimentos da opção trim são: esquerda, embaixo, direita e topo.

Então está feito!

Desta forma é possível criar gráficos vetoriais em PDF de qualidade utilizando o LibreOffice Calc, para inclusão em documentos LaTeX.

Alem dos gráficos vetoriais maravilhosos,outra vantagem é poder agrupar vários gráficos em um único arquivo PDF, ficando mais fácil organizar a pasta de imagens.

Software R no Ubuntu Linux

Instalando software R

É fácil instalar o software R no Ubuntu Linux. Use o comando abaixo:

$ sudo apt install r-base

Executável em linguagem R

No Linux podemos criar scripts (programas executáveis em arquivos de texto) e marcá-los com uma configuração para que possam ser executados facilmente. Basta usar o comando chmod. Assim podemos executar o programa com o comando ./PROGRAMA.

$ chmod +x PROGRAMA
$ ./PROGRAMA

Linux, a linguagem é R!

Mas e se o programa estiver escrito na linguagem do software R? Como fazer para o Linux saber que deve ser executado com na linguagem de programação R?

Basta colocar a seguinte primeira linha do programa em software R:

#!/usr/bin/r
# Programa ...
print(1+1)

#!/usr/bin/r – faz o Linux saber que o programa está escrito na linguagem do software R, já com opções adequadas para execução de scripts.

Outra opção, que imprime os comandos e as respostas intermediárias é o seguinte:

#!/usr/bin/R --vanilla -q -f
# Programa ...
print(1+1)

#!/usr/bin/R – faz o Linux saber que o programa está escrito na linguagem do software R.

--vanilla – faz o R não salvar, nem restaurar, o espaço de trabalho.

-q – faz o R não imprimir a versão

-f – indica que o R deve ler o próprio arquivo sendo executado (./PROGRAMA)

Para explorar mais opções verifique o manual do programa R. Só não se esqueça de deixar a opção -f por último!

man R

Memória de programa AVR/ATmega328P

Sempre que utilizamos strings e arrays constantes em nossos programas, por padrão elas vão parar na memória RAM. Como tempo pouca memória RAM, seria ótimo conseguir colocar isso na memória de programa, liberando a preciosa RAM para as variáveis.

Neste post vemos como fazer isso nos microcontroladores AVR, como o ATmega328P do Arduino Uno.

Continue lendo “Memória de programa AVR/ATmega328P”

Reduzindo o programa AVR/ATmega328P

O seu programa está grande demais? Muito lento para gravar o microcontrolador? Não cabe na memória? Vamos reduzir o programa!

Há alguns truques simples para reduzir o tamanho dos programas e, se não está utilizando todos, as chances são que seu executável está maior do que o necessário.

Vejamos como podemos reduzir o tamanho do programa gerado pelo compilador.

Continue lendo “Reduzindo o programa AVR/ATmega328P”

Compilando código C/C++ com Makefile

Neste post mostramos como criar um Makefile para realizar a compilação de programas C/C++.

Makefiles são muito bons pra automatizar a execução de comandos, evitando ter que digitá-los toda vez.

Também gerenciam dependências entre arquivos, recompilando apenas o que é necessário.

Continue lendo “Compilando código C/C++ com Makefile”

TDD: Testando código C/C++ com Gcov

No post anterior (TDD: Testando código C/C++ com Boost.Test), explicamos como se cria uma suíte de testes com a biblioteca Boost.Test. Muito útil para testar a funcionalidade correta do código.

Neste post mostramos como utilizar o Gcov para verificar se todo o código é executado pelos testes. Criamos uma biblioteca simples e um conjunto de testes para ela.

Ferramentas de code coverage (cobertura de código) como Gcov são muito utilizados para “Desenvolvimento a partir de testes” (TDD – Test Driven Development).

No TDD desenvolvemos os códigos e seus testes em paralelo, para verificar que o código funciona e, no futuro, poder verificar se alguma mudança no código tenha causado um bug.

A análise da cobertura de código auxilia no TDD, identificando partes do código que não estão sendo testadas por completo.

Continue lendo “TDD: Testando código C/C++ com Gcov”

TDD: Testando código C/C++ com Boost.Test

Neste post mostramos como utilizar a biblioteca Boost.Test para testar seus códigos. Podemos compilar a biblioteca junto aos testes, sendo também possível utilizar uma versão pré-compilada para melhorar o tempo de compilação.

Bibliotecas de teste são muito utilizados para “Desenvolvimento a partir de testes” (TDD – Test Driven Development).

No TDD desenvolvemos os códigos e seus testes em paralelo, para verificar que o código funciona e, mais importante, no futuro poder facilmente verificar se alguma mudança no código tenha causado um bug.

Continue lendo “TDD: Testando código C/C++ com Boost.Test”