Tutorial gnuplot - Introdução

Gnuplot é com certeza o programa open source mais usado para plotar e visualizar dados.

O comando mais importante do gnuplot, é justamente o plot, ele pode plotar funções, como sin(x) ou dado de um arquivo, ele também tem uma variedade de opções e sub comandos que controlam a aparência e a interpretação do dados em um arquivo

Primeiros passos...

Invoque o gnuplot em um shell: gnuplot
Será exibida uma mensagem de boas vindas, e o shell exibirá "gnuplot>"
Para sair, digite quit, exit ou pressione ^C-d

um simples plot seria: plot sin(x)

Plotando um arquivo

 Vamos aprender praticando, com "problemas reais" crie um arquivo de texto simples, sem extensão com o seguinte conteúdo, salve como "sistemas"

#FreeBSD x Debian
#faculdades que aderiram aos sistemas em 10 anos
2001     10      60
2002     15      10
2003     50      20
2004     14      47
2005     23      12
2006     76      38
2007     32      80
2008     7       41
2009     61      22
2010     34      17

 Analisando, na primeira linha, o caractere "#" define como um comentário, o gnuplot ignora a linha inteira, depois temos três colunas, separadas por espaços, a primeira representa o ano, a segunda os valores para o FreeBSD e a terceira para o Debian, no caso o número de faculdades que aderiram aos sistemas

Hora de plotar

 No shell, insira o comando plot, seguido do caminho/nome do arquivo entre aspas, no caso, "sistemas"

gnuplot> plot "sistemas"

o gnuplot vai "adaptar" os dados em um quadro, considerando a coluna 1 como x e a 2 como y, note que só exibiu o básico, precisamos especificar o que queremos para o programa, é ai que entram as opções e sub comandos.

selecionando colunas para x ou y:

é usada a diretiva using no comando plot

>plot "sistemas" using 1:2

vai plotar o tempo, linha 1 em x e o uso do FreeBSD, linha 2 em y.
você pode ainda plotar os dois sistemas simultaneamente, separando por vírgula os dois comandos, assim:

>plot "sistemas" using 1:2, "sistemas" using 1:3

por padrão, os dados de um arquivo são mostrados como símbolos desconectados, gnuplot tem diversos "styles" que podem ser alterados com a diretiva with, os mais usados são with linespoints que conecta pontos por linhas, e with lines, que conecta somente por linhas, assim:

>plot "sistemas" using 1:2 with lines, "sistemas" using 1:3 with linespoints

Estamos indo bem, mas até agora, não sabemos distinguir "quem é quem" no gráfico, o gnuplot cria uma key nada descritiva e associa com o símbolo no gráfico, vamos adicionar uma legenda incluindo title no nosso comando, o title deve vir depois de using, devemos especificar os dados primeiro e depois as descrições, assim:

>plot "sistemas" using 1:2 title "FreeBSD" with lines, "sistemas" using 1:3 title "Debian" with linespoints

Você pode até comparar a relação entre FreeBSD e Debian diretamente, sem o tempo, assim:

>plot "sistemas" using 2:3

serão representadas as colunas 2 como x e 3 como y

Abreviações

 Qualquer comando ou opção pode ser abreviado para uma forma não ambígua, por exemplo:
>plot "sistemas" using 1:2 with lines, "sistemas" using 1:3 with linespoints

ficaria assim:
>plot "sistemas" u 1:2 w l, "sistemas" u 1:3 w lp

Se uma parte de um comando não for fornecida explicitamente, o gnuplot tenta substituir os valores com os ja passados pelo usuário, se não houver sucesso, ele usa padrões, quando não se tem um nome de arquivo, o gnuplot usa o ultimo nome inserido
>plot "sistemas" u 1:2 w l, "" u 1:3 w lp

Em geral, qualquer entrada do usuário se mantém inalterada até ser substituída por outra,

salvando e exportando

 Você pode salvar sua configuração e comandos atuais com:
>save "sistema.gp"
e carregar a sessão novamente com:
>load "sistema.gp"

 Arquivos de comando são texto puro, geralmente um comando por linha, ou são combinados em uma linha separados por ";"
Podemos exportar nosso gráfico para diversos formatos, como png, gif, jpg etc...
 Precisamos antes mudar o tipo de terminal, com o comando set, para o formato desejado, para exportar nosso grafico em png por exemplo, primeiro definimos o tipo de arquivo a ser gerado:
>set terminal "png"
depois escolhemos o nome do arquivo de saída:
>set output "grafico.png"

 Lembrando que devemos voltar o terminal ao modo normal após exportar com o comando:
>set terminal x11

Uma rotina para exportar seria basicamente assim:

Plota o grafico normalmente:
>plot "sistemas" u 1:2 w l, "" u 1:3 w lp

Muda para o formato e saída de exportação:
>set terminal png
>set output "sistemas.png"

Plota a ultima configuração passada ao programa:
>replot

Retorna ao modo normal:
>set terminal x11
>set output

 O comando set output sem argumentos retorna a saída para o modo interativo.
 Lembre-se, o gnuplot se recorda de todas as alterações, então você deve desfazer os comandos após exportar

história

 O gnuplot foi elaborado por volta de 1986, para garantir portabilidade, ele tinha que ser compatível com os diferentes recursos gráficos, que eram muito fracos se comparados aos de hoje, por isso ele usa os terminais como abstração, para o usuário escolher e exportar diversos modos gráficos.

script export

 o comando call, executa todos os comandos existentes em um arquivo, você pode inserir todos os comandos para exportar em um único arquivo e usar o call para executa-lo
 Para melhorar nosso script ainda mais, o comando call aceita argumentos, então podemos inserir o nome do nosso arquivo logo após ele.
insira estes comandos em um arquivo e salve como export.gp para exportar um gráfico em png e retornar ao terminal anterior

set terminal push
set terminal png
set output "$0"
replot
set terminal pop
set output

 Usamos dois pseudo terminais, push e pop, o push salva o estado atual, e o pop restaura o valor do push
agora para criar o arquivo png chamado gráfico, execute :
>call "export.gp" "grafico.png"

 O nome será atribuído a variável $0 dentro do script.
 Lembrando, sempre salve os comandos que fez antes de exportar um gráfico.

Divirta-se!

Válvulas de controle direcional - Pneumática

Características principais

Orienta o fluxo de ar para executar o trabalho proposto.

 

Posições:

 Válvulas direcionais são representadas por um retângulo, dividido no número de posições.

 O número de posições é a quantidade de manobras que uma válvula pode executar.

Vias: 

 São as conexões de trabalho que a válvula possui

--------------------------------------------

 As setas indicam a ligação interna das vias, mas não necessariamente o sentido de fluxo. 

 

 --------------------------------------------

 Passagem bloqueada, como o pŕoprio nome diz, bloqueia a passagem de fluxo.

 

-------------------------------------------- 

  Escape para atmosfera, o fluxo de ar é direcionado diretamente para a atmosfera por abertura na própria válvula. 

   

-------------------------------------------- 

 Escape para atmosfera canalizado.

  

--------------------------------------------

 Número de vias em uma só posição da válvula (é igual em todas as posições).

 

Amplificador TDA2822M

Amplificador TDA2822M C1 - 100uF x 16V C2 - 100uF x 16V C3 - 470uF x 16V C4 - 470uF x 16V C5 - 10uF x 16V C6 - 0.1uF C7 - 0.1uF R1 - 10 KOhm R2 - 10 KOhm R3 - 4.7 Ohm R4 - 4.7 Ohm CI - TDA2822M Relação entre potencia x tensão x impedância Rl |Vs |mW | ---|----|-----| 32 |9 |1000 | -- |6 |400 | -- |4.5 |200 | -- |3 |65 | -- |2 |8 | 16 |9 |2000 | -- |6 |800 | -- |3 |120 | 8 |6 |1350 | - |4.5 |700 | - |3 |220 | 4 |4.5 |1000 | - |3 |350 | - |2 |80 |

LED's Sequenciais

//Efeito sequencial
//Fernando Ferreira Silva, 10/06/2014
//Licença: GPL

byte led_pin[] = {4, 5, 6, 7, 8, 9, 10, 11, 12, 13}; //array para os pinos

int led_delay(70); //intervalo
int direcao = 1;
int led_atual = 0;
unsigned long changetime;

void setup() {
  for (int x=0; x<10; x++) { //define todos como saida
    pinMode(led_pin[x], OUTPUT);
  }
  changetime = millis();
}

void loop() {
  //verifica o tempo da ultima alteraçao
  if ((millis() - changetime) > led_delay) { 
    troca_led();
    changetime = millis();
  }
}

void troca_led() {
  //apaga todos os leds
  for (int x=0; x<10; x++) {
    digitalWrite(led_pin[x], LOW);
  }
  digitalWrite(led_pin[led_atual], HIGH);
  led_atual += direcao; //incrementa o valor de direçao
  //altera a direcao quando chega ao fim
  if (led_atual == 9) {direcao = -1;}
  if (led_atual == 0) {direcao = 1;}
}

Semáforo Interativo Arduino

//Semaforo interativo
//Fernando Ferreira Silva, 18/02/2014
//Licença:GPL

int car_verm = 12;
int car_ama = 11;
int car_verde = 10;
int ped_verm = 9;
int ped_verde = 8;
int botao = 2;
int crossTime = 5000;
unsigned long changeTime;

void setup(){
  pinMode(car_verm, OUTPUT);
  pinMode(car_ama, OUTPUT);
  pinMode(car_verm, OUTPUT);
  pinMode(car_verde, OUTPUT);
  pinMode(ped_verm, OUTPUT);
  pinMode(ped_verde, OUTPUT);
  pinMode(botao, INPUT);
  
  digitalWrite(car_verde, HIGH);
  digitalWrite(ped_verm, HIGH);
}
void loop(){
  
  int state = digitalRead(botao); //verifica estado de S1
  
  if (state == HIGH && (millis() - changeTime) > 5000){
    changeLights();
  }
}
  void changeLights(){
    
    digitalWrite(car_verde, LOW);
    digitalWrite(car_ama, HIGH);
    delay(2000);
    digitalWrite(car_ama, LOW);
    digitalWrite(car_verm, HIGH);
    digitalWrite(ped_verm, LOW);
    digitalWrite(ped_verde, HIGH);
    delay(crossTime);
    
    for(int x=0; x<10; x++){
  
      digitalWrite(ped_verde, HIGH);
      delay(250);
      digitalWrite(ped_verde, LOW);
      delay(250);
      
      }
  
  digitalWrite(ped_verm, HIGH);
  delay(500);
  digitalWrite(car_verm, LOW);
  digitalWrite(car_verde, HIGH);
  
  //registra o tempo
  changeTime = millis();
  
}

Semáforo Arduino

//Semaforo
//Fernando Ferreira Silva, 09/06/2014
//Licença: GPL
int ledDelay = 10000;
int p_verm = 10;
int p_ama = 9;
int p_verde = 8;

void setup (){
     pinMode(p_verm, OUTPUT);
     pinMode(p_ama, OUTPUT);
     pinMode(p_verde, OUTPUT);
}

void loop(){
     digitalWrite(p_verm, HIGH);
     delay(ledDelay);
     digitalWrite(p_verm, LOW);
     digitalWrite(p_verde, HIGH);
     delay(ledDelay);
     digitalWrite(p_verde, LOW);
     digitalWrite(p_ama, HIGH);
     delay(2000);
     digitalWrite(p_ama, LOW);
}