Oui mais entre deux il y a tous les write qui servent à choisir le registre ensuite les requestFrom les boucles et les read pour 6 registres.. je passe d'une ligne à 30. m'enfin ça encore je m'en fous ce n'est qu'un problème de présentation, tant que ça marche je prend moi ^^ mais actuellement ça déconne dans le vent pour rien et ça commence à me les geler... mon code marchait auparavant

Actuellement j'ai une trentaine d'onglets et 3 googledoc d'ouvert, ton Mp est quelque pars dans ce bordel 

Ma Moman m'a toujours dit de faire une chose après l'autre  :

À la fin oui normalement (pas tout à fait si tu as vu mon mp)
D'après la description de lib c'est une amélioration de la lib de base en terme de performance et de logique.
Mais pour moi c'est surtout la simplicité d'utilisation en une ligne avec un simple read je récupère 6 registres différent de mon gyroscope avec ou sans bit de stop. alors qu'avec la lib de base... c'est toute une épopée et c'est moins clair à la relecture du code, ça prend énormément plus de place... bref j'aime moins la lib de base, mais je vais être obligé de l'utiliser vu les problèmes causés par l'autre 

Tu as raison le problème provient bien de la librairie I2C que j'utilise... plus précisément le problème vient de la méthode "read()"

Je vais donc être obligé de repartir sur la lib de base 

Merci de ton aide !

J'ai donc passé Ccleaner et installé le 1.0.4
et toujours cette belle erreur :

Code:

d:/programmes/arduino-1.0.4/hardware/tools/avr/bin/../lib/gcc/avr/4.3.2/../../../../avr/lib/avr6/crtm2560.o: In function `__vector_default':
(.vectors+0x1c): relocation truncated to fit: R_AVR_13_PCREL against symbol `__vector_7' defined in .text.__vector_7 section in core.a(WInterrupts.c.o)

Merci d'avoir répondu !

La crius All In One Pro, elle utilise un ATMEGA 2560
J'utilise Arduino pour windows 1.0.2 sur windows 7 64bits à jour.

Dans ton lien je vois que pour lui c'était dû à trop de variable globale, j'ai souvent vu ça sur google. Je n'ai qu'un tableau de 5 cases... Si jamais c'est ça le problème je vois mal comment terminer mon projet... Ce qui est étonnant c'est que ça soit depuis que j'ai déplacé mes prototypes...

Personne n'a eu ce problème et à trouvé la solution ?

Bonne journée,

Bonjour à tous,

Je viens vous demander un peu d'aide concernant cette erreur de compil :

Code:

d:/programmes/arduino-1.0.2/hardware/tools/avr/bin/../lib/gcc/avr/4.3.2/../../../../avr/lib/avr6/crtm2560.o: In function `__vector_default':
(.vectors+0x1c): relocation truncated to fit: R_AVR_13_PCREL against symbol `__vector_7' defined in .text.__vector_7 section in core.a(WInterrupts.c.o)

Il y a à peine 20 minutes j'étais tout content d'avoir réussi à faire marcher mon programme quand tout à coup j'ai eu ce message quand j'ai réordonné mon code pour qu'il soit à peu près lisible après mes multiples tests ^^ Et puis juste à bouger les lignes de place (les prototypes de fonctions principalement) j'ai eu cette erreur. Google n'a pas été capable de me dire ce que j'ai fait de mal... Et le moteur de recherche d'Arduino non plus.

Quelqu'un saurait me dire sur quel bouton j'aurais pas du appuyer ?  

Ne sachant pas quoi vous donner comme code au vue de l'erreur j'ai tout mis dans un ptit rar en pièce jointe.

Merci d'avance,

Je viens de faire un test :

Code:

void setup()
{
  Serial.begin(115200);
 
  DDRK = 0;
  PORTK = 255;
 
    DDRB = DDRB | 0x80;  // led rouge
    PORTB = PORTB | 0x80;
    //DDRC = DDRC | 0x40;  //led jaune
    //PORTC = PORTC | 0x40;
    DDRC = DDRC | 0x80;  //led verte
    PORTC = PORTC | 0x80;
}

void loop()
{ Serial.println(PORTK&1);
  /*
    if (PORTK & 1)
    {
        PORTC &= 0x7F;
        delay(200);
    }
    else
    {
        PORTC |= 0x80;
        delay(200);
    }*/
}

Au départ je n'avais pas la connexion série. La led rouge était bien allumée, mais la verte toujours éteinte. J'ai tout bazardé en commentaire et mis le Serial. Résultat ma console est pleine à craquer de "1" . J'en ai donc conclu que le microcontroleur ne détectait jamais un niveau bas. Ce qui n'est pas normal, j'ai regardé le signal d'entré à l'oscilloscope pour vérifier, j'ai bien un niveau haut pendant 1.5ms et un niveau bas pendant 18.5ms. Je ne comprend plus rien, Quelqu'un saurait ce que j'ai fait de mal pour que ça fasse ça ?

Merci d'avance,

J'ai mis le programme en pièces jointes =)
Mais pour plus de simplicité je poste la page correspondante.

Il y a eu du changement depuis mon premier post. Cette fonction qui pose problème me sert à attendre la fin d'un cycle de réception en provenance de mon recepteur RC. Cet à dire que j'attend que toutes les impulsions soient passées pour activer les interruptions, qui elles, se chargeront de récupérer en continue tous les cycles et de les mettre de côté en mémoire pour la suite du programme.

J'ai lu je ne sais plus où que la fin d'une trame sur le récepteur devait obligatoirement se terminer par un niveau bas sur toutes les sorties pendant 8ms.
De ce fait, mon ancien programme attendait que toutes les sorties soient à 0 et que au moins 5ms se soient écoulées.
C'est là dessus que je lutte depuis près d'un moins maintenant

Après un peu de cogite et de problème, j'ai trouvé une version nettement plus pertinente et performante de repérer cette fin de cycle: il suffit d'attendre que l'impulsion soie passée sur la dernière sortie du récepteur (toutes les impulsions arrivent une à la fois et l'une après l'autre)

Du coup je n'ai plus le problème liée aux interruptions (mais j'aimerais quand même comprendre pourquoi ça ne fonctionne pas) et je suis encore et toujours bloqué sur un nouveau problème (on s'en serait presque douté)
Le nouveau problème est : le programme rentre dans la première boucle et en ressors bien comme prévu, ça rentre dans la deuxième boucle MAIS on en ressors jamais.
J'ai essayé toutes les écritures possible et imaginable et rien n'y fait. Je tiens à préciser que le signal d'entré passe bien par 0 périodiquement (50Hz).

Petit résumé : Pourquoi mon ancien programme marche pas ? ^^ et pourquoi le nouveau reste bloqué dans sa boucle ?

Merci pour vos réponses et merci d'avance pour les prochaines !

Code:

// label de simplification d'écriture
#define RX_PIN0 PORTK&ROLL_PIN
#define RX_PIN1 PORTK&PITCH_PIN
#define RX_PIN2 PORTK&THROTTLE_PIN
#define RX_PIN3 PORTK&YAW_PIN
#define RX_PIN4 PORTK&AUX1_PIN
#define RX_PIN5 PORTK&AUX2_PIN
#define RX_PIN6 PORTK&AUX3_PIN
#define RX_PIN7 PORTK&AUX4_PIN

/* Déclaration des variables */
uint8_t throttle;
uint8_t yaw;
uint8_t pitch;
uint8_t roll;
uint8_t aux1;
uint8_t aux2;
uint8_t aux3;
uint8_t aux4;
boolean motorLock;

/* Déclaration des fonctions */
boolean MotorLock(void);
boolean isRTF(void);

/********************************************/
/*         Définition des fonctions         */
/********************************************/

void radiocommandInitialisation(void)
{
    Q_INIT_RX;
   
    noInterrupts(); // pas d'interruption afin de ne pas perturber l'init
   
    while(!(PORTK & 1)); // on attend un passage à 1 de la derniere pulse
   
    while(PORTK & 1)
    {
      if (PORTK & 1)
          digitalWrite(Q_LED_RED, HIGH);
      else
          digitalWrite(Q_LED_YELLOW, HIGH);
    };    // on attend une retombé à 0 de la derniere pulse
   
    interrupts(); // rétablissement des interruptions
   
    Q_INIT_RX_INT;
}

/********************************************/
/* Définition de la fonction d'interruption */
/********************************************/

ISR(PCINT2_vect)
{
    volatile static unsigned long previousTime;
    volatile static uint8_t currentInterruption = 0;
    volatile uint16_t largeurImpulsion = 0;

    switch(currentInterruption)
    {
// ROLL
case 0: previousTime = micros(); currentInterruption++; break;
case 1: largeurImpulsion = micros() - previousTime; //temps d'une pulse
                // protection dépassements de temps d'impulsion
        largeurImpulsion = (largeurImpulsion < 1000) ? 1000 : largeurImpulsion;
        largeurImpulsion = (largeurImpulsion > 2000) ? 2000 : largeurImpulsion;
        // conversion microseconde / byte
roll = ((255.0/1000.0)*(largeurImpulsion) - 255);
currentInterruption++;
break;

// PITCH
case 2: previousTime = micros(); currentInterruption++; break;
case 3: largeurImpulsion = micros() - previousTime; //temps d'une pulse
// protection dépassements de temps d'impulsion
largeurImpulsion = (largeurImpulsion < 1000) ? 1000 : largeurImpulsion;
largeurImpulsion = (largeurImpulsion > 2000) ? 2000 : largeurImpulsion;
// conversion microseconde / byte
pitch = ((255.0/1000.0)*(largeurImpulsion) - 255);
currentInterruption++;
break;

// THROTTLE
case 4: previousTime = micros(); currentInterruption++; break;
case 5: largeurImpulsion = micros() - previousTime; //temps d'une pulse
// protection dépassements de temps d'impulsion
largeurImpulsion = (largeurImpulsion < 1000) ? 1000 : largeurImpulsion;
largeurImpulsion = (largeurImpulsion > 2000) ? 2000 : largeurImpulsion;
// conversion microseconde / byte
throttle = ((255.0/1000.0)*(largeurImpulsion) - 255);
currentInterruption++;
break;

// YAW
case 6: previousTime = micros(); currentInterruption++; break;
case 7: largeurImpulsion = micros() - previousTime; //temps d'une pulse
// protection dépassements de temps d'impulsion
largeurImpulsion = (largeurImpulsion < 1000) ? 1000 : largeurImpulsion;
largeurImpulsion = (largeurImpulsion > 2000) ? 2000 : largeurImpulsion;
// conversion microseconde / byte
yaw = ((255.0/1000.0)*(largeurImpulsion) - 255);
currentInterruption++;
break;

//AUX1
case 8: previousTime = micros(); currentInterruption++; break;
case 9: largeurImpulsion = micros() - previousTime; //temps d'une pulse
// protection dépassements de temps d'impulsion
largeurImpulsion = (largeurImpulsion < 1000) ? 1000 : largeurImpulsion;
largeurImpulsion = (largeurImpulsion > 2000) ? 2000 : largeurImpulsion;
// conversion microseconde / byte
        aux1 = ((255.0/1000.0)*(largeurImpulsion) - 255);
currentInterruption++;
break;

//AUX2
case 10: previousTime = micros(); currentInterruption++; break;
case 11: largeurImpulsion = micros() - previousTime; //temps d'une pulse
// protection dépassements de temps d'impulsion
largeurImpulsion = (largeurImpulsion < 1000) ? 1000 : largeurImpulsion;
largeurImpulsion = (largeurImpulsion > 2000) ? 2000 : largeurImpulsion;
// conversion microseconde / byte
aux2 = ((255.0/1000.0)*(largeurImpulsion) - 255);
currentInterruption++;
break;

//AUX3
case 12: previousTime = micros(); currentInterruption++; break;
case 13: largeurImpulsion = micros() - previousTime; //temps d'une pulse
// protection dépassements de temps d'impulsion
largeurImpulsion = (largeurImpulsion < 1000) ? 1000 : largeurImpulsion;
largeurImpulsion = (largeurImpulsion > 2000) ? 2000 : largeurImpulsion;
// conversion microseconde / byte
aux3 = ((255.0/1000.0)*(largeurImpulsion) - 255);
currentInterruption++;
break;

//AUX4
case 14: previousTime = micros(); currentInterruption++; break;
case 15: largeurImpulsion = micros() - previousTime; //temps d'une pulse
// protection dépassements de temps d'impulsion
largeurImpulsion = (largeurImpulsion < 1000) ? 1000 : largeurImpulsion;
largeurImpulsion = (largeurImpulsion > 2000) ? 2000 : largeurImpulsion;
// conversion microseconde / byte
aux4 = ((255.0/1000.0)*(largeurImpulsion) - 255);
currentInterruption = 0;
break;
}
}

et la page principale :

Code:

#include <I2C.h>
#include <Servo.h>
#include "config.h"
#include "def.h"

// Déclaration des fonctions d'initialisation
void motorInitialisation(void);
void gyroscopeInitialisation(void);
void radiocommandInitialisation(void);


void setup()
{
  Serial.begin(9600);
  I2c.begin();
  I2c.setSpeed(1);
 
  pinMode(Q_LED_GREEN, OUTPUT);
  pinMode(Q_LED_YELLOW, OUTPUT);
  pinMode(Q_LED_RED, OUTPUT);
 
  motorInitialisation();
  gyroscopeInitialisation();
  radiocommandInitialisation();
}

void loop()
{
  // Petit Check batterie
  //if (Quadri.etatBatterie() == Q_BAT_HS)
   // Quadri.LED_etatBatterie(Q_BLINK);
 
  // Condition de mise route
 // if (Quadri.areMotorsRotating() == false) // si tous les moteurs sont arrêtés
   // while (Radio.isRTF() == Q_NOT_READY_TO_FLY);// et que l'inter est actif : on attend
 
  /***************************/
  /* PHASE DE CONTROL DE VOL */
  /***************************/
  //Quadri.setConsignesDeVol(/*quelque chose*/);
  //Quadri.CorrectionsDeVol(/* éventuellement quelques chose *unknown 4 the moment* */);
 
  /*delay(200);
  digitalWrite(Q_LED_RED, HIGH);
  delay(200);
  digitalWrite(Q_LED_RED, LOW);*/
}

Je crois qu'on s'est mal compris ^^ La fonction ici présente n'est pas une routine interruption, c'est juste une fonction qui a besoin que les interruptions soient désactivées pour remplir sa tâche.

Bonsoir,

Je suis d'accord, mais ça n'explique pas pourquoi en désactivant les interruptions ça ne fonctionne plus =/

Bonjour à tous !

Suite à mon problème sur ce topic, j'ai commandé un lcd pas encore reçu à ce jour, donc j'ai trouvé un autre moyen afin de "grossièrement" debugger le plus vite possible (oui j'ai malheureusement une date limite pour ce projet).

Bienvenue à tous sur ce nouveau topic tout propre ! ^^

Premièrement j'ai repassé le programme en C au lieu du C++. Et j'utilise une led intégrée à ma carte pour voir où plante le programme.
La fonction problème :

Code:

void radiocommandInitialisation(void)
{
    unsigned long pTime;
    boolean initialisationOn = true;
    noInterrupts(); // pas d'interruption afin de ne pas perturber l'init
    
    while(initialisationOn)
    {
   if (!(RX_PIN0 || RX_PIN1 || RX_PIN2 || RX_PIN3 || RX_PIN4 || RX_PIN5 || RX_PIN6 || RX_PIN7))
        {
            pTime = micros();
   while ((!(RX_PIN0 || RX_PIN1 || RX_PIN2 || RX_PIN3 || RX_PIN4 || RX_PIN5 || RX_PIN6 || RX_PIN7)))
   {
                digitalWrite(Q_LED_RED, HIGH);
if ((micros() - pTime) >= 5000)
{digitalWrite(Q_LED_YELLOW, HIGH);
   initialisationOn = false;
   break;
}
                
   }
        }
    }
    interrupts();
    digitalWrite(Q_LED_RED, HIGH);
    Q_INIT_RX;
    Q_INIT_RX_INT;
}

Cette ligne :

Code:

digitalWrite(Q_LED_RED, HIGH);

indique l'endroit ou le programme reste bloqué quand les interruptions sont inhibées.

Code:

digitalWrite(Q_LED_YELLOW, HIGH);

Et celle là indique que le programme s'exécute complètement quand les interruptions sont actives.

Est-ce que quelqu'un peut me dire ce que j'ai fait de mal ? Je ne comprend pas  

Merci d'avance,

Je met le projet Arduino en pièces jointes, le code est trop long pour être incorporé directement ici.

Après je vois pas qu'est-ce qui lève l'interruption dans le code ? Materielle (soft) ou soft (timer) ?

L'interruption est levée sur une pin change sur le portK entier de mon 2560.

Et en chine LCD 16*4 + module i2c j'en ai eu pour 5€ xD

Ca va se terminer comme ça je pense si j'arrive pas à trouver d'où vient le problème...
Au fait, le I²C fonctionne aussi grâce aux interruptions ? On ne retombe pas sur le même souci ?

Sinon le code n'a choqué personne ? pas de grosse bourdes bien visible ? aucune idée quant au problème que je rencontre ? ^^

Ok merci, je vais essayer ça !

Je ne possède pas d'écran LCD... Je ne peux pas faire autrement ?