Pages: [1] 2   Go Down
Author Topic: Problème dans mon code et debug Serial impossible  (Read 1331 times)
0 Members and 1 Guest are viewing this topic.
Behind you
Offline Offline
Jr. Member
**
Karma: 0
Posts: 91
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

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

Code:
#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
Code:
#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
Code:
// 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  smiley
Logged

France
Online Online
Faraday Member
**
Karma: 38
Posts: 3542
There is an Arduino for that
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

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

Behind you
Offline Offline
Jr. Member
**
Karma: 0
Posts: 91
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

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 ?  smiley-lol
Logged

Bretagne
Offline Offline
Full Member
***
Karma: 2
Posts: 196
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

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 ?  smiley-lol

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 smiley-wink
Logged

...ils embarquèrent la logique, coupèrent les cordons, alors, libérés de leurs chaînes, une immensité s'ouvrait devant eux...

Behind you
Offline Offline
Jr. Member
**
Karma: 0
Posts: 91
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

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 =/
Logged

Sud-Ouest
Offline Offline
Full Member
***
Karma: 0
Posts: 117
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

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

Behind you
Offline Offline
Jr. Member
**
Karma: 0
Posts: 91
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

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

Ales
Offline Offline
Faraday Member
**
Karma: 39
Posts: 3642
Do or DIY
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

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 !!
Logged


Behind you
Offline Offline
Jr. Member
**
Karma: 0
Posts: 91
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Ok merci, je vais essayer ça !
Logged

France
Online Online
Faraday Member
**
Karma: 38
Posts: 3542
There is an Arduino for that
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

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.
Logged

Ales
Offline Offline
Faraday Member
**
Karma: 39
Posts: 3642
Do or DIY
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

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


Sud-Ouest
Offline Offline
Full Member
***
Karma: 0
Posts: 117
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

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...  smiley-lol
Trêve de plaisanterie, bon courage pour passer par le soft...
Logged

Ales
Offline Offline
Faraday Member
**
Karma: 39
Posts: 3642
Do or DIY
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

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


Behind you
Offline Offline
Jr. Member
**
Karma: 0
Posts: 91
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

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 ? ^^
« Last Edit: February 08, 2013, 11:05:43 am by Reynosa » Logged

Ales
Offline Offline
Faraday Member
**
Karma: 39
Posts: 3642
Do or DIY
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

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é
Logged


Pages: [1] 2   Go Up
Jump to: