Postagem em destaque

Controle PID de Potência em Corrente Alternada - Arduino e TRIAC - Parte I

Este post é o primeiro de uma série de seis que escrevi tratando de controle de potência e PID (controle proporcional, integral e derivativo...

sábado, 29 de setembro de 2018

Fazendo Cerveja III - Método #Fófis

Deixei a nossa cerveja maturando por uma semana na temperatura ambiente, num canto fresco da casa e ao abrigo da luz solar. Depois coloquei na geladeira (tem uma geladeira do condomínio que fica ligada sem nada dentro, então...) a uns 5°C por mais uma semana.

Ao fim e ao cabo, retirei o balde da geladeira e preparei a passagem da fase de maturação para o primming, última etapa a nos separar da degustação.

Quando vc abrir o balde, poderá já provar a sua cerveja. Ela já terá o sabor que vc vai beber ao final do preparo. Se tiver acontecido alguma contaminação, ela estará ruim (muito ácida), então é simplesmente jogar fora e começar de novo... se a fermentação não tiver sido completa, ela pode estar um pouco adocicada, aí dá pra salvar na próxima etapa.

Se a cerva estiver no ponto, falta apenas gás, certo? O gás da cerveja é o CO2, e vc tem que adicioná-lo de alguma forma. Esse processo de adição de CO2 é chamado carbonatação, e pode ser feito de duas formas:

Image result for equipamento post mix1) Se vc tem um equipamento post-mix como esse aí do lado, pode simplesmente encher o recipiente de cerva, ligar as mangueiras, abrir a válvula do gás e cair pra dentro! Só alegria!










2) Se vc, como eu, não tem o post-mix, então o jeito é improvisar. O processo descrito a seguir chama-se primming, e nada mais é do que aproveitar o resíduo de fermento que ainda tem misturado na cerva pra adicionar o CO2 prá nóis.

Para obter esse resultado, vc deve engarrafar a sua cerveja, e para isso precisamos de alguns insumos:

a) Garrafas (dããããã!) que vão caber o volume que vc produziu.

b) Tampinhas de garrafa "abertas", que vc compra nas lojas do ramo

c) Uma ferramenta de aplicar a tampinha na garrafa.

d) Açúcar (qualquer tipo serve, eu uso cristal).

A ideia é a seguinte: misturado com a cerva tem algum resíduo de fermento que ficou em suspensão quando vc trocou de balde. A ideia é dar açúcar pra ele "comer" e produzir CO2 (e também álcool, o que não atrapalha, né?). Então a gente adiciona açúcar à cerveja, engarrafa e tapa a bicha, deixando a garrafa na temperatura ambiente. O fermento acordará e processará o açúcar, dando a carbonatação à nossa cerva.

Existe uma tabelinha que diz a quantidade de açúcar por litro:

Estilo com Baixa Carbonatação: 4g de açúcar por litro;
Estilo com Média Carbonatação: 5-6g/l;
Estilo com Alta Carbonatação: 7-8g/l.

E o que nos diz se uma cerveja é de baixa, média, ou alta carbonatação? A receita que estamos fazendo. Uma regra geral é: quanto mais álcool, menos carbonatação. Assim, as escuras inglesas, caso dessa que estou fazendo, as stouts, Porters e tal são de baixa carbonatação. A Canadian Blonde que eu estou fazendo junto com essa seria de maior carbonatação, e as de trigo (Weiss, Wit) são as de carbonatação mais alta.

Mas vai do gosto do freguês tb, né? Eu gosto de cervas mais carbonatadas, de modo que taquei açúcar nessa English Bitter... 😂😂😂. Coloquei 7g/litro.

Bora trabalhar?

Primeiro as garrafas: dessa vez estou experimentando uns growlers de plástico especiais pra cerveja, de dois litros cada. Comprei dez a R$ 10,00 cada, pra caber parte das duas cervas, pretendo levar vinte litros pra Escarpas no dia 12/10. Pretendo reutilizá-los, o povo diz que dá certo, é só comprar mais tampas.

Image result for growler plastico cerveja

Como a cerveja não vai caber toda nos growlers, porque ainda tem a outra, separei seis pra essa e o resto vou engarrafar. Se vc tiver uma geladeira para deixar cerveja no balde, pode deixar maturando mais uma parte, mas o ideal é engarrafar tudo de uma só vez.

Primeiro higienize MUITO as garrafas. Aí tem um monte de jeito diferente de fazer. Eu uso detergente com uma daquelas escovinhas de limpar mamadeira por dentro. Em seguida enxáguo bem e  borrifo álcool lá dentro, fazendo com que ele percorra a garrafa toda. Jogo fora o álcool e dou o serviço por terminado. Tem gente que passa iodo, põe garrafa no forno etc.

Em seguida, coloque o balde num lugar alto (em cima da pia ou de uma mesa), colocando uma cadeira em frente pra ficar confortável.


Taí o balde aberto. Pegue um copo bem limpo e prove. Sua cerva será isso com gás.

















Balde posicionado...


















Garrafas higienizadas... observem que eu vou usar umas garrafinhas de 300 ml. Isso porque quero dar algumas de presente, aí quanto menor a garrafa, mais amigos homenageados!












A patroa é craque em encher garrafa, e eu sou melhor em tampar, então montamos um "tempos e movimentos" (saudoso Evaldo Cordeiro!) pra agilizar a bagaça.

Deve-se tentar evitar ao máximo que a cerveja borbulhe, para não aerá-la. O oxigênio é inimigo da cerva, lembram?













As tampinhas também devem ser higienizadas com álcool. Na hora de aplicá-las às garrafas, chacoalhe pra tirar o excesso.












Esse é o aplicador de tampinha que eu uso. Ele tem um ímã que segura a tampinha pra ser aplicada, e parece uma espécie de alicate: coloca na boca da garrafa, aperta, dá uma giradinha, aperta de novo e pronto: prego batido, ponta virada!











































E taí! Seis growlers de 2 litros cada, 21 garrafinhas de 300 ml e duas garrafas com tampa que ganhei de um amigo. Rendeu uns 19 litros de cerva, o que significa um custo de R$ 130,00 / 19 = R$ 6,73/litro.

Se calcular por garrafa de 600 ml dá R$ 4,00. Bem em conta, né? Fora a diversão... 














Agora é esperar no mínimo uma semana com as garrafas à temperatura ambiente, por pra gelar e...

Saúde! Prost! Salud! Santé! Cheers! Kippis!

domingo, 16 de setembro de 2018

Fazendo cerveja II - Método #fófis

Ingredientes e equipamentos à mão, boralá começar.

- ESTERILIZE os equipamentos, as mãos, tudo o que puder entrar em contato com a cerveja ou com suas mãos. Eu passo álcool até no celular. A maior causa de perda de cerveja é contaminação, e eu nunca perdi nenhuma por isso. Como o processo #roots envolve fervura e cozimento e esse aqui é feito na temperatura ambiente, pode ser que a chance de contaminação inclusive seja maior.

Abra a lata com o malte.

Lá dentro tem um líquido bem viscoso (segundo a pequena Karina, "Nutella"). Se quiser, prove. É malte concentrado, bem doce porque o malte realmente é um grão com bastante açúcar.





















- Coloque o bicho em banho-maria por uns 10 min pra facilitar a retirada do extrato.

- Derrame o extrato no balde

- Dissolva um kg de açúcar cristal em dois litros de água quente e acrescente ao balde. Detalhe: no processo #roots nunca adicionei açúcar, mas tem muito cervejeiro bom que adiciona. Como esse processo pra mim é novo, sigamos o manual.

- Misture bem e complete com água até 1 cm abaixo da borda. Lembre-se que quanto mais água, mais cerva..

- Abra o envelope do fermento, despeje em um recipiente que vc tenha esterilizado previamente e dissolva em uns 150 ml de água.

- Coloque a tampa com o sifão. Aqui o sifão improvisado que eu fiz e deu muito certo, caso vc não queira comprar um.

E o que é a fermentação? É a transformação do açúcar presente nos grãos da receita (ou adicionado, como foi nosso caso) em álcool. Ou seja, no fundo, quem "faz" a cerveja é a levedura ou fermento, que é basicamente um fungo que, de forma anaeróbica (sem a presença de ar, por isso é importante a vedação do balde), "come" o açúcar e o transforma em álcool.

Como um subproduto da fermentação é gás (CO2), se a gente simplesmente vedar o balde com a tampa pra que o ar não entre (anaeróbico, lembra?) o balde vao acabar explodindo a tampa, né?

É aí que entra o sifão. É um dispositivo que permite que o CO2 produzido no balde escape pra atmosfera ao mesmo tempo em que impede o ar de entrar no balde. Vc pode usar um sifão comprado pronto (é baratim) em casas especializadas ou construir um, o que funciona muito bem. No post anterior eu descrevi como construir um.


É recomendada uma temperatura de fermentação de 18 a 24°C, e cá em Sanja dentro de casa anda fazendo 14. É muito pouco, a fermentação não começaria com essa temperatura.

O que fazer, então? Ser criativo:

Primeiro coloquei o balde na dispensa, um quarto pequeno e sem janelas.

Depois esperei a primeira noite e o promeiro dia pra ver se a fermentação "pegava". Como o processo fermentativo produz calor, uma vez que ele começa ele meio que se realimenta, crescendo em intensidade até que todo o açúcar seja processado.

E... nada!

Depois coloquei um aquecedor desses domésticos para aquecer o balde, de maneira a elevar a temperatura.

Aí o processo começou a acontecer, ainda tímido, como vcs podem ver no vídeo aí embaixo.









A mistura borbulha por cerca de um dia, mas a fermentação continua acontecendo depois disso, então temos que esperar por sete dias para que todo o açúcar seja realmente processado. Também ocorrem outros processos que tem a ver com o fermento, mas sobre esses não vou entrar em maiores detalhes.

Ao fim dos sete dias a fermentação termina. É hora de passar pra maturação, que é onde a cerveja vai apurar seu sabor.

Pra interromper a fermentação é necessário separar a cerveja do fermento, que a essa altura estará decantado no fundo do balde. Assim sendo, basta derramar a cerva devagarim pra dentro do balde de maturação cuidando para que o fermento se mantenha no fundo do balde de fermentação, sem passar pro balde de maturação. O balde de maturação é aquele em que colocamos uma torneirinha, lembra? A torneirinha var ser usada pra transferir a cerveja para a garraja, na mudança de maturação para o primming.

Taí o filminho do processo:



Taí uma imagem do fundo do balde de fermentação, com o fermento.

Observe que colocamos uns 20g de fermento e no fim tem mais ou menos 10 vezes isso no fundo do balde. É que o fermento, sendo um ser vivo, em presença de um ambiente favorável se reproduz. Esse fermento aí pode ser guardado em geladeira e reutilizado, mas como provavelmente as próximas cervejas que farei serão no mesmo processo e o fermento já vem quando a gente compra o extrato de malte, joguei o bicho fora.

Depois de transferida a cerva, vc pode observar que o volume deu uma "abaixada". Isso é fruto da evaporação, do consumo de açúcar e da própria retirada do fermento:

 Não é pecado, vc pode completar o balde com água pura (do mesmo tipo que vc usou na mistura). Como eu não tinha dessa água em casa e o parque já estava fechado na hora em que eu fiz a interrupção da fermentação, não pude completar, ou seja, perdi uns 2 litros de cerveja da boa... :(









Agora, é vedar o balde com a tampa (dessa vez sem furo, porque não vamos por o sifão) e esperar uns 15 dias para que a maturação se dê.

No próximo post, a descrição da transição para o primming, última etapa que nos separa da cerveja boa!

quarta-feira, 12 de setembro de 2018

Fazendo cerveja I - método #fófis


Image result for extrato de malte de cevada 

Depois de mais de dois anos sem cozinhar uma cerva, resolvi retomar a divertida e saudável atividade.

Confesso que o que me motivou foi descobrir um método mais tranquilo de fazer cerveja, a partir de extrato de malte lupulado. Algo assim como o da figura ao lado.

Esse é do tipo líquido (na realidade um melado bem viscoso). Tem em pó tb, e acham-se as mais diversas receitas.

E porque esse método é mais tranquilo? Bom, o "fazimento" de cerveja é composto de quatro etapas, de maneira geral: brassagem, fermentação, maturação e primming. Vamos ver essas etapas em detalhes mais adiante.

A etapa da brassagem é a mais complicada. Da maneira tradicional seria necessário (resumo):
  • Moer o grão
  • Cozinhá-lo (o que implica em controle preciso de tempo e temperatura, o que demora em torno de umas duas horas)
  • Tirar os grãos cozidos da panela
  • Continuar cozinhando, de olho no relógio e no termômetro
  • Adicionar o lúpulo
  • Ao fim do cozimento, esfriar o mosto (líquido produto do cozimento) até a temperatura ambiente
  • Colocar no balde de fermentação
  • Colocar a fermento no mosto
  • Fechar o balde, colocando a válvula
  • Lavar tudo, inclusive a enorme panela, claro.

Dá pra ver o trampo, principalmente se estamos falando de uma panela de mais de 20 litros, como é o caso da que eu uso. Aí estão imagens da etapa de resfriamento, onde dá pra ver o calderão de cozimento, o fogareiro, o schiller (resfriador de cerveja, que a gente fez) e o balde de fermentação.












Já o "processo #fófis é bem mais simples, tendo vantagens sobre o processo "roots", mais tradicional. Vou comparar os dois listando as vantagens do último:
  • Investimento inicial mais baixo: se vc for começar a fazer cerva, pra fazer 20 litros do método #roots vc terá que investir uns R$ 1.200,00 em equipamentos. Já no método #fofis vc terá qe gastar uns R$ 250,00 pra começar (os dois valores são sem os insumos, só equipamento). Se vc se dispuser a constriur pelo menos parte dos equipamentos, poderá gastar uns R$ 600,00 no primeiro e ZERO no último! E depois ainda poderá usar o que tiver montado pro método #fofis no #roots, caso deseje depois passar a fazer cerva a partir do grão.
  •  Ideal pra quem tá começando, por ser mais simples e rápido e não exigir o cozimento, que é a etapa mais complicada.
  • Rapidez: No método roots, como tem a brassagem, demora umas 5h para passar à fermentação. No #fofis, dá pra iniciar em 1h, eu acho. Da primeira vez que eu fiz, como tive alguns imprevistos, demorou umas 3h.
  • Possibilidade de fazer mais de uma leva por dia: como é mais rápido...
  • Equipamento e ingredientes ocupam menos espaço pra guardar e usar: por exemplo, meu kit de 20 litros do processo tradicional não dá pra fazer na cozinha de casa, tem que ser na área de lazer do prédio. Já o método a partir do malte líquido fiz na cozinha de casa.
  • Perfeito pra testar novas receitas
  • Custo de produção: semelhante nos dois casos, mas o método #fofis ai um pouco mais caro por litro produzido.
Bom, boralá descrever como fazer, então. A diferença entre os métodos é só no início, ou seja, não tem a etapa de brassagem (cozimento), então essa será a etapa mais detalhada. Depois farei posts sobre as outras etapas. Nesse post falarei dos equipamentos e insumos necessários. Depois vou escrever um outro sobre o post em si.

a) Equipamentos

Dois baldes plásticos de aproximadamente 22 litros de capacidade, com tampa: esses baldes podem ser comprados numa loja de insumos cervejeiros ou simplesmente "ganhados": normalmente padarias e restaurantes compram insumos nesses baldes, e vc pode pedir pra eles alguns. Vale lembrar que, caso vc vá reutilizar baldes, SOMENTE USE aqueles que já tiverem sido usados pra guardar ALIMENTOS. Não tente usar um balde de tinta, já que o cheiro não sairia na lavagem.

Se vc optar por comprar a válcula de fermentação e não construir uma (instruções abaixo), sugiro que vc compre também o balde já com a tampa, porque os caras colocam uma bucha de borracha que facilita o acoplamento entre a válvula e a tampa, como vc pode ver na foto ao lado.

Caso vc opte por reutilizar o balde, essas são as instruções de como fazer:

Lave MUITO BEM o balde. Lavou. ficou sem cheiro algum? Lave de novo!

Em seguida, esterilize com álcool e guarde, de preferência tampado.








Num dos baldes, o de maturação, vc deve adaptar uma torneirinha dessas de filtro d´àgua. Coloque a torneira o mais baixo possível no balde, pra ficar mais fácil tirar a cerva do fundo depois, mas de maneira que ela não toque o chão quando o balde estiver apoiado. Cuide para que a vedação da torneira seja perfeita.














Uma válvula de fermentação: vc pode comprá-la pronta ou fazer uma usando o fundo de uma garrafa PET e um pequeno pedaço (uns 30 cm) de mangueira de chuveiro. Ela pronta deve custar uns R$ 30,00 no máximo.

Aí ao lado a imagem da válvula feita com garrafa PET. Faça um furo na tampa um pouco menor que o diâmetro da mangueirinha. Insira uma ponta da manguera no furo, deixando uns 0,5 cm ou menos pra dentro da tampa. Vede com o bom e velho Araldite, cola branca ou silicone, sempre do lado externo da tampa.

Corte um recipiente de uns 7 cm de altura no fundo da garrafa PET. Na hora de usar, coloque água até 1 cm abaixo da borda, coloque o recipiente em cima da tampa e a outra ponta da mangueirinha dentro da água. Pronto!



Uma "colher de pau de plástico", ou pá de mexer cerveja: necessária para misturar os ingredientes quando necessário. Essa pode ser encontrada em lojas de cerveja, no Mercado Livre etc. Quando for comprar o extrato de malte vc pode comprar uma.









Opcional: um densímetro. Equipamento útil para acompanhar o andamento das etapas de fabricação de cerveja, já que, como o álcool é menos denso que a água, a densidade vai caindo à medida em que vai ocorrendo o aumento de álcool na futura cerveja. Nunca usei, então não vou falar sobre. O que eu faço é deixar sempre o "tempo regulamentar", quer dizer, deixo fermentando o número de dias adequado para aquele processo. Se medisse a densidade, poderia diminuir o tempo de processamento.

b) Insumos

Lata de extrato de malte líquido

A receita que escolhi fazer foi uma English Bitter. Porque escolhi essa? Gosto muito das cervas inglesas, então escolhi basicamente pelo nome. O cara da loja também falou que eles fizeram e ficou muito boa. Mais sobre ela aqui.

Esses produtos são importados, mas são encontrados nas lojas que vendem insumos cervejeiros. Não acho que seja muita vantagem comprar para ser entregue pelo correio, já que a lata é bem pesada.










Fermento: acima da lata vem uma tampa plástica. Debaixo dela tem o envelope de fermento adeuado a aquela cerva.

30 litros de água pura não tratada: todo mundo já ouviu falar que a água é muito importante para a fabricação de cerveja, e de fato ela é. A presença de cloro na água de fabricação da cerveja pode prejudicar a fermentação e gerar compostos de cloro que dão um cheiro bem ruim na cerveja, fazendo com que a gente tenha que jogá-la fora.

Vc pode comprar água mineral, uns dois galões porque um só não dá, ou então pegar água da torneira e ferver por uma hora anter de começar o processo de fabricação ou ainda usar uns filtros de carvão ativdado que se vendem nos Leroys da vida.

1 kg de açúcar cristal.

O processo mesmo será descrito no post Fazendo Cerveja II - método #fófis.

domingo, 22 de julho de 2018

Música, maestro Raspberry Pi!

"A música é a matemática que canta. A matemática, a música que conta."

Se eu tenho uma frustração na vida e nunca ter aprendido a tocar um instrumento decentemente. Estudei piano por cinco longos anos e não toco nem o bife, estudei clarineta, tenho um violão (nesse até fiz minhas serenatas em Viçosa, mas tb não toco). Não desisto, agora mesmo ando pensando em comprar um teclado melhor. Como sou um cara bom de teoria, leio partitura, tenho noções de arranjo e composição, ou seja, o que dei conta de aprender, aprendi. E de vez em quando a música traz alguma diversão além da audição e aplauso, que é o que normalmente me cabe nessa hostória.

Estou ajudando um aluno num projeto legal, uma harpa laser. Como ele é baseado no Pi, fomos estudar as alternativas pro bichinho lidar com o assunto, e como Python é a "melhor linguagem de programação da última semana", demos preferência a bibliotecas escritas para essa linguagem.

De cara achamos um negócio chamado SuperCollider. É simplesmente sensacional! Basicamente são três troços:

1)  scsynth, um sintetizador em tempo real muito sofisticado com um monte de plugins e outros gadgets.

2) sclang, uma linguagem de programação interpretada específica para esse ambiente.

3) scide, um IDE (editor de programas) que, claro, integra as duas outras ferramentas.

A instalação do SuperCollider no Pi foi bem fácil, seguimos basicamente o que está aqui. Como tem que compilar, é demorado, então se vc quiser brincar num dia convém colocar pra intalar na noite anterior... ;)

Pra fazer o Pi se comunicar com o SC estamos usando o pythonosc. A comunicação se dá no protocolo UDP, então eu acho que qualquer lib de UDP deve dar legal.

Ontem foi o dia em que comecei a me exercitar com a parte de software. Resolvi fazer um "pograminha" que, uma vez fornecido um tom e a escala (altura da nota), calcula-se a escala maior ou menor correspondente e toca-se a escala.

Usei aquela notação musical que chama as notas pelas letras A (lá) a G(sol), seguida de um # indicando o sustenido. Assim, D# é o nosso ré sustenido. Usei números para indicar a oitava, sendo que C0 é o dó grave da escala do piano e o A4 é o lá do "dó da chave", aquela oitava que fica no meio do piano, perto da chave de sua tampa. Como existem diferentes tipos de escala menor, escolhi a escala menor natural, mas se alguém quiser trocar, é só alterar a variável minorinterval para a estrutura correspondente.

Abaixo o código Python devidamente comentado.

import serial
import time
from pythonosc import osc_message_builder
from pythonosc import udp_client
from math import log2, pow

C0 = 16.352 #C0 pitch frequency im Hz
semitone = pow(2,1/12) #one semitone 
octave = semitone * 12

# SuperCollider UDP client, default port=57120
client = udp_client.SimpleUDPClient("127.0.0.1", 57120)

# Chromatic scale
pitchname = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#','G', 'G#', 'A', 'A#', 'B']

# scales intervals, 1 for tone, 0.5 for semitone. 
majorinterval = [1,1,0.5,1,1,1,0.5]

minorinterval = [1,0.5,1,1,0.5,1,1]

# stops SC sound
def silent():
    client.send_message("/print",0)

# Calculate corresponding frequency for a pitch (A..F) and a octave, using:
# f=2^(pich/12)*(C0frequency)
def freq(pitch, octv):
    global pitchname,C0
    p=pitchname.index(pitch) + (12 * octv)
    return pow(2,p/12)*C0

# play a note (pich) in a octave for duration (dur) in secs.
def play(pitch,octave,dur=0.5):
    client.send_message("/print",freq(pitch,octave))
    time.sleep(dur)

# return a scale based in tonic (fundamental note), octave and scale type (major False=minor scale')
# Example: if you call getScale('C',4,False) it returns:
# [('C',4),('D',4),('D#',4),('E',4),('F,4),('F#',]
def getScale(tonic,octv,major):
    interval = majorinterval if major else minorinterval
    s=[]
    n=pitchname.index(tonic)
    for i in range(0,7):
        s.append((pitchname[n],octv))
  # if we reach the end of chromatic scale, should go back to beginning and increment scale
        if n == 11:
            n=-1
            octv+=1
        n+=int(2 * interval[i % 7])
    return s

# Play a scale generate by getScale
def playScale(scale):
    for pitch,octave in scale:
        play(pitch,octave)
    silent() 

s=getScale('C',4,True)
print(s)
playScale(s)

s=getScale('A',3,False)
print(s)
playScale(s)

s=getScale('F#',6,False)
print(s)
playScale(s)

s=getScale('D',3,True)
print(s)
playScale(s)

Abaixo, a saída da rotina acima rodando, escalas de CM, Am, F#m, DM, respectivamente na quarta, terceira, sexta e terceira oitavas a partir do dó mais grave do piano.


[('C', 4), ('D', 4), ('E', 4), ('F', 4), ('G', 4), ('A', 4), ('B', 4)]
[('A', 3), ('B', 3), ('C', 4), ('D', 4), ('E', 4), ('F', 4), ('G', 4)]
[('F#', 6), ('G#', 6), ('A', 6), ('B', 6), ('C#', 7), ('D', 7), ('E', 7)]
[('D', 3), ('E', 3), ('F#', 3), ('G', 3), ('A', 3), ('B', 3), ('C#', 4)]

Aqui o código SuperCollider, que basicamente recebe a mensagem de frequência e a toca:

(
SynthDef.new(\teste, {|
 freq = 440, gate = 1,
amp = 0.5, out = 0|
 var synt1;

 synt1 = SinOsc.ar(freq,0);

 Out.ar(out,synt1);
}).add;

~x=Synth(\teste, [\freq, 440]);

~a = OSCdef(\oscTeste,
 {
   | ... msg | msg.postln;

   ~x.set(\freq, msg);
 },
 '/print'
);
)

Por fim, um videozinho da bagaça a funcionar:


É isso! À medida que o projeto for avançando, posto outras novidades.

Ah, e enquanto escrevia essas maltraçadas estava a escutar esse primor, #ficadica.

Abracadabrass!

domingo, 27 de novembro de 2016

Conceitos em automação: threshold (limiar) e calibração

Sabadão estivemos mais uma vez no parque Santos Dumont para o nosso Automação no Parque.

Um projeto interessante que apareceu foi um "míssil" (na verdade uma maquete) a ser controlado por uma fonte de calor. O sensor infravermelho acabou sendo substituído por um LDR, porque o aluno apanhou do funcionamento dos primeiros. Isso, claro, não muda o conceito.

O protótipo está muito bem feito, como vcs podem ver na imagem abaixo.

Do lado esquerdo é a "ogiva", onde estão localizado os quatro sensores LDR, um pra cima, outro pra baixo, e um pra cada lado.

Em seguida vem uma plaquinha especializada que o aluno construiu para lidar com os infravermelhos. Como ele não tá usando mais esse sensor (eu sugeri que ele volte a usar), usamos um Arduino Uno em nossos testes.

Seguindo o corpo do "míssil" vcs podem ver em seguida o servo que controla as aletas de direcionamento esquerda/direita (se clicarem na figura ela dá um zoom e fica mais fácil de ver), depois vem o mecanismo de engrenagem dos eixos vertical e horizontal, e por fim vem o servo que controla o eixo da inclinação horizontal.

O aluno já trouxe um "pograminha" pronto, que não funcionava. A ideia é que eu achasse o motivo e ajudasse-o a consertar.

O aluno em questão faz parte de um programa de especialização em automação e controle aqui de SJC.

Ao analisar o programa do cabra, constatei que ele não funcionava porque ele não tinha atentado para dois conceitos básicos de automação industrial: threshold e calibração. Sem entrar na discussão sobre o porque disso, muitas vezes os alunos me procuram no Parque por esse tipo de demanda, quer dizer, está faltando um pouco de atenção talvez com o currículos desses cursos por aqui.

Como no Automação no Parque a gente mata a cobra e mostra o pau, quer dizer, ajuda a resolver os pepinos, abacaxis e outros vegetais de duplo sentido e ainda ensina a mágica, resolvemos a questão juntos e o camarada entendeu direitinho os dois conceitos, que passo a explicar aqui. Observe que minha intenção não é esgotar o assunto, mas dar uma visão geral e ao mesmo tempo prática para que os leitores possam entender e usar esses conceitos essenciais na ciência de automação.

Calibração


Podemos classificar os sensores de várias formas: ativos e passivos, elétricos, pneumáticos eou mecânicos etc. Para efeito de calibração, podemos dizer que existem sensores que precisam de calibração e os que não precisam.

Como exemplo, vamos comparar dois sensores de temperatura, um termistor e um LM35.

Resumindo o que vc pode ler nos dois links, o termistor é um sensor passivo (ou seja, não demanda energia de alimentação para funcionar) enquanto que o LM35 é um sensor ativo que possui um pequeno circuito integrado dentro.

O que mais diferencia os dois? O termistor apresenta uma variação na resistência elétrica em função da variação da temperatura, ou seja, se vc precisar fazer uma leitura da temperatura vc tem que calibrá-lo. Isso significa ser necessário determinar a resistência dele em função da temperatura em alguns pontos gerando uma curva, ajustar uma equação para essa curva e então usar a equação ajustada no seu programa para calcular a temperatura em função da resistência.

Já no caso do LM35 a leitura "já sai" calibrada e linearizada, ou seja, junto com o sensor vem publicada uma constante de mV/°C, então basta vc multiplicar a saída do sensor em mV pela constante e pronto. No caso do Arduino, vc usa o seguinte código, supondo que o sensor está

 // supondo que o sensor está ligado à porta 0 analógica  
 int mv = (analogRead(0)/1024.0)*5000;   
 int temperatura = mv * 10;  

Muito mais simples, sem necessidade de calibração.

No caso dos LDRs, sensores de luz usados pelo nosso míssil, o mesmo sofre grande influência do ambiente, então é necessário calibrá-lo em runtime, ou seja, fazer uma função que calcule o "zero" de cada sensor antes de usá-lo, facilitando a comparação entre os valores deles quando em funcionamento. Exemplo: se vc disparar o míssil com o sol posicionado à esquerda deste, o sensor do lado esquerdo dará leituras mais baixas que o do lado direito (já que quanto mais luz menos resistência) sem que tenha necessariamente um alvo a ser seguido desse lado.

Para isso, usa-se uma função de calibração semelhante à escrita abaixo, que foi usada para o projeto em questão:

 int pinL = 0;  // pinos de conexão dos sensores: esquerda, direita, acima abaixo
 int pinR = 1;  
 int pinU = 2;  
 int pinD = 3;  
 
 long calL = 0; // Valores de calibraçao, a serem calculados na função calibracao()
 long calR = 0;  
 long calU = 0;  
 long calD = 0;  
 
 int iterCal = 50; // Número de iterações para calibração  

 void calibracao()  // função de calibração
 {  
  for(int i=0;i<iterCal;i++)  
  {  
   calL += analogRead(pinL);  
   calR += analogRead(pinR);  
   calU += analogRead(pinU);  
   calD += analogRead(pinD);  
   delay(50);  
  }  
  calL /= iterCal;  
  calR /= iterCal;  
  calU /= iterCal;  
  calD /= iterCal;    
 } 
 
 void setup() {  
  calibracao();  
 } 
 
 void loop() {  
 }
  

A rotina calibração acumula iterCal leituras dos sensores e depois tira a média, achando os valores calL etc.

Para usar esses valores é muito fácil. basta descontá-los na hora da leitura dos sensores dentro do projeto:

 long valL = analogRead(pinL) - calL + 1000;   
 long valR = analogRead(pinR) - calR + 1000;   
 long valU = analogRead(pinU) - calU + 1000;   
 long valD = analogRead(pinD) - calD + 1000;   

Quando se faz essa subtração se elimina algum efeito de diferença de fabricação entre os sensores, ou de posicionamento relativo às fontes de luz ambiente etc.

E porque adicionar 1000? É que com isso nos livramos de valores negativos, já que o desconto da calibração leva a números próximos de zero mas não necessariamente positivos. Como as leituras do LDR variam mais ou menos de 40 a 300, somar 1000 faz com que os valores sejam necessariamente positivos. Para o seu sensor pode ser diferente.

Threshold ou Limiar


Quando comparamos valores de sensores temos que imaginar que eles tem imprecisões, e também que muitas vezes são mais sensíveis do que a gente necessita, captando alterações de valores que são muito pequenas para nos interessar.

Nesse caso, devemos usar um valor de threshold, que nada mais é do que um limite mínimo de variação de valores que deve ser observado para que o sistema considere realmente que houve uma variação. Assim, num sistema de aquecimento por exemplo, em vez de escrever:

if (temp< setPoint)  
   // liga o aquecedor
else 
  // desliga o aquecedor

o que poderia fazer com que o sistema ficasse oscilando, ligando e desligando o aquecimento muito rapidamente, o que no caso de um relé poderia levar a superaquecimento e deterioração do dito, podemos escrever:

if ((setPoint - temp) > threshold)  
 // liga o aquecedor.  
 else  
   if ((temp - setPoint) > threshold)  
   // desliga o aquecedor.  

E qual o valor de threshold? Bom, aí cada caso é um caso. Vc deve ajustar o seu de maneira que o circuito não oscile muito mas também não fique "insensível", ou seja, demore a responder ao distúrbio na variável medida.

Abaixo, outras imagens que o Fábio, dono do projeto, me mandou:







É isso! Por fim, a bagaça funcionando. Com uma lanterna, vou incidindo a luz em cada sensor, como dá pra ver do lado esquerdo do vídeo. Observem o detalhe do grampo de cabelo funcionando como "aleta" do foguete... isso, claro, foi feito para facilitar a percepção da posição nos testes.

Abracadabraço,

Mauro


segunda-feira, 11 de julho de 2016

... e a minha geladeira agora roda Python!

Ultimamente tenho me dedicado a um novo hobby, que é cozinhar a minha própria cerveja. A ideia é produzir 20 litros por sábado, que são divididos com os amigos que participam da farra, ops, trabalho.

Em função disso tenho feito projetos legais de automação ligados ao processo cervejeiro, e agora vou passar a publicá-los cá. Sápassado (como dizemos nós de BH) fiz uma palestra no TDC sobre o assunto e surgiu a ideia de criar uma trilha de Tecnologia Cervejeira por lá ano que vem, então vamos já juntando os assuntos por aqui.

Depois eu pretendo fazer um post sobre o processo de produção de cerveja para contextualizar vcs. O fato é que essa é a minha nanocervejaria:

Toda vez que eu construo um equipamento novo, a mangueirinha do chuveiro de hóspedes encolhe...
Os processos cervejeiros são basicamente quatro: brassagem, fermentação, maturação e primming.

Nesse domingão (ontem) eu e o meu Mestre Cervejeiro Tiago, também programador e praticante do Arduinismo, automatizamos a etapa de maturação.

A maturação consiste em deixar a cerveja em um balde tampado em um ambiente climatizado, com temperatura constante e fria. Dependendo do tipo de cerveja pode haver uma rampa de temperatura, ou seja, começa-se na temperatura ambiente e vai resfriando-se o líquido até uma temperatura de uns 3 °C.

Até outro dia eu fazia essa maturação na geladeira do condomínio, em temperatura constante. Aí resolvi aperfeiçoar o processo fazendo uma câmara de maturação em casa, o que nada mais é do que uma geladeira em que eu consiga controlar a temperatura.

Ao começar a "prospectar" a geladeira, o amigo e colega de cerveja Pedro Valle conseguiu com a sogra dele uma geladeira, e ela ainda nos fez a gentileza de emprestar o veículo para transporte.

Acontece que o termostato da geladeira tava quebrado, então ela tava ligando direto. Com esse frio, olhem o que aconteceu com a cerva...


Pois é, virou picolé... isso deve ter feito com que ela se perdesse, pois o fermento deve ter morrido congelado e ele é necessário para o primming. Vou tentar "consertá-la", mas acho que vai rolar não... :(

Bom, o fato é que precisamos controlar a temperatura da máquina, e a melhor forma de fazer isso foi substituir o termostato "zuado" por um outro. E porque não um Raspberry, de maneira a colocar a geladeira na web?

Eis aí o resultado de algumas horas de trabalho no domingão:


Eu tinha um Pi antigão, relés, o Mauríllio, colega cervejeiro com quem fiz um projeto junto e do qual falarei em outros posts me deu um sensor de temperatura, mais um plug wifi que eu já tinha e a geladeira foi parar na intranet da casa!



Vcs podem ver acima o furo que fizemos na bicha para passar:

- O cabo do sensor

- Um par de fios para se conectar no par que substituiu o termostato, agora substituído pelo relé que dá pra ver na foto em detalhe (aquele gadget com o LED vermelhor aceso).

Daí fizemos uma aplicaçãozinha Python que monitora a temperatura, acionando a geladeira quando passa um grau do setpoint e desligando-a quando passa de meio grau abaixo.

Aqui o monitoramento da dita via telnet:



Bom, é isso. Nos próximos posts vamos aos detalhes.

Abracadabraço,

Mauro




domingo, 6 de março de 2016

Detectando pulsos com o Arduino

Dia desses apareceu no Automação no Parque um velho conhecido, o Bruno, um aluno que trouxe o seu TCC tempos atrás e que foi um dos projetos mais legais que a gente já fez. Foi um controle de potência de chuveiro, que deu origem aos posts mais acessados desse blog, a série sobre Controle de Potência por Ângulo de Fase.

Dessa vez ele trouxe um problema, senão tão difícil,  bem interessante. Ele está fazendo estágio num desses vários centros de pesquisa do governo que tem em SJC (me esqueci qual) e por lá rolou o seguinte problema:

- Os caras tem um equipamento que precisa coletar pulsos de um pouco mais de 2V e de 50µs de duração. Existe por lá um equipamento caro que detecta esse pulso, mas eles querem tentar substituir por algo mais em conta.

A pergunta: será que o Arduino "auguenta"???

Como o equipamento não poderia vir até nós, tínhamos que tentar gerar um sinal semelhante para testar. Prá isso, nada melhor que outro Arduino.

























Circuito "simplão", com um Arduino para gerar os pulsos e outro para detectá-los. O Arduino da esquerda gera os pulsos, o da direita detecta. O potenciômetro ajusta a tensão do pulso, para que possamos fazê-la semelhante ao que o Bruno precisa.

Para monitorar os pulsos, usamos um osciloscópio para monitorar o comportamento da bagaça:

Os pulsos vistos aqui foram os que fizemos inicialmente, de 100µs a cada ms. O potenciômetro foi usado para ajustar a tensão, também medida pelo osciloscópio e ajustada para 2V.









Os pulsos foram gerados pelo seguinte código:

#define P_OUT 7

void setup()
{
  pinMode(P_OUT,OUTPUT);
}

void loop()
{
  digitalWrite(P_OUT,LOW);
  delayMicroseconds(1000);
  digitalWrite(P_OUT,HIGH);
  delayMicroseconds(100);
}

Já na detecção foi usado o seguinte código:

#define P_IN 8

void setup()
{
  pinMode(P_IN,INPUT);
  Serial.begin(115200);
}

long t = 0;
int i = 0;

void loop()
{
  t=pulseIn(P_IN,HIGH);
  if(t==0)
    return;
  Serial.print(t-7);
  Serial.print(' ');
  i++;
  if(i > 20)
  {
    Serial.println();
    i=0;
  }
}

O comando pulseIn do Arduino é chave no processo. Ele espera, na porta P_IN, que um pulso HIGH aconteça. Um pulso HIGH significa que o sinal do Arduino saiu de LOW (0V), foi prá HIGH (mais sobre isso abaixo) e prá LOW de novo. A função retorna a duração, em µs, do pulso detectado.

A função possui um terceiro parâmetro, opcional, que recebe o tempo de espera, quer dizer, quanto tempo a função espera pelo pulso. O default é 1s. Mais informações aqui.

E qual é exatamente o valor HIGH, quer dizer, qual o valor mínimo de tensão que o Arduino detectaria? E qual a mínima largura do pulso, ou seja, quanto tempo o pino tem que ficar HIGH para que o Arduino o detecte? Esse foi o objetivo do nosso experimento, a própria documentação do Arduino fala que tem que ser assim, empiricamente.

O programa de detecção imprime a duração de cada pulso detectado. O valor da variável t é subtraído de 7 porque, depois de vários experimentos, determinamos que  chama da função retorna sempre 7µs a mais a cada valor medido. Talvez seja esse o tempo consumido pela própria função, sei lá eu.

A gente conseguiu baixar a largura do pulso até 5µs, e a tensão até 2,1V. Menos do que isso o Arduino Mega (detector) não conseguia perceber o pulso.


Ao lado, pulso de 5µs.

Acho que depois vale a pena fazer um estudo melhor disso, ver se existem outras implementações do pulseIn na internet, ver se o valor da tensão tem alguma correlação com a largura do pulso (quer dizer, se por exemplo o pulso fosse de 5V, será que ele detectaria um pulso de menos de 5µs de duração?) etc.

De toda forma, atingimos com uma certa folga (pelo menos na largura do pulso) o objetivo buscado pelo Bruno. Ele vai seguir com o projeto e depois (espero eu!) nos dará retorno sobre o que aconteceu.

É isso.

Abaixo, filme do troço funcionando. Dá prá ver os dois Arduinos, o circuito com o potenciômetro, a tela do osciloscópio e os resultados no notebook.




E abaixo, funcionando com pulsos de 5µs a cada segundo. Repare que é bem difícil de perceber o pulso na tela do oscilocópio.

É isso.