projet sti electronique 2012

[invitee2ad46bd]

Bonjour a tous je suis en électronique et cet année le projet c'est le robot moway.
J'ai choisi la problématique 1 celle de navigation qui vise a faire faire aux robot une ronde prédéfini en évitant qu'il perde sa trajectoire.
Comme solution on nous a donné une boussole CMP03 qui fonctionne en I2C.

Mais voila le programme en C ne fonctionne pas il ne corrige pas du tout la trajectoire il est disponible ici : Lien externe supprimé. umfred a recopié le code, qu'il en soit remercié.



Si vous voyer l'erreur je vous dit bien joué car là moi je sèche complétement.
-----

[umfred]

tu as sur le forum la balise code pour poster ton code, c'est plus simple que d'aller le télécharger

pour ceux qui ne veulent pas aller le télécharger:

#include "p18f86j50.h"  		//Moway microcontroller
#include "lib_mot_moway.h"		//Engines library
#include "lib_sen_moway.h"		//Sensor library
#include "port_ext.h"
#include "i2c_ext.h"
//****************************************************************************************************************//
// JUMPING THE BOOTLOADER
//****************************************************************************************************************//
#define REMAPPED_RESET_VECTOR_ADDRESS			0x1000	//Reset adress for the correct bootloader jump
#define REMAPPED_HIGH_INTERRUPT_VECTOR_ADDRESS	0x1008	//High priority interruption adress for the correct bootloader jump
#define REMAPPED_LOW_INTERRUPT_VECTOR_ADDRESS	0x1018	//Low priority interruption adress for the correct bootloader jump

void YourHighPriorityISRCode();	//Function that executes the needed code in case of the high priority interruption jumps.
void YourLowPriorityISRCode();	//Function that executes the needed code in case of the low priority interruption jumps.
//*********************RESET, HIGH AND LOW PRIORITY INTERRUPTION REMAP****************************//
extern void _startup (void);    
#pragma code REMAPPED_RESET_VECTOR = REMAPPED_RESET_VECTOR_ADDRESS  
void _reset (void)
{
    _asm goto _startup _endasm  
}
#pragma code

#pragma code REMAPPED_HIGH_INTERRUPT_VECTOR = REMAPPED_HIGH_INTERRUPT_VECTOR_ADDRESS
void Remapped_High_ISR (void) { _asm goto YourHighPriorityISRCode _endasm }

#pragma code REMAPPED_LOW_INTERRUPT_VECTOR = REMAPPED_LOW_INTERRUPT_VECTOR_ADDRESS
void Remapped_Low_ISR (void) { _asm goto YourLowPriorityISRCode _endasm }

#pragma code

#pragma interrupt YourHighPriorityISRCode
void YourHighPriorityISRCode() {
    //high priority interrupt code
}
#pragma interruptlow YourLowPriorityISRCode
void YourLowPriorityISRCode() {
    //low priority interrupt code
}

//************************************[MAIN]**************************************************

void PAUSE_SECONDE(unsigned char nb_secondes)
{
	unsigned char i;
	for (i=0;i<nb_secondes;i++)
	{
		Delay10KTCYx (100);		//pause de 1 seconde
	}
}


//--------------------------------------------------------------------------------------//
//--------------------------------------------------------------------------------------//
																				
//P R O G R A M M E			P R I N C I P A L				//
//																				
//--------------------------------------------------------------------------------------//
//--------------------------------------------------------------------------------------//
void main()
{

    	//**********définition variable*************//

	unsigned int distancer=0;          
	unsigned int longeur=20000;
	signed int correction=0;
	unsigned int trajetoire=1800;
	unsigned int angle=0;
	unsigned int angles=0;
	unsigned int ack1=0;


    	//**********SENSOR CONFIGURATION************//
		      SEN_CONFIG();
        //**********ENGINE CONFIGURATION************// 
		      MOT_CONFIG(); 
        //***********I2C CONFIGURATION*************// 
                     Config_I2C1();

	while(1)
	{
		PAUSE_SECONDE(1);
		Start_I2C1 ();
		Write_I2C1 (0xc0);                                                  // écriture adresse module //
		ack1=IN_ACK_NACK1 ();
		if (ack1) LED_BRAKE_ON;
		Write_I2C1 (2);                                                     // définition du mod de travail en 16 bit //
		ack1=IN_ACK_NACK1 ();
		if (ack1) LED_BRAKE_ON;
		Stop_I2C1 ();
		Delay10KTCYx (10);                                                  // délai nécésssaire pour que le stop soit prit en compte //
		Start_I2C1 ();   
		Write_I2C1 (0xc1);                                                  // adresse de la 1er partie de l'information recherché //
		ack1=IN_ACK_NACK1 ();
		if (ack1) LED_BRAKE_ON; 
		angle=Read_I2C1 ();                                                 // lecture de la premiere partie d'information //
		OUT_NACK1 ();
		Stop_I2C1 ();
		Delay10KTCYx (10);
		Start_I2C1 ();
		Write_I2C1 (0xc2);                                                  // adresse de la 2eme partie de l'information recherché //
		ack1=IN_ACK_NACK1 ();
		if (ack1) LED_BRAKE_ON;
		angles=Read_I2C1 ();                                                // lecture de la 2eme partie d'information //
		OUT_NACK1 ();
		Stop_I2C1 ();
		angle=angle << 8;                                                   // incrémentation a 8 //
		angle=angle + angles;                                               // rassemblement des 2 partie de l'information //
		if(longeur>distancer)                                              // vérification de l'avancement du trajet //
		{
			if(angle != trajetoire)                                           // vérification de l'alignement //
			{
	
				correction=trajetoire-angle;                                // détermination de la corection a aporté //
				if(correction<0)                                            // test pour savoir de quelle coté doit s'éffectuer la correction //
				{                                                           // correction vers coté droit //
					LED_TOP_RED_ON;
					Delay10KTCYx (50);
					LED_TOP_RED_OFF;
					correction=correction-correction-correction;            // transformation de la correction en une valeur positive //
					correction=correction/10;                               // transformation de la correction en un angle de rotation //	
					MOT_ROT(100,FWD,CENTER,RIGHT,angle,correction);         // éxéution de la correction //
				}
				else
				{                                                           // correction coté gauche //
					LED_TOP_GREEN_ON;
					Delay10KTCYx (50);
					LED_TOP_GREEN_OFF;
					correction=correction/10;                               // transformation de la correction en un angle de rotation //
					MOT_ROT(100,FWD,CENTER,LEFT,angle,correction);          // éxéution de la correction //
				}
			}
			MOT_STR(100,FWD,DISTANCE, 250);                                 // éxécution du partie du trajet //
			distancer=distancer+250;                                        // mise a jour de la position du robot dans la rone //
			LED_FRONT_ON;
			Delay10KTCYx (50);
			LED_FRONT_OFF;
		} 
	}
}

[Metalhearf]

Salut.
J'ai actuellement la même problématique que toi, et ça doit faire bien quatre mois que j'essaye quotidiennement de nouveaux programmes en vain.

J'ai essayé de comprendre et de réutiliser ton programme. J'y ai trouvé deux trois choses assez difficiles à comprendre.
Pourrais-tu m'expliquer certaines lignes, telles que :

correction=correction-correction-correction;
correction=correction/10;

J'aurais aussi besoin d'informations concernant tes deux conditions ("if(correction<0)" et son complément "else" juste après).
Merci d'avance pour ta réponse, et si jamais tu as trouvé une solution plus efficace, ce serait sympa que l'on en discute !

Bonne journée !

[invitee2ad46bd]

correction=correction-correction-correction;
 correction=correction/10;

ces ligne me permète d'avoir un variable de correction positive

exemple :
(-6)-(-6)-(-6)=+6

quand a correction=corection/10 cela me permetde pouvoir mettre directement la variable dans le robot moway qu'y ne prend des valeur que de 0 a 255

[A voir en vidéo sur Futura]

[Jack]

il faudra m'expliquer la différence qui existe entre:

correction=correction-correction-correction;

et

correction=-correction;

A+

[Metalhearf]

Effectivement, Jack montre bien l'étrangeté de la chose qui m'avait étonné. On peut aussi multiplier "correction" par "(-1)", de mon côté les résultats sur le moway étaient identiques.

Oh, et tu utilises le registre 1 de la boussole ? (0 - 255) Intéressant... puisque pour ma part, j'ai plutôt essayé d'utiliser le registre 2 ou 3, permettant de nommer des angles de 0-359.9°. Ca m'évitait de passer par ces calculs et cette division et ça me paraissait plus simple au début, mais c'est vrai qu'après réflexion on remarque que la commande de rotation n'utilise que des valeurs de 0-255. Je vais peut être adopter cette idée !

Tu devrais aussi peut être créer une fonction bien déterminée pour la "Lecture boussole" qui regrouperait tout en une ligne, et ne l’appeler qu'une fois dans ton programme afin de faire quelque chose de plus clair et allégé. Simple proposition .

Autre petite question qui me turlupine, ce serait au niveau de la fonction de rotation donc, celle qui permet de retrouver le bon cap de la trajectoire. Dans la librairie en question on y voit que la dernière valeur modifiable est celle de l'angle à décrire. Est-ce que l'on a le droit de le remplacer par "correction" dans notre programme ? J'ai trouvé ça assez étrange.

Finalement, j'ai relevé le signal entre le PWM et la masse de la Boussole (avec un programme de lecture boussole fonctionnel) et effectivement je remarque bien que la longueur d'impulsion varie selon l'angle du robot : tout va bien de ce côté là... donc va falloir continuer à plancher côté programme !
De plus, je vais me brancher sur le convertisseur de la problématique Obstacle. Ils passent de la tension délivrée par le mOway de 3,3v à 5v ; je te dirais si c'est plus efficace comme ça et si j'arrive à quelque chose.

[inviteb0a6dc3b]

je travaille sur la même problématique, ton programme a l'air super complexe.
Je pense par contre que tu devrais définir les registres dans lesquelles tu veux travailler dans:
JUMPING THE BOOTLOADER
Nous c'est comme ça que nous avons fait et on arrive à faire pas mal de test concluant.
Et j'ai fait comme Metalhearf en créant une fonction Lecture_boussole, et la tu arrives sur des programmes bien plus simples.
Si jamais vous avez trouvé d'autres solutions faites tourner svp