Codage sur le robot

Aller en bas

Codage sur le robot

Message par Nadar le Jeu 10 Juil - 16:37

Je met ici le code actuel mis sur le robot ; c'est un peu bourrin mais j'ai mis des explications :

Voici la bete :

Code:
#include "C:\Users\Nadar\Documents\Scolaire\Projet tut\Robot\PIC\Programme\robot_v1.h"
  #include <stdio.h>
  #ZERO_RAM

  //****************************************************************************
  //*Programme pour robot quadrupede à 2 degrés de liberté pour chaques pattes *
  //*                                                                          *
  //****************************************************************************
  //*                                                                          *
  //*  NOM:robot_v1                                                          *
  //*  DATE(début):27/06/2008                                                *
  //*                                                                          *
  //*  Version : 1.23                                                        *
  //*                                                                          *
  //*  Auteur: NADAR                                                          *
  //*                                                                          *
  //****************************************************************************



VOID init_i2c(INT8 r21,INT8 r22,INT8 r23)
{
  //***************************************************************************
  //*      Etablissement des débattements et des departs d'impulsion pour
  //*                      l'ensemble des servomoteurs
  //*
  //* Registre 21: definie la LONGueur maximum de l'impulsion a envoyer.
  //* C'est le débattement
  //* Range Width (uS) = (255 * 256) / Reg21
  //* Registres 22:23 :Le couple 22:23 determine l'impulsion qui DOnne le 0°
  //* du servomoteur.
  //* Le registre 22 est le poids FORt et le registre 23 le poids faible en
  //* hexadecimal
  //* Pulse Width (uS) = ( (255 * 256) / Reg21) + (Reg22:23 + 20)
  //***************************************************************************
  i2c_start ();
  i2c_write (0xC2); //* adresse du SD20
  i2c_write (21); //* registre 21 : largeur max d'impulsion
  i2c_write (r21);
  delay_ms (20);
  i2c_stop ();
  delay_ms (100);

  IF (r21 != 0)
  {
      i2c_start ();
      i2c_write (0xC2); //* adresse du SD20
      i2c_write (22); //* registre 22 : debut de l'impulsion (poids FORt)
      i2c_write (r22);
      delay_ms (20);
      i2c_stop ();
      delay_ms (100);
      i2c_start ();
      i2c_write (0xC2); //* adresse du SD20
      i2c_write (23); //* registre 23 : debut de l'impulsion (poids faibles)
      i2c_write (r23);
      delay_ms (20);
      i2c_stop ();
      delay_ms (100);
  }
}

VOID servo(INT8 s,INT8 a,INT16 T1,int16 T0)
{
  //**********************************************************************
  //*            Routines d'usages d'un servomoteur
  //* Afin de simplifier et d'alleger le programme, je présente ici
  //* une routine de fonctionnement d'un servomoteur dans laquelle est
  //* inclu l'ensemble du codage I²C pour la gestion d'un servomoteur.
  //* Pour faire fonctionner un servomoteur, l'utilisateur DOit DOnc
  //* entrer 4 variables:les numéro du servo, l'angle à réaliser, la
  //* durée de tenu de l'angle, et la durée de coupure d'un servo.
  //* Si une des durée est égale a 0, la fonction concernée n'est pas
  //* prise en compte ce qui permet de choisir entre la désactivation
  //* d'un servomoteur ou du fonctionnement ou des deux a la fois en
  //* une seul et meme ligne.
  //**********************************************************************
  IF (T1 != 0)
  {
      i2c_start ();
      i2c_write (0xC2); //* adresse du SD20
      i2c_write (s); //* registre : selection du servomoteur
      i2c_write (a); //* angle en rotation
      i2c_stop ();
      delay_ms (T1);
}

  IF (T0 != 0)
  {
      i2c_start ();
      i2c_write (0xC2); //* adresse du SD20
      i2c_write (s); //* registre : selection du servomoteur
      i2c_write (0); //* angle en rotation
      i2c_stop ();
      delay_ms (T0);
}
}

VOID signal(int32 n)
{
  //*******************************************************
  //* Signal lumineux et sonore
  //* Prevu pour signaler un probleme ou la fin d'une
  //* action en cour. L'usage le plus important est au
  //* début du programme pour signaler un eventuel
  //* rebootage du PIC.
  //*******************************************************
  int32 i=0;
  int32 x=0;
  //beeper et signal lumineux
  n=1000000/n;
  x=200000/n;
  n=n/2;

  WHILE (i<=x)
  {
      output_high (PIN_B5);
      delay_us (n);
      output_low (PIN_B5);
      delay_us (n);
      i=i+1;
  }
  delay_ms (200);
  i=0;
  x=0;
  //fin beeper et signal lumineux
}

VOID init(VOID)
{
  //******************************************************
  //* Reglage à la position initial
  //* On regle les pattes sur leurs position initial
  //* afin de ne pas avoir de probleme lors des
  //* séquences de marche.
  //******************************************************

  signal(880);

  servo (10, 10, 20, 0);
  servo (6, 230, 20, 0);
  servo (7, 10, 20, 0);
  servo (2, 100, 20, 0);
  delay_ms(300);
  servo (10, 10, 0, 20);
  servo (6, 230, 0, 20);
  servo (7, 10, 0, 20);
  servo (2, 100, 0, 20);

  servo (9, 120, 500, 20);
  servo (8, 120, 500, 20);
  servo (1, 140, 500, 20);
  servo (3, 140, 500, 20);

  signal(880);

  //Fin de reglage
}

VOID marche_avant(VOID)
{
  //***************************************************************
  //* Programme qui définie une séquence de marche typique
  //* du robot en avant.lorsque une patte avance et est en l'air,
  //* les autres poussent le robot vers l'avant.
  //***************************************************************

  servo (11, 60, 20,0);

  output_high (PIN_B1);
  servo (11, 10, 20, 0);
  servo (9, 5, 300, 20);

  servo (10, 100, 20, 0);
  servo (6, 200, 20, 0);
  servo (7, 120, 20, 0);
  servo (2, 154, 20, 0);
  delay_ms(250);
  servo (10, 100, 0, 20);
  servo (6, 200, 0, 20);
  servo (7, 120, 0, 20);
  servo (2, 154, 0, 20);

  servo (9, 120, 300, 20);
  output_low (PIN_B1);

  output_high (PIN_B0);
  servo (11, 110, 20, 0);
  servo (1, 250, 300, 20);

  servo (10, 70, 20, 0);
  servo (6, 170, 20, 0);
  servo (7, 10, 20, 0);
  servo (2, 180, 20, 0);
  delay_ms(250);
  servo (10, 70, 0, 20);
  servo (6, 170, 0, 20);
  servo (7, 10, 0, 20);
  servo (2, 180, 0, 20);

  servo (1, 140, 300, 20);
  output_low (PIN_B0);

  output_high (PIN_B0);
  servo (11, 110, 20, 0);
  servo (3, 250, 300, 20);

  servo (10, 40, 20, 0);
  servo (6, 140, 20, 0);
  servo (7, 47, 20, 0);
  servo (2, 100, 20, 0);
  delay_ms(250);
  servo (10, 40, 0, 20);
  servo (6, 140, 0, 20);
  servo (7, 47, 0, 20);
  servo (2, 100, 0, 20);

  servo (3, 140, 300, 20);
  output_low (PIN_B0);

  output_high (PIN_B1);
  servo (11, 10, 20, 0);
  servo (8, 10, 300, 20);

  servo (10, 10, 20, 0);
  servo (6, 230, 20, 0);
  servo (7, 84, 20, 0);
  servo (2, 127, 20, 0);
  delay_ms(250);
  servo (10, 10, 0, 20);
  servo (6, 230, 0, 20);
  servo (7, 84, 0, 20);
  servo (2, 127, 0, 20);

  servo (8, 140, 300, 20);
  output_low (PIN_B1);



}
VOID marche_arriere(VOID)
{
  //***************************************************************
  //* Programme qui définie une séquence de marche typique
  //* du robot en arriere.lorsque une patte avance et est en l'air,
  //* les autres poussent le robot vers l'arriere.
  //***************************************************************

  servo (11, 60, 20,0);

  output_high (PIN_B1);
  servo (11, 10, 20, 0);
  servo (9, 5, 300, 20);

  servo (10, 10, 20, 0);
  servo (6, 170, 20, 0);
  servo (7, 10, 20, 0);
  servo (2, 127, 20, 0);
  delay_ms(250);
  servo (10, 10, 0, 20);
  servo (6, 200, 0, 20);
  servo (7, 120, 0, 20);
  servo (2, 154, 0, 20);

  servo (9, 120, 300, 20);
  output_low (PIN_B1);

  output_high (PIN_B0);
  servo (11, 110, 20, 0);
  servo (1, 250, 300, 20);

  servo (10, 40, 20, 0);
  servo (6, 200, 20, 0);
  servo (7, 120, 20, 0);
  servo (2, 100, 20, 0);
  delay_ms(250);
  servo (10, 70, 0, 20);
  servo (6, 170, 0, 20);
  servo (7, 10, 0, 20);
  servo (2, 180, 0, 20);

  servo (1, 140, 300, 20);
  output_low (PIN_B0);

  output_high (PIN_B0);
  servo (11, 110, 20, 0);
  servo (3, 250, 300, 20);

  servo (10, 70, 20, 0);
  servo (6, 230, 20, 0);
  servo (7, 84, 20, 0);
  servo (2, 180, 20, 0);
  delay_ms(250);
  servo (10, 40, 0, 20);
  servo (6, 140, 0, 20);
  servo (7, 47, 0, 20);
  servo (2, 100, 0, 20);

  servo (3, 140, 300, 20);
  output_low (PIN_B0);

  output_high (PIN_B1);
  servo (11, 10, 20, 0);
  servo (8, 10, 300, 20);

  servo (10, 100, 20, 0);
  servo (6, 140, 20, 0);
  servo (7, 47, 20, 0);
  servo (2, 154, 20, 0);
  delay_ms(250);
  servo (10, 10, 0, 20);
  servo (6, 230, 0, 20);
  servo (7, 84, 0, 20);
  servo (2, 127, 0, 20);

  servo (8, 140, 300, 20);
  output_low (PIN_B1);


}
VOID tourne_droite(VOID)
{
  //***************************************************************
  //* Programme qui définie une séquence de marche typique
  //* du robot en avant. Chaque pattes avancent les unes
  //* aprés les autres puis le robot avance en poussant
  //* sur toutes ses pattes vers l'arriere. Autre solution
  //* à envisager:lorsque une patte avance et est en l'air,
  //* les autres poussent le robot vers l'avant.
  //***************************************************************
  servo (11, 10, 20,0);


  output_high (PIN_B1);
  servo (9, 10, 400, 20);
  servo (10, 10, 400, 20);
  servo (9, 120, 400, 20);
  output_low (PIN_B1);

  output_high (PIN_B1);
  servo (8, 10, 400, 20);
  servo (6, 140, 400, 20);
  servo (8, 140, 400, 20);
  output_low (PIN_B1);

  output_high (PIN_B0);
  servo (1, 250, 400, 20);
  servo (7, 10, 400, 20);
  servo (1, 140, 400, 20);
  output_low (PIN_B0);

  output_high (PIN_B0);
  servo (3, 250, 400, 20);
  servo (2, 100, 400, 20);
  servo (3, 140, 400, 20);
  output_low (PIN_B0);

  servo (10, 100, 20, 0);
  servo (6, 230, 20, 0);
  servo (7, 120, 20, 0);
  servo (2, 180, 20, 0);
  delay_ms (250);
  servo (10, 100, 0, 20);
  servo (6, 230, 0, 20);
  servo (7, 120, 0, 20);
  servo (2, 180, 0, 20);

  servo (11, 10,0,20);
}
VOID tourne_gauche(VOID)
{
  //***************************************************************
  //* Programme qui définie une séquence de marche typique
  //* du robot en avant. Chaque pattes avancent les unes
  //* aprés les autres puis le robot avance en poussant
  //* sur toutes ses pattes vers l'arriere. Autre solution
  //* à envisager:lorsque une patte avance et est en l'air,
  //* les autres poussent le robot vers l'avant.
  //***************************************************************
  servo (11, 110, 20,0);

  output_high (PIN_B0);
  servo (3, 250, 400, 20);
  servo (2, 180, 400, 20);
  servo (3, 140, 400, 20);
  output_low (PIN_B0);

  output_high (PIN_B0);
  servo (1, 250, 400, 20);
  servo (7, 120, 400, 20);
  servo (1, 140, 400, 20);
  output_low (PIN_B0);

  output_high (PIN_B1);
  servo (9, 10, 400, 20);
  servo (10, 100, 400, 20);
  servo (9, 120, 400, 20);
  output_low (PIN_B1);

  output_high (PIN_B1);
  servo (8, 10, 400, 20);
  servo (6, 230, 400, 20);
  servo (8, 140, 400, 20);
  output_low (PIN_B1);

  servo (10, 10, 20, 0);
  servo (6, 140, 20, 0);
  servo (7, 10, 20, 0);
  servo (2, 100, 20, 0);
  delay_ms (250);
  servo (10, 10, 0, 20);
  servo (6, 140, 0, 20);
  servo (7, 10, 0, 20);
  servo (2, 100, 0, 20);

  servo (11, 110, 0,20);
}
VOID tourel(VOID)
{
  //****************************************************************
  //* On effectue ici un test pour savoir d'où vient la lumiere.
  //* La tourelle va indiquer le sens de la source lumineuse la
  //* plus forte et va pointer sur cette direction .
  //****************************************************************
  servo (11, 10, 600, 20);    // regarde a droite
  servo (11, 110, 600, 20);  // regarde a gauche

  IF (input (PIN_D2) == 1){servo (11, 10, 1000, 20);}
  IF (input (PIN_D2) == 0){servo (11, 110, 1000, 20);}

  //fin de test retour a l'état initial
  servo (11, 60, 1000, 20);
  // fin de REI; signal de fin
  signal (880);
}


VOID main()
{
  int8 i=1,a,b;

  setup_adc_ports (AN0_AN1_AN2_AN3_AN4);
  setup_adc (ADC_CLOCK_INTERNAL);
  setup_psp (PSP_DISABLED);
  setup_timer_0 (RTCC_INTERNAL|RTCC_DIV_1);
  setup_timer_1 (T1_DISABLED);
  setup_timer_2 (T2_DISABLED, 0, 1);


  set_TRIS_B (0x00);
  init_i2c (0, 0x02, 0x44);

  init ();
  tourel ();

  while(1)
  {

      WHILE (input(PIN_D1)==1) // le robot fonctionne en mode filoguidage
      {
      a=0;
      set_adc_channel(0);
      delay_us(20);
      a=read_adc();

      b=0;
      set_adc_channel(1);
      delay_us(20);
      b=read_adc();

      IF (a>=187){marche_avant();}
      IF (a<=62){marche_arriere();}
      IF (b>=187){tourne_gauche();}
      IF (b<=62){tourne_droite();}

      }
      WHILE (input(PIN_D1)==0) // Le robot fonctionne de maniere autonome
      {
      WHILE (input(PIN_D0)==0 && input(PIN_D4)==0 && input(PIN_D1)==0 ){marche_avant ();}

      IF (input(PIN_D0)==1 && input(PIN_D4)==0 && input(PIN_D1)==0)
      {signal(784);signal(784);marche_arriere();marche_arriere();
        while(i!=4){tourne_gauche();i=i+1;}
        i=1;signal(784);signal(784);
      }
      IF (input(PIN_D0)==0 && input(PIN_D4)==1 && input(PIN_D1)==0)
      {signal(784);signal(784);marche_arriere();marche_arriere();
        while(i!=4){tourne_droite();i=i+1;}
        i=1;signal(784);signal(784);
      }
      IF (input(PIN_D0)==1 && input(PIN_D4)==1 && input(PIN_D1)==0)
      {signal(784);signal(262);marche_arriere();
        while(i!=14){tourne_droite();i=i+1;}
        i=1;signal(784);signal(262);signal(784);
      }
      }
  }
}

Voila comme sa tu pourras un peut voir ce que sa donne et me donner des conseille si tu vois des truc bizarre ou que j'aurais pu réduire Shocked
Nadar
Nadar
Admin

Nombre de messages : 220
Date d'inscription : 10/07/2008

Voir le profil de l'utilisateur http://robotique-iut.forum-actif.eu

Revenir en haut Aller en bas

Re: Codage sur le robot

Message par Shindara le Ven 8 Aoû - 21:37

ya pas mal de chose que j'ai pas compris mes bon tu m'expliquera sa plus tar pour lisntant jai besoin d'information.

Entre chaque servomoteur tu mais un delay de cb de temps??
Pourquoi?
Peu on le reduire??

Peu on faire bouger des servomoteurs presque en meme temp?? (ps:meme si ya un leger decalage c pas grave)
Si oui explique moi precisement comment stp??


Ya toujours un probleme de registre comment et quoi mettre pour benificier d"une largeur d'angle importante??



stp repond a ces question precisement au plus vite j'essaye de creer quelque programme bien que je n'est pas de debuger pour m'ameliorer et mieu comprendre le robot?
Shindara
Shindara
Admin

Nombre de messages : 49
Date d'inscription : 16/07/2008

Voir le profil de l'utilisateur

Revenir en haut Aller en bas

Re: Codage sur le robot

Message par Nadar le Ven 8 Aoû - 23:59

Je vais tenter de t'expliquer le code clairement :

- Fonction " servo (numero servo,angle,durée,desactivation)" :

cette fonction permet de simplifier le code general du robot. Elle inclut toutes les routine I2C pour un servomoteur. Elle permet de choisir le servomoteur a faire tourner , l'angle de rotation de ce servo , la durée de la rotation et si on veut désactiver le servomoteur aprés son angle tous sela en une seul ligne .exemple :

Je veux faire tourner le servomoteur 1 d'un angle de 165 pendant 300 ms et le desactiver juste parés l'angle effectué ( en insérant 20 ) , le code donnera:

Code:
servo(1,165,300,20);

Si on veut faire tourner deux sero en meme temps et les desactiver aprés , le code sera:

Code:
servo(1,165,20,0);
servo(2,165,20,0);

delay_ms(300);

servo(1,0,0,20);
servo(2,0,0,20);

voila , ce code fonctionne a merveille pour le robot et permet de faire fonctionner des servomoteur en meme temps ou par a-coup de la maniere qu'on le désire.

- Pour les séquences de marche :

J'utilise des fonctions du type " marche_avant" et " tourne_gauche" pour commander le robot . Ces fonctions integre toutes les séquences de fonctionnement des servo via la fonction que j'ai expliqué precedemment.

Cette solution simple permet de bon resultat lorsqu'il s'agit de faire avancer le robot simplement. MAIS , lorsque l'on fait de la detection d'obstacle on doit alors attedre la fin de la séquence de marche complete ( c a d le mouvement des 4 pattes ) pour faire un calcul de détection .

Si le robot heurte un obstacle pendant sa séquence , elle ne sera prise en compte que a la fin de la séquence .

Je suis en train de revoir la programmation pour palier a ce genre de probleme. La solution la plus simple que j'ai trouvé je croi est de créer une fonction delay_ms() plus avancer ...

Cette fonction remplacerai la fonction delay_ms actuel en se qui concerne le mouvement des servomoteur.elle renvaierai une variable qui nous informerais si il y a eu contact ou pas avec un objet ; le probleme est que cette solution est assez lourde.

On peut aussi imaginer travailler avec des interruptions du PIC via des commande comme interupt ... Il faudrait donc interpréter le signal envoyer lors d'une collision ( solide ou detection d'obstacle par IR ) et de la caracteriser via une interruption qui déclencherait une séquence de fonctionnement du robot en fonction du probleme qui se présente a lui .

Pour moi cette derniere solution reste la meilleur meme si elle est difficile a coder , c'est celle qui a le plus de chance de marcher ; mais elle fait aussi appelle a beaucoup de notions de codage . J'ai deja fait des essai en mélangeant de l'assembleur et du C ( Et oui malheureusement je ne sait gerer les interuptions que via l'assembleur ) maisceci n'ont pas été trés concluant . Entend par la que sa a été la merde Very Happy
Nadar
Nadar
Admin

Nombre de messages : 220
Date d'inscription : 10/07/2008

Voir le profil de l'utilisateur http://robotique-iut.forum-actif.eu

Revenir en haut Aller en bas

Re: Codage sur le robot

Message par Nadar le Sam 9 Aoû - 1:14

Sinon que dire du reste du code , surtout que celui ci se fait vieux et qu'il a été modifier depuis le temps, je te met d'ailleur le nouveau code que j'utilise actuellement et qui gere la detection par Infrarouge :

Code:

#include "C:\Users\Nadar\Documents\Scolaire\Projet tut\Robot\PIC\Programme\robot_v1.h"
  #include <stdio.h>
  #ZERO_RAM

  //****************************************************************************
  //*Programme pour robot quadrupede à 2 degrés de liberté pour chaques pattes *
  //*                                                                          *
  //****************************************************************************
  //*                                                                          *
  //*  NOM:robot_v1                                                          *
  //*  DATE(début):27/06/2008                                                *
  //*                                                                          *
  //*  Version : 2.00                                                        *
  //*                                                                          *
  //*  Auteur: NADAR                                                          *
  //*                                                                          *
  //****************************************************************************


VOID init_i2c(INT8 r21,INT8 r22,INT8 r23)
{
  //***************************************************************************
  //*      Etablissement des débattements et des departs d'impulsion pour
  //*                      l'ensemble des servomoteurs
  //*
  //* Registre 21: definie la LONGueur maximum de l'impulsion a envoyer.
  //* C'est le débattement
  //* Range Width (uS) = (255 * 256) / Reg21
  //* Registres 22:23 :Le couple 22:23 determine l'impulsion qui DOnne le 0°
  //* du servomoteur.
  //* Le registre 22 est le poids FORt et le registre 23 le poids faible en
  //* hexadecimal
  //* Pulse Width (uS) = ( (255 * 256) / Reg21) + (Reg22:23 + 20)
  //***************************************************************************
  i2c_start ();
  i2c_write (0xC2); //* adresse du SD20
  i2c_write (21); //* registre 21 : largeur max d'impulsion
  i2c_write (r21);
  delay_ms (20);
  i2c_stop ();
  delay_ms (100);

  IF (r21 != 0)
  {
      i2c_start ();
      i2c_write (0xC2); //* adresse du SD20
      i2c_write (22); //* registre 22 : debut de l'impulsion (poids FORt)
      i2c_write (r22);
      delay_ms (20);
      i2c_stop ();
      delay_ms (100);
      i2c_start ();
      i2c_write (0xC2); //* adresse du SD20
      i2c_write (23); //* registre 23 : debut de l'impulsion (poids faibles)
      i2c_write (r23);
      delay_ms (20);
      i2c_stop ();
      delay_ms (100);
  }
}
VOID servo(INT8 s,INT8 a,INT16 T1,int16 T0)
{
  //**********************************************************************
  //*            Routines d'usages d'un servomoteur
  //* Afin de simplifier et d'alleger le programme, je présente ici
  //* une routine de fonctionnement d'un servomoteur dans laquelle est
  //* inclu l'ensemble du codage I²C pour la gestion d'un servomoteur.
  //* Pour faire fonctionner un servomoteur, l'utilisateur DOit DOnc
  //* entrer 4 variables:les numéro du servo, l'angle à réaliser, la
  //* durée de tenu de l'angle, et la durée de coupure d'un servo.
  //* Si une des durée est égale a 0, la fonction concernée n'est pas
  //* prise en compte ce qui permet de choisir entre la désactivation
  //* d'un servomoteur ou du fonctionnement ou des deux a la fois en
  //* une seul et meme ligne.
  //**********************************************************************
  IF (T1 != 0)
  {
      i2c_start ();
      i2c_write (0xC2); //* adresse du SD20
      i2c_write (s); //* registre : selection du servomoteur
      i2c_write (a); //* angle en rotation
      i2c_stop ();
      delay_ms (T1);
}

  IF (T0 != 0)
  {
      i2c_start ();
      i2c_write (0xC2); //* adresse du SD20
      i2c_write (s); //* registre : selection du servomoteur
      i2c_write (0); //* angle en rotation
      i2c_stop ();
      delay_ms (T0);
}
}

VOID signal(int32 n)
{
  //*******************************************************
  //* Signal lumineux et sonore
  //* Prevu pour signaler un probleme ou la fin d'une
  //* action en cour. L'usage le plus important est au
  //* début du programme pour signaler un eventuel
  //* rebootage du PIC.
  //*******************************************************
  int32 i=0;
  int32 x=0;
  //beeper et signal lumineux
  n=1000000/n;
  x=200000/n;
  n=n/2;

  WHILE (i<=x)
  {
      output_high (PIN_B5);
      delay_us (n);
      output_low (PIN_B5);
      delay_us (n);
      i=i+1;
  }
  delay_ms (200);
  i=0;
  x=0;
  //fin beeper et signal lumineux
}

VOID init(VOID)
{
  //******************************************************
  //* Reglage à la position initial
  //* On regle les pattes sur leurs position initial
  //* afin de ne pas avoir de probleme lors des
  //* séquences de marche.
  //******************************************************

  signal(880);

  servo (10, 10, 20, 0);
  servo (6, 230, 20, 0);
  servo (7, 10, 20, 0);
  servo (2, 100, 20, 0);
  delay_ms(300);
  servo (10, 10, 0, 20);
  servo (6, 230, 0, 20);
  servo (7, 10, 0, 20);
  servo (2, 100, 0, 20);

  servo (9, 170, 500, 20);
  servo (8, 190, 500, 20);
  servo (1, 120, 500, 20);
  servo (3, 50, 500, 20);

  signal(880);

  //Fin de reglage
}

VOID marche_avant(VOID)
{
  //***************************************************************
  //* Programme qui définie une séquence de marche typique
  //* du robot en avant.lorsque une patte avance et est en l'air,
  //* les autres poussent le robot vers l'avant.
  //***************************************************************
  servo (9, 5, 500, 20);

  servo (10, 100, 20, 0);
  servo (6, 200, 20, 0);
  servo (7, 120, 20, 0);
  servo (2, 154, 20, 0);
  delay_ms(250);
  servo (10, 100, 0, 20);
  servo (6, 200, 0, 20);
  servo (7, 120, 0, 20);
  servo (2, 154, 0, 20);

  servo (9, 170, 500, 0);


  servo (1, 250, 500, 20);

  servo (10, 70, 20, 0);
  servo (6, 170, 20, 0);
  servo (7, 10, 20, 0);
  servo (2, 180, 20, 0);
  delay_ms(250);
  servo (10, 70, 0, 20);
  servo (6, 170, 0, 20);
  servo (7, 10, 0, 20);
  servo (2, 180, 0, 20);

  servo (1, 120, 500, 0);


  servo (3, 250, 500, 20);

  servo (10, 40, 20, 0);
  servo (6, 140, 20, 0);
  servo (7, 47, 20, 0);
  servo (2, 100, 20, 0);
  delay_ms(250);
  servo (10, 40, 0, 20);
  servo (6, 140, 0, 20);
  servo (7, 47, 0, 20);
  servo (2, 100, 0, 20);

  servo (3, 50, 500, 0);


  servo (8, 10, 500, 20);

  servo (10, 10, 20, 0);
  servo (6, 230, 20, 0);
  servo (7, 84, 20, 0);
  servo (2, 127, 20, 0);
  delay_ms(250);
  servo (10, 10, 0, 20);
  servo (6, 230, 0, 20);
  servo (7, 84, 0, 20);
  servo (2, 127, 0, 20);

  servo (8, 190, 500, 0);



}
VOID marche_arriere(VOID)
{
  //***************************************************************
  //* Programme qui définie une séquence de marche typique
  //* du robot en arriere.lorsque une patte avance et est en l'air,
  //* les autres poussent le robot vers l'arriere.
  //***************************************************************

  servo (9, 5, 300, 20);

  servo (10, 10, 20, 0);
  servo (6, 170, 20, 0);
  servo (7, 10, 20, 0);
  servo (2, 127, 20, 0);
  delay_ms(250);
  servo (10, 10, 0, 20);
  servo (6, 200, 0, 20);
  servo (7, 120, 0, 20);
  servo (2, 154, 0, 20);

  servo (9, 170, 300, 0);


  servo (1, 250, 300, 20);

  servo (10, 40, 20, 0);
  servo (6, 200, 20, 0);
  servo (7, 120, 20, 0);
  servo (2, 100, 20, 0);
  delay_ms(250);
  servo (10, 70, 0, 20);
  servo (6, 170, 0, 20);
  servo (7, 10, 0, 20);
  servo (2, 180, 0, 20);

  servo (1, 120, 300, 0);


  servo (3, 250, 300, 20);

  servo (10, 70, 20, 0);
  servo (6, 230, 20, 0);
  servo (7, 84, 20, 0);
  servo (2, 180, 20, 0);
  delay_ms(250);
  servo (10, 40, 0, 20);
  servo (6, 140, 0, 20);
  servo (7, 47, 0, 20);
  servo (2, 100, 0, 20);

  servo (3, 50, 300, 0);


  servo (8, 10, 300, 20);

  servo (10, 100, 20, 0);
  servo (6, 140, 20, 0);
  servo (7, 47, 20, 0);
  servo (2, 154, 20, 0);
  delay_ms(250);
  servo (10, 10, 0, 20);
  servo (6, 230, 0, 20);
  servo (7, 84, 0, 20);
  servo (2, 127, 0, 20);

  servo (8, 190, 300, 0);



}
VOID tourne_droite(VOID)
{
  //***************************************************************
  //* Programme qui définie une séquence de marche typique
  //* du robot en avant. Chaque pattes avancent les unes
  //* aprés les autres puis le robot avance en poussant
  //* sur toutes ses pattes vers l'arriere. Autre solution
  //* à envisager:lorsque une patte avance et est en l'air,
  //* les autres poussent le robot vers l'avant.
  //***************************************************************


  servo (9, 10, 400, 20);
  servo (10, 10, 400, 20);
  servo (9, 170, 400, 0);

  servo (8, 10, 400, 20);
  servo (6, 140, 400, 20);
  servo (8, 190, 400, 0);

  servo (1, 250, 400, 20);
  servo (7, 10, 400, 20);
  servo (1, 120, 400, 0);

  servo (3, 250, 400, 20);
  servo (2, 100, 400, 20);
  servo (3, 50, 400, 0);

  servo (10, 100, 20, 0);
  servo (6, 230, 20, 0);
  servo (7, 120, 20, 0);
  servo (2, 180, 20, 0);
  delay_ms (250);
  servo (10, 100, 0, 20);
  servo (6, 230, 0, 20);
  servo (7, 120, 0, 20);
  servo (2, 180, 0, 20);

}
VOID tourne_gauche(VOID)
{
  //***************************************************************
  //* Programme qui définie une séquence de marche typique
  //* du robot en avant. Chaque pattes avancent les unes
  //* aprés les autres puis le robot avance en poussant
  //* sur toutes ses pattes vers l'arriere. Autre solution
  //* à envisager:lorsque une patte avance et est en l'air,
  //* les autres poussent le robot vers l'avant.
  //***************************************************************
  servo (3, 250, 400, 20);
  servo (2, 180, 400, 20);
  servo (3, 50, 400, 0);

  servo (1, 250, 400, 20);
  servo (7, 120, 400, 20);
  servo (1, 120, 400, 0);

  servo (9, 10, 400, 20);
  servo (10, 100, 400, 20);
  servo (9, 170, 400, 0);

  servo (8, 10, 400, 20);
  servo (6, 230, 400, 20);
  servo (8, 190, 400, 0);

  servo (10, 10, 20, 0);
  servo (6, 140, 20, 0);
  servo (7, 10, 20, 0);
  servo (2, 100, 20, 0);
  delay_ms (250);
  servo (10, 10, 0, 20);
  servo (6, 140, 0, 20);
  servo (7, 10, 0, 20);
  servo (2, 100, 0, 20);


}
VOID filo(VOID)
{

  int8 a,b;
      a=0;
      set_adc_channel(0);
      delay_us(20);
      a=read_adc();

      b=0;
      set_adc_channel(1);
      delay_us(20);
      b=read_adc();

      IF (a>=187){marche_avant();}
      IF (a<=62){marche_arriere();}
      IF (b>=187){tourne_gauche();}
      IF (b<=62){tourne_droite();}
}

VOID tourel(VOID)
{
  //****************************************************************
  //* On effectue ici un test pour savoir d'où vient la lumiere.
  //* La tourelle va indiquer le sens de la source lumineuse la
  //* plus forte et va pointer sur cette direction .
  //****************************************************************
  servo (4, 10, 600, 20);    // regarde a droite
  servo (4, 110, 600, 20);  // regarde a gauche

  IF (input (PIN_D2) == 1){servo (4, 10, 1000, 20);}
  IF (input (PIN_D2) == 0){servo (4, 110, 1000, 20);}

  //fin de test retour a l'état initial
  servo (4, 60, 1000, 20);
  // fin de REI; signal de fin
  signal (880);
}


VOID main()
{
  int8 i=1,c,d,g;

  setup_adc_ports (AN0_AN1_AN2_AN3_AN4);
  setup_adc (ADC_CLOCK_INTERNAL);
  setup_psp (PSP_DISABLED);
  setup_timer_0 (RTCC_INTERNAL|RTCC_DIV_1);
  setup_timer_1 (T1_DISABLED);
  setup_timer_2 (T2_DISABLED, 0, 1);

  set_TRIS_B (0x00);
  init_i2c (0, 0x02, 0x44);

  init ();
  tourel();

  while(1)
  {
  marche_avant();

  c=0;
  set_adc_channel(2);
  delay_us(20);
  c=read_adc();

  if (c>=100)
  {
  servo (4, 10, 1500, 20);    // regarde a droite
  d=0;
  set_adc_channel(2);
  delay_us(20);
  d=read_adc();

  servo (4, 110, 1500, 20);  // regarde a gauche
  g=0;
  set_adc_channel(2);
  delay_us(20);
  g=read_adc();

  servo (4, 60, 1000, 20);

      IF (d>=g)
      {signal(262);signal(784);marche_arriere();marche_arriere();
        while(i!=4){tourne_gauche();i=i+1;}
        i=1;signal(784);signal(784);
      }
      IF (g>=d)
      {signal(784);signal(262);marche_arriere();marche_arriere();
        while(i!=4){tourne_droite();i=i+1;}
        i=1;signal(784);signal(784);
      }
  }
  }
  }
Nadar
Nadar
Admin

Nombre de messages : 220
Date d'inscription : 10/07/2008

Voir le profil de l'utilisateur http://robotique-iut.forum-actif.eu

Revenir en haut Aller en bas

Re: Codage sur le robot

Message par Shindara le Sam 9 Aoû - 13:03

Ya toujours un probleme de registre comment et quoi mettre pour benificier d"une largeur d'angle importante??


Et aussi j'ai bien compris le principe mais les fonction que tu fait appelle ne boucle pas n'ayant pas de while ou de boucle de repetition comment sa marche.

par exemple:

VOID servo(INT8 s,INT8 a,INT16 T1,int16 T0)
{
IF (T1 != 0)
{
i2c_start ();
i2c_write (0xC2); //* adresse du SD20
i2c_write (s); //* registre : selection du servomoteur
i2c_write (a); //* angle en rotation
i2c_stop ();
delay_ms (T1);
}

IF (T0 != 0)
{
i2c_start ();
i2c_write (0xC2); //* adresse du SD20
i2c_write (s); //* registre : selection du servomoteur
i2c_write (0); //* angle en rotation
i2c_stop ();
delay_ms (T0);
}
}

bon sa c la fonction ou tu déclare tes valeurs et ou tu va ten servir daccord mes la fonction va effectuer q'un cycle???
si non pourquoi?? soit preci ^^

VOID marche_avant(VOID)
{
servo (9, 5, 500, 20);

servo (10, 100, 20, 0);
servo (6, 200, 20, 0);
servo (7, 120, 20, 0);
servo (2, 154, 20, 0);
delay_ms(250);
servo (10, 100, 0, 20);
servo (6, 200, 0, 20);
servo (7, 120, 0, 20);
servo (2, 154, 0, 20);

servo (9, 170, 500, 0);


servo (1, 250, 500, 20);

servo (10, 70, 20, 0);
servo (6, 170, 20, 0);
}

la c la fonction de la marche et renvoi les valeur qui vont sur la fonction davant mes ya toujours un problème je vois pas le coter répétitif de la fonction.

En gros pourquoi te fonction se repete alors qu'elle devrai etre effectuer q'une seul fois et aussi comment tu choisi te delay sacant que tu met 20 pour etre synchro et 500 pour laisser un petit laps de temp avant un autre mouvement important.

explique moi jsute sa et soit preci??

Noubli pas la premier question avec les registre

Merci merci
Shindara
Shindara
Admin

Nombre de messages : 49
Date d'inscription : 16/07/2008

Voir le profil de l'utilisateur

Revenir en haut Aller en bas

Re: Codage sur le robot

Message par Nadar le Sam 9 Aoû - 15:06

beaucoup de question dont les réponses ne sont pas simple ^^

- Le registre :

Pour augmenter le débattement il suffit de modifier les valeur qui sont mises dans la fonction "init_i2c()" qui est la suivante :

Code:
VOID init_i2c(INT8 r21,INT8 r22,INT8 r23)
{
  //***************************************************************************
  //*      Etablissement des débattements et des departs d'impulsion pour
  //*                      l'ensemble des servomoteurs
  //*
  //* Registre 21: definie la LONGueur maximum de l'impulsion a envoyer.
  //* C'est le débattement
  //* Range Width (uS) = (255 * 256) / Reg21
  //* Registres 22:23 :Le couple 22:23 determine l'impulsion qui DOnne le 0°
  //* du servomoteur.
  //* Le registre 22 est le poids FORt et le registre 23 le poids faible en
  //* hexadecimal
  //* Pulse Width (uS) = ( (255 * 256) / Reg21) + (Reg22:23 + 20)
  //***************************************************************************
  i2c_start ();
  i2c_write (0xC2); //* adresse du SD20
  i2c_write (21); //* registre 21 : largeur max d'impulsion
  i2c_write (r21);
  delay_ms (20);
  i2c_stop ();
  delay_ms (100);

  IF (r21 != 0)
  {
      i2c_start ();
      i2c_write (0xC2); //* adresse du SD20
      i2c_write (22); //* registre 22 : debut de l'impulsion (poids FORt)
      i2c_write (r22);
      delay_ms (20);
      i2c_stop ();
      delay_ms (100);
      i2c_start ();
      i2c_write (0xC2); //* adresse du SD20
      i2c_write (23); //* registre 23 : debut de l'impulsion (poids faibles)
      i2c_write (r23);
      delay_ms (20);
      i2c_stop ();
      delay_ms (100);
  }
}

Il faudrat refaire des test avec un oscilloscope et tout le tatoint pour déterminer des angles de butés. Vila , c'est la seul chose a faire. sachant que grace a cette fonction on pourras toujours attacher a chaque servomoteur une configuration qui lui est propre , mais je croi que se sera inutile.
Nadar
Nadar
Admin

Nombre de messages : 220
Date d'inscription : 10/07/2008

Voir le profil de l'utilisateur http://robotique-iut.forum-actif.eu

Revenir en haut Aller en bas

Re: Codage sur le robot

Message par Nadar le Sam 9 Aoû - 15:22

- La fonction "servo()"

D'abord le code :

Code:
VOID servo(INT8 s,INT8 a,INT16 T1,int16 T0)
{
IF (T1 != 0)
{
i2c_start ();
i2c_write (0xC2); //* adresse du SD20
i2c_write (s); //* registre : selection du servomoteur
i2c_write (a); //* angle en rotation
i2c_stop ();
delay_ms (T1);
}

IF (T0 != 0)
{
i2c_start ();
i2c_write (0xC2); //* adresse du SD20
i2c_write (s); //* registre : selection du servomoteur
i2c_write (0); //* angle en rotation
i2c_stop ();
delay_ms (T0);
}
}

Explications :

Pour faire marcher un moteur je doit envoyer le code suivant au sd20:
Code:
IF (T1 != 0)
{
i2c_start ();
i2c_write (0xC2); //* adresse du SD20
i2c_write (s); //* registre : selection du servomoteur
i2c_write (a); //* angle en rotation
i2c_stop ();
delay_ms (T1);
}
La variable "s" determine le numero du servomoteur a faire bouger et la variable "a" determine l'angle de rotation. Vient ensuite la variable "T1" qui determine la durée pendant laquelle le servomoteur va bouger sachant que tant que cette durée n'est pas terminé , aucun servomoteur autre ne peut bouger . La valeur minimal de cette variable est 20 ( 20 ms).
Remarque la branche en "IF" qui permet de passer a l'étape suivante si la valeur de durée est nul.

Suis ensuite le code suivant :
Code:
IF (T0 != 0)
{
i2c_start ();
i2c_write (0xC2); //* adresse du SD20
i2c_write (s); //* registre : selection du servomoteur
i2c_write (0); //* angle en rotation
i2c_stop ();
delay_ms (T0);
}
Ce code est similaire au précedent a ceci prét qu'il a été rajouter dans l'unique but de désactiver les servomoteur. La variable "s" corespond encore au numero du servomoteur mais la variable d'angle a été passé a 0 ( désactivation du servomoteur donc le servomoteur est libre et ne consomme pas de courant ). Pour fonctionner il faut que la durée de la désactivation du servo ( "T0" ) soit égale au minimum a 20ms.
Remarque également la branche en "IF" qui permet de désactiver cette fonction si la durée T0 est nul.

PROBLEME : Comment faire fonctionner plusieur servo en meme temps ? En utilisant la technique suivante :
Code:
servo(1,165,20,0);
servo(2,165,20,0);

delay_ms(300);

servo(1,0,0,20);
servo(2,0,0,20);
Que fait le code suivant ?
Le principe est basé sur le fait que lorsque l'on envoie une demande d'angle sans désactivation du servomoteur pendant un temps minimum de 20ms , le servomoteur continue de tourner jusqu'a ce qu'il ais effectué son angle , et il le conservera jusqu'a une autre commande ou jusqu'a ce qu'il soit désactivé.C'est le principe que j'utilise.
Le servomoteur 1 et 2 recoivent une information d'angle pratiquement en meme temps ( a 20ms de difference ) . Puis on attend 300 ms ( delay_ms(300) ) avant de désactiver les servomoteur la aussi a 20 ms de difference .

La valeur du delay est determiné a l'arrache si on peut dire . J'ai commencé a mettre des delays extremement long , puis j'ai diminué jusqu'a obtenir un bon compromis.

La fonction en se repete pas puisque elle n'en a pas besoin : on ne demande un ordre a un servomoteur que un par un . Ce sera la fonction marche qui va assurée le bouclage par l'intermédiaire de la fonction main decrite juste aprés.
Nadar
Nadar
Admin

Nombre de messages : 220
Date d'inscription : 10/07/2008

Voir le profil de l'utilisateur http://robotique-iut.forum-actif.eu

Revenir en haut Aller en bas

Re: Codage sur le robot

Message par Nadar le Sam 9 Aoû - 15:41

-La fonction "main()"

C'est le coeur du programme ! sans elle toutes les fonctions décritent precedemment sont inutiles ! Voici le code ( ATTENTION , ce code contient également les code pour la gestion de l'Infrarouge donc pas de panique ^^):
Code:
VOID main()
{
  int8 i=1,c,d,g;

  setup_adc_ports (AN0_AN1_AN2_AN3_AN4);
  setup_adc (ADC_CLOCK_INTERNAL);
  setup_psp (PSP_DISABLED);
  setup_timer_0 (RTCC_INTERNAL|RTCC_DIV_1);
  setup_timer_1 (T1_DISABLED);
  setup_timer_2 (T2_DISABLED, 0, 1);

  set_TRIS_B (0x00);
  init_i2c (0, 0x02, 0x44);

  init ();
  tourel();

  while(1)
  {
  marche_avant();

  c=0;
  set_adc_channel(2);
  delay_us(20);
  c=read_adc();

  if (c>=100)
  {
  servo (4, 10, 1500, 20);    // regarde a droite
  d=0;
  set_adc_channel(2);
  delay_us(20);
  d=read_adc();

  servo (4, 110, 1500, 20);  // regarde a gauche
  g=0;
  set_adc_channel(2);
  delay_us(20);
  g=read_adc();

  servo (4, 60, 1000, 20);

      IF (d>=g)
      {signal(262);signal(784);marche_arriere();marche_arriere();
        while(i!=4){tourne_gauche();i=i+1;}
        i=1;signal(784);signal(784);
      }
      IF (g>=d)
      {signal(784);signal(262);marche_arriere();marche_arriere();
        while(i!=4){tourne_droite();i=i+1;}
        i=1;signal(784);signal(784);
      }
  }
  }
  }
Deriere ce code qui peut paraitre barbare , le principe est trés simple. Remarque que je n'expliquerais pas l'infrarouge dans cette partie .

Etape 1 : On déclare les variables et on configure les fusibles ( je croi mais de toute facon tout est géré par PICC )
Code:
int8 i=1,c,d,g;

  setup_adc_ports (AN0_AN1_AN2_AN3_AN4);
  setup_adc (ADC_CLOCK_INTERNAL);
  setup_psp (PSP_DISABLED);
  setup_timer_0 (RTCC_INTERNAL|RTCC_DIV_1);
  setup_timer_1 (T1_DISABLED);
  setup_timer_2 (T2_DISABLED, 0, 1);

  set_TRIS_B (0x00);
Rien a dire sur cette partie du code , rien que du classique !

Etape 2:Initialisation du robot.
Code:
init_i2c (0, 0x02, 0x44);

  init ();
  tourel();
Cette partie du code fait appel a trois fonctions:
init_i2c() : initialisation des débattement pour les servomoteurs
init() : initialisation du robot ; on remet le robot dans une position d'équilibre optimal pour commencer la marche
tourel() : fonction suplémentaire qui fait juste tourner la tete dans les deux sens et s'orienté en fonction de la luminosité la plus forte ( pas encore géré par le robot)

Etape 3: La marche !
Code:
while(1)
  {
  marche_avant();
  }
Ce code n'est pas exactement celui que tu trouvera au dessus mais résume clairement l'idée général. On boucle indéfiniment sur la fonction marche avant ! Le code que tu voit aprés gere juste la détection des obstacles par infrarouge . Le principe est le suivant :
On marche en avant . Si un obstacle se présente devant nous on stop le robot. On tourne la tete a droit et a gauche pour déterminer la distance la plus longue et la plus courte qui nous sépare de l'obstacle qui est devant nous . On recule et on tourne dans le sens opposé a celui duquel on a relevé la distance la plus proche ( cela veut dire par exemple que le robot et plus proche de l'obstacle a droite que a gauche, donc on tourne a gauche ), puis on reboucle en faisant une marche avant.

J'espere que tu a tout saisi , sinon n'hesite pas surtout !
Nadar
Nadar
Admin

Nombre de messages : 220
Date d'inscription : 10/07/2008

Voir le profil de l'utilisateur http://robotique-iut.forum-actif.eu

Revenir en haut Aller en bas

Re: Codage sur le robot

Message par Shindara le Sam 9 Aoû - 21:00

J'ai compris:

VOID servo(INT8 s,INT8 a,INT16 T1,int16 T0)

alors j'ai touts compris a pars une petit chose tu boucle dans le main la fonction marche et elle renvoi des donner a chaque fois dans le void servo mes par contre le void servo n'est pas bouclier donc n'est pas effectuer car la fonction qui tourne en boucle et la fonction marche et pas la fonctions ervo explique moi ce passage la
Shindara
Shindara
Admin

Nombre de messages : 49
Date d'inscription : 16/07/2008

Voir le profil de l'utilisateur

Revenir en haut Aller en bas

Re: Codage sur le robot

Message par Shindara le Sam 9 Aoû - 22:20

dit moi si je me trompe quand tu fait

void main
{
while(1)
{
marche();
}
}
---------------------------------------------------------

VOID servo(INT8 s,INT8 a,INT16 T1,int16 T0)
{
IF (T1 != 0)
{
i2c_start ();
i2c_write (0xC2); //* adresse du SD20
i2c_write (s); //* registre : selection du servomoteur
i2c_write (a); //* angle en rotation
i2c_stop ();
delay_ms (T1);
}

IF (T0 != 0)
{
i2c_start ();
i2c_write (0xC2); //* adresse du SD20
i2c_write (s); //* registre : selection du servomoteur
i2c_write (0); //* angle en rotation
i2c_stop ();
delay_ms (T0);
}
}


--------------------

VOID marche(VOID)
{
servo (9, 5, 500, 20); en faite apres cette ligne la il va effectuer la fonction servo puis ensuite passer a la ligne suivante??????

servo (10, 100, 20, 0);
servo (6, 200, 20, 0);
servo (7, 120, 20, 0);
}

-------------------


sa fonctionne comme sa??

et aussi tu desactive te servo a chaque fois apre te mouvement pourquoi???
sa peu marcher sans avoir besoin de faire sa????
pour limiter le courant???

repond au question une par une sa me permet de progresse beaucoup et je te remerci de m'aider a chaque fois sur mes question.

sa me permet de me remettre a jour dans la prog du robot.
Shindara
Shindara
Admin

Nombre de messages : 49
Date d'inscription : 16/07/2008

Voir le profil de l'utilisateur

Revenir en haut Aller en bas

Re: Codage sur le robot

Message par Nadar le Dim 10 Aoû - 20:56

SA fonctionne exactement comme sa !! Tu a compris !! la fonction est efectué une fois puis elle passe a la ligne suivant l'apel de la fonction .

Je desactive les servomoteur a chaque fois pour limiter le courant uniquement et pour ne pas user les servomoteur trop vite. Par contre on peut bien sur utiliser sans desactiver les servomoteur . C'est d'ailleur ce que je fait dans mon nouveau programme car comme mes pattes sont plus grande je préfere faire tourner les moteur tous le temps pour ne pas etre géné si les angles sont modifié pendant le course du robot ( c'est trés compliqué a expliqué avec des mots mais en réalité c'est trés simple mais ilfaudrait que tu voi le robot marcher pour sa , je vais essayé de faire une vidéo le plus rapidement possible)

En réalité , cette fonction était trés utilie au début quand je devais limiter mon courant a cause des régulateur. Maintenant elle sert surtout a ne pas bouffer la batterie trop vite et a préserver l'electronique des servomoteur et le nouveau régulateur.

PS: C'est pratique que tu pose des questions, comme sa si je fait une connerie je m'en apercoit et les explications on va pouvoir les réutiliser dans le rapport. Very Happy
Nadar
Nadar
Admin

Nombre de messages : 220
Date d'inscription : 10/07/2008

Voir le profil de l'utilisateur http://robotique-iut.forum-actif.eu

Revenir en haut Aller en bas

Re: Codage sur le robot

Message par Shindara le Mer 13 Aoû - 22:35

int8 var; Tu voi la je declare une variable pour toutes les fonctions jusque la pas de souci.


VOID servo(INT8 s,INT8 a,INT16 T1,int16 T0)
{
IF (T1 != 0)
{
i2c_start ();
i2c_write (0xC2); //* adresse du SD20
i2c_write (s); //* registre : selection du servomoteur
i2c_write (a); //* angle en rotation
i2c_stop ();
delay_ms (T1);
}

IF (T0 != 0)
{
i2c_start ();
i2c_write (0xC2); //* adresse du SD20
i2c_write (s); //* registre : selection du servomoteur
i2c_write (0); //* angle en rotation
i2c_stop ();
delay_ms (T0);
}
}


--------------------

VOID marche(VOID)
{
var=60; ici je met quelque chose dans la variable toujour pas de souci.
servo (9, var, 500, 20);
servo (10, var, 20, 0);
servo (6, var, 20, 0);
servo (7, var, 20, 0);
}


void main
{
while(1)
{
marche(); Voila le souci sa me mark comme message d'erreur (error 12 :Undefined identifier marche)
}
}


Donc voila je voudrai que tu mexplique pourquoi??
je pense que c parce que j utilise des variables dans ma fonction du coup il la reconnait plus dans le main()
Explique moi sa pour regler le problemes.

Sachant que je c que tu ne fait jamais de declaration de variable avant les fonction mes moi sa a toujour marcher.

explique moi pour sa??
si sa marche pas je procede comme sa dit moi si c bon?

main()
{
while(1)
{
marche( 60);
}
}

void marche(int8 var)
{
servo ( 10, var, 50, 200);
servo ( 10, var, 50, 200);
servo ( 10, var, 50, 200);
}


sa c pu classique mes je voudrai surtout savoir pour la methode que jai fait au dessu sa coinse au niveaux de l'appelle de fonction dans le main()
Shindara
Shindara
Admin

Nombre de messages : 49
Date d'inscription : 16/07/2008

Voir le profil de l'utilisateur

Revenir en haut Aller en bas

Re: Codage sur le robot

Message par Shindara le Mer 13 Aoû - 22:43

bon voila jai essayer l'autre methode que j'ai proposer et sa me met la meme erreur jai beau chercher je trouve pas dou sa vien


main()
{
while(1)
{
marche( 60); meme message d'erreur
}
}

void marche(int8 var)
{
servo ( 10, var, 50, 200);
servo ( 10, var, 50, 200);
servo ( 10, var, 50, 200);
}

faut que tu m'aide la je suis bloquer a cette erreur j'ai beau chercher je trouve pas le problemes.

sa un role important ou on place la fonction main()
Shindara
Shindara
Admin

Nombre de messages : 49
Date d'inscription : 16/07/2008

Voir le profil de l'utilisateur

Revenir en haut Aller en bas

Re: Codage sur le robot

Message par Shindara le Jeu 14 Aoû - 14:44

je crois que faut que je mette la fonction main() en dernier sinon il connait pas les variable je pens que c sa
Shindara
Shindara
Admin

Nombre de messages : 49
Date d'inscription : 16/07/2008

Voir le profil de l'utilisateur

Revenir en haut Aller en bas

Re: Codage sur le robot

Message par Nadar le Dim 17 Aoû - 1:56

Je croi qu'il y a une maniere d'utiliser les variables globales mais je ne sais pas comment .
Dans ton cas , tu veut déclarer une variable global "var" mais par experience sa ne marche pasdans une fonction .Pour utiliser une variable dans une fonction , mieu vaut la déclarer en local directement dans la fonction .

Code:
VOID marche(VOID)
{
int8 var;
var=60;
}
Par exemple.

C'est different dans le cas ou tu voudrais renvoyer le contenu de ta variable var dans la fonction main(). Dans ce cas il faudrait faire quelque chose comme sa je pense:



Code:
int8 marche(VOID)
{
int8 var;
var = 60;
return var;
}

Dans ce cas la fonction s'apelerait de cette maniere :

Code:
VOID main()
{
int8 resultat;
resultat=marche();
}

la valeur de la variable "resultat" serait alors dans ce cas 60 ;
Nadar
Nadar
Admin

Nombre de messages : 220
Date d'inscription : 10/07/2008

Voir le profil de l'utilisateur http://robotique-iut.forum-actif.eu

Revenir en haut Aller en bas

Re: Codage sur le robot

Message par Nadar le Dim 17 Aoû - 2:00

Aprés vérification , la position de la fonction main a une importance Very Happy

Essaye ton programme avec la fonction main() a la fin et sa devrait marcher.
Nadar
Nadar
Admin

Nombre de messages : 220
Date d'inscription : 10/07/2008

Voir le profil de l'utilisateur http://robotique-iut.forum-actif.eu

Revenir en haut Aller en bas

Re: Codage sur le robot

Message par Nadar le Jeu 28 Aoû - 2:15

RE !!

Je up ce post en mettant en ligne le nouveau code du robot prés depuis longtemps :
Code:
#include "C:\Users\Nadar\Documents\Scolaire\Projet tut\Robot\PIC\Programme\robot_v1.h"
  #include <stdio.h>
  #ZERO_RAM

  //****************************************************************************
  //*Programme pour robot quadrupede à 2 degrés de liberté pour chaques pattes *
  //*                                                                          *
  //****************************************************************************
  //*                                                                          *
  //*  NOM:robot_v1                                                          *
  //*  DATE(début):27/06/2008                                                *
  //*                                                                          *
  //*  Version : 2.20                                                        *
  //*                                                                          *
  //*  Auteur: NADAR                                                          *
  //*                                                                          *
  //****************************************************************************

VOID init_i2c(INT8 r21,INT8 r22,INT8 r23)
{
  //***************************************************************************
  //*      Etablissement des débattements et des departs d'impulsion pour
  //*                      l'ensemble des servomoteurs
  //*
  //* Registre 21: definie la LONGueur maximum de l'impulsion a envoyer.
  //* C'est le débattement
  //* Range Width (uS) = (255 * 256) / Reg21
  //* Registres 22:23 :Le couple 22:23 determine l'impulsion qui DOnne le 0°
  //* du servomoteur.
  //* Le registre 22 est le poids FORt et le registre 23 le poids faible en
  //* hexadecimal
  //* Pulse Width (uS) = ( (255 * 256) / Reg21) + (Reg22:23 + 20)
  //***************************************************************************
  i2c_start ();
  i2c_write (0xC2); //* adresse du SD20
  i2c_write (21); //* registre 21 : largeur max d'impulsion
  i2c_write (r21);
  delay_ms (20);
  i2c_stop ();
  delay_ms (100);

  IF (r21 != 0)
  {
      i2c_start ();
      i2c_write (0xC2); //* adresse du SD20
      i2c_write (22); //* registre 22 : debut de l'impulsion (poids FORt)
      i2c_write (r22);
      delay_ms (20);
      i2c_stop ();
      delay_ms (100);
      i2c_start ();
      i2c_write (0xC2); //* adresse du SD20
      i2c_write (23); //* registre 23 : debut de l'impulsion (poids faibles)
      i2c_write (r23);
      delay_ms (20);
      i2c_stop ();
      delay_ms (100);
  }
}
VOID servo(INT8 s,INT8 a,INT16 T1,int16 T0)
{
  //**************************************************************************
  //*            Routines d'usages d'un servomoteur
  //* Afin de simplifier et d'alleger le programme, je présente ici
  //* une routine de fonctionnement d'un servomoteur dans laquelle est
  //* inclu l'ensemble du codage I²C pour la gestion d'un servomoteur.
  //* Pour faire fonctionner un servomoteur, l'utilisateur DOit DOnc
  //* entrer 4 variables:les numéro du servo, l'angle à réaliser, la
  //* durée de tenu de l'angle, et la durée de coupure d'un servo.
  //* Si une des durée est égale a 0, la fonction concernée n'est pas
  //* prise en compte ce qui permet de choisir entre la désactivation
  //* d'un servomoteur ou du fonctionnement ou des deux a la fois en
  //* une seul et meme ligne.
  //**************************************************************************
  IF (T1 != 0)
  {
      i2c_start ();
      i2c_write (0xC2); //* adresse du SD20
      i2c_write (s); //* registre : selection du servomoteur
      i2c_write (a); //* angle en rotation
      i2c_stop ();
      delay_ms (T1);
}

  IF (T0 != 0)
  {
      i2c_start ();
      i2c_write (0xC2); //* adresse du SD20
      i2c_write (s); //* registre : selection du servomoteur
      i2c_write (0); //* angle en rotation
      i2c_stop ();
      delay_ms (T0);
}
}

VOID signal(int32 n)
{
  //**************************************************************************
  //* Signal lumineux et sonore
  //* Prevu pour signaler un probleme ou la fin d'une
  //* action en cour. L'usage le plus important est au
  //* début du programme pour signaler un eventuel
  //* rebootage du PIC.
  //**************************************************************************
  int32 i=0;
  int32 x=0;
  //beeper et signal lumineux
  n=1000000/n;
  x=200000/n;
  n=n/2;

  WHILE (i<=x)
  {
      output_high (PIN_B5);
      delay_us (n);
      output_low (PIN_B5);
      delay_us (n);
      i=i+1;
  }
  delay_ms (200);
  i=0;
  x=0;
  //fin beeper et signal lumineux
}

VOID init(VOID)
{
  //**************************************************************************
  //* Reglage à la position initial
  //* On regle les pattes sur leurs position initial
  //* afin de ne pas avoir de probleme lors des
  //* séquences de marche.
  //**************************************************************************

  signal(880);

  servo (10, 10, 20, 0);
  servo (6, 230, 20, 0);
  servo (7, 10, 20, 0);
  servo (2, 100, 20, 0);
  delay_ms(300);
  servo (10, 10, 0, 20);
  servo (6, 230, 0, 20);
  servo (7, 10, 0, 20);
  servo (2, 100, 0, 20);

  servo (9, 170, 500, 20);
  servo (8, 190, 500, 20);
  servo (1, 120, 500, 20);
  servo (3, 50, 500, 20);

  signal(880);

  servo (4, 10, 600, 20);    // regarde a droite
  servo (4, 110, 600, 20);  // regarde a gauche
  servo (4, 60, 1000, 20);  // regarde au centre
  signal (880);// fin de REI; signal de fin

  //Fin de reglage
}
VOID marche_arriere(VOID)
{
  //**************************************************************************
  //* Programme qui définie une séquence de marche typique
  //* du robot en arriere.lorsque une patte avance et est en l'air,
  //* les autres poussent le robot vers l'arriere.
  //**************************************************************************

  servo (9, 5, 300, 20);

  servo (10, 10, 20, 0);
  servo (6, 170, 20, 0);
  servo (7, 10, 20, 0);
  servo (2, 127, 20, 0);
  delay_ms(250);
  servo (10, 10, 0, 20);
  servo (6, 200, 0, 20);
  servo (7, 120, 0, 20);
  servo (2, 154, 0, 20);

  servo (9, 170, 300, 0);


  servo (1, 250, 300, 20);

  servo (10, 40, 20, 0);
  servo (6, 200, 20, 0);
  servo (7, 120, 20, 0);
  servo (2, 100, 20, 0);
  delay_ms(250);
  servo (10, 70, 0, 20);
  servo (6, 170, 0, 20);
  servo (7, 10, 0, 20);
  servo (2, 180, 0, 20);

  servo (1, 120, 300, 0);


  servo (3, 250, 300, 20);

  servo (10, 70, 20, 0);
  servo (6, 230, 20, 0);
  servo (7, 84, 20, 0);
  servo (2, 180, 20, 0);
  delay_ms(250);
  servo (10, 40, 0, 20);
  servo (6, 140, 0, 20);
  servo (7, 47, 0, 20);
  servo (2, 100, 0, 20);

  servo (3, 50, 300, 0);


  servo (8, 10, 300, 20);

  servo (10, 100, 20, 0);
  servo (6, 140, 20, 0);
  servo (7, 47, 20, 0);
  servo (2, 154, 20, 0);
  delay_ms(250);
  servo (10, 10, 0, 20);
  servo (6, 230, 0, 20);
  servo (7, 84, 0, 20);
  servo (2, 127, 0, 20);

  servo (8, 190, 300, 0);



}
VOID tourne_droite(VOID)
{
  //**************************************************************************
  //* Programme qui définie une séquence de marche typique
  //* du robot en avant. Chaque pattes avancent les unes
  //* aprés les autres puis le robot avance en poussant
  //* sur toutes ses pattes vers l'arriere. Autre solution
  //* à envisager:lorsque une patte avance et est en l'air,
  //* les autres poussent le robot vers l'avant.
  //**************************************************************************


  servo (9, 10, 400, 20);
  servo (10, 10, 400, 20);
  servo (9, 170, 400, 0);

  servo (8, 10, 400, 20);
  servo (6, 140, 400, 20);
  servo (8, 190, 400, 0);

  servo (1, 250, 400, 20);
  servo (7, 10, 400, 20);
  servo (1, 120, 400, 0);

  servo (3, 250, 400, 20);
  servo (2, 100, 400, 20);
  servo (3, 50, 400, 0);

  servo (10, 100, 20, 0);
  servo (6, 230, 20, 0);
  servo (7, 120, 20, 0);
  servo (2, 180, 20, 0);
  delay_ms (250);
  servo (10, 100, 0, 20);
  servo (6, 230, 0, 20);
  servo (7, 120, 0, 20);
  servo (2, 180, 0, 20);

}
Nadar
Nadar
Admin

Nombre de messages : 220
Date d'inscription : 10/07/2008

Voir le profil de l'utilisateur http://robotique-iut.forum-actif.eu

Revenir en haut Aller en bas

Re: Codage sur le robot

Message par Nadar le Jeu 28 Aoû - 2:16

Et la suite !!!

Code:

VOID tourne_gauche(VOID)
{
  //**************************************************************************
  //* Programme qui définie une séquence de marche typique
  //* du robot en avant. Chaque pattes avancent les unes
  //* aprés les autres puis le robot avance en poussant
  //* sur toutes ses pattes vers l'arriere. Autre solution
  //* à envisager:lorsque une patte avance et est en l'air,
  //* les autres poussent le robot vers l'avant.
  //**************************************************************************
  servo (3, 250, 400, 20);
  servo (2, 180, 400, 20);
  servo (3, 50, 400, 0);

  servo (1, 250, 400, 20);
  servo (7, 120, 400, 20);
  servo (1, 120, 400, 0);

  servo (9, 10, 400, 20);
  servo (10, 100, 400, 20);
  servo (9, 170, 400, 0);

  servo (8, 10, 400, 20);
  servo (6, 230, 400, 20);
  servo (8, 190, 400, 0);

  servo (10, 10, 20, 0);
  servo (6, 140, 20, 0);
  servo (7, 10, 20, 0);
  servo (2, 100, 20, 0);
  delay_ms (250);
  servo (10, 10, 0, 20);
  servo (6, 140, 0, 20);
  servo (7, 10, 0, 20);
  servo (2, 100, 0, 20);


}

INT8 clavier(VOID)
{
/*
*******************************************************************************
            FONCTION GESTION D'UN CLAVIER MATRICIEL 12 TOUCHES

Cette fonction réalise la gestion d'un clavier matriciel 12 touches dans le but
de selectionner ou de faire des réglages lorsque le robot est en marche.
Il pourra etre couplé avec un ecran LCD afin d'accéder a une meilleur
lisibilité des modes selectionnés.
Cette fonction renvoi un nombre compris entre 0 et 250. Le bon fonctionnement
du clavier est annoncé par des sons provenant du buzzer.

*******************************************************************************
*/
int8 pr=1,cen,diz,num=22;
while (num==22)
{
    output_high (PIN_D2);
    delay_ms(50);
      //if (input (PIN_D3) == 1){num=2; }
      if (input (PIN_D4) == 1){num=5; }
      if (input (PIN_D5) == 1){num=8; }
      if (input (PIN_D6) == 1){num=0; }
    output_low (PIN_D2);
    output_high (PIN_D1);
    delay_ms(50);
      if (input (PIN_D3) == 1){num=1; }
      if (input (PIN_D4) == 1){num=4; }
      if (input (PIN_D5) == 1){num=7; }
      if (input (PIN_D6) == 1){num=10; }
    output_low (PIN_D1);
    output_high (PIN_D0);
    delay_ms(50);
      if (input (PIN_D3) == 1){num=3; }
      if (input (PIN_D4) == 1){num=6; }
      if (input (PIN_D5) == 1){num=9; }
      if (input (PIN_D6) == 1){num=11; }
    output_low (PIN_D0);

    if (pr==1 && num!=22){cen=num*100;pr=2;num=22;signal(400);delay_ms(500);}
    if (pr==2 && num!=22){diz=num*10;pr=3;num=22;signal(400);delay_ms(500);}
    if (pr==3 && num!=22){num=num+cen+diz;signal(400);delay_ms(500);}
}

return (num);

}
VOID infra(VOID)
{
/******************************************************************************

        FONCTION DE DETECTION DES OBSTACLES PAR INFRAROUGE

Cette fonction permet la detection des obstacles par infrarouge via le
detecteur GP2D12 en utilisant le port analogique du PIC.Elle gere les obstacles
venant de devant et ceux de gauche et de droite.Elle se termine uniquement
lorsque tous les obstacles avec lesquels le robot peut entrer en collision
sont évité.
Le robot effectue une premiere detection des obstacles vers l'avant.Si un
obstacle est présent, il effectue une detection d'obstacles a gauche et a
droite. Il choisi de tourner vers la direction ou l'obstacle est le plus loin.
Aprés sa rotation, il effectue une seconde verification a gauche et a droite
afin de vérifier qu'il a bien éviter l'obstacle détecté. Si ce n'est pas le cas
les étapes précédente sont répété 4 fois jusqu'a ce que le robot ais trouvé
une solution convenable. Si il y a toujours présence d'obstacle, alors le robot
effectue un demi tour sur lui meme et reprend sa marche normal.

*******************************************************************************

*/
  int8 c,d,g,IR=0,i,foi=0;

  while(foi!=5)
  {

  c=0;
  set_adc_channel(2);
  delay_us(20);
  c=read_adc();

  if (c<=50&&foi==0)
  {
  foi=5;
  }

  if (c>=50 && foi<=4 || foi>=1 && foi<=4)
  {
  foi=foi+1;

  servo (4, 10, 1500, 20);    // regarde a droite
  d=0;
  set_adc_channel(2);
  delay_us(20);
  d=read_adc();

  servo (4, 110, 1500, 20);  // regarde a gauche
  g=0;
  set_adc_channel(2);
  delay_us(20);
  g=read_adc();

  servo (4, 60, 1000, 20);  //retour a l'etat initial

  IF(d>=g){IR=1;}
  IF(g>=d){IR=2;}
  IF(d<=50&&g<=50){foi=5;}

  }
  if (foi==4)
  {
  IR=3;
  foi=5;
  }

      IF (IR==1)
      {signal(262);signal(784);tourne_gauche();
        IR=0;
      }
      IF (IR==2)
      {signal(784);signal(262);tourne_droite();
        IR=0;

      }
      IF (IR==3)
      {signal(784);signal(784);signal(262);signal(784);for(i=1;i<=8;i++){tourne_gauche();}
        IR=0;

      }
  }

}
VOID marche_avant(VOID)
{
  //**************************************************************************
  //* Programme qui définie une séquence de marche typique
  //* du robot en avant.lorsque une patte avance et est en l'air,
  //* les autres poussent le robot vers l'avant.
  //**************************************************************************
  servo (9, 5, 500, 20);

  servo (10, 100, 20, 0);
  servo (6, 200, 20, 0);
  servo (7, 120, 20, 0);
  servo (2, 154, 20, 0);
  delay_ms(250);
  servo (10, 100, 0, 20);
  servo (6, 200, 0, 20);
  servo (7, 120, 0, 20);
  servo (2, 154, 0, 20);

  servo (9, 170, 500, 0);

  infra();

  servo (1, 250, 500, 20);

  servo (10, 70, 20, 0);
  servo (6, 170, 20, 0);
  servo (7, 10, 20, 0);
  servo (2, 180, 20, 0);
  delay_ms(250);
  servo (10, 70, 0, 20);
  servo (6, 170, 0, 20);
  servo (7, 10, 0, 20);
  servo (2, 180, 0, 20);

  servo (1, 120, 500, 0);

  infra();

  servo (3, 250, 500, 20);

  servo (10, 40, 20, 0);
  servo (6, 140, 20, 0);
  servo (7, 47, 20, 0);
  servo (2, 100, 20, 0);
  delay_ms(250);
  servo (10, 40, 0, 20);
  servo (6, 140, 0, 20);
  servo (7, 47, 0, 20);
  servo (2, 100, 0, 20);

  servo (3, 50, 500, 0);

  infra();

  servo (8, 10, 500, 20);

  servo (10, 10, 20, 0);
  servo (6, 230, 20, 0);
  servo (7, 84, 20, 0);
  servo (2, 127, 20, 0);
  delay_ms(250);
  servo (10, 10, 0, 20);
  servo (6, 230, 0, 20);
  servo (7, 84, 0, 20);
  servo (2, 127, 0, 20);

  servo (8, 190, 500, 0);

  infra();
}
VOID filo(VOID)
{
  //**************************************************************************
  //*                    FONCTION DE GUIDAGE MANUEL
  //*Fonction qui permet de controler le robot grace a un joystick branché sur
  //*le port analogique du microcontroleur sur A0 et A1 .
  //*Cette fonction est surtout utile pour tester des séquences de marches et
  //*des situations spéciales : en effet elle utilise la fonction
  //*marche_avant() qui inclue la detection d'obstacle.
  //**************************************************************************
  int8 a,b;
      a=0;
      set_adc_channel(0);
      delay_us(20);
      a=read_adc();

      b=0;
      set_adc_channel(1);
      delay_us(20);
      b=read_adc();

      IF (a>=187){marche_avant();}
      IF (a<=62){marche_arriere();}
      IF (b>=187){tourne_gauche();}
      IF (b<=62){tourne_droite();}
}
VOID main()
{
      int8 mode;

  setup_adc_ports (AN0_AN1_AN2_AN3_AN4);
  setup_adc (ADC_CLOCK_INTERNAL);
  setup_psp (PSP_DISABLED);
  setup_timer_0 (RTCC_INTERNAL|RTCC_DIV_1);
  setup_timer_1 (T1_DISABLED);
  setup_timer_2 (T2_DISABLED, 0, 1);

  set_TRIS_B (0x00);
  set_TRIS_D (0xF8);

  init_i2c (0, 0x02, 0x44);
  init ();

  mode=clavier();

  if (mode==1){while(1){marche_avant();}}
  if (mode==10){while(1){filo();}}

  }
Nadar
Nadar
Admin

Nombre de messages : 220
Date d'inscription : 10/07/2008

Voir le profil de l'utilisateur http://robotique-iut.forum-actif.eu

Revenir en haut Aller en bas

Re: Codage sur le robot

Message par Nadar le Jeu 28 Aoû - 2:23

1 er question : mais qu'elles sont les modifications apporté ?

- Intégration d'un clavier 12 touches pour modes de fonctionnements
- Modification de la détection d'obstacle et de la gestion des mouvement

Pourquoi cette dernière modification ?

Pour la petite histoire j'ai laissé fonctionné le robot pendant 20 min avec le programme précedent. Il devait éviter des obstacles et séloigner d'eux dans le sens opposé. Trés simple mais il s'est fait piégé par le test du " coin " !!! Lorsque le robot est confronté a un coin dans une piéce , il n'est plus capable de prendre une bonne décision sur la direction a prendre et reste coincé dans le coin !!

Donc modification du codage : augmentation de la distance de détection et nouvelle maniere d'eviter les obstacles . Tout est expliqué dans le code mais je remet ici la partie interessante :

Code:
VOID infra(VOID)
{
/******************************************************************************

        FONCTION DE DETECTION DES OBSTACLES PAR INFRAROUGE

Cette fonction permet la detection des obstacles par infrarouge via le
detecteur GP2D12 en utilisant le port analogique du PIC.Elle gere les obstacles
venant de devant et ceux de gauche et de droite.Elle se termine uniquement
lorsque tous les obstacles avec lesquels le robot peut entrer en collision
sont évité.
Le robot effectue une premiere detection des obstacles vers l'avant.Si un
obstacle est présent, il effectue une detection d'obstacles a gauche et a
droite. Il choisi de tourner vers la direction ou l'obstacle est le plus loin.
Aprés sa rotation, il effectue une seconde verification a gauche et a droite
afin de vérifier qu'il a bien éviter l'obstacle détecté. Si ce n'est pas le cas
les étapes précédente sont répété 4 fois jusqu'a ce que le robot ais trouvé
une solution convenable. Si il y a toujours présence d'obstacle, alors le robot
effectue un demi tour sur lui meme et reprend sa marche normal.

*******************************************************************************

*/
  int8 c,d,g,IR=0,i,foi=0;

  while(foi!=5)
  {

  c=0;
  set_adc_channel(2);
  delay_us(20);
  c=read_adc();

  if (c<=50&&foi==0)
  {
  foi=5;
  }

  if (c>=50 && foi<=4 || foi>=1 && foi<=4)
  {
  foi=foi+1;

  servo (4, 10, 1500, 20);    // regarde a droite
  d=0;
  set_adc_channel(2);
  delay_us(20);
  d=read_adc();

  servo (4, 110, 1500, 20);  // regarde a gauche
  g=0;
  set_adc_channel(2);
  delay_us(20);
  g=read_adc();

  servo (4, 60, 1000, 20);  //retour a l'etat initial

  IF(d>=g){IR=1;}
  IF(g>=d){IR=2;}
  IF(d<=50&&g<=50){foi=5;}

  }
  if (foi==4)
  {
  IR=3;
  foi=5;
  }

      IF (IR==1)
      {signal(262);signal(784);tourne_gauche();
        IR=0;
      }
      IF (IR==2)
      {signal(784);signal(262);tourne_droite();
        IR=0;

      }
      IF (IR==3)
      {signal(784);signal(784);signal(262);signal(784);for(i=1;i<=8;i++){tourne_gauche();}
        IR=0;

      }
  }

}

Voila , si tu a des questions n'hésite pas !!
Nadar
Nadar
Admin

Nombre de messages : 220
Date d'inscription : 10/07/2008

Voir le profil de l'utilisateur http://robotique-iut.forum-actif.eu

Revenir en haut Aller en bas

Re: Codage sur le robot

Message par Contenu sponsorisé


Contenu sponsorisé


Revenir en haut Aller en bas

Revenir en haut

- Sujets similaires

 
Permission de ce forum:
Vous ne pouvez pas répondre aux sujets dans ce forum