Midification de la pédale AKAI headrush

Parlez nous de vos projets et de vos idées, imaginez des applications

Midification de la pédale AKAI headrush

Message non lude did » Mar 20 Sep 2011 15:13

Bonjour à tous.
Voici mon projet.
L'akai headrush est une pédale qui permet de sampler 12 secondes (environ) en temps réel et de pouvoir rejouer dessus autant que l'on désire. Il existes quelques autres pédales de ce types mais pour la plupart ce sont un peu des usines à gaz et peu d'entre elles sont équipées en midi. La headrush n'est pas midi. La headrush est très simple il ya deux boutons "rec" et "play". On enregistre une boucle en appuyant sur "rec" et on la valide en appuyant sur "play", si on rappuie sur "play" ça s'éteind, si on appuie de nouveau, c'est reparti. L'idée serait donc de piloter grâce à une arduino la commandes play de manière à ce qu'elle soit synchronisée avec le tempo midi.

J'ai (eu du mal à) réussi(r) à écrire un code qui marche (assez bien) pour repérer les mouvements des boutons (selon si "rec" est activé ou pas, "play" réagit différemment), j'ai aussi un code récupéré sur internet pour recevoir les commandes midi par contre, ce qui me manque ce serait une sorte de chronomètre qui mesurerait le temps entre le moment ou on presse "rec" et le moment ou on presse "play" pour pouvoir convertir ça en mesures qui suivraient d'autres éléments midi.

Voici le code des boutons :
Code: Tout sélectionner
int playPin = 5;       
int playLed = 12;
int recPin = 6;
int recLed = 11;

int playState = LOW;     
int playReading;           
int playPrevious = HIGH;

int recState = LOW;     
int recReading;           
int recPrevious = HIGH;

int play;
int rec;
int playpause = 0;
int playstart = 0;

long playTime = 0;         
long playDebounce = 300; 
long recTime = 0;         
long recDebounce = 200;


void setup()
{
  pinMode(playPin, INPUT);
  digitalWrite(playPin, HIGH);
  pinMode(playLed, OUTPUT);
  pinMode(recPin, INPUT);
  digitalWrite(recPin, HIGH);
  pinMode(recLed, OUTPUT);
 
  Serial.begin(300);
}


void loop()
{

playReading = digitalRead(playPin);

if (playstart > 0){
if (playReading == HIGH && playPrevious == LOW && millis() - playTime > playDebounce) {
   play += 1;
   playTime =  millis();
}
}

recReading = digitalRead(recPin);
if (recReading == HIGH && recPrevious == LOW && millis() - recTime > recDebounce) {
  rec += 1;
  recTime = millis();   
}

 

if (rec != 0){
recState = 1;
}else{
recState = 0;
}

if (rec != 0){
  playstart = 1;
}

if (play != 0){
playState = 1;
}else{
playState = 0;
}
 
if (playpause == 0){
  if (rec > 0 && play > 0){
    rec = 0;
    play = 1;
    playpause = 1; 
  }
}

if (playpause == 1){
  if (rec > 0 && play > 1){
    play = 1;
    rec = 0;
  }
 
  if (rec == 0 && play > 1){
    play = 0;
    rec = 0;
  }
  if (rec == 0 && play == 0){
    playpause = 2;
  }
}

if (playpause == 2){
  if (rec > 0 && play > 0){
    rec = 0;
    play = 1;
    playpause = 1;
  }
  if (rec == 0 && play == 2){
    rec = 0;
    play = 0;
  }
}

 
digitalWrite(playLed, playState);
digitalWrite(recLed, recState);
playPrevious = playReading;
recPrevious = recReading;
 
Serial.print(rec);
Serial.print(play);
Serial.println(playpause);
}


et le code pour recevoir le signal midi, récupérer a cette adresse : http://little-scale.blogspot.com/2008/05/how-to-deal-with-midi-clock-signals-in.html

Code: Tout sélectionner
byte midi_start = 0xfa;
byte midi_stop = 0xfc;
byte midi_clock = 0xf8;
byte midi_continue = 0xfb;
int play_flag = 0;
byte data;

void setup() {
Serial.begin(31250);
}

void loop() {
if(Serial.available() > 0) {
data = Serial.read();
if(data == midi_start) {
play_flag = 1;
}
else if(data == midi_continue) {
play_flag = 1;
}
else if(data == midi_stop) {
play_flag = 0;
}
else if((data == midi_clock) && (play_flag == 1)) {
Sync();
}
}
}

void Sync() {
// do something for every MIDI Clock pulse when the sequencer is running
}


Si vous avez des idées ou besoin de précisions vu que je n'ai pas commenté le code, je suis prêt.
did
 
Messages: 14
Inscription: Mar 13 Sep 2011 19:42

Re: Midification de la pédale AKAI headrush

Message non lude Lionel » Mar 20 Sep 2011 18:01

Hmmmm,

pas spécialiste du tout du midi et pas sûr d'avoir tout compris, cependant, il me semble que tu as déjà le compteur et que tu t'en sers déjà :)

la fonction millis() !!!

Description
Returns the number of milliseconds since the Arduino board began running the current program. This number will overflow (go back to zero), after approximately 50 days.

Returns
Number of milliseconds since the program started (unsigned long)


Donc il te suffirait de placer au bon endroit un truc genre playDuration = recTime - playTime pour récupérer l'info non ?

Et d'autre part, pourquoi la vitesse de ton serial est à 300 ??
Image - Distributeur officiel Arduino - Conception de shields
Avatar de l’utilisateur
Lionel
 
Messages: 734
Inscription: Mar 21 Déc 2010 09:52
Localisation: Toulouse

Re: Midification de la pédale AKAI headrush

Message non lude Lionel » Jeu 22 Sep 2011 14:25

A mon avis, il y a des choses a voir par ici :
http://www.arduino.cc/playground/Main/MIDILibrary
Image - Distributeur officiel Arduino - Conception de shields
Avatar de l’utilisateur
Lionel
 
Messages: 734
Inscription: Mar 21 Déc 2010 09:52
Localisation: Toulouse

Re: Midification de la pédale AKAI headrush

Message non lude did » Ven 23 Sep 2011 17:12

Bon après cette petite discussion, j'ai remis le projet en route. J'ai aussi lu la doc sur les signaux midi mais je préfère dans un premier temps conserver le compteur de clock midi (qui n'est pas affiché dans le code ci-dessus :? ) vu que ça marche. Je pense que je vais aussi simplifier l'interface prévue au départ (avec plein de leds et de boutons) pour un truc beaucoup plus sobre. Je posterai ici mes avancées :) dès que possible.
did
 
Messages: 14
Inscription: Mar 13 Sep 2011 19:42

Re: Midification de la pédale AKAI headrush

Message non lude did » Mar 4 Oct 2011 13:17

bon j'ai changé tout mon code. Au lieu de prendre en compte les mouvements des boutons, j'ai pris en compte les leds qui correspondent aux différents états de la Headrush, c'est beaucoup plus simple au final. Voici où j'en suis (pas encore fini bien sûr) mais pour le moment il fait ce que j'attends de lui.

Code: Tout sélectionner
// switch de l'akaiA pour lecture de l'état
int playPin = 3;
int recPin = 2;
// envoi impulsion vers switch akaiB
int playTrPin = 4;

// Lecture de l'état des leds
int playLed = 5;
int recLed = 6;
// lecture de l'état des leds
int playLedReading;           
int recLedReading;
int playReading;


int play = 0;
int rec = 0;
int playstart = 0;



   
// les bits midis
byte midi_start = 0xfa;
byte midi_stop = 0xfc;
byte midi_clock = 0xf8;
byte midi_continue = 0xfb;
int play_flag = 0;
byte data;

// compteur des clocks midi
int counter = 0;

    void setup()
    {
      pinMode(playPin, INPUT);
      digitalWrite(playPin, HIGH);
     
      pinMode(playLed, INPUT);
      digitalWrite(playLed, HIGH);
     
      pinMode(recLed, INPUT);
      digitalWrite(recLed, HIGH);
     
      pinMode(recPin, INPUT);
      digitalWrite(recPin, HIGH);
     
      pinMode(playTrPin, OUTPUT);
      Serial.begin(300); // vitesse du midi
    }


    void loop()
    {
//////////////////////////////////////////////////////////
//if(Serial.available() > 0) {
//data = Serial.read();
//if(data == midi_start) {
//play_flag = 1;
//}
//else if(data == midi_continue) {
//play_flag = 1;
//}
//else if(data == midi_stop) {
//play_flag = 0;
//}
//else if((data == midi_clock) && (play_flag == 1)) {
//////////////////////////////////////////////////////////
  bouton();
    Serial.print(rec, DEC);
    Serial.print(play,DEC);
    Serial.println(counter,DEC);
sync();



//    }
//  }
}




// fonction qui gère le comportement étrange des boutons de la machine
void bouton(){
playLedReading = !digitalRead(playLed);
recLedReading = !digitalRead(recLed);
playReading = !digitalRead(playPin);

if (recLedReading == 1){
  rec = 1;
  playstart = 1;
}else{
  rec = 0;
}
if (playLedReading == 1){
  play = 1;
}else{
  play = 0;
}

digitalWrite (playTrPin, playReading);
digitalWrite (13, playLedReading);
   
    }


// fonction qui synchronise le tempo (à tester)
void sync(){
if (playstart != 0){
  if (play == 0  && rec == 1){
    counter += 1;
  }else{
    counter = counter;
  }
 }
}



j'aurais besoin d'un conseil en ce qui concerne la dernière partie du code :

Code: Tout sélectionner
void sync(){
if (playstart != 0){
  if (play == 0  && rec == 1){
    counter += 1;
  }else{
    counter = counter;
  }
 }
}


Comment puis je faire pour remettre counter à zero et re-incrémenter quand play=0 et rec=1?
tel quel le code fait simplement continuer l'incrémentation.
did
 
Messages: 14
Inscription: Mar 13 Sep 2011 19:42

Re: Midification de la pédale AKAI headrush

Message non lude did » Lun 17 Oct 2011 20:16

Salut.

Je reviens pour demander de l'aide. J'ai réussi à faire à peu près tout ce que je voulais, sauf cette histoire de boutons.
Je voulais donc savoir, si il n'existe pas un code qui permet de transformer un "toggle switch" alias "dpdt switch" en bouton momentané alias "momentary switch" ou "push button".
Je pourrai comme ça contrôler l'état du bouton dans mon code, puisque qu'il soit haut ou bas à l'extinction de la machine, il est toujours considéré comme bas au (re-)démarrage
did
 
Messages: 14
Inscription: Mar 13 Sep 2011 19:42

Re: Midification de la pédale AKAI headrush

Message non lude did » Ven 21 Oct 2011 11:44

Salut à tous...c'est encore moi :D

J'ai fait quelques progrès, j'ai enfin trouvé une solution pour avoir un comportement de switchs momentanés avec mes switch dpdt, je les ai remplacé par des switchs momentanés :| .
J'ai réussi à pas mal avancer dans mon code mais maintenant je bloque...
voici le code :
Code: Tout sélectionner
int recsw = 3; //pin du switch rec (bouton momentane)
int swrec; // etat du transitor de commande du switch rec
int recstate; // etat du switch rec
int Rstate =  LOW;
int playsw = 2; //pin du switch play (bouton momentane)
int swplay; // etat du transistor de commande du switch play
int SWstate = HIGH;
int playstate; // etat du switch play
int Pstate = HIGH;
int trplay = 4; //transistor de commande play (2N3904 + 1kR)
int trrec = 5; // transistor de commande rec  (2N3904 + 1kR)
int midionoff; // etat du switch midi on off
int midisw = 6; //pin du switch midi on off


int play; // mode play
int rec; // mode rec
int playstart = 0; // differents etats des modes de lecture et enregistrement
int playpause = 11; // etat initial de la pedale
int counter = 0; // compteur de clock pour la synchro
int counter2 = 0; // deuxième compteur pour sauvegarde du dernier compatge des clocks midi
int laps = 20; // temps de bascule pour le transistor en mode synchro
int i; // compatge pour commande des transistors en mode synchro


long playtime = 0;         //
long playdebounce = 200;   //  differentes variables pour les débounces des
long rectime = 0;          //  inters PLAY et REC
long recdebounce = 200;    //

void setup() {
      pinMode(playsw, INPUT);
      digitalWrite(playsw, HIGH);
     
      pinMode(recsw, INPUT);
      digitalWrite(recsw, HIGH);
     
      pinMode(midisw, INPUT);
      digitalWrite(midisw, HIGH);
     
      pinMode(trplay, OUTPUT);
      pinMode(trrec, OUTPUT);
      Serial.begin(9600); // vitesse du midi (31250)
}

void loop() {
  midionoff = digitalRead(midisw);
if (midionoff == HIGH){
  sync();
  test();

}
if (midionoff == LOW){
  nosync();
  test();

}
}



////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////           /™\ \_/ |\ |  /™\        ///
/////////////////////////////////////////           \_   |  | \| |           ///
//  synchro midi de la pedale. //                     \  |  |  | |           ///
/////////////////////////////////////////           \_/  |  |  |  \_/        ///
//////////////////////////////////////////////////////////////////////////////////////////////////
                                                                                               ///
void sync(){                                                                                   ///
recstate = !digitalRead(recsw);                                                                ///
playstate = digitalRead(playsw);                                                               ///
                                                                                               ///
                                                                                               ///
//  etat du switch rec                                                                  ///
if (recstate == HIGH && Rstate == LOW && millis() - rectime > recdebounce) {                   ///
   rec += 1;                                                                                   ///
   swrec += 1;                                                                                 ///
   playstart = 1;                                                                              ///
   rectime =  millis();                                                                        ///
}                                                                                              ///
if (swrec == 2){                                                                               ///
  swrec = 0;                                                                                   ///
}                                                                                              ///
                                                                                               ///
                                                                                               ///
                                                                                               ///
// etat du switch play                                                       ///

  if (playstate == LOW && Pstate == HIGH && millis() - playtime > playdebounce) {
     play += 1;    ///
     swplay += 1;                                                                                ///
     playtime =  millis();                                                                       ///
  }                                                                                              ///
  if (swplay == 2){                                                                              ///
    swplay = 0;                                                                                  ///
  }


 
// différents modes définis par playstart, si ==11 début, ==0 en standby, ==1 ou 2 play.                                                                                               ///
                                                                                               ///
if (playstart != 0){   
  if (playpause == 11){
    if (rec > 0 && play == 0){
      counter += 1;
      counter2 = counter;
    }
    if (rec > 0 && play > 0){
    rec = 0;
    counter = 0;
    playpause = 1;
    }

  }

  if (playpause == 0){
    if (rec > 0 && play == 0){
      counter += 1;
      counter2 = counter;
      }
    if (rec > 0 && play > 0){
      rec = 0;
      play = 1;
      playpause = 1;
     }
    if (rec == 0 && play > 0){
      playpause = 1;
      play = 1;
      rec = 0;
    }
  }

  if (playpause == 1){ 
    if (play == 2 && rec == 0){
      play = 0;
      playpause = 0;
      counter = 0;
    }
    if (play == 2 && rec != 0){
      rec = 0;
      play == 1;
      playpause = 2;
    }
  }
 
  if (playpause == 2){
    if (play != 0 && rec != 0){
      playpause = 1;
      play = 1;
    }
    if (play == 3 && rec == 0){
      play = 0;
      rec = 0;
      playpause = 0;
      counter = 0;
    }                                                                                          ///
  }                                                                                            ///
}


// clignotement du transistor de commande de play (CA MARCHE PAS)

if (playpause > 0){
  if (i<counter2){
    i += 1;
      if (i > counter2-laps){ 
        swplay = !swplay;
      }
      if (i < counter2-laps){
        swplay = swplay;
      }
      if (i == counter2){
        i = 0;
      }
    }
 

}
digitalWrite (trrec, swrec);
digitalWrite (trplay, swplay); ///
                                                                                               ///
}                                                                                              ///
//////////////////////////////////////////////////////////////////////////////////////////////////






//////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////        |\ | |™™|    /™\ \_/ |\ |  /™\        ///
/////////////////////////////////////////        | \| |  |    \_   |  | \| |           ///
// fonctionnement normal de la pedale. //        |  | |  |      \  |  |  | |           ///
/////////////////////////////////////////        |  | |__|    \_/  |  |  |  \_/        ///
//////////////////////////////////////////////////////////////////////////////////////////
                                                                                       ///
void nosync(){                                                                         ///
playstate = digitalRead(playsw);                                                       ///
recstate = !digitalRead(recsw);                                                        ///
if (playstate == LOW && Pstate == HIGH && millis() - playtime > playdebounce) {        ///
   swplay += 1;                                                                        ///
   playtime =  millis();                                                               ///
}                                                                                      ///
if (swplay == 2){                                                                      ///
  swplay = 0;                                                                          ///
}                                                                                      ///
if (recstate == HIGH && Rstate == LOW && millis() - rectime > recdebounce) {           ///
   swrec += 1;                                                                         ///
   rectime =  millis();                                                                ///
}                                                                                      ///
if (swrec == 2){                                                                       ///
  swrec = 0;                                                                           ///
}                                                                                      ///
                                                                                       ///
digitalWrite (trplay, swplay);                                                         ///
digitalWrite (trrec, swrec);                                                           ///
                                                                                       ///
}                                                                                      ///
//////////////////////////////////////////////////////////////////////////////////////////
 
void test(){
    Serial.print("play =");
    Serial.print(play,DEC);
    Serial.print("  ");
    Serial.print("rec =");
    Serial.print(rec,DEC);
    Serial.print(" ");
    Serial.print("playpause =");
    Serial.print(playpause,DEC);
    Serial.print(" ");
    Serial.print("swplay =");
    Serial.print(swplay,DEC);
    Serial.print("---");
    Serial.print(counter2,DEC);
    Serial.print("-");
    Serial.println(i,DEC);
}


Je bloque sur cette partie :
Code: Tout sélectionner
if (playpause > 0){
  if (i<counter2){
    i += 1;
      if (i > counter2-laps){ 
        swplay = !swplay;
      }
      if (i < counter2-laps){
        swplay = swplay;
      }
      if (i == counter2){
        i = 0;
      }
    }
 

}
digitalWrite (trrec, swrec);
digitalWrite (trplay, swplay);


Quand swplay = !swplay, la variable swplay passe de 0 à 1 en permanence...
quelqu'un aurait une idée pour me dépatouiller?
Sinon, le reste marche bien :D
merci merci...

did
did
 
Messages: 14
Inscription: Mar 13 Sep 2011 19:42

Re: Midification de la pédale AKAI headrush

Message non lude Lionel » Ven 21 Oct 2011 21:08

Je ne réponds pas mais je suis hein !!
vais essayer de montrer ça à Arne (notre vieille star du code)
Tu nous fais une petite photo de l'ensemble pour comprendre le tout ?
Image - Distributeur officiel Arduino - Conception de shields
Avatar de l’utilisateur
Lionel
 
Messages: 734
Inscription: Mar 21 Déc 2010 09:52
Localisation: Toulouse

Re: Midification de la pédale AKAI headrush

Message non lude did » Ven 21 Oct 2011 21:37

Je pense avoir trouvé une solution,mais j'ai pas pu la tester encore. Après, je veux bien qu'un codeur y jette un oeil, ne serait ce que pour avoir un avis.

Voilà ma solution possible, elle marche avec la LED13, mais j'ai pas eu la possibilité aujourd’hui de faire le test avec la pédale.

Code: Tout sélectionner
if (playpause > 0){


  if (i<counter2){
    i += 1;
      if (i > counter2-laps){ 
        digitalWrite (trplay,swplay);
        digitalWrite (13,swplay);
      }
      if (i < counter2-laps){
        digitalWrite (trplay,!swplay);
        digitalWrite (13,!swplay);
      }
      if (i == counter2){
        i = 0;
      }
    }
 

}


il reste encore la partie midi à écrire, mais je pense que j'ai fait le plus dur ou presque.
did
 
Messages: 14
Inscription: Mar 13 Sep 2011 19:42

Re: Midification de la pédale AKAI headrush

Message non lude did » Sam 22 Oct 2011 16:28

j'ai fait ça aujourd'hui mais ça marche pas en fait :cry: :cry: :cry:

Code: Tout sélectionner
int recsw = 3; //pin du switch rec (bouton momentane)
int swrec; // etat du transitor de commande du switch rec
int recstate; // etat du switch rec
int Rstate =  LOW;
int playsw = 2; //pin du switch play (bouton momentane)
int swplay; // etat du transistor de commande du switch play
int SWstate = HIGH;
int playstate; // etat du switch play
int Pstate = HIGH;
int trplay = 4; //transistor de commande play (2N3904 + 1kR)
int trrec = 5; // transistor de commande rec  (2N3904 + 1kR)
int midionoff; // etat du switch midi on off
int midisw = 6; //pin du switch midi on off


int play; // mode play
int rec; // mode rec
int playstart = 0; // differents etats des modes de lecture et enregistrement
int playpause = 11; // etat initial de la pedale
int counter = 0; // compteur de clock pour la synchro
int counter2 = 0; // deuxième compteur pour sauvegarde du dernier compatge des clocks midi
int laps = 20; // temps de bascule pour le transistor en mode synchro
int i; // compatge pour commande des transistors en mode synchro


long playtime = 0;         //
long playdebounce = 200;   //  débounces des
long rectime = 0;          //  inters PLAY et REC
long recdebounce = 200;    //

void setup() {
      pinMode(playsw, INPUT);
      digitalWrite(playsw, HIGH);
     
      pinMode(recsw, INPUT);
      digitalWrite(recsw, HIGH);
     
      pinMode(midisw, INPUT);
      digitalWrite(midisw, HIGH);
     
      pinMode(trplay, OUTPUT);
      pinMode(trrec, OUTPUT);
      Serial.begin(9600); // vitesse du midi (31250)
}

void loop() {
  midionoff = digitalRead(midisw);
if (midionoff == HIGH){
  sync();
  test();

}
if (midionoff == LOW){
  nosync();
  test();

}
}



//////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////           /™\ \_/ |\ | /™\        /////////////////////
/////////////////////////////////////////           \_   |  | \| |           /////////////////////
//  synchro midi de la pedale. //////////             \  |  |  | |           /////////////////////
/////////////////////////////////////////           \_/  |  |  |  \_/        /////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////
                                                                                               ///
void sync(){                                                                                   ///
recstate = !digitalRead(recsw);                                                                ///
playstate = digitalRead(playsw);                                                               ///
                                                                                               ///
                                                                                               ///
//  etat du switch rec                                                                         ///
if (recstate == HIGH && Rstate == LOW && millis() - rectime > recdebounce) {                   ///
   rec += 1;                                                                                   ///
   swrec += 1;                                                                                 ///
   playstart = 1;                                                                              ///
   rectime =  millis();                                                                        ///
}                                                                                              ///
if (swrec == 2){                                                                               ///
  swrec = 0;                                                                                   ///
}                                                                                              ///
                                                                                               ///
                                                                                               ///
                                                                                               ///
// etat du switch play                                                                         ///
                                                                                               ///
  if (playstate == LOW && Pstate == HIGH && millis() - playtime > playdebounce) {              ///
     play += 1;                                                                                ///
     swplay += 1;                                                                              ///
     playtime =  millis();                                                                     ///
  }                                                                                            ///
  if (swplay == 2){                                                                            ///
    swplay = 0;                                                                                ///
  }                                                                                            ///
                                                                                               ///
                                                                                               ///
                                                                                               ///
// différents modes définis par playstart, si ==11 début, ==0 en standby, ==1 ou 2 play.       ///
                                                                                               ///
if (playstart != 0){                                                                           ///   
  if (playpause == 11){                                                                        ///
    if (rec > 0 && play == 0){                                                                 ///
      counter += 1;                                                                            ///
      counter2 = counter;                                                                      ///
    }                                                                                          ///
    if (rec > 0 && play > 0){                                                                  ///
    rec = 0;                                                                                   ///
    counter = 0;                                                                               ///
    playpause = 1;                                                                             ///
    }                                                                                          ///
    digitalWrite (trplay, swplay);                 
    if (i > counter2){                                                           ///
    i = 0;                                                                                       ///
    }                                                                                           ///
  }                                                                                            ///
                                                                                               ///
  if (playpause == 0){                                                                         ///
    if (rec > 0 && play == 0){                                                                 ///
      counter += 1;                                                                            ///
      counter2 = counter;                                                                      ///
      }                                                                                        ///
    if (rec > 0 && play > 0){                                                                  ///
      rec = 0;                                                                                 ///
      play = 1;                                                                                ///
      playpause = 1;                                                                           ///
     }                                                                                         ///
    if (rec == 0 && play > 0){                                                                 ///
      playpause = 1;                                                                           ///
      play = 1;                                                                                ///
      rec = 0;                                                                                 ///
    }
    digitalWrite (trplay, swplay);                 
    if (i > counter2){                                                           ///
    i = 0;                                                                                       ///
    }    ///
  }                                                                                            ///
                                                                                               ///
  if (playpause == 1){                                                                         ///
    if (play == 2 && rec == 0){                                                                ///
      play = 0;                                                                                ///
      playpause = 0;                                                                           ///
      counter = 0;                                                                             ///
    }                                                                                          ///
    if (play == 2 && rec != 0){                                                                ///
      rec = 0;                                                                                 ///
      play == 1;                                                                               ///
      playpause = 2;                                                                           ///
    }
  if (i<counter2){                                                                             ///
    i += 1;                                                                                    ///
      if (i > counter2-laps){
        swplay += 1;///
          if (swplay > 2){
            swplay == 0;
          }
        digitalWrite (trplay,!swplay);                                                         ///
        digitalWrite (13,swplay);                                                              ///
      }                                                                                        ///
      if (i < counter2-laps){                                                                  ///
        digitalWrite (trplay, swplay);                                                         ///
        digitalWrite (13,!swplay);                                                             ///
      }                                                                                        ///
      if (i == counter2){                                                                      ///
        i = 0;                                                                                 ///
      }                                                                                        ///
    }     ///
  }                                                                                            ///
                                                                                               ///
  if (playpause == 2){                                                                         ///
    if (play != 0 && rec != 0){                                                                ///
      playpause = 1;                                                                           ///
      play = 1;                                                                                ///
    }                                                                                          ///
    if (play == 3 && rec == 0){                                                                ///
      play = 0;                                                                                ///
      rec = 0;                                                                                 ///
      playpause = 0;                                                                           ///
      counter = 0;                                                                             ///
    }
    if (i<counter2){                                                                             ///
      i += 1;                                                                                    ///
      if (i > counter2-laps){
        swplay +=1;
        if (swplay > 3){
          swplay = 0;
      }
        digitalWrite (trplay,swplay);                                                         ///
        digitalWrite (13,swplay);                                                              ///
      }                                                                                        ///
      if (i < counter2-laps){                                                                  ///
        digitalWrite (trplay, !swplay);                                                         ///
        digitalWrite (13,!swplay);                                                             ///
      }                                                                                        ///
      if (i == counter2){                                                                      ///
        i = 0;                                                                                 ///
      }                                                                                        ///
    }     ///
  }                                                                                            ///
}                                                                                              ///
                                                                                               ///
                                                                                               ///                                                                                             ///
digitalWrite (trrec, swrec);                                                                   ///
                                                                                               ///
                                                                                               ///
                                                                                               ///
}                                                                                              ///
//////////////////////////////////////////////////////////////////////////////////////////////////






//////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////        |\ | |™™|    /™\ \_/ |\ |  /™\      ///
/////////////////////////////////////////        | \| |   |    \_   |  | \| |          ///
// fonctionnement normal de la pedale. //        |  | |   |      \  |  |  | |          ///
/////////////////////////////////////////        |  | |___|    \_/  |  |  |  \_/       ///
//////////////////////////////////////////////////////////////////////////////////////////
                                                                                       ///
void nosync(){                                                                         ///
playstate = digitalRead(playsw);                                                       ///
recstate = !digitalRead(recsw);                                                        ///
if (playstate == LOW && Pstate == HIGH && millis() - playtime > playdebounce) {        ///
   swplay += 1;                                                                        ///
   playtime =  millis();                                                               ///
}                                                                                      ///
if (swplay == 2){                                                                      ///
  swplay = 0;                                                                          ///
}                                                                                      ///
if (recstate == HIGH && Rstate == LOW && millis() - rectime > recdebounce) {           ///
   swrec += 1;                                                                         ///
   rectime =  millis();                                                                ///
}                                                                                      ///
if (swrec == 2){                                                                       ///
  swrec = 0;                                                                           ///
}                                                                                      ///
                                                                                       ///
digitalWrite (trplay, swplay);                                                         ///
digitalWrite (trrec, swrec);                                                           ///
                                                                                       ///
}                                                                                      ///
//////////////////////////////////////////////////////////////////////////////////////////
 
void test(){
    Serial.print("play =");
    Serial.print(play,DEC);
    Serial.print("  ");
    Serial.print("rec =");
    Serial.print(rec,DEC);
    Serial.print(" ");
    Serial.print("playpause =");
    Serial.print(playpause,DEC);
    Serial.print(" ");
    Serial.print("swplay =");
    Serial.print(swplay,DEC);
    Serial.print("---");
    Serial.print(counter2,DEC);
    Serial.print("-");
    Serial.println(i,DEC);
}
did
 
Messages: 14
Inscription: Mar 13 Sep 2011 19:42

Re: Midification de la pédale AKAI headrush

Message non lude did » Sam 22 Oct 2011 16:57

Voilà une image du montage.
Image

et voici une video qui montre comment est censée marcher la pédale (sans modifs quoi...)

*

j'ai pas trouvé plus clair...
did
 
Messages: 14
Inscription: Mar 13 Sep 2011 19:42

Re: Midification de la pédale AKAI headrush

Message non lude did » Dim 23 Oct 2011 21:55

J'ai l'impression que j'ai réussi. Maintenant il me manque juste la parti midi.
Voilà mon code :
Code: Tout sélectionner
int recsw = 3; //pin du switch rec (bouton momentane)
int swrec; // etat du transitor de commande du switch rec
int recstate; // etat du switch rec
int Rstate =  LOW;
int playsw = 2; //pin du switch play (bouton momentane)
int swplay; // etat du transistor de commande du switch play
int SWstate = HIGH;
int playstate; // etat du switch play
int Pstate = HIGH;
int trplay = 4; //transistor de commande play (2N3904 + 1kR)
int trrec = 5; // transistor de commande rec  (2N3904 + 1kR)
int midionoff; // etat du switch midi on off
int midisw = 6; //pin du switch midi on off

int recled = 7;
int eled;


int play; // mode play
int rec; // mode rec
int playstart = 0; // differents etats des modes de lecture et enregistrement
int playpause = 11; // etat initial de la pedale
int counter = 0; // compteur de clock pour la synchro
int counter2 = 0; // deuxième compteur pour sauvegarde du dernier compatge des clocks midi
int laps = 7  ; // temps de bascule pour le transistor en mode synchro
int i; // compatge pour commande des transistors en mode synchro


long playtime = 0;         //
long playdebouncecourt = 200;   //  débounces des
long rectime = 0;          //  inters PLAY et REC
long recdebounce = 200;    //

void setup() {
      pinMode(playsw, INPUT);
      digitalWrite(playsw, HIGH);
     
      pinMode(recsw, INPUT);
      digitalWrite(recsw, HIGH);
     
      pinMode(midisw, INPUT);
      digitalWrite(midisw, HIGH);
     
      pinMode(recled, INPUT);
      digitalWrite(recled, HIGH);
     
      pinMode(trplay, OUTPUT);
      pinMode(trrec, OUTPUT);
      Serial.begin(9600); // vitesse du midi (31250)
}

void loop() {
  midionoff = digitalRead(midisw);
if (midionoff == HIGH){
  sync();
  test();

}
if (midionoff == LOW){
  nosync();
  test();

}
}



//////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////           /™\ \_/ |\ | /™\        /////////////////////
/////////////////////////////////////////           \_   |  | \| |           /////////////////////
//  synchro midi de la pedale. //////////                     \  |  |  | |           /////////////////////
/////////////////////////////////////////           \_/  |  |  |  \_/        /////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////
                                                                                               
void sync(){                                                                                   
recstate = !digitalRead(recsw);                                                               
playstate = digitalRead(playsw);
eled = !digitalRead(recled);///
                                                                                               
if (eled == HIGH){
  rec = 1;
  playstart = 1;

//  etat du switch rec                                                                         
if (recstate == HIGH && Rstate == LOW && millis() - rectime > recdebounce) {                   
   swrec += 1;                                                                                 
   rectime =  millis();                                                                       
}                                                                                             
if (swrec == 2){                                                                               
  swrec = 0;                                                                                   
}                                                                                             
                                                                                               

                                                                                               
// etat du switch play                                                                         

  if (playstate == LOW && Pstate == HIGH && millis() - playtime > playdebouncecourt) {             
     play += 1;     ///
     swplay += 1;                                                                             
     playtime =  millis();                                                                     
  }
  if (swplay == 2){                                                                           
    swplay = 0;                                                                               
  }
  if (playstart == 0){
    play = 0;
  }

 
 
                                                                                               
switch (rec){
  case 0:
    if (play == 1){
      rec = 2;
    }
    counter = 0;
    i = 0;
    break;
  case 1:
    if (play == 0){
    counter += 1;
    counter2 = counter;
    }
    if (play > 0){
        rec = 2;
        play = 1;
    }
    break;

  case 2:

    if (play == 2){
      rec = 0;
      play = 0;
    }
    break;
}


  i += 1;
  if (i < counter2 - laps){
    digitalWrite(13, swplay);
  }
  if (i > counter2 - laps){
    if (eled == HIGH){
      digitalWrite(13, swplay);
    }
    if (eled == LOW){
      digitalWrite(13, !swplay);
    }
  }
  if (i > counter2){
  i = 0;
  }

   


 
                                                                                               

 
 
 
                                                                                               
digitalWrite(trplay, swplay);                                                                  ///                                                                                               ///                                                                                             
digitalWrite (trrec, swrec);
                                                                                               
                                                                                               
                                                                                               
}                                                                                             
//////////////////////////////////////////////////////////////////////////////////////////////////






//////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////        |\ | |™™|    /™\ \_/ |\ |  /™\      ///
/////////////////////////////////////////        | \| |   |    \_   |  | \| |          ///
// fonctionnement normal de la pedale. //                 |  | |   |      \  |  |  | |          ///
/////////////////////////////////////////        |  | |___|    \_/  |  |  |  \_/       ///
//////////////////////////////////////////////////////////////////////////////////////////
                                                                                       
void nosync(){                                                                       
playstate = digitalRead(playsw);                                                       
recstate = !digitalRead(recsw);                                                     
if (playstate == LOW && Pstate == HIGH && millis() - playtime > playdebouncecourt) {       
   swplay += 1;                                                                       
   playtime =  millis();                                                               
}                                                                                     
if (swplay == 2){                                                                     
  swplay = 0;                                                                         
}                                                                                     
if (recstate == HIGH && Rstate == LOW && millis() - rectime > recdebounce) {           
   swrec += 1;                                                                         
   rectime =  millis();                                                               
}                                                                                     
if (swrec == 2){                                                                       
  swrec = 0;                                                                           
}                                                                                     
                                                                                       
digitalWrite (trplay, swplay);                                                         
digitalWrite (trrec, swrec);                                                           
                                                                                       
}                                                                                     
//////////////////////////////////////////////////////////////////////////////////////////
 
void test(){
    Serial.print("play =");
    Serial.print(play,DEC);
    Serial.print("  ");
    Serial.print("rec =");
    Serial.print(rec,DEC);
    Serial.print(" ");
    Serial.print("swplay =");
    Serial.print(counter,DEC);
    Serial.print("---");
    Serial.print(counter2,DEC);
    Serial.print("-");
    Serial.println(i,DEC);
}
did
 
Messages: 14
Inscription: Mar 13 Sep 2011 19:42

Re: Midification de la pédale AKAI headrush

Message non lude did » Mer 26 Oct 2011 10:31

Bon voilà, c'est la fin des haricots...
j'ai un code qui devrait marcher :
Code: Tout sélectionner
int recsw = 3; //pin du switch rec (bouton momentane)
int swrec; // etat du transitor de commande du switch rec
int recstate; // etat du switch rec
int Rstate =  LOW;
int playsw = 2; //pin du switch play (bouton momentane)
int swplay; // etat du transistor de commande du switch play
int SWstate = HIGH;
int playstate; // etat du switch play
int Pstate = HIGH;
int trplay = 4; //transistor de commande play (2N3904 + 1kR)
int trrec = 5; // transistor de commande rec  (2N3904 + 1kR)
int midionoff; // etat du switch midi on off
int midisw = 6; //pin du switch midi on off

int recled = 7;
int eled;


int play; // mode play
int rec; // mode rec
int playstart = 0; // differents etats des modes de lecture et enregistrement
int playpause = 0; // etat initial de la pedale
int counter = 0; // compteur de clock pour la synchro
int counter2 = 0; // deuxième compteur pour sauvegarde du dernier compatge des clocks midi
int laps = 12  ; // temps de bascule pour le transistor en mode synchro
int i; // compatge pour commande des transistors en mode synchro
int j;
int inter;


long playtime = 0;         //
long playdebouncecourt = 200;   //  débounces des
long rectime = 0;          //  inters PLAY et REC
long recdebounce = 200;    //

//bits midi/////////////
byte midi_start = 0xfa;
byte midi_stop = 0xfc;
byte midi_clock = 0xf8;
byte midi_continue = 0xfb;
int play_flag = 0;
byte data;
/////////////////////////

void setup() {
  pinMode(playsw, INPUT);
  digitalWrite(playsw, HIGH);

  pinMode(recsw, INPUT);
  digitalWrite(recsw, HIGH);

  pinMode(midisw, INPUT);
  digitalWrite(midisw, HIGH);

  pinMode(recled, INPUT);
  digitalWrite(recled, HIGH);

  pinMode(trplay, OUTPUT);
  pinMode(trrec, OUTPUT);
  Serial.begin(31250); // vitesse du midi (31250)
}

void loop() {

  midionoff = digitalRead(midisw);

  if (midionoff == HIGH){
    if(Serial.available() > 0) {
      data = Serial.read();
      if(data == midi_start) {
        play_flag = 1;
      }
      else if(data == midi_continue) {
        play_flag = 1;
      }
      else if(data == midi_stop) {
        play_flag = 0;
      }
      else if((data == midi_clock) && (play_flag == 1)) {

      }
    }

    sync();


  }
  if (midionoff == LOW){
    nosync();


  }
}



//////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////           /™\ \_/ |\ | /™\        /////////////////////
/////////////////////////////////////////           \_   |  | \| |           /////////////////////
//  synchro midi de la pedale. //////////             \  |  |  | |           /////////////////////
/////////////////////////////////////////           \_/  |  |  | \_/        /////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////
///
void sync(){                                                                                 
  recstate = !digitalRead(recsw);                                                               
  playstate = digitalRead(playsw);
  eled = !digitalRead(recled);///
 
  if (eled == HIGH){
    rec = 1;
    playstart = 1;
  }
  //  etat du switch rec                                                                       
  if (recstate == HIGH && Rstate == LOW && millis() - rectime > recdebounce) {                 
    swrec += 1;                                                                               
    rectime =  millis();                                                                       
  }                                                                                             
  if (swrec == 2){                                                                             
    swrec = 0;                                                                                 
  }                                                                                             
 

 
  // etat du switch play                                                                       

  if (playstate == LOW && Pstate == HIGH && millis() - playtime > playdebouncecourt) {             
    play += 1;   
    swplay += 1;                                                                             
    playtime =  millis();                                                                   
  }
  if (swplay == 2){                                                                           
    swplay = 0;                                                                               
  }
  if (playstart == 0){
    play = 0;
  }



 
  switch (rec){
  case 0:
    if (play == 1){
      rec = 2;
    }
    counter = 0;
    i = 0;
    break;
  case 1:
    if (play == 0){
      counter += 1;
      counter2 = int(counter/96*96);
    }
    if (play > 0){
      rec = 2;
      play = 1;
    }
    break;

  case 2:
    if (play == 2){
      rec = 0;
      play = 0;
    }
    break;
  }


  i += 1;

  if (i < counter2 - laps){
      digitalWrite(13, swplay);
  }
  if (i > counter2 - laps){
    if (eled == HIGH){ 
        digitalWrite(13, swplay);
    }
    if (eled == LOW){
        digitalWrite(13 , !swplay);
    }
  }
  if (i > counter2){
    i = 0;
  }






 
 



 
 

  digitalWrite (trplay, swplay);
  digitalWrite (trrec, swrec);
 
 
 
}                                                                                             
//////////////////////////////////////////////////////////////////////////////////////////////////






//////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////        |\ | |™™™|    /™\ \_/ |\ |  /™\      ///
/////////////////////////////////////////        | \| |   |    \_   |  | \| |          ///
// fonctionnement normal de la pedale. //        |  | |   |      \  |  |  | |          ///
/////////////////////////////////////////        |  | |___|    \_/  |  |  |  \_/       ///
//////////////////////////////////////////////////////////////////////////////////////////

void nosync(){                                                                         
  playstate = digitalRead(playsw);                                                       
  recstate = !digitalRead(recsw);                                                       
  if (playstate == LOW && Pstate == HIGH && millis() - playtime > playdebouncecourt) { 
    swplay += 1;                                                                       
    playtime =  millis();                                                               
  }                                                                                     
  if (swplay == 2){                                                                     
    swplay = 0;                                                                         
  }                                                                                     
  if (recstate == HIGH && Rstate == LOW && millis() - rectime > recdebounce) {           
    swrec += 1;                                                                         
    rectime =  millis();                                                               
  }                                                                                     
  if (swrec == 2){                                                                       
    swrec = 0;                                                                           
  }                                                                                     
 
  digitalWrite (trplay, swplay);                                                         
  digitalWrite (trrec, swrec);                                                           
 
}                                                                                     
//////////////////////////////////////////////////////////////////////////////////////////



j'arrive à faire clignoter la led 13 sans problèmes grâce à ce bout :
Code: Tout sélectionner
  switch (rec){
  case 0:
    if (play == 1){
      rec = 2;
    }
    counter = 0;
    i = 0;
    break;
  case 1:
    if (play == 0){
      counter += 1;
      counter2 = int(counter/96*96);
    }
    if (play > 0){
      rec = 2;
      play = 1;
    }
    break;

  case 2:
    if (play == 2){
      rec = 0;
      play = 0;
    }
    break;
  }


  i += 1;

  if (i < counter2 - laps){
      digitalWrite(13, swplay);
  }
  if (i > counter2 - laps){
    if (eled == HIGH){ 
        digitalWrite(13, swplay);
    }
    if (eled == LOW){
        digitalWrite(13 , !swplay);
    }
  }
  if (i > counter2){
    i = 0;
  }


mais si je remplace 13 par "trplay" (pin du transistor à commander) après avoir enlevé le digitalWrite(trplay,swplay) tout en bas, ben ça marche pô.
:cry:
did
 
Messages: 14
Inscription: Mar 13 Sep 2011 19:42

Re: Midification de la pédale AKAI headrush

Message non lude Lionel » Ven 28 Oct 2011 16:46

Bon, j'ai essayé sur une breadboard et j'ai arrêté parce que j'avais pas de signal midi :)
Tu veux pas passer un mercredi soir à Myrys avec tout ton matos ??
Image - Distributeur officiel Arduino - Conception de shields
Avatar de l’utilisateur
Lionel
 
Messages: 734
Inscription: Mar 21 Déc 2010 09:52
Localisation: Toulouse

Re: Midification de la pédale AKAI headrush

Message non lude Lionel » Mer 9 Nov 2011 10:15

Salut !

J'ai vu passer un lien sur HaD avec un arduino qui cause en midi
http://www.charlesgershom.com/2011/11/l ... synth.html

"It features a basic wavetable synth engine, midi in (Program change, note on, note off), binary 4bit display (for the program indicator), 4 pots (not yet with functions) and a mess of wires since I dislike tidy things when making my work."


Peut être que l'étude du code pourrait être utile à ton projet ??
Image - Distributeur officiel Arduino - Conception de shields
Avatar de l’utilisateur
Lionel
 
Messages: 734
Inscription: Mar 21 Déc 2010 09:52
Localisation: Toulouse

Re: Midification de la pédale AKAI headrush

Message non lude did » Mer 9 Nov 2011 11:31

je viens de regarder, et dans ce que j'ai compris il n'y a que des notes et pas les "play/stop/clock" dont j'aimerais me servir.
did
 
Messages: 14
Inscription: Mar 13 Sep 2011 19:42


Retourner vers Vos projets, vos idées

Qui est en ligne

Utilisateurs parcourant ce forum: Aucun utilisateur enregistré et 2 invités