Problème dans mon code et debug Serial impossible

Bonjour,

Depuis un moment je butte sur un problème: j'ai un bug dans mon code (jusque là tout paraît normal ^^ ) je debug donc comme d'habitude par le Serial histoire de voir ce qui ne va pas et surprise...
Enfin si on peut appeler ça comme tel. J'ai mis tout un panel de Serial.println(), et au final je n'ai que deux lettres qui apparaissent dans le moniteur série, alors que mes println comportent plus de 2 caractères. Quelque soit l'endroit ou il y a le premier println je n'ai que le deux premiers caractères.
Après quelques essaies j'ai pu déterminer que le problème se posait que quand j'appelle le fonction Radio.Initialisation()

Est-ce que quelqu'un a déjà eu ce problème ou saurait m'aider ?

Je poste les pages qui posent problème

#include <I2C.h>
#include <Servo.h>
#include "configuration.h"
#include "def.h"
#include <RADIOCOMMAND.h>
#include <QUADRICOPTER.h>

RADIOCOMMAND Radio;
//QUADRICOPTER Quadri(MOT_A_PIN, MOT_B_PIN, MOT_C_PIN, MOT_D_PIN, PULSE_MOTOR_WIDTH_MIN, PULSE_MOTOR_WIDTH_MAX, BATT_PIN, LED_BATT_PIN);

void setup()
{
  Serial.begin(9600);
  I2c.begin();
  I2c.setSpeed(1);
  Serial.println("nono");
  pinMode(Q_LED_GREEN, OUTPUT);
  pinMode(Q_LED_YELLOW, OUTPUT);
  pinMode(Q_LED_RED, OUTPUT);
  pinMode(MOT_A_PIN, OUTPUT);
  pinMode(MOT_B_PIN, OUTPUT);
  pinMode(MOT_C_PIN, OUTPUT);
  pinMode(MOT_D_PIN, OUTPUT);
  
  //Quadri.GyroInit();
  Serial.println("ppp");
  Radio.Initialisation();
}

void loop()
{
  int val = 2;

  //val = digitalRead(THROTTLE_PIN);
  Serial.println(val);
  /*Serial.print("\t");
  Serial.print(Radio.Pitch());
  Serial.print("\t");
  Serial.print(Radio.Roll());
  Serial.print("\t");
  Serial.println(Radio.Yaw());*/
  
  delay(10);
  
}

RADIOCOMMAND.h

#ifndef RADIO_H
#define RADIO_H

#include <Arduino.h>

//** définitions indispensables à la bibliothèque RADIOCOMMAND **//
// cablage du recepteur
// PORT K utilisé
#define RX_PORT PORTK
#define RX_PIN PINK
#define ROLL_PIN 0x01 // pin 0
#define PITCH_PIN 0x02 // pin 1
#define THROTTLE_PIN 0x04 // pin 2
#define YAW_PIN 0x08 // pin 3
#define AUX1_PIN 0x10 // pin 4
#define AUX2_PIN 0x20 // pin 5
#define AUX3_PIN 0x40 // pin 6
#define AUX4_PIN 0x80 // pin 7
#define Q_INIT_RX DDRK=0;PORTK=255
#define Q_INIT_RX_INT PCMSK2=255

#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

class RADIOCOMMAND
{
	public:
		RADIOCOMMAND(void);

		void Initialisation(void);

		uint8_t Throttle(void);
		uint8_t Roll(void);
		uint8_t Pitch(void);
		uint8_t Yaw(void);
		uint8_t Aux1(void);
		uint8_t Aux2(void);
		uint8_t Aux3(void);
		uint8_t Aux4(void);
		boolean MotorLock(void);

		boolean isRTF(void);

		//friend void __vector_11(RADIOCOMMAND *);

	private:
		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;
};

#endif

RADIOCOMMAND.cpp

// radiocommand.cpp

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

RADIOCOMMAND::RADIOCOMMAND(void)
{
	throttle = 0;
	yaw = 0;
	pitch = 0;
	roll = 0;
	motorLock = true;
}

void RADIOCOMMAND::Initialisation(void)
{
	unsigned long pTime;
	Serial.println("azerty");
	boolean initialisationOn = true;
	Serial.println("good1");
	noInterrupts(); // pas d'interruption afin de ne pas perturber l'init
	Serial.println("good2");
	while(initialisationOn)
	{Serial.println("good3");
		if (!(RX_PIN0 || RX_PIN1 || RX_PIN2 || RX_PIN3 || RX_PIN4 || RX_PIN5 || RX_PIN6 || RX_PIN7))
		{Serial.println("good4");
			pTime = micros();
			Serial.println("good5");
			while ((!(RX_PIN0 || RX_PIN1 || RX_PIN2 || RX_PIN3 || RX_PIN4 || RX_PIN5 || RX_PIN6 || RX_PIN7)))
			{Serial.println("good6");
				if ((micros() - pTime) >= 5000)
				{Serial.println("good7");
					initialisationOn = false;
					Serial.println("good8");
					break;
				}
			}
		}
	}
	interrupts();
	Serial.println("good9");
	Q_INIT_RX;
	Serial.println("good10");
	Q_INIT_RX_INT;
	Serial.println("good11");
}

uint8_t RADIOCOMMAND::Throttle(void)
{
	return RADIOCOMMAND::throttle;
}

uint8_t RADIOCOMMAND::Roll(void)
{
	return RADIOCOMMAND::roll;
}

uint8_t RADIOCOMMAND::Pitch(void)
{
	return RADIOCOMMAND::pitch;
}

uint8_t RADIOCOMMAND::Yaw(void)
{
	return RADIOCOMMAND::yaw;
}

uint8_t RADIOCOMMAND::Aux1(void)
{
	return RADIOCOMMAND::aux1;
}

uint8_t RADIOCOMMAND::Aux2(void)
{
	return RADIOCOMMAND::aux2;
}

uint8_t RADIOCOMMAND::Aux3(void)
{
	return RADIOCOMMAND::aux3;
}

uint8_t RADIOCOMMAND::Aux4(void)
{
	return RADIOCOMMAND::aux4;
}

boolean RADIOCOMMAND::isRTF(void)
{
	return (RADIOCOMMAND::motorLock) ? false : true;
}

/*void __vector_11(RADIOCOMMAND * rad) 	// routine d'interruption unique à toutes les interruptions
{										// interruptions utilisée uniquement pour le recepteur
	static unsigned long previousTime;
	static uint8_t currentInterruption = 0;
	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
				rad->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
				rad->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
				rad->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
				rad->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
				rad->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
				 rad->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
				 rad->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
				 rad->aux4 = ((255.0/1000.0)*(largeurImpulsion) - 255);
				 currentInterruption = 0;
		break;
	}
}*/

Merci d'avance :slight_smile:

Serial utilise les interruptions. Le code de radiocommand intercepte les interruptions. Il ne seriat pas impossible que le problème vienne de là.

Ah je vois... Dans ce cas là comment je fais moi ^^ Si je peux pas debug par serial comment peux t-on faire autrement ?
Et juste au cas où, personne vois pourquoi de base ça ne marche pas ? XD

Reynosa:
Ah je vois... Dans ce cas là comment je fais moi ^^ Si je peux pas debug par serial comment peux t-on faire autrement ?
Et juste au cas où, personne vois pourquoi de base ça ne marche pas ? XD

A tester:?? mettre des delay après chaque Serial.print et ne pas toucher à la radiocommande pendant ces print pour éviter les interruptions dues à celle-ci.
Si ça marche c'est mieux que rien :wink:

Le problème, c'est que les interruptions sont chroniques, elles apparaissent chaque 20ms toutes les 1 à 2 ms. Même si on touche pas à la radio, le récepteur envoie les infos en continue =/

Bonjour,
si il te reste des pins de libre debug sur un lcd I2c ou SPI.

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

Bah virer les interruptions avant les envois série puis les remettre, et puis passer à 115200 baud ! Cette dernière mesure divisera le temps d'émission série par 12 !!

Ok merci, je vais essayer ça !

B@tto:
Bah virer les interruptions avant les envois série puis les remettre, et puis passer à 115200 baud ! Cette dernière mesure divisera le temps d'émission série par 12 !!

La librairie Serial utilise les interruptions donc tu ne peux pas les masquer ET avoir une com série.

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

Sinon avec une pin de libre et un kit RX TX 433 Mhz tu envoi tes paramètres a debuger sur une autre carte... mais la tu va me dire " j'ai pas de module 433 Mhz", et la moi je vais te répondre : "il va bien falloir que tu investisse 10 euros soit dans l'un soit dans l'autre" (433 Mhz ou LCD) car depuis le temps tu les aurais déjà reçu... XD
Trêve de plaisanterie, bon courage pour passer par le soft...

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

B@tto:
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.

B@tto:
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 ? ^^

Ah oui remarque il y a des chances ^^'

Non mais essaye en calant des nointerrupt() interrupt autour de tes serial.print, et passe en 115200 le serial aura moins de chance d'être perturbé

Bonjour,

J'utilise le port SPI quand j'ai besoin de debug avec les interruptions désactivées.

Tu as un exemple de code ici :