| Autor |
Mensagem |
TrebleH
Veterano |
# mar/18
· votar
Sr. Casper. Tenho sim.
Na verdade, meu plano é fazer um synth de zoeira e tal, mas futuramente começar a integrar DSP's pra trabalhar com amostras tipo sampler mesmo
É um projeto um tanto ambicioso, mas com o tempo, quem sabe?
|
Casper
Veterano
 |
# mar/18
· votar
Caro TrebleH:
Bem vindo. Que bom que existem
interessados. Acho que pode render
um projeto interessante.
|
Jonathas Lacerda
Veterano |
# mar/18
· votar
Interessantíssimo! Até hoje, só brinquei com controlador midi e arduino. Como gerador de som, nem sabia que dava pra fazer algo usável.
|
xmarhunterx
Membro Novato |
# mar/18
· votar
Bem legal o projeto. Acompanhando.
E dá pra fazer coisas mais complexas, sabendo pouco? Robótica é mais difícil que programação?
E Casper, tu estás gastando quanto pra montar o sintetizador?
|
entamoeba
Membro Novato |
# mar/18
· votar
Bela inciativa, Casper. Assim que tiver um tempo extra acho que vou tentar fazer um. Há tempo que quero fazer algo com arduino.
|
Casper
Veterano
|
# mar/18 · Editado por: Casper
· votar
Caro xmarhunterx:
Com polifonia = 8 (Um arduino Uno + 8 Nanos)
calculo que tudo vai sair em torno de 160 reais.
Preço do ebay.
No mercado livre fica um pouco mais caro, mas
nada que comprometa.
|
xmarhunterx
Membro Novato |
# mar/18
· votar
Casper
Mas e a parte de fora e as teclas? Estão inclusos nesse preço?
|
silvG8
Veterano |
# mar/18
· votar
xmarhunterx
A ideia do projeto é ser apenas um módulo. As teclas seriam usadas de outro instrumento, como um controlador MIDI.
|
Casper
Veterano
|
# mar/18
· votar
Caro xmarhunterx:
Acho que fazer o teclado que seja funcional
sai muito caro e dá muito mais trabalho que todo
o resto. Por isso estou me concentrando no módulo.
Mas quem quiser transformar algum teclado
inutilizado em controlador MIDI, tem um monte de
projetos na internet que é só copiar:
|
xmarhunterx
Membro Novato |
# mar/18
· votar
Casper
E será que um raspberry Pi 3 daria mais funcionalidades ao sintetizador que você está montando?
|
Casper
Veterano
|
# mar/18
· votar
Caro xmarhunterx:
Sim, daria mais funcionalidades, o processamento
do Raspberry Pi não se compara, é ordens de grandeza
maior. Por exemplo:
Foge um pouco da proposta original do projeto, porque
envolve um grau maior de aprendizado em programação,
uso de sistema operacional etc...
Mas fique a vontade para adaptar o projeto para qualquer
outra plataforma.
|
Casper
Veterano
|
# mar/18
· votar
Outras bibliotecas de áudio para Arduino
(ainda não tive tempo para testar):
http://bauhausinteraction.org/opl/the-arduino-as-a-native-sound-genera tor/
|
silvG8
Veterano |
# mar/18
· votar
Casper
Continuo acompanhando... ainda não encomendei os Arduino. Vida corrida!
Ainda assim, os artigos que manda e tudo mais estão sendo vistos, no meu ritmo mais lento, mas vejo.
Algum novo desenvolvimento, desdobramento da coisa? Bastante curioso!
|
Casper
Veterano
|
# mar/18
· votar
Caro silvG8:
Encomendei 8 arduinos nano + 8 nano shields
(equivalentes a esse).
Nesse projeto não vou fazer nenhuma placa, quero
que tudo seja reproduzível facilmente.
Por isso peguei um MIDI shield de Uno também,
tudo no eBay. Vai demorar mais ou menos um mês
para chegar tudo, mas vou adiantando as coisas
por aqui. O Código do I2C vou colocar aqui nesses
dias, e o MIDI polifônico está dando mais trabalho
que o previsto, porque quero fazer algo parecido com
os modos do Future Retro Mondovox:
http://www.analoguehaven.com/futureretro/mondovox/
Na verdade vou precisar de ajuda.
|
Casper
Veterano
|
# mar/18 · Editado por: Casper
· votar
// Uno (master) mandando dummy data
// para o nano (slave) através do I2C
#include <MIDI.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
MIDI_CREATE_DEFAULT_INSTANCE();
LiquidCrystal_I2C lcd(0x27,20,4); // usando display LCD I2C
unsigned char MIDI_NOTE = 0;
unsigned char MIDI_VELOCITY = 0;
void setup()
{
lcd.init(); // initialize the lcd
MIDI.begin(1); // Launch MIDI and listen to channel 1
Wire.begin(); // join i2c bus
pinMode(13, OUTPUT); // led
lcd.backlight();
lcd.setCursor(0,0);
lcd.print("Fentuino Open Synth"); // Print a message to the LCD.
}
void loop()
{
MIDI_NOTE = random(1,127);
MIDI_VELOCITY = random(1,127);
Wire.beginTransmission(0x30); // transmit to slave 0x30
Wire.write(MIDI_NOTE); // sends one byte
Wire.write(MIDI_VELOCITY); // sends one byte
Wire.endTransmission(); // stop transmitting
delay(500);
digitalWrite(13,1); // led on
Wire.beginTransmission(0x30); // transmit to slave 0x30
Wire.write(MIDI_NOTE); // sends one byte
Wire.write(0); // note off
Wire.endTransmission(); // stop transmitting
delay(500);
digitalWrite(13,0); // led off
}
|
Casper
Veterano
|
# mar/18
· votar
|
Casper
Veterano
|
# mar/18
· votar
Uma biblioteca interessante:
https://github.com/adelrune/Llammas
|
Casper
Veterano
|
# mar/18
· votar
http://www.instructables.com/id/Send-and-Receive-MIDI-with-Arduino/
|
silvG8
Veterano |
# mar/18
· votar
Casper
Conteúdo top que vem compartilhando Casper... estou meio enrolado nos últimos dias, mas dou certeza que vou olhando quando dá.
Eu estou pensando em manter ele monofônico inicialmente. Acho que vai ser mais fácil pra mim. Não só pelas conexões mas também por conta da própria compra em si (não pelo dinheiro, sim pela espera). Vamos ver... viagem em 2 semanas.
|
Casper
Veterano
|
# mar/18 · Editado por: Casper
· votar
=============================
MIDI NOTE_ON / NOTE_OFF
=============================
//--------------------------------------------------
O NOTE_ON tem essa cara:
Status byte : 1001 CCCC
Data byte 1 : 0PPP PPPP
Data byte 2 : 0VVV VVVV
//--------------------------------------------------
//--------------------------------------------------
O NOTE_OFF tem essa cara:
Status byte : 1001 CCCC
Data byte 1 : 0PPP PPPP
Data byte 2 : 0VVV VVVV
ou
O NOTE_OFF tem essa cara:
Status byte : 1000 CCCC // igual do note ON
Data byte 1 : 0PPP PPPP
Data byte 2 : 0000 0000 //velocity = 0
//--------------------------------------------------
onde:
"CCCC" canal MIDI (0 ~ 15)
"PPP PPPP" NOTA (0 ~ 127)
"VVV VVVV" VELOCIDADE (0 ~ 127)
Porque isso é relevante?
Porque alguns controladores simplesmente não
enviam NOTE_OFF. Mandam um NOTE_ON
com o parâmetro VELOCIDADE = 0. E tem módulo
que considera NOTE_ON mesmo com VELOCIDADE = 0,
mas não gera som, mas gera o Gate quando tem saída
CV, o que faz sentido em um sistema modular onde
esse Gate pode ser o retrigger de alguma outra coisa.
Resumindo:
Vale a pena tratar os dois modos de NOTE_OFF, porque
desse modo não importa quem manda a mensagem,
ela sempre será interpretada corretamente.
Felizmente isso é fácil: Bateu uma velocidade = 0
(em qualquer mensagem de nota)
OU
um Status byte : 1000 CCCC
já consideraremos como um NOTE_OFF.
Isso levanta uma questão conceitual importante:
Se o synth recebe duas notas iguais de dois lugares
diferentes (por exemplo de um teclado e de um sequenciador)
o NOTE_OFF de um pode matar a nota de outro?
Pensei muito sobre isso fiz uns testes em uns equipamentos
aqui e a resposta é sim. Em tudo que tenho aqui o NOTE_OFF
mata mesmo. Acho que de outra forma seria o caos.
Uma coisa importante que acabei de lembrar:
E se aparecer um NOTE_OFF falso?
Sim, acontece. E o NOTE_ON desacompanhado
do seu respectivo NOTE_OFF também existe.
Para o primeiro(NOTE_OFF falso), um tratamento
esperto para saber se existiu mesmo um NOTE_ON
dele basta. Tem que ser um pouquinho esperto,
porque caso contrário ele ficará para sempre procurando
a nota que não existe.
Para o segundo caso (NOTE_ON desacompanhado
do seu respectivo NOTE_OFF) não tem muito o que
ser feito. Geralmente um botão "all notes off" no
painel é a solução.
|
Casper
Veterano
|
# mar/18 · Editado por: Casper
· votar
===============================================
Distribuindo as notas entre os osciladores (modo polifônico)
===============================================
Quando se tem um oscilador apenas as coisas são
bem mais simples. No caso de aparecer mais de
uma nota, coloca-se a prioridade em algo, por
exemplo, a nota mais alta, a nota mais baixa, a
última tecla pressionada etc...
Já em um esquema polifônico, a coisa complica.
Digamos que temos 8 osciladores independentes.
Pressionamos uma nota isolada. Para onde ela vai?
Ela vai para o primeiro oscilador que não estiver ocupado.
Eu imaginei um esquema assim:
bool SLOT_BUSY[8] = {0,0,0,0,0,0,0,0}; // 0 = free / 1 = busy
Esse vetor vai ser consultado o tempo todo, para distribuir
a nota para o oscilador livre.
O SLOT_BUSY[0] é o primeiro oscilador.
Uma vez que ele está livre, pode ser utilizado.
Ele estará ocupado até que uma das duas coisas
aconteça:
1) Ele receba um NOTE_OFF;
2) Ele não esteja mais gerando som (OBS1)
OBS1) O ADSR dele tem sustain nulo e o
ciclo com som dura, digamos, 2 segundos (até
o fim do release). Não faz sentido deixar
esse oscilador ocupado (OBS2).
OBS2) Tratar isso necessariamente implica que
o oscilador (escravo) avise para o sistema que
está livre. Mas, pelo jeito, usando Mozzi, é difícil
gerar um flag para essa condição.
Tenho a intuição que deixar o oscilador ocupado
por um tempo a mais e esperar a condição 1
(NOTE_OFF) acontecer é muito mais jogo. Na
prática isso pode diminuir a polifonia, mas aumenta
a simplicidade do sistema de distribuição.
Como é feita a distribuição?
Em uma distribuição conhecida como round robin.
Funciona assim: as notas, na ordem de chegada, vão
pegando para si os osciladores livres. No momento que
os NOTE_OFF vão chegando, vão liberando esses
osciladores para uma nova nota.
Pergunta: Mandei um acorde de 6 notas. O que acontece?
Resposta: 6 osciladores estarão ocupados, ainda cabem 2 notas.
Pergunta: Mandei um acorde de 8 notas. O que acontece?
Resposta: 8 osciladores estarão ocupados, nada mais que
chegar vai ter como acrescentar nada ao acorde.
Pergunta: Mandei um acorde de 10 notas. O que acontece?
Resposta: somente os 8 osciladores referente as 8 primeiras
notas que chegaram estarão ocupados. As duas que não
poderão ir para os osciladores se perderão no mar de
bits do infinito.
Para um pianista, isso pode ser um problema.
Mas, acredito eu, um usuário de sintetizador não
costuma fazer acordes com mais de 4 notas na mão
esquerda e mais uma nota na mão direita. Então
uma polifonia de 8 seria (em tese) suficiente para
brincar com uma folga razoável. Se isso for um
problema em seu projeto, coloque 16 osciladores.
Basta acrescentar mais um bit no endereço de
posição do endereço do oscilador e comprar mais
8 arduinos Nano. E o esquema dos gates será diferente,
todo através do I2C. Isso me parece uma ideia boa até
para uma quantidade menor de osciladores.
O preenchimento é do tipo circular. Se os osciladores
1, 3, 5, 7 e 8 estiverem ocupados, o próximo a ser
ocupado será o 2, depois o 4... e vai ocupando em ordem
circular conforme os osciladores. Esse tipo de distribuição
é o que parece fazer mais sentido na minha concepção.
Uma distribuição aleatória (pegue qualquer um livre)
também poderia funcionar. Não tenho argumentos para
dizer se um tem vantagem sobre outro. Mas posso dizer que
a maioria dos produtos comerciais opta pelo modo
circular (round robin). Deve haver um motivo.
Esse é o comportamento para modo polifônico. Uma vez
que esse estiver funcionando, penso que implementar
outros modos será mais tranquilo. Ou não.
|
Casper
Veterano
|
# mar/18 · Editado por: Casper
· votar
===========================
Esboço do Hardware V4.0
===========================
Arduino Uno (master)
Pino 0 - RX (MIDI)
Pino 1 - TX (MIDI)
Pino 2 - Gate Ch 1 (gera interrupção para atualizar o valor de frequência do oscilador)
Pino 3 - Gate Ch 2 (gera interrupção para atualizar o valor de frequência do oscilador)
Pino 4 - Gate Ch 3 (gera interrupção para atualizar o valor de frequência do oscilador)
Pino 5 - Gate Ch 4 (gera interrupção para atualizar o valor de frequência do oscilador)
Pino 6 - Gate Ch 5 (gera interrupção para atualizar o valor de frequência do oscilador)
Pino 7 - Gate Ch 6 (gera interrupção para atualizar o valor de frequência do oscilador)
Pino 8 - Gate Ch 7 (gera interrupção para atualizar o valor de frequência do oscilador)
Pino 9 - Gate Ch 8 (gera interrupção para atualizar o valor de frequência do oscilador)
Pino 13 - LED MIDI
Pino 18 - SDA (I2C)
Pino 19 - SCL (I2C)
Pino A0 - Potênciometro uso geral (seleciona canal MIDI (1~16) )
Pino A1 - Potênciometro uso geral (seleciona MODO - Poli/Unison)
Pino A2 - Potênciometro uso geral (depende da implementação)
Pino A3 - Potênciometro uso geral (depende da implementação)
Arduino Nano (cada um é um oscilador, escravo do Uno)
Pino 2 - Entrada GATE vindo do Uno (dispara interrupção para ler o novo valor de frequência do oscilador)
Pino 4 - Endereço físico da placa do oscilador (de 0 até 7 - 8canais) (bit 0) LSB
Pino 5 - Endereço físico da placa do oscilador (de 0 até 7 - 8canais) (bit 1)
Pino 6 - Endereço físico da placa do oscilador (de 0 até 7 - 8canais) (bit 2) MSB - para os que fizerem 8 osciladores
Pino 6 - Endereço físico da placa do oscilador (de 0 até 15 - 16 canais) (bit 3) MSB - para os que fizerem 16 osciladores
Pino 9 - Saída do oscilador (1/2) - junto com o pino 10 compõe o sinal
Pino 10 - Saída do oscilador (1/2) - junto com o pino 10 compõe o sinal
Pino A0 - Potênciometro uso geral (depende da implementação)
Pino A1 - Potênciometro uso geral (depende da implementação)
Pino A2 - Potênciometro uso geral (depende da implementação)
Pino A3 - Potênciometro uso geral (depende da implementação)
Pino A6 - Potênciometro uso geral (depende da implementação)
Pino A7 - Potênciometro uso geral (depende da implementação)
Pino 18 - SDA (I2C)
Pino 19 - SCL (I2C)
|
Casper
Veterano
|
# mar/18 · Editado por: Casper
· votar
Acho que encontrei uma solução para
simplificar muito o projeto.
A biblioteca do Mozzi manipula MIDI.
MIDI é um protocolo serial, não I2C.
Eu estava fazendo uma ponte entre os
dois, até que percebi que poderia manter
tudo serial mesmo.
A biblioteca SoftwareSerial do Arduino
permite ter muitas seriais. Mas ela cria
um TX e um RX. Só precisamos do TX.
Uma boa alma da comunidade adaptou a
biblioteca para ter apenas TX:
==========================================================
I adapted SoftwareSerial to only have a send function.
Download library here:
http://gammon.com.au/Arduino/SendOnlySoftwareSerial.zip
fonte:
https://forum.arduino.cc/index.php?topic=112013.0
=========================================================
Então, temos o Uno ainda como Mestre, distribuindo
as notas entre os osciladores, e ficou assim:
a) O TX e o RX de hardware do Arduino manipula entrada
e saída MIDI;
b) Os TX's de software do Arduino manipulam os osciladores.
o código para criar os TX's é:
======================================
#include <SendOnlySoftwareSerial.h>
//bla...bla...bla...
SendOnlySoftwareSerial OSC1 (3); // Tx pin
SendOnlySoftwareSerial OSC2 (4); // Tx pin
SendOnlySoftwareSerial OSC3 (5); // Tx pin
SendOnlySoftwareSerial OSC4 (6); // Tx pin
SendOnlySoftwareSerial OSC5 (7); // Tx pin
SendOnlySoftwareSerial OSC6 (8); // Tx pin
SendOnlySoftwareSerial OSC7 (9); // Tx pin
SendOnlySoftwareSerial OSC8 (10); // Tx pin
//bla...bla...bla...
void setup()
{
//bla...bla...bla...
OSC1.begin(31250);
OSC2.begin(31250);
OSC3.begin(31250);
OSC4.begin(31250);
OSC5.begin(31250);
OSC6.begin(31250);
OSC7.begin(31250);
OSC8.begin(31250);
//bla...bla...bla...
}
======================================
Para mandar uma nota para o oscilador 1,
que soa por 1 segundo:
OSC1.print (10010000); //Status byte - note on - CH1
OSC1.print (00010000); //Nota
OSC1.print (01111111); //Intensidade
delay(1000);
OSC1.print (10000000); //Status byte - note off - CH1
OSC1.print (00010000); //Nota
OSC1.print (00000000); //Intensidade
Isso resolve um monte de problemas.
Os osciladores não precisam mais
de endereços. O trigger do ADSR
fica por conta do Mozzi.
Sobrou mais 2 entradas analógicas no
Nano, que antes eram usadas para o I2C.
Pode-se implementar então 8 controles de painel.
:)
|
Casper
Veterano
|
# mar/18
· votar
===========================
Esboço do Hardware V5.0
===========================
Arduino Uno (master)
Pino 0 - RX (entrada MIDI)
Pino 1 - TX (saída MIDI)
Pino 2 - Botão "All Notes Off" (Panic)
Pino 3 - SERIAL OSC1 (31250 Hz)
Pino 4 - SERIAL OSC2 (31250 Hz)
Pino 5 - SERIAL OSC3 (31250 Hz)
Pino 6 - SERIAL OSC4 (31250 Hz)
Pino 7 - SERIAL OSC5 (31250 Hz)
Pino 8 - SERIAL OSC6 (31250 Hz)
Pino 9 - SERIAL OSC7 (31250 Hz)
Pino 10 - SERIAL OSC8 (31250 Hz)
Pino 13 - LED MIDI
Pino 18 - SDA (I2C) Display
Pino 19 - SCL (I2C) Display
Pino A0 - Potênciometro uso geral (seleciona canal MIDI (1~16) )
Pino A1 - Potênciometro uso geral (seleciona MODO - Poli/Unison)
Pino A2 - Potênciometro uso geral (?)
Pino A3 - Potênciometro uso geral (?)
Arduino Nano (cada um é um oscilador, escravo do Uno)
Pino 0 - RX (entrada serial)
Pino 9 - Saída do oscilador (1/2) - junto com o pino 10 compõe o sinal
Pino 10 - Saída do oscilador (1/2) - junto com o pino 10 compõe o sinal
Pino A0 - Potênciometro uso geral (depende da implementação)
Pino A1 - Potênciometro uso geral (depende da implementação)
Pino A2 - Potênciometro uso geral (depende da implementação)
Pino A3 - Potênciometro uso geral (depende da implementação)
Pino A4 - Potênciometro uso geral (depende da implementação)
Pino A5 - Potênciometro uso geral (depende da implementação)
Pino A6 - Potênciometro uso geral (depende da implementação)
Pino A7 - Potênciometro uso geral (depende da implementação)
|
Casper
Veterano
|
# mar/18
· votar
Esboço do painel:
PAINEL
Depois de desenvolvido, não colocarei display,
vai ser mais velha guarda o visual.
|
Casper
Veterano
|
# mar/18
· votar
Boas ideias aqui:
http://bloghoskins.blogspot.com.br/2016/11/diy-arduino-string-synth.ht ml
https://janostman.wordpress.com/how-to-build-your-very-own-string-synt h/
|
silvG8
Veterano |
# abr/18
· votar
Casper
Algumas ideias aqui... o Mondovox, me pareceu ter um roteamento MIDI parecido com o do MIDI PAL da Mutable Instruments. Existe o código do MIDI PAL no github, deve dar pra extrair algumas coisas dele.
Em relação ao note on e off, será que o comportamento dele em mono, quando usar legato, vai funcionar normalmente? Na minha cabeça sim, pois antes do note on com velocity zero, haverá outra note on com a velocidade que for tocada. Mas é pra fazer o legato tradicional, funcionaria?
Quanto ao painel, acho que seria interessante 3 para controle do filtro, no mínimo... cutoff, res, eg amount. Mas posso ter entendido errado. Gosto da ideia do painel mais raiz, mas acho que eu não o faria no formato rack, e sim módulo. Isso seria detalhe.
Precisando de gerar alguma imagem, ou ideias para o painel, e só me dizer o que devo colocar que da pra fazer algo legal.
São apenas ideias...
|
Casper
Veterano
|
# abr/18
· votar
Caro silvG8:
Legato é parâmetro da biblioteca, é só ativar ou não.
Outras coisas como glide, portamento etc também
estão disponíveis.
Pretendo ter 10 potenciometros no projeto:
Dois para controle Midi e e oito parâmetros
para o som. O resto vai por CC.
|
Beto Guitar Player
Veterano |
# abr/18
· votar
Casper
Cara, sou um bosta porque não entendo quase nada de tudo que você colocou aqui... mas aguardo ansiosamente pelo resultado.
|
kiki
Moderador |
# abr/18
· votar
Que dahora, to acompanhando aqui!
To tentando mexer com arduino tambem (na verdade com ajuda de uns amigos), estava justamente pesquisando o mozzi esses dias.
Pra ajudar, vou postar esse video aqui que dá um panorama do mozzi
|