Aller au contenu


Photo
- - - - -

Robot Cylon

Débuté par Bobbyshoot, mai 26 2009 10:18

42 réponses à ce sujet

#21 webshinra

webshinra

    Membre passionné

  • Membres
  • PipPipPip
  • 510 messages

Posté 30 mai 2009 - 10:46

hum, normalement, on ne peut pas mettre de binaire dans du code C, il faut convertir en hexadecimal ( 0xff par exemple) (ouais 0b, ça marche peut etre (pas partout en tout cas), mais c'est pas standard alors, on l'utilise pas).
et hum, tu n'aurais pas une version de tes erreurs, avec les retours a la ligne, là, c'est clairement illisible.

#22 Bobbyshoot

Bobbyshoot

    Membre occasionnel

  • Membres
  • Pip
  • 140 messages

Posté 30 mai 2009 - 01:07

Toute façon il m'indique pas d'erreur à ce niveau donc c'est que ça doit pas poser de problème.

Edit : j'ai beaucoup avancé aujourd'hui^^ Pas la peine de chercher les erreurs du programme précédent il sert plus à rien, faut que je fasse un nouveau programme qui marche sur CodeVision.

C'est booooooonnn !! j'ai réussis, j'ai étudier toute la journée la programmation sur Codevision, il est trés bien ce logiciel, on a un aperçu graphique de tout les registres avec l'état des bits et leur utilité c'est vachement bien pour s'y retrouver, donc j'ai fais le programme je l'ai testé sous protéus et c'est niquel il marche! avec la vitesse réglable sur une seule ligne, me reste plus qu'a créé d'autre pattern pour chaque situation par rapport au capteur avec les interuptions externe sur les capteurs jsp que cst possible les deux en même temps, et voilà^^

#23 webshinra

webshinra

    Membre passionné

  • Membres
  • PipPipPip
  • 510 messages

Posté 31 mai 2009 - 11:15

[quote"Harry"]Hmm si les 0b fonctionnent et que c'est plus clair, pourquoi s'en priver ? Je ne suis pas d'accord avec toi sur ce point webshinra, c'est se mettre des batons dans les roues pour se mettre des batons dans les roues.

Par contre +1 pour les erreurs illisibles...[/quote]
que tu soit d'accord ou pas ne change rien, c'est le meme principe que les standard pour le html, tu les respecte pour que ton code puisse marcher partout, c'est le meme principe, si tu utilise des syntaxes gauques, ton code il compileras dans un coin et pas ailleur.

cela importe peu qu'il soit moins facile de lire l'hexa que le binaire pour un port, (en plus, c'est pas du tout comme si l'un etais directement deductible de l'autre avec un tant soit peut d'entrainement).
peut est-ce ma frequentation des certains chan, mais j'avoue que la mentalité du "ça marche donc osef" en informatique, ça me file des boutons, et que se genre de comportement renforce le bordel ambiant au niveau des codes (déjà qu'avec les liberté apporté par les langages dans les type d'indentation c'est la jungle, si on se met a utilisé des syntaxe nouvelle, j'imagine meme pas)

sinon, pour être plus pragmatique Bobbyshoot, tu est sur que faire conrespondre un motif a chaque situation est le mieux? n'a tu pas la possibilité de programmer "tel bout du port doit etre activer dans tel cas, mais tel autre dans tel autre" plutot que préatablir des situation?

#24 Esprit

Esprit

    Pilier du forum

  • Membres
  • PipPipPipPipPip
  • 1 503 messages
  • Gender:Male
  • Location:Belgique

Posté 31 mai 2009 - 11:59

C'est vrai que l'hexa, c'est assez simple... J'ai vu ça en cours cette année.



Puis il y a un tuto aussi : Du binaire vers l'hexadécimal





Je comprends ce que tu essayes d'expliquer. Si tout le monde utilise les mêmes normes, ça permet de s'y retrouver beaucoup plus facilement dans le code de quelqu'un d'autre. C'est plus clean et plus simple pour tout le monde.

#25 Bobbyshoot

Bobbyshoot

    Membre occasionnel

  • Membres
  • Pip
  • 140 messages

Posté 31 mai 2009 - 01:04

[quote"Webshinra"]sinon, pour être plus pragmatique Bobbyshoot, tu est sur que faire conrespondre un motif a chaque situation est le mieux? n'a tu pas la possibilité de programmer "tel bout du port doit etre activer dans tel cas, mais tel autre dans tel autre" plutot que préatablir des situation?[/quote]

bah euh, en fait je sais pas comment on fait, pour l'instant j'experimente avec un pattern pour chaque situation mais, si tu as une idée de comment faire autrement je suis tout ouïe :)

(puis pour le binaire ou hexa toute façon c'est pas le code définitif, pour l'instant c'est en binaire car il faut testé si le déroulement est bon, car si je me trompe d'un bit ou deux ou que j'ai fais un inversion entre le 7 et le 8, c'est plus rapide de modifier ça à la volé que de devoir modifié 30 ligne de code en Hexa, je mettrai l'hexa une fois le programme complet pour le simplifier :) )

Voilà mon code pour l'instant :

Chip type : AT90LS8535
AVR Core Clock frequency: 3,684600 MHz
Memory model : Small
External RAM size : 0
Data Stack size : 128
*****************************************************/

#include <90s8535.h>
unsigned char cTime, cSignal;
// Timer 0 overflow interrupt service routine
interrupt [TIM0_OVF] void timer0_ovf_isr(void)
{
if(cTime++ >=0,85) cSignal=1;

}
unsigned char patternsnormal []= { // la liste des patterns d'allumage des LEDs en temps normal
0b00100011,
0b00100111,
0b00101011,
0b00101111,
0b00100000,
0b00100100,
0b00101000,
0b00101100,
0b00111010,
0b01110010,
0b10110010,
0b11110010,
0b00000010,
0b01000010,
0b10000010,
0b01000010,
0b00000010,
0b11110010,
0b10110010,
0b01110010,
0b00111010,
0b00101100,
0b00101000,
0b00100100,
0b00100000,
0b00101111,
0b00101011,
0b00100111,};
unsigned char pattern = 0 ; // index du pattern courant
unsigned char patternsdroite []= { // la liste des patterns d'allumage des LEDs quand le capteur droite est allumé
0b00100011,
0b00100111,
0b00101011,
0b00101111,
0b00101011,
0b00100111,
0b00100011,};
unsigned char patternsgauche []= { // la liste des patterns d'allumage des LEDs quand le capteur gauche est allumé
0b00000010,
0b01000010,
0b10000010,
0b01000010,
0b00000010,
0b11110010,};
unsigned char patternsgauchehautbas []= { // la liste des patterns d'allumage des LEDs quand le capteur gauche et vertical sont allumés
0b00101100,
0b00111010,
0b01110010,
0b10110010,
0b01110010,
0b00111010,
0b00101100,};
unsigned char patternsdroitehautbas []= { // la liste des patterns d'allumage des LEDs quand le capteur droite et vertical sont allumés
0b00101100,
0b00111010,
0b01110010,
0b10110010,
0b01110010,
0b00111010,
0b00101100,};
// Declare your global variables here

void main(void)
{
// Declare your local variables here
DDRA=0xFF;
PORTA=0x44;
PORTB=0x00;
DDRB=0x00;
PORTC=0x00;
DDRC=0x00;
PORTD=0x00;
DDRD=0x00;

// Timer/Counter 0 initialization
// Clock source: System Clock
// Clock value: 3,598 kHz
TCCR0=0x05;
TCNT0=0x00;

// Timer/Counter 1 initialization
// Clock source: System Clock
// Clock value: Timer 1 Stopped
// Mode: Normal top=FFFFh
// OC1A output: Discon.
// OC1B output: Discon.
// Noise Canceler: Off
// Input Capture on Falling Edge
// Timer 1 Overflow Interrupt: Off
// Input Capture Interrupt: Off
// Compare A Match Interrupt: Off
// Compare B Match Interrupt: Off
TCCR1A=0x00;
TCCR1B=0x00;
TCNT1H=0x00;
TCNT1L=0x00;
OCR1AH=0x00;
OCR1AL=0x00;
OCR1BH=0x00;
OCR1BL=0x00;

// Timer/Counter 2 initialization
// Clock source: System Clock
// Clock value: Timer 2 Stopped
// Mode: Normal top=FFh
// OC2 output: Disconnected
ASSR=0x00;
TCCR2=0x00;
TCNT2=0x00;
OCR2=0x00;

// External Interrupt(s) initialization
// INT0: Off
// INT1: Off
GIMSK=0x00;
MCUCR=0x00;

// Timer(s)/Counter(s) Interrupt(s) initialization
TIMSK=0x01;

// Analog Comparator initialization
// Analog Comparator: Off
// Analog Comparator Input Capture by Timer/Counter 1: Off
ACSR=0x80;

// Global enable interrupts
#asm("sei")

while (1)
{
if(cSignal) // si cSignal est égal à 1
{
cSignal=0;
cTime=0;
PORTA = patternsnormal[pattern];
pattern = (pattern + 1) % sizeof(patternsnormal);
};
}
}[/code]

Voilà, ils fonctionne bien mais, j'arrive pas à faire en sorte que, suivant les niveaux de sorties du capteur ça utilise tel ou tel pattern...

Maintenant j'ai fais ça :

Chip type : AT90LS8535
AVR Core Clock frequency: 3,684600 MHz
Memory model : Small
External RAM size : 0
Data Stack size : 128
*****************************************************/

#include <90s8535.h>
#define CXD PINC.0
#define CXG PINC.1
#define CYD PINC.2
#define CYG PINC.3

unsigned char cTime, cSignal;
// Timer 0 overflow interrupt service routine
interrupt [TIM0_OVF] void timer0_ovf_isr(void)
{
if(cTime++ >=0,85) cSignal=1;

}
unsigned char patternsnormal []= { // la liste des patterns d'allumage des LEDs en temps normal
0b00100011,
0b00100111,
0b00101011,
0b00101111,
0b00100000,
0b00100100,
0b00101000,
0b00101100,
0b00111010,
0b01110010,
0b10110010,
0b11110010,
0b00000010,
0b01000010,
0b10000010,
0b01000010,
0b00000010,
0b11110010,
0b10110010,
0b01110010,
0b00111010,
0b00101100,
0b00101000,
0b00100100,
0b00100000,
0b00101111,
0b00101011,
0b00100111,};
unsigned char pattern = 0 ; // index du pattern courant
unsigned char patternsdroite []= { // la liste des patterns d'allumage des LEDs quand le capteur droite est allumé
0b00100011,
0b00100111,
0b00101011,
0b00101111,
0b00101011,
0b00100111,
0b00100011,};
unsigned char patternsgauche []= { // la liste des patterns d'allumage des LEDs quand le capteur gauche est allumé
0b00000010,
0b01000010,
0b10000010,
0b01000010,
0b00000010,
0b11110010,};
unsigned char patternsgauchehautbas []= { // la liste des patterns d'allumage des LEDs quand le capteur gauche et vertical sont allumés
0b00101100,
0b00111010,
0b01110010,
0b10110010,
0b01110010,
0b00111010,
0b00101100,};
unsigned char patternsdroitehautbas []= { // la liste des patterns d'allumage des LEDs quand le capteur droite et vertical sont allumés
0b00101100,
0b00111010,
0b01110010,
0b10110010,
0b01110010,
0b00111010,
0b00101100,};
unsigned char patternshautbas []= { // la liste des patterns d'allumage des LEDs quand le capteur droite et vertical sont allumés
0b00101000,
0b00101100,
0b00111010,
0b01110010,
0b00111010,
0b00101100,
0b00101000,};
// Declare your global variables here

void main(void)
{
// Declare your local variables here
DDRA=0xFF;
PORTA=0xFF;
PORTB=0x00;
DDRB=0x00;
PORTC=0x00;
DDRC=0x00;
PORTD=0xFF;
DDRD=0x00;

// Timer/Counter 0 initialization
// Clock source: System Clock
// Clock value: 3,598 kHz
TCCR0=0x05;
TCNT0=0x00;

// Timer/Counter 1 initialization
// Clock source: System Clock
// Clock value: Timer 1 Stopped
// Mode: Normal top=FFFFh
// OC1A output: Discon.
// OC1B output: Discon.
// Noise Canceler: Off
// Input Capture on Falling Edge
// Timer 1 Overflow Interrupt: Off
// Input Capture Interrupt: Off
// Compare A Match Interrupt: Off
// Compare B Match Interrupt: Off
TCCR1A=0x00;
TCCR1B=0x00;
TCNT1H=0x00;
TCNT1L=0x00;
OCR1AH=0x00;
OCR1AL=0x00;
OCR1BH=0x00;
OCR1BL=0x00;

// Timer/Counter 2 initialization
// Clock source: System Clock
// Clock value: Timer 2 Stopped
// Mode: Normal top=FFh
// OC2 output: Disconnected
ASSR=0x00;
TCCR2=0x00;
TCNT2=0x00;
OCR2=0x00;

// External Interrupt(s) initialization
// INT0: Off
// INT1: Off
GIMSK=0x00;
MCUCR=0x00;

// Timer(s)/Counter(s) Interrupt(s) initialization
TIMSK=0x01;

// Analog Comparator initialization
// Analog Comparator: Off
// Analog Comparator Input Capture by Timer/Counter 1: Off
ACSR=0x80;

// Global enable interrupts
#asm("sei")

while (1)
{
if (cSignal & CXD == 0 & CXG == 1 & CYD == 0 & CYG == 0) // Capteur Gauche actif
{
cSignal=0;
cTime=0;
PORTA = patternsgauche[pattern];
pattern = (pattern + 1) % sizeof(patternsgauche);
}
else if (cSignal & CXD == 1 & CXG == 0 & CYD == 0 & CYG == 0) // Capteur droit actif
{
cSignal=0;
cTime=0;
PORTA = patternsdroite[pattern];
pattern = (pattern + 1) % sizeof(patternsdroite);
}
else if (cSignal & CXD == 0 & CXG == 0 & CYD == 1 | CYG == 1) // Capteur haut/bas actif
{
cSignal=0;
cTime=0;
PORTA = patternshautbas[pattern];
pattern = (pattern + 1) % sizeof(patternshautbas);
DDRD = 0xFF;
}
else if (cSignal & CXD == 1 & CXG == 0 & CYD == 1 | CYG == 1) // Capteur droite et bas/haut actif
{
cSignal=0;
cTime=0;
PORTA = patternsdroitehautbas[pattern];
pattern = (pattern + 1) % sizeof(patternsdroitehautbas);
}
else if (cSignal & CXD == 0 & CXG == 1 & CYD == 1 | CYG == 1) // Capteur Gauche et Bas/haut actif
{
cSignal=0;
cTime=0;
PORTA = patternsgauchehautbas[pattern];
pattern = (pattern + 1) % sizeof(patternsgauchehautbas);
}
else if (cSignal & CXD == 0 & CXG == 1 & CYD == 1 | CYG == 1) // Capteur Gauche et Bas/haut actif
{
cSignal=0;
cTime=0;
PORTA = patternsgauchehautbas[pattern];
pattern = (pattern + 1) % sizeof(patternsgauchehautbas);
}
elsa // Etat normal
{
cSignal=0;
cTime=0;
PORTA = patternsnormal[pattern];
pattern = (pattern + 1) % sizeof(patternsnormal);
}


;
}
}[/code]

j'ai un problème quand le capteur CYD est actif ça bug le pattern fait n'importe quoi, alors qu'il reste quand même dans la même fonction, et que le CYG qui fait la même chose marche lui.

#26 Bobbyshoot

Bobbyshoot

    Membre occasionnel

  • Membres
  • Pip
  • 140 messages

Posté 01 juin 2009 - 11:38

lol ne t'en fais pas l'hexa ne me découragera pas^^ j'en ai fais toute l'année dernière

T'es pas venu >.<

#27 Bobbyshoot

Bobbyshoot

    Membre occasionnel

  • Membres
  • Pip
  • 140 messages

Posté 02 juin 2009 - 06:33

Bon voilà! J'ai tout réglé, les sorties sont bien en numériques, en fait le problème venait des équations, ils étaient pas bien construite et donc elles interféraient entre elles, mais c'est terminé maintenant, et donc, vu que ça marche j'ai tout mis en Hexa et voici le programme :)

Chip type : AT90LS8535
AVR Core Clock frequency: 3,684600 MHz
Memory model : Small
External RAM size : 0
Data Stack size : 128
*****************************************************/

#include <90s8535.h>
#define CXD PINC.0
#define CXG PINC.1
#define CYD PINC.2
#define CYG PINC.3

unsigned char cTime, cSignal;
// Timer 0 overflow interrupt service routine
interrupt [TIM0_OVF] void timer0_ovf_isr(void)
{
if(cTime++ >=0,85) cSignal=1;
}
unsigned char patternsnormal []= {0x23,0x27,0x2B,0x2F,0x20,0x24,0x28,0x2C,0x3A,0x72,0xB2,0xF2,0x02,0x42,0x82,0x42,0x02,0xF2,0xB2,0x72,0x3A,0x2C,0x28,0x24,0x20,0x2F,0x2B,0x27,};
unsigned char pattern = 0 ;
unsigned char patternsgauche []= {0x02,0x42,0x82,0x42,0x02,0xF2,};
unsigned char patternsdroite []= {0x27,0x2B,0x2F,0x2B,0x27,0x23,};
unsigned char patternsdroitehautbas []= {0x24,0x28,0x2C,0x28,0x24,0x20,};
unsigned char patternsgauchehautbas []= {0x3A,0x72,0xB2,0x72,0x3A,0x2C,};
unsigned char patternstout []= {0x2C,0x3A,0x2C,0x28,};
// Declare your global variables here

void main(void)
{
// Declare your local variables here
DDRA=0xFF;
PORTA=0xFF;
PORTB=0x00;
DDRB=0x00;
PORTC=0x00;
DDRC=0x00;
PORTD=0x00;
DDRD=0x00;

// Timer/Counter 0 initialization
// Clock source: System Clock
// Clock value: 3,598 kHz
TCCR0=0x05;
TCNT0=0x00;

// Timer/Counter 1 initialization
// Clock source: System Clock
// Clock value: Timer 1 Stopped
// Mode: Normal top=FFFFh
// OC1A output: Discon.
// OC1B output: Discon.
// Noise Canceler: Off
// Input Capture on Falling Edge
// Timer 1 Overflow Interrupt: Off
// Input Capture Interrupt: Off
// Compare A Match Interrupt: Off
// Compare B Match Interrupt: Off
TCCR1A=0x00;
TCCR1B=0x00;
TCNT1H=0x00;
TCNT1L=0x00;
OCR1AH=0x00;
OCR1AL=0x00;
OCR1BH=0x00;
OCR1BL=0x00;

// Timer/Counter 2 initialization
// Clock source: System Clock
// Clock value: Timer 2 Stopped
// Mode: Normal top=FFh
// OC2 output: Disconnected
ASSR=0x00;
TCCR2=0x00;
TCNT2=0x00;
OCR2=0x00;

// External Interrupt(s) initialization
// INT0: Off
// INT1: Off
GIMSK=0x00;
MCUCR=0x00;

// Timer(s)/Counter(s) Interrupt(s) initialization
TIMSK=0x01;

// Analog Comparator initialization
// Analog Comparator: Off
// Analog Comparator Input Capture by Timer/Counter 1: Off
ACSR=0x80;

// Global enable interrupts
#asm("sei")

while (1)
{
if (cSignal & CXD == 0 & CXG == 0 & CYD == 0 & CYG == 0) // Etat normal
{
cSignal=0;
cTime=0;
PORTA = patternsnormal[pattern];
pattern = (pattern + 1) % sizeof(patternsnormal);
}
else if (cSignal & CXD == 0 & CXG == 1 & CYD == 0 & CYG == 0) // Capteur Gauche actif
{
cSignal=0;
cTime=0;
PORTA = patternsgauche[pattern];
pattern = (pattern + 1) % sizeof(patternsgauche);
}
else if (cSignal & CXD == 1 & CXG == 0 & CYD == 0 & CYG == 0) // Capteur droit actif
{
cSignal=0;
cTime=0;
PORTA = patternsdroite[pattern];
pattern = (pattern + 1) % sizeof(patternsdroite);
}

else if ((cSignal & CXD == 1 & CXG == 0) & (CYD == 1 ^ CYG == 1)) // Capteur droite et bas/haut actif
{
cSignal=0;
cTime=0;
PORTA = patternsdroitehautbas[pattern];
pattern = (pattern + 1) % sizeof(patternsdroitehautbas);
}
else if ((cSignal & CXD == 0 & CXG == 1) & (CYD == 1 ^ CYG == 1)) // Capteur Gauche et Bas/haut actif
{
cSignal=0;
cTime=0;
PORTA = patternsgauchehautbas[pattern];
pattern = (pattern + 1) % sizeof(patternsgauchehautbas);
}
else if (((cSignal) & (CYD == 1 & CYG == 1)) | (cSignal & CXD == 1 & CXG == 1) | (cSignal) & (CYD == 1 | CYG == 1) & (CXD == 0 & CXG == 0))
{
cSignal=0;
cTime=0;
PORTA = patternstout[pattern];
pattern = (pattern + 1) % sizeof(patternstout);
};
}}[/code]


[quote"Harry"] je te conseille de mettre tout ça dans une fonction que tu appelles directement dans ton interruption.[/quote]

Comment je fais ça ?^^

Et maintenant, je fais comment pour faire autre chose, c'est à dire piloter les deux moteurs pas à pas avec les même capteurs ? Il faut que je fasse ce que tu me dis ? que je mette tout dans une seule interuption et du coup que je fasse un nouveau...truc ? xD

#28 Bobbyshoot

Bobbyshoot

    Membre occasionnel

  • Membres
  • Pip
  • 140 messages

Posté 03 juin 2009 - 12:26

Oki d'accord parfait^^
Donc maintenant, j'ai plus qu'a mettre les moteur pas à pas pour les mouvements et c'est réglés

Hum pour les moteur pas à pas je suis un expert pour les faire tourner^^, ce qu'il faut cst comme tu as dis, que j'apprenne à utiliser le timer pour faire varié la vitesse sachant que je dois pas faire varier la fréquences des Leds...
Merci pour tes liens^^ j'irai voir demain peut être, parceque faut que je révise mon bac un peu >.<

Pour les moteurs j'ai déja 2 L298N, ya que la programmation à faire, le plus dure oui, surtout savoir ce que ça donne en reel, en + que j'ai pas les capteurs encore xD mais ça encore je peux remplacer par des interupteur, je commanderai tout le reste quand j'aurai un programme qui marche, bon ben, à bientot !

#29 Bobbyshoot

Bobbyshoot

    Membre occasionnel

  • Membres
  • Pip
  • 140 messages

Posté 03 juin 2009 - 01:58

non mais, je sais comment marche un moteur pas à pas^^ justement c'est ce que j'ai dis plus haut, t'as peut être lu un peu trop vite ?

#30 Bobbyshoot

Bobbyshoot

    Membre occasionnel

  • Membres
  • Pip
  • 140 messages

Posté 03 juin 2009 - 06:37

tkt je vais le faire quand j'aurai le temps^^ ouff qu'elle chaleur il fait ici (au sud de la france au bord de la plage) trop chiant pour travailler

#31 Bobbyshoot

Bobbyshoot

    Membre occasionnel

  • Membres
  • Pip
  • 140 messages

Posté 04 juin 2009 - 03:30

ah okay j'ai cru que t'étais un vrai anglais :p
Moi j'habite à Agde si tu connais^^ tu dois connaitre le cap d'agde en tout cas.

#32 Bobbyshoot

Bobbyshoot

    Membre occasionnel

  • Membres
  • Pip
  • 140 messages

Posté 07 juin 2009 - 04:25

c'est de l'ironie ? Parceque je suis au bord de la méditerranée moi :p

Bon je stagne un peu pour le moment vu que je suis en période de Bac :)
Mais, j'ai quelques autres idées que je met de coté pour plus tard, par exemple je me suis procuré des photorésistances, et j'ai déja 4 panneaux solaire qui peuvent fournir jusqu'a 10volts chacun, mais en temps normale, avec une luminosité normale ça sort du 3v chacun, j'ai dans l'idée de faire en sorte que lorsque la batterie est presque à plat il déploie ses petit panneaux solaire si la luminosité le permet pour pouvoir se recharger :p

#33 Bobbyshoot

Bobbyshoot

    Membre occasionnel

  • Membres
  • Pip
  • 140 messages

Posté 07 juin 2009 - 11:12

ah oui oui pardon j'avais pas fait le rapprochement ! milles excuses je suis un noob -_-

#34 miky-mike

miky-mike

    Pilier du forum

  • Membres
  • PipPipPipPipPip
  • 1 232 messages
  • Gender:Male
  • Location:Belgique

Posté 08 juin 2009 - 03:53

Ohhh les gras, c'est moi qui offre l'apéro ou quoi :D


#35 miky-mike

miky-mike

    Pilier du forum

  • Membres
  • PipPipPipPipPip
  • 1 232 messages
  • Gender:Male
  • Location:Belgique

Posté 09 juin 2009 - 07:56

[quote"Harry"]Bah quoi ? Moi j'ai donné les conseils, je ne vais pas faire le boulot à sa place :| et il a l'air occuppé c'est normal aussi ;) [/quote]
Bah et pourquoi pas ? :p

#36 Bobbyshoot

Bobbyshoot

    Membre occasionnel

  • Membres
  • Pip
  • 140 messages

Posté 26 juin 2009 - 12:52

Ben là c'est le point mort, je suis en plein examen :) mais, mon dernier exam est mercredi, à partir de là je pourrai reprendre^^
Et voilà ! Exam terminé :p
Puis j'ai eu le temps de tester mon programmateur il marche niquel :)
Bon ben, les prochaines étapes dans l'ordre :
_Intégrés la fonction allumages des led dans une boucle d'interuption comme me l'a montré Harry
_Faire le programme du moteur pas à pas
_Me procuré les Multiplexeur vu que j'ai déja tout le reste :p

#37 Bobbyshoot

Bobbyshoot

    Membre occasionnel

  • Membres
  • Pip
  • 140 messages

Posté 02 juillet 2009 - 11:59

j'ai une question, comment on fait, une fois que j'ai mis tout ce qu'il y avait dans while, dans un void comme tu m'as dis, pour l'appeller aprés pendant le while ?





Hop voici mon schéma à nouveau complété :




Puis, mon code un peu nettoyé en attente de mettre le code pour les moteurs pas à pas je le ferai demain, assez tard vu que je travaille jusqu'a minuit, faut bien se payer le matos :p :


Chip type : AT90LS8535

AVR Core Clock frequency: 3,684600 MHz

Memory model : Small

External RAM size : 0

Data Stack size : 128

*****************************************************/



#include <90s8535.h>

#define CXD PINC.0

#define CXG PINC.1

#define CYH PINC.2

#define CYB PINC.3



unsigned char cTime, cSignal;

interrupt [TIM0_OVF] void timer0_ovf_isr(void)

{

if(cTime++ >=0,85) cSignal=1;

}

unsigned char patternsnormal []= {0x23,0x27,0x2B,0x2F,0x20,0x24,0x28,0x2C,0x3A,0x72,0xB2,0xF2,0x02,0x42,0x82,0xC2,0x42,0x42,0x02,0xF2,0xB2,0x72,0x3A,0x2C,0x28,0x24,0x20,0x2F,0x2B,0x27,};

unsigned char pattern = 0 ;

unsigned char patternsgauche []= {0x42,0x82,0xC2,0x82,0x42,0x02,};

unsigned char patternsdroite []= {0x27,0x2B,0x2F,0x2B,0x27,0x23,};

unsigned char patternsdroitehautbas []= {0x24,0x28,0x2C,0x28,0x24,0x20,};

unsigned char patternsgauchehautbas []= {0x72,0xB2,0xF2,0xB2,0x72,0x3A,};

unsigned char patternstout []= {0x2C,0x3A,0x2C,0x28,};



void main(void)

{

// Declare your local variables here

DDRA=0xFF;

PORTA=0xFF;

PORTB=0x00;

DDRB=0x00;

PORTC=0x00;

DDRC=0x00;

PORTD=0x00;

DDRD=0x00;



// Timer/Counter 0 initialization

// Clock source: System Clock

// Clock value: 3,598 kHz

TCCR0=0x05;

TCNT0=0x00;



// Timer/Counter 1 initialization

// Clock source: System Clock

// Clock value: Timer 1 Stopped

// Mode: Normal top=FFFFh

// OC1A output: Discon.

// OC1B output: Discon.

// Noise Canceler: Off

// Input Capture on Falling Edge

// Timer 1 Overflow Interrupt: Off

// Input Capture Interrupt: Off

// Compare A Match Interrupt: Off

// Compare B Match Interrupt: Off

TCCR1A=0x00;

TCCR1B=0x00;

TCNT1H=0x00;

TCNT1L=0x00;

OCR1AH=0x00;

OCR1AL=0x00;

OCR1BH=0x00;

OCR1BL=0x00;



// Timer/Counter 2 initialization

// Clock source: System Clock

// Clock value: Timer 2 Stopped

// Mode: Normal top=FFh

// OC2 output: Disconnected

ASSR=0x00;

TCCR2=0x00;

TCNT2=0x00;

OCR2=0x00;



// External Interrupt(s) initialization

// INT0: Off

// INT1: Off

GIMSK=0x00;

MCUCR=0x00;



// Timer(s)/Counter(s) Interrupt(s) initialization

TIMSK=0x01;



// Analog Comparator initialization

// Analog Comparator: Off

// Analog Comparator Input Capture by Timer/Counter 1: Off

ACSR=0x80;

}

void Vision(void)

{

{

if (cSignal & CXD == 0 & CXG == 0 & CYH == 0 & CYB == 0) // Etat normal

{

cSignal=0;

cTime=0;

PORTA = patternsnormal[pattern];

pattern = (pattern + 1) % sizeof(patternsnormal);

}

else if (cSignal & CXD == 0 & CXG == 1 & CYH == 0 & CYB == 0) // Capteur Gauche actif

{

cSignal=0;

cTime=0;

PORTA = patternsgauche[pattern];

pattern = (pattern + 1) % sizeof(patternsgauche);

}

else if (cSignal & CXD == 1 & CXG == 0 & CYH == 0 & CYB == 0) // Capteur droit actif

{

cSignal=0;

cTime=0;

PORTA = patternsdroite[pattern];

pattern = (pattern + 1) % sizeof(patternsdroite);

}



else if ((cSignal & CXD == 1 & CXG == 0) & (CYH == 1 ^ CYB == 1)) // Capteur droite et bas/haut actif

{

cSignal=0;

cTime=0;

PORTA = patternsdroitehautbas[pattern];

pattern = (pattern + 1) % sizeof(patternsdroitehautbas);

}

else if ((cSignal & CXD == 0 & CXG == 1) & (CYH == 1 ^ CYB == 1)) // Capteur Gauche et Bas/haut actif

{

cSignal=0;

cTime=0;

PORTA = patternsgauchehautbas[pattern];

pattern = (pattern + 1) % sizeof(patternsgauchehautbas);

}

else if (((cSignal) & (CYH == 1 & CYB == 1)) | (cSignal & CXD == 1 & CXG == 1) | (cSignal) & (CYH == 1 | CYB == 1) & (CXD == 0 & CXG == 0))

{

cSignal=0;

cTime=0;

PORTA = patternstout[pattern];

pattern = (pattern + 1) % sizeof(patternstout);

};

}

// Global enable interrupts

#asm("sei")



while(1)

{

// Ici à placer le futur code

}}[/code]



Bon, je vous l'explique pas maintenant chuis trop fatigué et je pense que vous allez comprendre desuite toute façon, donc je vous dis à demain pour de prochaines aventures :p

ça fait du bien de reprendre^^

#38 robocop

robocop

    Membre passionné

  • Membres
  • PipPipPip
  • 357 messages
  • Gender:Male

Posté 03 juillet 2009 - 09:33

Y'a beaucoup de répétitions dans ton code, tu peux peut être le factoriser, non ?

#39 miky-mike

miky-mike

    Pilier du forum

  • Membres
  • PipPipPipPipPip
  • 1 232 messages
  • Gender:Male
  • Location:Belgique

Posté 03 juillet 2009 - 10:37

Effectivement, beaucoup de répétition.

il serait préférable de créer une autre fonction avec en paramètre (patternsgauchehautbas, ...).

#40 Bobbyshoot

Bobbyshoot

    Membre occasionnel

  • Membres
  • Pip
  • 140 messages

Posté 03 juillet 2009 - 12:26

Cst à dire ? créé une fonction pour chaque évenement?
Des répétitions au niveau des equations logiques?
boh du coup de tout avoir mis dans une seule fonction ça change plus d'état suivant les états des 4 entrées...
Cst pour ça que je dois faire une fonction pour chaque pattern? et ensuite réécrire les équations pour les appeller ? en fait ça réduit pas tant que ça le code alors
Rahhhh ya plus rien qui marche :(

j'avais ça mais, ça ne marche pas, un problème au niveau de l'assemblage
Chip type : AT90LS8535
AVR Core Clock frequency: 3,684600 MHz
Memory model : Small
External RAM size : 0
Data Stack size : 128
*****************************************************/

#include <90s8535.h>
#define CXD PINC.0
#define CXG PINC.1
#define CYH PINC.2
#define CYB PINC.3

unsigned char cTime, cSignal;
interrupt [TIM0_OVF] void timer0_ovf_isr(void)
{
if(cTime++ >=0,85) cSignal=1;
}
unsigned char patternsnormal []= {0x23,0x27,0x2B,0x2F,0x20,0x24,0x28,0x2C,0x3A,0x72,0xB2,0xF2,0x02,0x42,0x82,0xC2,0x42,0x42,0x02,0xF2,0xB2,0x72,0x3A,0x2C,0x28,0x24,0x20,0x2F,0x2B,0x27,};
unsigned char pattern = 0 ;
unsigned char patternsgauche []= {0x42,0x82,0xC2,0x82,0x42,0x02,};
unsigned char patternsdroite []= {0x27,0x2B,0x2F,0x2B,0x27,0x23,};
unsigned char patternsdroitehautbas []= {0x24,0x28,0x2C,0x28,0x24,0x20,};
unsigned char patternsgauchehautbas []= {0x72,0xB2,0xF2,0xB2,0x72,0x3A,};
unsigned char patternstout []= {0x2C,0x3A,0x2C,0x28,};

void Patternsnormal(void)
{
while (1)
{
cSignal=0;
cTime=0;
PORTA = patternsnormal[pattern];
pattern = (pattern + 1) % sizeof(patternsnormal);
}}

void Patternsgauche(void)
{
cSignal=0;
cTime=0;
PORTA = patternsgauche[pattern];
pattern = (pattern + 1) % sizeof(patternsgauche);
}

void Patternsdroite(void)
{
cSignal=0;
cTime=0;
PORTA = patternsdroite[pattern];
pattern = (pattern + 1) % sizeof(patternsdroite);
}

void Patternsdroitehautbas(void)
{
cSignal=0;
cTime=0;
PORTA = patternsdroitehautbas[pattern];
pattern = (pattern + 1) % sizeof(patternsdroitehautbas);
}

void Patternsgauchehautbas(void)
{
cSignal=0;
cTime=0;
PORTA = patternsgauchehautbas[pattern];
pattern = (pattern + 1) % sizeof(patternsgauchehautbas);
}

void Patternstout(void)
{
cSignal=0;
cTime=0;
PORTA = patternstout[pattern];
pattern = (pattern + 1) % sizeof(patternstout);
};

void main(void)
{
// Declare your local variables here
DDRA=0xFF;
PORTA=0xFF;
PORTB=0x00;
DDRB=0x00;
PORTC=0x00;
DDRC=0x00;
PORTD=0x00;
DDRD=0x00;

// Timer/Counter 0 initialization
// Clock source: System Clock
// Clock value: 3,598 kHz
TCCR0=0x05;
TCNT0=0x00;

// Timer/Counter 1 initialization
// Clock source: System Clock
// Clock value: Timer 1 Stopped
// Mode: Normal top=FFFFh
// OC1A output: Discon.
// OC1B output: Discon.
// Noise Canceler: Off
// Input Capture on Falling Edge
// Timer 1 Overflow Interrupt: Off
// Input Capture Interrupt: Off
// Compare A Match Interrupt: Off
// Compare B Match Interrupt: Off
TCCR1A=0x00;
TCCR1B=0x00;
TCNT1H=0x00;
TCNT1L=0x00;
OCR1AH=0x00;
OCR1AL=0x00;
OCR1BH=0x00;
OCR1BL=0x00;

// Timer/Counter 2 initialization
// Clock source: System Clock
// Clock value: Timer 2 Stopped
// Mode: Normal top=FFh
// OC2 output: Disconnected
ASSR=0x00;
TCCR2=0x00;
TCNT2=0x00;
OCR2=0x00;

// External Interrupt(s) initialization
// INT0: Off
// INT1: Off
GIMSK=0x00;
MCUCR=0x00;

// Timer(s)/Counter(s) Interrupt(s) initialization
TIMSK=0x01;

// Analog Comparator initialization
// Analog Comparator: Off
// Analog Comparator Input Capture by Timer/Counter 1: Off
ACSR=0x80;


// Global enable interrupts
#asm("sei")

while (1)
{
{
if (cSignal & CXD == 0 & CXG == 0 & CYH == 0 & CYB == 0) // Etat normal
{
Patternsnormal();
}
else if (cSignal & CXD == 0 & CXG == 1 & CYH == 0 & CYB == 0) // Capteur Gauche actif
{
Patternsgauche();
}
else if (cSignal & CXD == 1 & CXG == 0 & CYH == 0 & CYB == 0) // Capteur droit actif
{
Patternsdroite();
}
else if ((cSignal & CXD == 1 & CXG == 0) & (CYH == 1 ^ CYB == 1)) // Capteur droite et bas/haut actif
{
Patternsdroitehautbas();
}
else if ((cSignal & CXD == 1 & CXG == 0) & (CYH == 1 ^ CYB == 1)) // Capteur droite et bas/haut actif
{
Patternsgauchehautbas();
}
else if (((cSignal) & (CYH == 1 & CYB == 1)) | (cSignal & CXD == 1 & CXG == 1) | (cSignal) & (CYH == 1 | CYB == 1) & (CXD == 0 & CXG == 0))
{
Patternstout();
}
}}}[/code]
Retourner dans Robots mixtes / hybride

Répondre à ce sujet



  


0 utilisateur(s) li(sen)t ce sujet

0 members, 0 guests, 0 anonymous users

  1. Robot Maker
  2. → Projets et réalisations, robots et machines en tout genre
  3. → Robots mixtes / hybride
  4. Privacy Policy