next topic »

[on:]

Bonsoir,

Voilà, je bloque depuis quelques heures sur un gros problème... J'ai programmé un bouton poussoir pour qu'il fasse une fonction switch.
Mon projet étant un séquenceur midi (5 séquences différentes et indépendantes à activer ou désactiver, contenant chacune 16 notes qui seront activées ou désactivées aussi. Au total, 5 switches pour lancer les séquences, et 16 switches pour gérer les 16 notes d'une des cinq séquences. Il faudra compter aussi un bouton start/stop.)
Pour ça, je ne vois pas d'autre solution que lire l'état de l'entrée du bouton poussoir à tous moments du programme. Mais comment faire ? J'avais cru comprendre avec la fonction millis mais ce n'est pas ça.

Voilà mon programme : (l'entrée qui doit être lue étant "BP1reading", "state" est la variable on/off)
Code du switch venant de là : http://www.arduino.cc/en/Tutorial/Switch

Code:

void loop ()

{

  BP1reading = digitalRead (BP1); // Lecture BP marche

  
  
  // switch and debounce
   if (BP1reading == HIGH && BP1previous == LOW && millis() - time > debounce) {
    if (state == HIGH)
      state = LOW;
    else
      state = HIGH;

    time = millis();    
  }
  
  // Séquence
  
     while (state == LOW) {

// step 1
sensorValue = analogRead(sensorPin);
  digitalWrite (L2, LOW);
  digitalWrite (L5, HIGH);
  MIDImessage(noteON, 50, 115);
  delay(sensorValue);
  
//step 2
sensorValue = analogRead(sensorPin);
  digitalWrite (L2, HIGH);
  digitalWrite (L3, LOW);
  MIDImessage(noteON, 52, 115);
  delay(sensorValue);
  
//step 3
sensorValue = analogRead(sensorPin);
  digitalWrite (L3, HIGH);
  digitalWrite (L4, LOW);
  MIDImessage(noteON, 54, 115);
  delay(sensorValue);
  
//step 4
  sensorValue = analogRead(sensorPin);
  digitalWrite (L4, HIGH);
  digitalWrite (L5, LOW);
  MIDImessage(noteON, 56, 115);
  delay(sensorValue);  
}
BP1previous = BP1reading;
}
 
 void MIDImessage(int command, int MIDInote, int MIDIvelocity) {
  Serial.write(command);//send note on or note off command
  Serial.write(MIDInote);//send pitch data
  Serial.write(MIDIvelocity);//send velocity data
}

Quelqu'un pour me sauver ?  

[Reply #1 on:]

Utilise une interruption :

http://arduino.cc/en/Reference/AttachInterrupt

[Reply #2 on:]

Merci
Je ne connaissais pas cette fonction, mais d'après ce que je viens de lire, il n'y a qu'un nombre spécifique d'entrées pour ça. Or dans le cadre de mon projet, j'aurai besoin de 5 BP différents pour interrompre 5 séquences individuellement.

[Reply #3 on:]

Tu fais que chaque BP actionne l'interruption sur la même pin et en même temps change l'état d'une autre pin.... et hop  

[Reply #4 on:]

sinon si tu ne veux pas utiliser d'interruptions, tu utilise une machine à état et un sketch qui boucle en permanence, avec une lecture des boutons au début de la boucle.

[Reply #5 on:]

Bonjour,

Un truc bien sympa dans ce genre de cas, les interruptions de port
http://www.arduino.cc/playground/Main/PcInt

Et comme j'avais du temps à perdre je joint le .h prés à être utilisé
(oui c'est un bête copier coller )
(pour l'utiliser il suffit de le mettre dans le même dossier que le sketch)

Code d'exemple :

Code:

#include <Arduino.h>
#include "AnyPinInterrupt.h"

volatile long ticktocks = 0;
long i = 0;

void tick(void) {
   ticktocks++;
}

void tock(void) {
   ticktocks--;
}

void setup()
{
   Serial.begin(9600);
   pinMode(4, INPUT);
   pinMode(5, INPUT);
   delay(3000);
   PCattachInterrupt(4, tick, CHANGE);
   PCattachInterrupt(5, tock, CHANGE);
}

void loop() {
   i++;
   delay(1000);
   Serial.print(i, DEC);
   Serial.print(" ");
   Serial.println(ticktocks);
   if (i > 256) {
     PCdetachInterrupt(4);
     PCdetachInterrupt(5);
   }
}

[Reply #6 on:]

@ Jean-Francois: J'ai pas trop compris ce que tu veux dire...
@ Bricofoy: C'est de ça dont tu parles ? http://www.mathertel.de/Arduino/FiniteStateMachine.aspx
J'ai l'impression que ça devient un peu compliqué, non ? 

@ skywood: En fait en ayant poussé la réflexion un peu plus loin, comme c'est un séquenceur et que les 16 notes seront activées et désactivées avec un switch pour chaque... Ca me fera beaucoup de boutons d'interruption !
Ta solution est peut être la bonne, seulement va falloir que je comprenne un peu plus...

Si j'ai bien compris, la bibliothèque AnyPinInterrupt permet de transformer n'importe quelle pin en une entrée "interrupt" ? Et c'est quoi cette bibliothèque pins_arduino.h ? Je n'ai pas trop compris le code d'exemple non plus... Si tu pouvais m'expliquer comment faire quoi, parce-que je me perds un peu avec tous ces morceaux de code par-ci par là  J'ai compris qu'il fallait inclure la bibliothèque mais le reste...

Merci à vous

Sinon j'ai pensé à autre-chose aujourd'hui, c'est d'utiliser une deuxième carte Arduino qui fera exclusivement des lectures d'entrée en boucle, et qui les communiquera à la carte du programme. Ca peut bien marcher et permettre d'alléger le code, non ?

[Reply #7 on:]

@ Bricofoy: C'est de ça dont tu parles ? http://www.mathertel.de/Arduino/FiniteStateMachine.aspx
J'ai l'impression que ça devient un peu compliqué, non ? 

oui, c'est bien ça. Mais la complexité dépend de ce que tu va faire dans ton programme, il n'y a pas forcément une multitude d'état avec des conditions multiples pour passer de l'un à l'autre.

Sinon j'ai pensé à autre-chose aujourd'hui, c'est d'utiliser une deuxième carte Arduino qui fera exclusivement des lectures d'entrée en boucle, et qui les communiquera à la carte du programme. Ca peut bien marcher et permettre d'alléger le code, non ?

oui, mais à ce moment là, il te faudra encore utiliser soit un principe de machine à états soit des interruptions pour pouvoir lire ce que ton arduino qui s'occupe des boutons aura à raconter au second... je ne suis pas certain que ça simplifie, au final

[Reply #8 on:]

Pour ce genre de cas, j'utilise les PCINT, c'est très pratique. Il suffit de déclarer dans les registres les pins concernées, et à chaque fois que l'une de ces pins va changer d'état, une interruption sera déclenchée. Tu crées la routine d'interruption concernée (ISR(PCINT_vect){...}) dans laquelle tu viens lire toutes tes entrées, et tu regardes celles qui ont changé. Je fais ça pour les claviers matriciels, on n'a pas besoin de scanner les touches, puisque ça se fait par interruption.

On rentre un peu dans le hard, mais je t'assure que ça vaut le coup.

[Reply #9 on:]

ouais, je ne connaissait pas ce truc, mais je crois que moi aussi je vais m'y mettre, ça simplifiera mes machines à état

[Reply #10 on:]

http://arduino.cc/forum/index.php/topic,100906.0.html

[Reply #11 on:]

@ Bricofoy: C'est de ça dont tu parles ? http://www.mathertel.de/Arduino/FiniteStateMachine.aspx
J'ai l'impression que ça devient un peu compliqué, non ?  

oui, c'est bien ça. Mais la complexité dépend de ce que tu va faire dans ton programme, il n'y a pas forcément une multitude d'état avec des conditions multiples pour passer de l'un à l'autre.

Sinon j'ai pensé à autre-chose aujourd'hui, c'est d'utiliser une deuxième carte Arduino qui fera exclusivement des lectures d'entrée en boucle, et qui les communiquera à la carte du programme. Ca peut bien marcher et permettre d'alléger le code, non ?

oui, mais à ce moment là, il te faudra encore utiliser soit un principe de machine à états soit des interruptions pour pouvoir lire ce que ton arduino qui s'occupe des boutons aura à raconter au second... je ne suis pas certain que ça simplifie, au final

Donc il est impossible que la 1ère carte puisse quand elle en a besoin aller chercher l'état d'une variable qui est lue et stockée par la 2ème carte ?

Ca me fait peur ce truc d'interruptions, de pointeurs.. Ca m'a l'air très barbare Mais bon, j'ai bien peur que va falloir y passer alors, je vais tenter de lire le tuto !

Super_Cinci, tu parles de la même chose que les autres en fait ?

[Reply #12 on:]

Si j'ai bien compris, la bibliothèque AnyPinInterrupt permet de transformer n'importe quelle pin en une entrée "interrupt" ?

Oui c'est ça, en gros c'est comme si tu avait une "vrai" interruption attachInterrupt() mais sur n'importe quelles broches de ton choix.

Et c'est quoi cette bibliothèque pins_arduino.h ?

C'est pas une librairie
C'est un fichier de base du "core" arduino qui contient les correspondances n° de pin <-> registre / bitmask bas niveau.

Je n'ai pas trop compris le code d'exemple non plus... Si tu pouvais m'expliquer comment faire quoi, parce-que je me perds un peu avec tous ces morceaux de code par-ci par là  J'ai compris qu'il fallait inclure la bibliothèque mais le reste...

C'est exactement pareil qu'avec attachInterrupt(), tu rajoute juste "PC" devant le nom de la fonction
Et au lieu d'avoir un numéro d'interruption en 1er argument tu donne directement le numéro de la broche.

Sinon j'ai pensé à autre-chose aujourd'hui, c'est d'utiliser une deuxième carte Arduino qui fera exclusivement des lectures d'entrée en boucle, et qui les communiquera à la carte du programme. Ca peut bien marcher et permettre d'alléger le code, non ?

Ça n'aurait aucun intérêt, tu devras quand même gérer la réception des données sur l'autre arduino.
En gros tu déporte le problème sans le résoudre

[Reply #13 on:]

Ok, bref c'est compliqué tout ça  Je vais voir ta solution en détails alors, merci pour les précisions ;-)

[Reply #14 on:]

Super_Cinci, tu parles de la même chose que les autres en fait ?

Oui, mais au lieu de passer par le core arduino qui ralentit énormément les choses, je passe en direct sur les registres, on y gagne un temps énorme...