Skip navigation

Category Archives: processing

estivemos de roda da exposição, testar os projectos, e a tratar dos arranjos para o projecto colectivo. já não usamos a mpe, usamos simples osc+udp em rede. vejam mais informações na página do projecto colectivo. bem vindos!

sompensamento-logo709-128

continuamos revisões e dúvidas durante a primeira parte da sessão. depois entramos no laboratório, onde estamos a desenvolver projectos individuais, colectivos e alguns exercícios a alojar na net.

no pure data focámos noções elementares de programação visual, o que é o som digital, como o sintetisamos e o processamos temporalmente, espacialmente ou espectralmente. ler ficheiros do disco, gerar frequências, ruídos, impulsos, granular inputs,  resintetisar frequências, filtrar microfones, analisar níveis de som, criar processos interactivos. (sessões 11, 12)

ainda analisámos comunicação via rede na própria máquina ou entre várias máquinas, entre o pure data, max e o processing, openframeworks. para tal usamos o protocolo osc através de udp para ser mais rápido, criamos objectos que escrevem e lêem para a rede nos vários ambientes de programação, e por fim criámos programas exemplo que enviam valores de uma aplicação para outra.

introduzimos depois o arduino, e criámos um digitalizador de sensores. fizemos um controlador à base de ldr’s e pot’s numa breadboard, conectamos os sensores ao arduino, e criámos programas que lêem e usam os valores recebidos, gerando sons, sintetisando imagens, controlando estados dinâmicos também com piezos. vimos como o arduino ide é tão semelhante ao processing e o código que usamos também é parecido com java/c. (sessões 13, 14)

ainda fomos usar o arduino como actuador, controlando motores 5v e ventoinhas através dos outputs analógicos conseguimos emitir voltagens variáveis até 5v que controlam directamente ou através de outros componentes motores e actuadores sobre o mundo físico, criando o esboço de uma escultura cinética com led’s, motores e ventoinhas.

por agora já temos umas luzes sobre conceber e implementar interfaces híbridos que recorrem a várias tecnologias, como interfaces à base de computação física usando sensores, arduino, actuadores, outros materiais; interfaces à base de câmara analisando e confrontando as imagens que chegam, destacando posições distintas do fundo, obtendo parâmetros de localização, fazer actuar esses parâmetros; interfaces à base de som, analisando intensidades de frequências e construir listas de valores que fazem oscilar outros algoritmos.

por fim analisamos vários projectos construídos em c++ com o ambiente de programação openframeworks. analisamos a estrutura e funcionamento do compilador, linker, geração de código executável, e expandimos alguns exemplos de processing em c++. primeiro analisamos a programação por objectos, recorrendo a classes que têm variáveis e funções membros, e construímos vários exemplos em c++ que usam partículas, reconhecimento de imagem, som, comunicação por rede, interacções com sons e rato e electrónicas. (sessões 15, 16)

o c++ é mais robusto, um degrau acima na complexidade de escrever código comparado com o processing, mas  com as bibliotecas do openframeworks, torna-se extremamente simples, tal como no processing. a grande diferença é que cada sketch de processing extende a classe base papplet, enquanto que no openframeworks cada aplicação testapp extende a aplicação ofsimpleapp, que engloba a mecânica inicial necessária de uma aplicação c++.

continuamos com a análise de projectos individuais e criação de um laboratório na sala que tenha alguns projectores e câmaras para situações video-interactivas, microfones e colunas, e mesas para construir circuitos entre arduinos e sensores. brevemente mais novidades. boa semana. vejam as plantas, sugiram alternativas,

fizemos revisões de todos os conteúdos das várias linguagens que aprendemos, frisando conceitos chave de programação como variáveis, ciclos for, testes if(){}else{}, classes e objectos, chegar as variáveis a modificar, construir algoritmos base no processing, pd, arduino, openframeworks.

primeiro as noções iniciais de programação exploradas em máquinas de desenhar, onde a posição do rato serve como foco para o lançamento de novos objectos de classes programadas por nós. o sistema de coordenadas cartesiano e o sistema de coordenadas polar. (sessão 2)

primeiras noções de interactividade usando os microfones ligados ao computador, samplando a energia rms sonora, ou um espectro fft que nos dá intensidade por banda de frequência. aplicar os parâmetros do áudio em variáveis que controlam gráficos. noções de classes mais avançadas com os exemplos dos triângulos de som. (sessão 3)

paralelamente, primeiras máquinas lógicas simples, onde a nossa interacção controla um ou mais elementos, e há outros elementos que reagem face à nossa posição, distância, status, etc. os sketches círculos_attack.

depois fomos analisar o tipo de dados pimage e a biblioteca video do processing, que é um tipo de dados que armazena imagens. começamos com os sketches que acedem à informação de cor de cada pixel — criando travelers que oscilam com base nessa cor –, depois ler e scrubbing de video, gravar video e aceder a câmaras. terminamos com acessos mais elaborados à array dos pixels de cada pimage, modificando-os ou lendo-os directamente. (sessão 4)

o próximo tópico foram as partículas e sistemas de partículas, onde elementos simples mantêm variáveis de posição, velocidade, aceleração. a aceleração será o vector que controla a magnitude da deslocação. é também o vector que define a totalidade das forças aplicadas nas partículas. os próximos passos são actualizar a velocidade com a aceleração, actualizar a posição com base na nova velocidade, desenhar o elemento na nova posição. (sessão 5)

introdução ao 3d com noções de coordenadas espaciais, onde está a câmara, onde estão os objectos no espaço, como criar algorimos que gerem formas que se movimentem em três dimensões. (sessão 6)

alguns exemplos mais elaborados de video, como slitscan, delays, texturas em 3d; início do tracking de vídeo: detecção de presença, movimento, background removal, detecção de posição de centróides de blobs, frame differencing, detecção de outras features como caras, mãos, … (sessão 7, 8)

arraylists como recipientes dinâmicos de dados, texto no processing, como ler linhas de texto, separar palavras e espalhá-las espacialmente para desenhar. o sistema esférico (semelhante ao polar, mas em 3d), como desenhar pontos no espaço em forma de esfera e modificá-los com base no som. (sessão 9)

máquinas de estado simples mais avançadas, onde criamos várias classes, obstáculos, bolas, tiros, e todos elas comunicam entre si. cada bola, mesmo as autónomas colidem com os obstáculos, a nossa bola envia tiros que colidem com bolas e obstáculos, e implementamos uma lógica simples quando as bolas em cena terminam, re-iniciamos um novo nível. (sessão 10)

depois vimos puredata, arduino, open frameworks, que ficará como resumo no próximo post.

o curso está na fase laboratorial, estamos activamente a desenvolver projectos individuais e uns projectos colectivos, tirar dúvidas mais específicas em torno de algumas coisas, estamos de antenas apontadas para uma apresentação de projectos de fim de curso que ocorrerá no início de julho.

hoje vemos mais processos áudio de síntese, e iniciamos arduino com dois sensores ligados a um patch de som e um sketch de processing.

1. audio
os patches que analisamos são quase todos do pd-extended, e acedem-se melhor através do browser do pd (menu help > browser ou maçã/ctrl+b). dentro do browser, são tudo exemplos de audio (help browser > 3.audio.examples > c08.etc)

começamos com emulação de sintetisador analógicos, e fomos ver mais patches de samplehold, síntese aditiva, vibrato, complex fm, delay loops e resíntese por fft. aqui ficam algumas imagens dos patches a correrem.

13-c8

13-complexfm1

13-delayfeedback

 

13-fft-resintese

 

 

2. arduino

o arduino é um aparelho que digitaliza o mundo analógico, ou para ele envia voltagens, através do protocolo série (rs-232). hoje vamos ligar dois sensores às portas analógicas do arduino; fazemos um mini-programa no chip do arduino que lê os valores dos sensores e os envia para o computador; por fim criamos um patch e um sketch que lêem os valores e fazem coisas simples, dois osciladores, e dois quadrados.

usamos um LDR, que é uma resistência variável foto-voltaica, e um knob, um potenciometro (ou pot), que também é uma resistência variável, e faz variar a resposta voltaica dos sensores que vamos ler para fazer interagir esses dados.

do arduino fazemos conexões do +5v e do ground para as fileiras horizontais da breadboard. um pin do ldr entra directamente num dos pins de +5v da fileira da breadboard; o outro pin liga-se a uma fileira horizontal. da fileira horizontal da breadboard lemos o sinal para uma das portas analógicas do arduino e finalizamos a ligar uma resistência do fim da fileira para a linha de ground da fileira horizontal da breadboard.

o potenciómetro é mais simples, visto que já tem 3 pins; os exteriores ligam-se aos +5v e ao ground, e ligamos o pin do meio a uma porta analógica do arduino.

13-arduino_4496

depois criamos os programas no arduino ide, e fazemos upload para o chip atmega168 do arduino; o código começa logo a funcionar no chip e a correr os programas que  se seguem. usamos duas versões, um lê um sensor apenas, e outra lê dois valores analógicos:

/// arduino ler um sensor
int valor = 0; // variavel para o valor
int pin = 5; // variavel para o pin de entrada do valor

void setup() {
// open the serial port at 9600 bps:
Serial.begin(9600);
digitalWrite(13,HIGH); //turn on led
}

void loop() {
// ler o valor do pin
valor = analogRead(pin);
// escrever para a porta série o valor
Serial.print(valor, BYTE);
// esperar 10 ms próxima leitura
delay(10);
}

 

/// arduino ler dois sensores
// aqui enviamos um caracter que sincroniza
// no fim da mensagem

int valorldr = 0;
int valorpot = 0;
int pinldr = 5;
int pinpot = 3;

void setup() {
// open the serial port at 9600 bps:
Serial.begin(9600);
digitalWrite(13,HIGH); //turn on led
}

void loop() {
// ler os valores do pin
valorldr = analogRead(pinldr);
valorpot = analogRead(pinpot)/4;
// escrever para a porta série a mensagem
Serial.print(valorldr, BYTE);
Serial.print(valorpot, BYTE);
Serial.print(9); // tab = 9 ascii
// esperar 10 ms próxima leitura
delay(10);
}

 

do lado físico as coisas já estão finalizadas: os valores dos sensores já são enviados para o computador. agora precisamos de os ler. no pd usamos o [comport], um objecto que lê tudo o que chega através de série, no processing fazemos o import da serial lib, configuramos a porta e lemos a data. aqui ficam algumas imagens dos patches e sketches que criámos para começar a ler os valores e brincar com eles. na próxima semana vamos rever esta introdução ao arduino e introduzir actuação física com alguns motores.

13-sensor1

 

13-sensor21

13-p5sensor2

programação em ambientes visuais. breve história, o patch, o metro, o bang, o toggle, o número, os sliders, e objectos de controlo de fluxo, como o gate, o switch, o select; objectos de sensores como as teclas no objecto key, o objecto  suddenmotionsensor que analisa a orientação dos portáteis mac; objectos de áudio, diferenças entre fluxos de controlo e fluxos de áudio.

 

1. introdução programação visual

o pd (puredata) surge da mente do miller puckette — e hoje em dia muitos mais outros developers espalhados pelo mundo — como a alternativa open source ao max/msp. o max foi iniciado no ircam em meados de 1980’s pelo miller puckette, e foi desenhado para ser usado por compositores, tentando simplificar a tarefa da compilação e sobretudo da programação de algoritmos que possam ser aplicados em tempo real ao som que é gerado por instrumentos. são ambientes de programação visuais, onde pequenos módulos (objectos) já se encontram compilados, apenas temos de os criar num patch, uma janela branca inicialmente vazia, e ligá-los uns aos outros através de patch cords  para criar qualquer tipo de programa. aqui estamos libertos da compilação do programa, o patch está sempre operacional, e pode ser editado à medida que corre. 

os módulos realizam tarefas de vários níveis, simples, como o caso dos bangs, toggles, números, e mais elaboradas como objectos áudio, o osc~ ,  44100 valores por segundo em forma de onda sinusoidal a determinada frequência são emitidos para outros objectos que manipulam ou expõem o áudio. 

todos os objectos têem um help files e os objectos gráficos (bang, toggle, sliders, num,…) têem propriedades que podem ser editadas. crtl+click ou butão direito do rato em cima de qualquer objecto, e seleccionar help ou properties. o help file tem informações das mensagens que o objecto recebe e uma curta explicação do seu funcionamento.

11-bang_properties

2. primeiros patches

há dois modos principais do programa: o modo de edição  e o de interacção ( maçã/ctrl+e , ou menu edit > edit mode). no de edição podemos criar novas caixas de objectos (através do menu put > object, ou maçã/ctrl+1) e depositá-las com um click algures na janela do patch. no de interacção, interagimos com os objectos que o permitem, interruptores, números, mensagens.

no modo de edição, escrevemos ‘metro’ na caixa e clickamos fora da janela. a caixa transforma-se de tracejada para uma caixa com 2 inlets e 1 outlet. clickamos novamente na caixa e a seguir a metro, espaço, 500. este 500 será o argumento em milisegundos para o objecto metro. este objecto emite bangs de x em x ms. em cima do metro colocamos um toggle (menu put > toggle) e já aparece um objecto gráfico distinto dos objectos. ligamos a outlet do toggle ao metro. colocamos um bang em baixo do metro e ligamos da outlet do metro à inlet do bang. passamos agora para o modo de interacção ( maçã/ctrl+e ou menu edit > edit mode) e clickamos no toggle. o toggle emite a mensagem ‘1’ que o metro recebe e interpreta-a ligando-se, emite bangs de meio em meio segundo.

11-bang

depois criámos mais dois objectos, um ‘random 127’ e um ‘counter 127’. estes recebem os bangs e geram números aleatórios até 126 ou contando de 0 a 127. para tal basta ligar do bang aos dois objectos, e de cada objecto a um número para observar os resultados.

11-p0_randomcounter

agora convertemos os resultados numéricos em pitchs de osciladores. estes resultados numéricos de 0-127 estão numa escala midi que é transformada em hz, a unidade da frequência dos osciladores. há um objecto ‘mtof’ que aplica internamente esta conversão. depois colocamos os objectos da cadeia de áudio. um osc~, um *~ que escala o volume do sinal, um dac~, digital to analogue converter, que emite o sinal de áudio para as colunas. notem que as cores das cordas áudio são diferentes das cores fluxo normal. isso indica que esses objectos comunicam entre si à sampling rate do funcionamento da cadeia de audio. o input output do áudio pode ser configurado no menu media > portaudio. e o ligar e desligar do processamento audio é realizado na window > pd window, a consola onde o programa vai escrevendo mensagens de erro ou coisas que nós printemos para lá (objecto print). aí, tem de se ligar o compute audio que liga internamente a compilação de todos os objectos áudio (objectos que terminam em til ~)

11-audio0

 

3. osciladores lfo e leitura de samples

um lfo é um oscilador que tem um centro numa  frequência e somamos a  esse valor outro oscilador que vai induzir uma oscilação de maior ou menor frequência e profundidade em torno da frequência fundamental.

11-lfo

para lermos ficheiros do disco ou lemos com o objecto readsf~, ou lemos para arrays, que são objectos do pd que armazenam o som na memória do computador. 

quando o som está nas arrays pode ser acedido através de outros objectos que os podem reproduzir à velocidade normal, ou fazer variar este valor.

11-readsf11-arraysom

4. delays

para fazer delays ao sinal áudio, há objectos que comunicam por nome, como é o caso da comunicação array / tabread4~. aí a array tem o nome soundarray e cada objecto tabread4~ tem como argumento soundarray. nos delays vamos ter o delwrite~ <nome do delay> <tempo máximo ms delay>. e depois podemos criar vários delread~ <nome do delay> <tempo de delay, entre 0 e tempo máximo>, cada um destes objectos lê a cadeia de som atrasada x ms. 

introduzimos aqui também a gravação de ficheiros de som para o disco e o uso de microfones do computador através do objecto adc~ , analogue to digital converter.

11-delays

5. comunicação pure-data <-> processing através de osc

criamos uma comunicação via localhost (morada ip: 127.0.0.1) entre o processing e o pd através de osc encapsulado em servidores udp. no pd precisamos dos objectos udpsend e udpreceive, e no processing da biblioteca oscp5. uma vez instaladas as bibliotecas ( a do processing, no pd-extended já temos os externos de rede), podemos criar uma ligação do pd para o processing e do processing para o pd. (quem diz pd, diz também max, of, etc). 

a ligação pd->processing vai para o ip da própria máquina, para a porta 12000. a ligação processing->pd vai para o mesmo ip para a porta 12001. o processing lê da porta 12000 e envia para a 12001, o pd lê da 12001 e envia para a 12000.

em cada um dos lados, verificamos o identificador da mensagem osc ( /audio, /b1, /x,…) e atribuímos a variáveis no programa que executam tarefas.

11-p5-pd

 

ainda vimos um último exemplo que correspondia à integração de audio em pd no sketch bolas e obstáculos 7 do processing. para tal, sempre que há lançamento de explosões enviamos uma mensagem osc do processing para o pd que despoleta a reprodução de samples.

11-pdprocessing-bolas