Wiki

Reso-nance numérique | Arts et cultures libres

Outils pour utilisateurs

Outils du site

Vous êtes ici: Accueil » Projets » light-synth
projets:light-synth:accueil

Différences

Ci-dessous, les différences entre deux révisions de la page.

Lien vers cette vue comparative

Les deux révisions précédentes Révision précédente
Prochaine révision 		Révision précédente
projets:light-synth:accueil [2017/07/09 13:06]
resonance [Note d'intention] 		projets:light-synth:accueil [2018/06/09 11:33] (Version actuelle)
resonance [Boite a rythme a led]
Ligne 4: Ligne 4:
   * Licence : [[http://creativecommons.org/licenses/by-sa/3.0/legalcode|CC-by-sa-3.0]]   * Licence : [[http://creativecommons.org/licenses/by-sa/3.0/legalcode|CC-by-sa-3.0]]
   * Description : synthé qui marche avec la lumiere   * Description : synthé qui marche avec la lumiere
-  * Fichiers sources : //mettre un lien//+  * Fichiers sources : voir plus bas pour les codes , design : {{ :projets:light-synth:lightsynthdesign.ai |}}
   * Lien : //mettre un lien//   * Lien : //mettre un lien//
  
Ligne 11: Ligne 11:
 ===== Note d'intention ===== ===== Note d'intention =====
 Synthé qui marche avec la lumiere : Synthé qui marche avec la lumiere :
-Plusieurs pistes sont possible, notamment en changeant les frequences des pwm avec library tone...+Plusieurs pistes sont possible, notamment en changeant les fréquences des pwm avec library Tone et Mozzi
  
 {{projets:light-synth:accueil:instrument_lumiere_minuscule.jpg?800|light-synth}} {{projets:light-synth:accueil:instrument_lumiere_minuscule.jpg?800|light-synth}}
  
-===== Notes techniques ===== +===== Codes ===== 
-Guide pas à pas et conseil pour la réalisation du projet.+Voici quelques codes pas mal... Certains utilisent les libraries Tone et Mozzi pour transformer l'arduino en petit synthé ! 
 + 
 +On capte le son emis en lumiere par des leds, via un panneau solaire. 
 +Ca donne ceci : 
 + 
 +{{youtube>nbi2d_UTToQ?large}} 
 +//Le troisieme synth de la video est l'exemple de la librarie mozzi  : Sensor/lighttemperature...// 
 + 
 + 
 + 
 +==== Boite a rythme a led ==== 
 +On fait clignoter 3 led a la noire, croche triolet, et on controle le temp avec un potentiometre et une photoresistance... 
 + 
 +++++ Le code   |   
 + 
 + 
 + 
 +<code c+> 
 +// 3 led a jouant a la noire, croche et triolet 
 +// un potentiometre 10k en A0 : controle le tempo général... 
 +// une photo resistance en A1 : controle un effet de delay 
 + 
 +#define led1 5 
 +#define led2 9   
 +#define led3 10   
 +#define factor 6  //factor for pwm tone ! 
 + 
 +unsigned long previousMillis[3]; //[x] = number of leds 
 + 
 +void setup() {  
 +  pinMode(led1, OUTPUT);    
 +  pinMode(led2, OUTPUT);   
 +  pinMode(led3, OUTPUT);   
 + 
 +  Serial.begin(9600); 
 +} 
 +void loop() { 
 + 
 +int sensorValue = analogRead(A0); 
 +sensorValue = map(sensorValue, 0, 1023, 0, 2000); 
 + 
 +  if(sensorValue > 1990) {  
 +sensorValue == 10000; 
 +} 
 +int sensorValueB = analogRead(A1); 
 +sensorValueB = map(sensorValueB, 0, 1023, 1023, 0); 
 + 
 +  if(sensorValueB > 800) {  
 + BlinkLedSimple(led1, sensorValue, 0,sensorValueB);   //BlinkLed( which led, interval, one of the stored prevMillis 
 + BlinkLedSimple(led2, sensorValue/3, 1,sensorValueB);  //last parameters must be different for each led 
 + BlinkLedSimple(led3, sensorValue/2, 2,sensorValueB);  
 +} 
 + 
 +  if(sensorValueB > 400 && sensorValueB < 800 ) {  
 + BlinkLed(led1, sensorValue, 0,sensorValueB);   //BlinkLed( which led, interval, one of the stored prevMillis 
 + BlinkLed(led2, sensorValue/3, 1,sensorValueB);  //last parameters must be different for each led 
 + BlinkLed(led3, sensorValue/2, 2,sensorValueB);  
 +} 
 + 
 +  if(sensorValueB < 400) {  
 + BlinkLedSuper(led1, sensorValue, 0,sensorValueB);   //BlinkLed( which led, interval, one of the stored prevMillis 
 + BlinkLedSuper(led2, sensorValue/3, 1,sensorValueB);  //last parameters must be different for each led 
 + BlinkLedSuper(led3, sensorValue/2, 2,sensorValueB);  
 +} 
 + 
 +Serial.print("potentiometre"); 
 +  Serial.println(sensorValue); 
 + 
 +Serial.print("ldr"); 
 +  Serial.println(sensorValueB); 
 +  delay(1);  
 + 
 +  
 +} 
 + 
 +///Simple blink 
 +  void BlinkLedSimple (int led, int interval, int array, int pwm){     
 +   if (((long)millis() - previousMillis[array]) >= interval){  
 +    previousMillis[array]= millis(); //stores the millis value in the selected array 
 +       digitalWrite(led, !digitalRead(led)); //changes led state 
 +  }} 
 + 
 +///delayyyy blink 
 +void BlinkLed (int led, int interval, int array, int pwm){    
 +   if (((long)millis() - previousMillis[array]) >= interval){  
 +    
 +    previousMillis[array]= millis(); //stores the millis value in the selected array 
 +    
 +    digitalWrite(led, !digitalRead(led)); //changes led state 
 +    delay (pwm/factor); 
 +    digitalWrite(led, !digitalRead(led)); //changes led state 
 +    delay (pwm/factor); 
 +    digitalWrite(led, !digitalRead(led)); //changes led state 
 +  } 
 +} 
 + 
 +///super delayyyy blink 
 +void BlinkLedSuper (int led, int interval, int array, int pwm){    
 +   if (((long)millis() - previousMillis[array]) >= interval){  
 +    
 +    previousMillis[array]= millis(); //stores the millis value in the selected array 
 +    
 +    digitalWrite(led, !digitalRead(led)); //changes led state 
 +    delay (pwm/factor); 
 +    digitalWrite(led, !digitalRead(led)); //changes led state 
 +    delay (pwm/factor); 
 +    digitalWrite(led, !digitalRead(led)); //changes led state 
 +        delay (pwm/factor); 
 +    digitalWrite(led, !digitalRead(led)); //changes led state 
 +    delay (pwm/factor); 
 +    digitalWrite(led, !digitalRead(led)); //changes led state 
 +        delay (pwm/factor); 
 +    digitalWrite(led, !digitalRead(led)); //changes led state 
 +    delay (pwm/factor); 
 +    digitalWrite(led, !digitalRead(led)); //changes led state 
 +        delay (pwm/factor); 
 +    digitalWrite(led, !digitalRead(led)); //changes led state 
 +    delay (pwm/factor); 
 +    digitalWrite(led, !digitalRead(led)); //changes led state 
 +  } 
 +} 
 + 
 +</code> 
 +++++ 
 + 
 +==== Synth fm avec 5 potentiomètres avec MOZZI ==== 
 +On controle un synthe fm avec 5 potards, 
 + le son passe par la led en pin 9... 
 + 
 + 
 +++++ Le code   |   
 + 
 + 
 + 
 +<code c+> 
 +/*  
 +Use 5 Analogic inputs to control fm synth (A0 - ... - A4 ) 
 +Output Pin 9 - led ... 
 +*/ 
 + 
 +#include <MozziGuts.h> 
 +#include <Oscil.h> // oscillator  
 +#include <tables/cos2048_int8.h> // table for Oscils to play 
 +#include <Smooth.h> 
 +#include <AutoMap.h> // maps unpredictable inputs to a range 
 +  
 +// int freqVal; 
 +  
 +// desired carrier frequency max and min, for AutoMap 
 +const int MIN_CARRIER_FREQ = 22; 
 +const int MAX_CARRIER_FREQ = 440; 
 + 
 +const int MIN = 1; 
 +const int MAX = 10; 
 + 
 +const int MIN_2 = 1; 
 +const int MAX_2 = 15; 
 + 
 +// desired intensity max and min, for AutoMap, note they're inverted for reverse dynamics 
 +const int MIN_INTENSITY = 700; 
 +const int MAX_INTENSITY = 10; 
 + 
 +// desired mod speed max and min, for AutoMap, note they're inverted for reverse dynamics 
 +const int MIN_MOD_SPEED = 10000; 
 +const int MAX_MOD_SPEED = 1; 
 + 
 +AutoMap kMapCarrierFreq(0,1023,MIN_CARRIER_FREQ,MAX_CARRIER_FREQ); 
 +AutoMap kMapIntensity(0,1023,MIN_INTENSITY,MAX_INTENSITY); 
 +AutoMap kMapModSpeed(0,1023,MIN_MOD_SPEED,MAX_MOD_SPEED); 
 +AutoMap mapThis(0,1023,MIN,MAX); 
 +AutoMap mapThisToo(0,1023,MIN_2,MAX_2); 
 + 
 +const int KNOB_PIN = 0; // set the input for the knob to analog pin 0 
 +const int LDR1_PIN=1; // set the analog input for fm_intensity to pin 1 
 +const int LDR2_PIN=2; // set the analog input for mod rate to pin 2 
 +const int LDR3_PIN=3; 
 +const int LDR4_PIN=4; 
 + 
 +Oscil<COS2048_NUM_CELLS, AUDIO_RATE> aCarrier(COS2048_DATA); 
 +Oscil<COS2048_NUM_CELLS, AUDIO_RATE> aModulator(COS2048_DATA); 
 +Oscil<COS2048_NUM_CELLS, CONTROL_RATE> kIntensityMod(COS2048_DATA); 
 + 
 +int mod_ratio = 5; // brightness (harmonics) 
 +long fm_intensity; // carries control info from updateControl to updateAudio 
 + 
 +// smoothing for intensity to remove clicks on transitions 
 +float smoothness = 0.95f; 
 +Smooth <long> aSmoothIntensity(smoothness); 
 + 
 + 
 +void setup(){ 
 +  Serial.begin(115200); // set up the Serial output so we can look at the light level 
 +  startMozzi(); // :)) 
 +} 
 + 
 +void updateControl(){ 
 +   
 +//  freqVal = map(LDR3_PIN, 0, 1023, 1, 100);  
 +   int freqVal = mozziAnalogRead(LDR3_PIN); // value is 0-1023 
 +   int FRQ = mapThis(freqVal); 
 +   int knob2 = mozziAnalogRead(LDR4_PIN); // value is 0-1023 
 +   int knob2Val = mapThis(knob2); 
 +   
 +  // read the knob 
 +  int knob_value = mozziAnalogRead(KNOB_PIN); // value is 0-1023 
 + 
 +  // map the knob to carrier frequency 
 +  int carrier_freq = kMapCarrierFreq(knob_value); 
 +   
 +  //calculate the modulation frequency to stay in ratio 
 +  int mod_freq = carrier_freq * mod_ratio * FRQ; 
 +   
 +  // set the FM oscillator frequencies 
 +  aCarrier.setFreq(carrier_freq);  
 +  aModulator.setFreq(mod_freq); 
 +   
 +  // read the light dependent resistor on the width Analog input pin 
 +  int LDR1_value= mozziAnalogRead(LDR1_PIN); // value is 0-1023 
 +  // print the value to the Serial monitor for debugging 
 + 
 +  int LDR1_calibrated = kMapIntensity(LDR1_value); 
 + 
 + // calculate the fm_intensity 
 +  fm_intensity = ((long)LDR1_calibrated * knob2Val * (kIntensityMod.next()+128))>>8; // shift back to range after 8 bit multiply 
 + 
 +   
 +  // read the light dependent resistor on the speed Analog input pin 
 +  int LDR2_value= mozziAnalogRead(LDR2_PIN); // value is 0-1023 
 + 
 +   
 +                                     Serial.print("LDR0 = ");  
 +                                      Serial.print(knob_value); 
 +                                      Serial.print("\t"); // prints a tab 
 +                                       
 +                                         Serial.print("LDR1 = ");  
 +                                      Serial.print(LDR1_value); 
 +                                      Serial.print("\t"); // prints a tab 
 +                                       
 +                                         Serial.print("LDR2 = ");  
 +                                      Serial.print(LDR2_value); 
 +                                      Serial.print("\t"); // prints a tab 
 + 
 + 
 +                                      Serial.print("LDR3 = ");  
 +                                      Serial.print(freqVal); 
 +                                      Serial.print("\t"); // prints a tab 
 + 
 +                                      Serial.print("LDR4 = ");  
 +                                      Serial.print(knob2); 
 +                                      Serial.print("\t"); // prints a tab 
 +   
 + 
 +  // use a float here for low frequencies 
 +  float mod_speed = (float)kMapModSpeed(LDR2_value)/1000; 
 + 
 +  kIntensityMod.setFreq(mod_speed); 
 +   
 +  Serial.println(); // finally, print a carraige return for the next line of debugging info 
 +} 
 + 
 +int updateAudio(){ 
 +  long modulation = aSmoothIntensity.next(fm_intensity) * aModulator.next(); 
 +  return aCarrier.phMod(modulation); 
 +} 
 + 
 +void loop(){ 
 +  audioHook(); 
 +} 
 +</code> 
 +++++ 
 + 
 +==== Code pour communiquer avec PureData COMPORT (2 led branché en 9 et 10): ==== 
 +On controle ainsi deux pins avec tone depuis Pure Data...  
 + 
 +**Patch PureData :** voir fichier 4 dans la page ressource [[http://reso-nance.org/wiki/logiciels/serial/accueil?s[]=puredata&s[]=serial]] 
 + 
 +++++ Le code   |  
 +<code c+> 
 +String inputString = "";   // chaine de caractères pour contenir les données 
 +boolean stringComplete = false;  // pour savoir si la chaine est complète 
 +String fct =""; 
 +String arg=""; 
 +int index; 
 + 
 +#include <Tone.h> 
 +Tone freq1; 
 +Tone freq2; 
 + 
 +void setup() { 
 +  Serial.begin(9600);     // port série 
 +  freq1.begin(9); 
 +  freq2.begin(10); 
 +} 
 + 
 +void loop() { 
 +  if (stringComplete) { 
 +    //Serial.println(inputString);  
 +    index = inputString.indexOf(' '); // on récupère la position du séparateur (l'espace " ") 
 +    fct = inputString.substring(0,index); // on coupe la chaine en deux : la fonction et l'argument 
 +    arg = inputString.substring(index,inputString.length()); 
 +     
 +    if (fct == "LED10") { 
 +      freq2.play(arg.toInt(),300); 
 +    } 
 +    else if (fct == "LED9") { 
 +      freq1.play(arg.toInt(),300);    
 +    } 
 + 
 +    inputString = "";            // vide la chaine 
 +    stringComplete = false; 
 +  } 
 +} 
 + 
 +/* 
 +  SerialEvent est déclenché quand de nouvelles données sont reçues.  
 +  Cett routine tourne entre chaque loop(), donc utiliser un delay la fait aussi attendre 
 + */ 
 +void serialEvent() { 
 +  while (Serial.available()) { 
 +    char inChar = (char)Serial.read(); // Récupérer le prochain octet (byte ou char) 
 +    inputString += inChar; // concaténation des octets 
 +    if (inChar == '\n') {  // caractère de fin pour notre chaine 
 +      stringComplete = true; 
 +    } 
 +  } 
 +} 
 + 
 + 
 +</code> 
 +++++  
 + 
 +==== Code sympa fluctuant Mozzi ==== 
 +2 pot volume et pitch 
 + 
 +++++ Le code   |  
 +<code c+> 
 +#include <MozziGuts.h> 
 +#include <Oscil.h> // oscillator template 
 +#include <tables/sin2048_int8.h> // sine table for oscillator 
 + 
 +const char KNOB_PIN = 0; // set the input for the knob to analog pin 0 
 +const char LDR_PIN = 1; // set the input for the LDR to analog pin 1 
 + 
 +// use: Oscil <table_size, update_rate> oscilName (wavetable), look in .h file of table #included above 
 +Oscil <SIN2048_NUM_CELLS, AUDIO_RATE> aSin(SIN2048_DATA); 
 + 
 +byte volume; 
 + 
 +void setup(){ 
 +  startMozzi(); // :)) 
 +} 
 + 
 + 
 +void updateControl(){ 
 +  // read the potentiometer 
 +  int knob_value = mozziAnalogRead(KNOB_PIN); // value is 0-1023 
 +   
 +  // map it to an 8 bit volume range for efficient calculations in updateAudio 
 +  volume = knob_value >> 2;  // 10 bits (0->1023) shifted right by 2 bits to give 8 bits (0->255) 
 +   
 +  // read the light dependent resistor 
 +  int light_level = mozziAnalogRead(LDR_PIN); // value is 0-1023 
 + 
 +  light_level = map(light_level,0,1023,0,12); 
 +  light_level = light_level*100 + 200; 
 + 
 +  // set the frequency 
 +  aSin.setFreq( light_level); 
 +   
 +} 
 + 
 + 
 +int updateAudio(){ 
 +  // cast char output from aSin.next() to int to make room for multiplication 
 +  return ((int)aSin.next() * volume) >> 8; // shift back into range after multiplying by 8 bit value 
 + 
 +} 
 + 
 +void loop(){ 
 +  audioHook(); // required here 
 +  delay(100); 
 +} 
 +</code> 
 +++++  
 + 
 +==== Theremin fluctuant Mozzi ==== 
 +2 pot (selecteur si pot ou ldr pour controler le pitch, pitch ) un ldr (pitch).... 
 + 
 +++++ Le code   |  
 +<code c+> 
 +/*   
 +*/ 
 + 
 +#include <MozziGuts.h> 
 +#include <Oscil.h> // oscillator template 
 +#include <tables/sin2048_int8.h> // sine table for oscillator 
 +#include <RollingAverage.h> 
 +#include <ControlDelay.h> 
 + 
 +#define INPUT_PIN 0 // analog control input 
 +#define INPUT_PINA 2 // analog control input 
 +#define MIX_PIN 3 // analog control input 
 + 
 +unsigned int echo_cells_1 = 32; 
 +unsigned int echo_cells_2 = 60; 
 +unsigned int echo_cells_3 = 127; 
 +    int bumpy_input = 12; 
 + 
 +#define CONTROL_RATE 64 
 +ControlDelay <128, int> kDelay; // 2seconds 
 + 
 +// oscils to compare bumpy to averaged control input 
 +Oscil <SIN2048_NUM_CELLS, AUDIO_RATE> aSin0(SIN2048_DATA); 
 +Oscil <SIN2048_NUM_CELLS, AUDIO_RATE> aSin1(SIN2048_DATA); 
 +Oscil <SIN2048_NUM_CELLS, AUDIO_RATE> aSin2(SIN2048_DATA); 
 +Oscil <SIN2048_NUM_CELLS, AUDIO_RATE> aSin3(SIN2048_DATA); 
 + 
 +// use: RollingAverage <number_type, how_many_to_average> myThing 
 +RollingAverage <int, 32> kAverage; // how_many_to_average has to be power of 2 
 +int averaged; 
 + 
 +void setup(){ 
 +  kDelay.set(echo_cells_1); 
 +  startMozzi(); 
 +} 
 + 
 + 
 +void updateControl(){ 
 +  int mix =  mozziAnalogRead(MIX_PIN); 
 +  int pot = mozziAnalogRead(INPUT_PINA) ; 
 +  int ldr = mozziAnalogRead(INPUT_PIN) ; 
 + 
 +if (mix > 500) 
 +{ 
 +  bumpy_input = ldr; 
 +} 
 +else 
 +{ 
 +  bumpy_input = pot; 
 +} 
 + 
 +   
 +  averaged = kAverage.next(bumpy_input); 
 +  aSin0.setFreq(averaged); 
 +  aSin1.setFreq(kDelay.next(averaged)); 
 +  aSin2.setFreq(kDelay.read(echo_cells_2)); 
 +  aSin3.setFreq(kDelay.read(echo_cells_3)); 
 +} 
 + 
 + 
 +int updateAudio(){ 
 +  return 3*((int)aSin0.next()+aSin1.next()+(aSin2.next()>>1) 
 +    +(aSin3.next()>>2)) >>3; 
 +} 
 + 
 + 
 +void loop(){ 
 +  audioHook(); 
 +} 
 + 
 +</code> 
 +++++ 
  
 ===== Matériaux et outils ===== ===== Matériaux et outils =====
/home/resonancg/www/wiki/data/attic/projets/light-synth/accueil.1499598375.txt.gz · Dernière modification: 2017/07/09 13:06 de resonance

Outils de la page

GNU Free Documentation License 1.3 Valid HTML5 Driven by DokuWiki