Notificações Amigos pendentes

      Fórum Cifra Club - maior fórum de m&uacite;sica do Brasil

      Fentuino Open Synth - projeto "faça você mesmo" seu sintetizador.

      Autor Mensagem
      TrebleH
      Veterano
      # 22/mar/18 17:25
      · 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
      # 22/mar/18 18:07
      · votar


      Caro TrebleH:

      Bem vindo. Que bom que existem
      interessados. Acho que pode render
      um projeto interessante.

      Jonathas Lacerda
      Veterano
      # 23/mar/18 12:21
      · 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
      # 23/mar/18 12:58
      · 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
      # 23/mar/18 14:32
      · 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
      # 23/mar/18 20:48 · 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
      # 24/mar/18 07:21
      · votar


      Casper
      Mas e a parte de fora e as teclas? Estão inclusos nesse preço?

      silvG8
      Veterano
      # 24/mar/18 08:56
      · votar


      xmarhunterx
      A ideia do projeto é ser apenas um módulo. As teclas seriam usadas de outro instrumento, como um controlador MIDI.

      Casper
      Veterano
      # 25/mar/18 11:59
      · 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
      # 25/mar/18 12:06
      · votar


      Casper
      E será que um raspberry Pi 3 daria mais funcionalidades ao sintetizador que você está montando?

      Casper
      Veterano
      # 25/mar/18 17: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
      # 26/mar/18 13:22
      · 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
      # 27/mar/18 10:58
      · 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
      # 27/mar/18 18:58
      · 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
      # 27/mar/18 21:13 · 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
      # 28/mar/18 15:05
      · votar




      Casper
      Veterano
      # 28/mar/18 19:09
      · votar


      Uma biblioteca interessante:

      https://github.com/adelrune/Llammas

      Casper
      Veterano
      # 28/mar/18 21:21
      · votar


      http://www.instructables.com/id/Send-and-Receive-MIDI-with-Arduino/

      silvG8
      Veterano
      # 29/mar/18 11:37
      · 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
      # 30/mar/18 10:36 · 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
      # 30/mar/18 13:54 · 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
      # 30/mar/18 14:33 · 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
      # 31/mar/18 09:26 · 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
      # 31/mar/18 09:38
      · 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
      # 31/mar/18 13:57
      · votar


      Esboço do painel:

      PAINEL


      Depois de desenvolvido, não colocarei display,
      vai ser mais velha guarda o visual.

      Casper
      Veterano
      # 31/mar/18 19:28
      · 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
      # 02/abr/18 16:13
      · 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
      # 04/abr/18 09:43
      · 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
      # 04/abr/18 10:00
      · 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
      # 04/abr/18 12:00
      · 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



      Enviar sua resposta para este assunto
              Tablatura   
      Responder tópico na versão original
       

      Tópicos relacionados a Fentuino Open Synth - projeto "faça você mesmo" seu sintetizador.

      305.734 tópicos 7.895.171 posts
      Fórum Cifra Club © 2001-2018 Studio Sol Comunicação Digital