Pic18F2620 - usart - Rs232 - ascii
Répondre à la discussion
Page 1 sur 2 1 DernièreDernière
Affichage des résultats 1 à 30 sur 53

Pic18F2620 - usart - Rs232 - ascii



  1. #1
    invite960f35e5

    Pic18F2620 - usart - Rs232 - ascii


    ------

    bonjour à tous,

    j'ai un projet que je dois avoir fini pour début septembre pour ma second sess mais là , je bloque totalement , j'ai jamais utilisé l'usart et étant pas très bon en programmation , j'aimerais que quelqu'un m'aide ...

    donc voila mon projet , s est un robot commandé par pc via le port serie RS232.

    j utilise un pic 18F2620

    donc j'utilise comme logiciel " Hyperterminal "

    j utilise comme module de émission - réception des radiometrix TDL2A-433-9

    ce que il me faudrait , s'est savoir faire 4 commandes donc on va dire

    - fleche du haut , sa fera avancé les 2 moteurs
    - fleche du bas , sa fera reculé les 2 moteurs
    - fleche de gauche , sa fera tourner à gauche les 2 moteurs
    - fleche de droite , sa fera tourner à droite les 2 moteurs

    ce qui me faudrait aussi , c'est envoyé un message de retour sur le Hyperterminal pour dire que la donné a bien été recu , donc par exemple j appuye sur la fleche du haut , sa ecrit dans hyperterminal " le robot avance "

    voila sa s est en gros ce que faudrait que je fasse

    si quelqu un pourrait m aidé , sa me ferait enormement plaisir

    voila le code ( ce code permet de faire avancer les moteurs tout droit bêtement )

    Code:
    #include <pic18.h>
    #include  <stdio.h> 
    #include <stdlib.h>
    #include "delay.h"
    #include "lcd.h"
    #include "usart.h"
    
    __CONFIG(1, HS&IESODIS&FCMDIS);
    __CONFIG(2, BORDIS&PWRTEN&WDTDIS );
    __CONFIG(3, PBANDIS);
    __CONFIG(4, LVPDIS&XINSTDIS&STVRDIS&LPT1DIS);
    __CONFIG(5, UNPROTECT);
    __CONFIG(6, WRTEN);
    
    #define S1 RA0
    #define S2 RA1
    #define S3 RA2
    #define S4 RA3
    
    #define OUTA RB3 
    #define OUTB RB2 
    #define OUTC RB1 
    #define OUTD RB0 
    
    
    #define OUTE RC0
    #define OUTF RC1
    #define OUTG RC2
    #define OUTH RC3
    
    int x=10;
    
    void main ()  
    {ADCON1=0x07;
     TRISA= 0b00000000;
     TRISB= 0b00000000;
     TRISC= 0b10000000;
    
    InitUSART (129);
    RC4=1;
    RC5=0;
    
    lcd_init ();
    lcd_clear ();
    
    while(1)
    	{
    
     OUTA=1, OUTB=0, OUTC=0, OUTD=0;
     OUTE=1, OUTF=0, OUTG=0, OUTH=0;
    	
     delay_ms(x);
     
     OUTA=1, OUTB=0, OUTC=0, OUTD=1;
     OUTE=1, OUTF=0, OUTG=0, OUTH=1;
     
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=0, OUTD=1;
     OUTE=0, OUTF=0, OUTG=0, OUTH=1;
      
    
     delay_ms(x);
     
     OUTA=0, OUTB=1, OUTC=0, OUTD=1;
     OUTE=0, OUTF=1, OUTG=0, OUTH=1;
     
    
     delay_ms(x);
    
     OUTA=0, OUTB=1, OUTC=0, OUTD=0;
     OUTE=0, OUTF=1, OUTG=0, OUTH=0;
    	
     delay_ms(x);
     
     OUTA=0, OUTB=1, OUTC=1, OUTD=0;
     OUTE=0, OUTF=1, OUTG=1, OUTH=0;
     
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=1, OUTD=0;
     OUTE=0, OUTF=0, OUTG=1, OUTH=0;
      
    
     delay_ms(x);
     
     OUTA=1, OUTB=0, OUTC=1, OUTD=0;
     OUTE=1, OUTF=0, OUTG=1, OUTH=0;
     
    
     delay_ms(x);
    }
    
     OUTA=0, OUTB=0, OUTC=0, OUTD=0;
     OUTE=0, OUTF=0, OUTG=0, OUTH=0;
    }
    	
    }
    et sa le code dans usart

    Code:
    /******************************************************************************
     * USART Routines (2004.02.26)
     * Fabrice Médol
     * 
     * This file contains the USART routines.
     * Each routine's parameters are explained above the function declaration.
     ******************************************************************************
     */
    
    #ifndef	_USART_C
    #define _USART_C
    
    #include <pic18.h>
    #include "usart.h"
    
    
    near char ser_tmp;
    
    
    
    /*******************************************************************************
     * InitUSART
     *
     * This subroutine initializes the USART
     * Asynchronous Mode 
     * 8 bit
     * Reception & Transmission Interrupts enabled
     *******************************************************************************
     */
    
    void InitUSART(char VALEURBRG)
    {	SYNC=0; 	// Asynchronous mode
    	SPEN=1;		// Asynchronous mode
    	BRGH=1;		// High Speed Mode
    	SPBRG=VALEURBRG;	// Baud Rate = Fosc / (16*(SPBGR+1)
    
    	// Reception config
    	RX9=0;		// 8 bit reception
    	RCIE=0;		// Enable Reception Interrupt
    	CREN=1;		// Enable Reception
    	
    	// Transmission config
    	TX9=0;		// 8 bit transmission
    	TXIE=0;		// Enable Transmission Interrupt
    	TXEN=1;		// set bit TXIF to Enable Transmission
    	
    	TRISC6=0;	// TX output
    	TRISC7=1;	// RX intput
    	
    	// Flush RX Buffer
    	ser_tmp=RCREG;
    	ser_tmp=RCREG;
    	ser_tmp=RCREG;	
    }
    /*******************************************************************************
     * getch
     *
     * Read one byte from serial
     *
     * Returns : the byte received
     *******************************************************************************
     */
    
    unsigned char getch(void)
    {	while(!RCIF);
    	return (RCREG);
    }
    /*******************************************************************************
     * getchR
     *
     * Read one byte from serial with indication of reception error
     *
     * Returns : the byte received
     *******************************************************************************
     */
    
    unsigned char getchR(void)
    {
    	while (!(OERR || FERR || RCIF)) 
    	{
    		if (OERR) 
    		{
    			// overflow error
    			// disable_interrupt(GIE)?
    			CREN = 0;
    			ser_tmp = RCREG; // flush the rx buffer
    			ser_tmp = RCREG;
    			ser_tmp = RCREG;
    			CREN = 1;
    			// enable_interrupt(GIE)?
    		}
    		else if (FERR) 
    		{
    			// framing error
    			// disable_interrupt(GIE)?
    			ser_tmp = RCREG;
    			// enable_interrupt(GIE)?
    		}
    		else if (RCIF) 
    		{
    			// RCIF!
    			// disable_interrupt(GIE)?
    			ser_tmp = RCREG;
    			// enable_interrupt(GIE)?
    		}
    	}
    	return ser_tmp;
    }
    /*******************************************************************************
     * getch_nb
     *
     * non blockong Read one byte from serial
     *
     * Returns : the byte received or 0 if error
     *******************************************************************************
     */
    char getch_nb(void) 
    {
    	if (PIR1 & 32) {
    		ser_tmp = RCREG;
    		return ser_tmp;
    	} else {
    		return 0;
    	}
    }
    
    /*******************************************************************************
     * putch()
     * 
     * byte : the byte to send
     *
     * Write one byte to serial
     *******************************************************************************
     */
    
    void putch(char byte)
    {
    	while(!TXIF);
    	TXREG=byte;
    	//while(!TRMT);
    }
    
    /*******************************************************************************
     * put_string
     * 		s : a pointer on the string to send!
     *
     * Send string s to serial
     *******************************************************************************
     */
    void put_string(const unsigned char * text)
    {	char i = 0;
        while( text[i] !=0 )
            putch(text[i++]); 
    }
    
    /*******************************************************************************
    * envoi d'un octet au format hex
    ********************************************************************************
    */
    void tx_hex_byte(unsigned char val) 		
    {
       char c;
       c = conv_ascii((val>>4) & 0x0f);
       putch(c);
       c = conv_ascii(val&0x0f);
       putch(c);
    }
    /*******************************************************************************
    * envoi d'un octet au format decimal
    ********************************************************************************
    */
    void tx_dec_byte(unsigned char val) // displays byte in decimal
    {	unsigned char d;
       	char c;
       	d=val/100;
       	c=conv_ascii(d);
       	putch(c);
       
       	val=val%100;
       	d=val/10;
       	c=conv_ascii(d);
       	putch(c);   	
       
       	d=val % 10;
       	c=conv_ascii(d);
       	putch(c);
    }   
    /*******************************************************************************
    * conversion ascii
    ********************************************************************************
    */
    char conv_ascii(unsigned char val)	
    {
       char c;
       if (val < 10)
       {
         c=val+'0';
       }
       else
       {
         val=val-10;	   
         c=val + 'A';
       }
       return(c);
    }
    
    #endif

    -----

  2. #2
    invite067d8d6c

    Re : Pic18F2620 - usart - Rs232 - ascii

    Salut,

    Alors il va falloir faire 3 choses je pense!

    1 - Changer de logiciel sur le PC! HyperTerminal c'est le mal! Utilises plutôt docklight qui permet de "voir" les trames en hexadécimal et ainsi utiliser les 256 caractères possibles! (hyperteminal n'affiche que les caractères affichables)

    2 - Utiliser les fonctions UART pour attendre un ordre et le renvoyer
    exemple
    ordre = getch();
    putch(ordre);
    PS : dé commentes //while(!TRMT); pour attendre d'avoir renvoyer l'ordre

    3 - avec un switch commandes tes moteurs
    switch (ordre)
    {
    case 0x00:
    // arret
    OUTA=0, OUTB=0, OUTC=0, OUTD=0;
    OUTE=0, OUTF=0, OUTG=0, OUTH=0;
    break;

    case 0x01:
    // avance
    ......
    }


    Voilà dans l'esprit, j'espère que ça va te suffire comme informations

    @+

  3. #3
    Seb.26

    Re : Pic18F2620 - usart - Rs232 - ascii

    Pour la partie PC, je te conseille de faire ce genre de mini-programme en C# via Visual C# express ... si tu ne trouve ton bonheur dans les freeware ...

    C# : c'est un peu comme du C++, mais surtout la productivité est excellente ... et les performances importent peu dans ton cas ...
    << L'histoire nous apprend que l'on apprend rien de l'histoire. >>

  4. #4
    invite960f35e5

    Re : Pic18F2620 - usart - Rs232 - ascii

    a propos Xtrem

    le logiciel docklight , faut avoir une licence non ??

    aussi non, vu que je ne suis pas très très douer en programmation , voulais me renseigner.

    dans ce code ci ? "ordre" , s est une variable que je défini ???
    et le code hexa 0x00 , s est le code hexa de la touche ???
    voila merci de me repondre

    est ce bon comme ca ??

    int ordre;

    switch (ordre)
    {
    case 0x41: // touche a
    // arret
    OUTA=0, OUTB=0, OUTC=0, OUTD=0;
    OUTE=0, OUTF=0, OUTG=0, OUTH=0;
    break;

    case 0x42: // touche b
    // avance
    ......
    }

  5. A voir en vidéo sur Futura
  6. #5
    invite067d8d6c

    Re : Pic18F2620 - usart - Rs232 - ascii

    Re,

    En effet il faut une licence pour docklight, mais la version avec licence permet uniquement de faire des copier/coller et de sauvegarder les trames. Mais pour 4 commandes, tu peux les rentrer à la main à chaque ouverture de session, c'est pas trop long^^

    Pour les codes ascii ce n'est pas bon
    A = 0x41
    a = 0x61
    Attention à ce genre d'erreur^^

    Ps : dans docklight justement tu peux "écrire" une trame en ascii (les boutons dans édit mode) puis les "voir" en hexa (toujours avec les boutons). Comme ça pas d'erreur

    @+

  7. #6
    invite960f35e5

    Re : Pic18F2620 - usart - Rs232 - ascii

    Citation Envoyé par Xtr£M Voir le message
    Re,

    En effet il faut une licence pour docklight, mais la version avec licence permet uniquement de faire des copier/coller et de sauvegarder les trames. Mais pour 4 commandes, tu peux les rentrer à la main à chaque ouverture de session, c'est pas trop long^^

    Pour les codes ascii ce n'est pas bon
    A = 0x41
    a = 0x61
    Attention à ce genre d'erreur^^

    Ps : dans docklight justement tu peux "écrire" une trame en ascii (les boutons dans édit mode) puis les "voir" en hexa (toujours avec les boutons). Comme ça pas d'erreur

    @+
    ah genial merci pour la faute que j'ai faite

    donc voila donc cette partie la , je crois que s est bon.

    par contre pour l envoie d information :

    ordre = getch();
    putch(ordre);
    PS : dé commentes //while(!TRMT); pour attendre d'avoir renvoyer l'ordre

    sa par contre j ai pas trop compris , parce que on a 1 seul switch pour avancé , reculé ,stop , ect ...

    donc sa veut dire que pour chaque commande , il enverra tj le meme message ??

    donc faudrait que je fasse a chaque fois un switch different pour chaque commande donc "ordre" pour la commande avancer , "ordre1" pour la commande reculer ????

    voila merci bien a toi

  8. #7
    invite960f35e5

    Re : Pic18F2620 - usart - Rs232 - ascii

    bon ben voila j ai testé comme tu m'as dit mais rien n y fais , sa fonctionne pas...

    est ce que y a une erreur dedans

    Code:
    #include <pic18.h>
    #include  <stdio.h> 
    #include <stdlib.h>
    #include "delay.h"
    #include "lcd.h"
    #include "usart.h"
    
    __CONFIG(1, HS&IESODIS&FCMDIS);
    __CONFIG(2, BORDIS&PWRTEN&WDTDIS );
    __CONFIG(3, PBANDIS);
    __CONFIG(4, LVPDIS&XINSTDIS&STVRDIS&LPT1DIS);
    __CONFIG(5, UNPROTECT);
    __CONFIG(6, WRTEN);
    
    #define S1 RA0
    #define S2 RA1
    #define S3 RA2
    #define S4 RA3
    
    #define OUTA RB3 
    #define OUTB RB2 
    #define OUTC RB1 
    #define OUTD RB0 
    
    
    #define OUTE RC0
    #define OUTF RC1
    #define OUTG RC2
    #define OUTH RC3
    
    int x=10;
    int ordre;
    
    void main ()  
    {ADCON1=0x07;
     TRISA= 0b00000000;
     TRISB= 0b00000000;
     TRISC= 0b10000000;
    
    InitUSART (129);
    RC4=1;
    RC5=0;
    
    lcd_init ();
    lcd_clear ();
    
    while (1)
    {
    switch (ordre)
    {
    case 0x00:
    // arret
    OUTA=0, OUTB=0, OUTC=0, OUTD=0;
    OUTE=0, OUTF=0, OUTG=0, OUTH=0;
    break;
    
    case 0x61:
    // avance
     OUTA=1, OUTB=0, OUTC=0, OUTD=0;
     OUTE=1, OUTF=0, OUTG=0, OUTH=0;
    	
     delay_ms(x);
     
     OUTA=1, OUTB=0, OUTC=0, OUTD=1;
     OUTE=1, OUTF=0, OUTG=0, OUTH=1;
     
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=0, OUTD=1;
     OUTE=0, OUTF=0, OUTG=0, OUTH=1;
      
    
     delay_ms(x);
     
     OUTA=0, OUTB=1, OUTC=0, OUTD=1;
     OUTE=0, OUTF=1, OUTG=0, OUTH=1;
     
    
     delay_ms(x);
    
     OUTA=0, OUTB=1, OUTC=0, OUTD=0;
     OUTE=0, OUTF=1, OUTG=0, OUTH=0;
    	
     delay_ms(x);
     
     OUTA=0, OUTB=1, OUTC=1, OUTD=0;
     OUTE=0, OUTF=1, OUTG=1, OUTH=0;
     
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=1, OUTD=0;
     OUTE=0, OUTF=0, OUTG=1, OUTH=0;
      
    
     delay_ms(x);
     
     OUTA=1, OUTB=0, OUTC=1, OUTD=0;
     OUTE=1, OUTF=0, OUTG=1, OUTH=0;
     
    
     delay_ms(x);
    
    }
    }
    }

  9. #8
    invite067d8d6c

    Re : Pic18F2620 - usart - Rs232 - ascii

    Re,

    Je te répond ici pour que d'autres personnes puisse également reprendre les éventuelles erreurs que je peux faire!

    Donc les problèmes ici sont:
    Tu ne va jamais lire l'ordre qui vient du pc
    Tu n'as que deux ordres dans ton code. Soit tu ne bouges plus, soit tu fais la séquence complète

    Essayes quelque chose comme ça
    je ne fais pas les entêtes qui me semblent bon à première vue
    Code:
    char ordre;
    
    while (1)
    {
    
    // 1- on attend un caractère donc un ordre
    ordre = getch();
    
    // 2- on renvoie l'ordre que l'on vient de recevoir au pc
    putch(ordre);
    
    // 3- on traite l'ordre que l'on vient de recevoir!
    // je vais prendre 5 ordres! Ils sont en majuscules !! 
    // A (code 0x41) = avance
    // R (code 0x52) = recule
    // D (code 0x44) = droite
    // G (code 0x47) = gauche
    // S (code 0x53) = stop
    
    switch (ordre)
    {
    case 0x41:
    // avance : règles tes sorties pour avancer
    break;
    
    case 0x44:
    // droite : règles tes sorties pour tourner à droite
    break;
    
    case 0x47:
    // gauche : règles tes sorties pour tourner à gauche
    break;
    
    case 0x52:
    // recule : règles tes sorties pour reculer
    break;
    
    case 0x53:
    // stop : règles tes sorties pour ne plus bouger
    OUTA=0, OUTB=0, OUTC=0, OUTD=0;
    OUTE=0, OUTF=0, OUTG=0, OUTH=0;
    break;
    
    }
    }
    Avec ce programme ou en t'en inspirant, le robot va continuer à faire toujours le même ordre jusqu'à un nouvel ordre!
    Par exemple, tu envoies 0x41 avec le pc!
    Le robot te renvoies 0x41 puis commence à avancer!
    Il continuera à avancer jusqu'à ce que tu lui envoies un autre ordre!
    Par exemple 0x53 --> le robot te renvoie 0x53 et s'arrête

    En espérant que tu comprennes mieux l'idée

    @+

  10. #9
    invite960f35e5

    Re : Pic18F2620 - usart - Rs232 - ascii

    ah oki je comprend mieux

    juste savoir quand tu dis " règle tes sorties "

    tu parles de la commande pour faire tourné les moteurs ??

    en tout cas grand merci pour ton aide précieuse , v allé testé ça

  11. #10
    invite067d8d6c

    Re : Pic18F2620 - usart - Rs232 - ascii

    RE,

    Oui oui tout à fait! C'est bien la commande des sorties pour faire tourner les moteurs

    Bonne continuation, dis-moi si ça fonctionne

  12. #11
    invite960f35e5

    Re : Pic18F2620 - usart - Rs232 - ascii

    bon ben sa allere de pas marché...

    enfaite ce que je constate , c'est que sa envoie bien dans le programme que la touche A ou R a été appuyé , par contre si t appuye sur A, on voit bien la lettre A affiché mais rien ne se passe ...

    et quand j appuye sur R , faut que je fasse un Reset si je veux que sa affiche...

    donc conclusion , on peut faire que une commande a la fois et mes moteurs n avancent pas , on dirait que mes moteurs se bloquent ...


  13. #12
    invite067d8d6c

    Re : Pic18F2620 - usart - Rs232 - ascii

    Re,

    Heu tu peux remettre ton code ici!

    merci, @+

  14. #13
    invite960f35e5

    Re : Pic18F2620 - usart - Rs232 - ascii

    oui voici le code :

    donc voici le code et v mettre aussi le code usart , parce que je suis pas sur du tout de la configuration

    Code:
    #include <pic18.h>
    #include  <stdio.h> 
    #include <stdlib.h>
    #include "delay.h"
    #include "lcd.h"
    #include "usart.h"
    
    __CONFIG(1, HS&IESODIS&FCMDIS);
    __CONFIG(2, BORDIS&PWRTEN&WDTDIS );
    __CONFIG(3, PBANDIS);
    __CONFIG(4, LVPDIS&XINSTDIS&STVRDIS&LPT1DIS);
    __CONFIG(5, UNPROTECT);
    __CONFIG(6, WRTEN);
    
    #define S1 RA0
    #define S2 RA1
    #define S3 RA2
    #define S4 RA3
    
    #define OUTA RB3 
    #define OUTB RB2 
    #define OUTC RB1 
    #define OUTD RB0 
    
    
    #define OUTE RC0
    #define OUTF RC1
    #define OUTG RC2
    #define OUTH RC3
    
    int x=10;
    char ordre;
    
    void main ()  
    {ADCON1=0x07;
     TRISA= 0b00000000;
     TRISB= 0b00000000;
     TRISC= 0b10000000;
    
    InitUSART (129);
    RC4=0;
    RC5=1;
    
    
    
    while (1)
    {
    
    // 1- on attend un caractère donc un ordre
    ordre = getch();
    
    // 2- on renvoie l'ordre que l'on vient de recevoir au pc
    putch(ordre);
    
    // 3- on traite l'ordre que l'on vient de recevoir!
    // je vais prendre 5 ordres! Ils sont en majuscules !! 
    // A (code 0x41) = avance
    // R (code 0x52) = recule
    // D (code 0x44) = droite
    // G (code 0x47) = gauche
    // S (code 0x53) = stop
    
    switch (ordre)
    {
    case 0x41:
    // avance : règles tes sorties pour avancer
    OUTA=1, OUTB=0, OUTC=0, OUTD=0;
     OUTE=1, OUTF=0, OUTG=0, OUTH=0;
    	
     delay_ms(x);
     
     OUTA=1, OUTB=0, OUTC=0, OUTD=1;
     OUTE=1, OUTF=0, OUTG=0, OUTH=1;
     
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=0, OUTD=1;
     OUTE=0, OUTF=0, OUTG=0, OUTH=1;
      
    
     delay_ms(x);
     
     OUTA=0, OUTB=1, OUTC=0, OUTD=1;
     OUTE=0, OUTF=1, OUTG=0, OUTH=1;
     
    
     delay_ms(x);
    
     OUTA=0, OUTB=1, OUTC=0, OUTD=0;
     OUTE=0, OUTF=1, OUTG=0, OUTH=0;
    	
     delay_ms(x);
     
     OUTA=0, OUTB=1, OUTC=1, OUTD=0;
     OUTE=0, OUTF=1, OUTG=1, OUTH=0;
     
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=1, OUTD=0;
     OUTE=0, OUTF=0, OUTG=1, OUTH=0;
      
    
     delay_ms(x);
     
     OUTA=1, OUTB=0, OUTC=1, OUTD=0;
     OUTE=1, OUTF=0, OUTG=1, OUTH=0;
     
    
     delay_ms(x);
    break;
    
    case 0x44:
    // droite : règles tes sorties pour tourner à droite
    OUTA=0, OUTB=0, OUTC=0, OUTD=0;
     OUTE=1, OUTF=0, OUTG=0, OUTH=0;
    	
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=0, OUTD=0;
     OUTE=1, OUTF=0, OUTG=0, OUTH=1;
     
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=0, OUTD=0;
     OUTE=0, OUTF=0, OUTG=0, OUTH=1;
      
    
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=0, OUTD=0;
     OUTE=0, OUTF=1, OUTG=0, OUTH=1;
     
    
     delay_ms(x);
    
     OUTA=0, OUTB=0, OUTC=0, OUTD=0;
     OUTE=0, OUTF=1, OUTG=0, OUTH=0;
    	
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=0, OUTD=0;
     OUTE=0, OUTF=1, OUTG=1, OUTH=0;
     
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=0, OUTD=0;
     OUTE=0, OUTF=0, OUTG=1, OUTH=0;
      
    
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=0, OUTD=0;
     OUTE=1, OUTF=0, OUTG=1, OUTH=0;
     
    
     delay_ms(x);
    break;
    
    case 0x47:
    // gauche : règles tes sorties pour tourner à gauche
    OUTA=1, OUTB=0, OUTC=0, OUTD=0;
     OUTE=0, OUTF=0, OUTG=0, OUTH=0;
    	
     delay_ms(x);
     
     OUTA=1, OUTB=0, OUTC=0, OUTD=1;
     OUTE=0, OUTF=0, OUTG=0, OUTH=0;
     
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=0, OUTD=1;
     OUTE=0, OUTF=0, OUTG=0, OUTH=0;
      
    
     delay_ms(x);
     
     OUTA=0, OUTB=1, OUTC=0, OUTD=1;
     OUTE=0, OUTF=0, OUTG=0, OUTH=0;
     
    
     delay_ms(x);
    
     OUTA=0, OUTB=1, OUTC=0, OUTD=0;
     OUTE=0, OUTF=0, OUTG=0, OUTH=0;
    	
     delay_ms(x);
     
     OUTA=0, OUTB=1, OUTC=1, OUTD=0;
     OUTE=0, OUTF=0, OUTG=0, OUTH=0;
     
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=1, OUTD=0;
     OUTE=0, OUTF=0, OUTG=0, OUTH=0;
      
    
     delay_ms(x);
     
     OUTA=1, OUTB=0, OUTC=1, OUTD=0;
     OUTE=0, OUTF=0, OUTG=0, OUTH=0;
     
    
     delay_ms(x);
    break;
    
    case 0x52:
    // recule : règles tes sorties pour reculer
    OUTA=1, OUTB=0, OUTC=1, OUTD=0;
     OUTE=1, OUTF=0, OUTG=1, OUTH=0;
    	
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=1, OUTD=0;
     OUTE=0, OUTF=0, OUTG=1, OUTH=0;
     
     delay_ms(x);
     
     OUTA=0, OUTB=1, OUTC=1, OUTD=0;
     OUTE=0, OUTF=1, OUTG=1, OUTH=0;
      
    
     delay_ms(x);
     
     OUTA=0, OUTB=1, OUTC=0, OUTD=0;
     OUTE=0, OUTF=1, OUTG=0, OUTH=0;
     
    
     delay_ms(x);
    
     OUTA=0, OUTB=1, OUTC=0, OUTD=1;
     OUTE=0, OUTF=1, OUTG=0, OUTH=1;
    	
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=0, OUTD=1;
     OUTE=0, OUTF=0, OUTG=0, OUTH=1;
     
     delay_ms(x);
     
     OUTA=1, OUTB=0, OUTC=0, OUTD=1;
     OUTE=1, OUTF=0, OUTG=0, OUTH=1;
      
    
     delay_ms(x);
     
     OUTA=1, OUTB=0, OUTC=0, OUTD=0;
     OUTE=1, OUTF=0, OUTG=0, OUTH=0;
     
    
     delay_ms(x);
    break;
    
    case 0x53:
    // stop : règles tes sorties pour ne plus bouger
    OUTA=0, OUTB=0, OUTC=0, OUTD=0;
    OUTE=0, OUTF=0, OUTG=0, OUTH=0;
    break;
    
    }
    }
    }

    le code usart #include usart.h

    Code:
    /******************************************************************************
     * USART Routines (2004.02.26)
     * Fabrice Médol
     * 
     * This file contains the USART routines.
     * Each routine's parameters are explained above the function declaration.
     ******************************************************************************
     */
    
    #ifndef	_USART_C
    #define _USART_C
    
    #include <pic18.h>
    #include "usart.h"
    
    
    near char ser_tmp;
    
    
    
    /*******************************************************************************
     * InitUSART
     *
     * This subroutine initializes the USART
     * Asynchronous Mode 
     * 8 bit
     * Reception & Transmission Interrupts enabled
     *******************************************************************************
     */
    
    void InitUSART(char VALEURBRG)
    {	SYNC=0; 	// Asynchronous mode
    	SPEN=1;		// Asynchronous mode
    	BRGH=1;		// High Speed Mode
    	SPBRG=VALEURBRG;	// Baud Rate = Fosc / (16*(SPBGR+1)
    
    	// Reception config
    	RX9=0;		// 8 bit reception
    	RCIE=0;		// Enable Reception Interrupt
    	CREN=1;		// Enable Reception
    	
    	// Transmission config
    	TX9=0;		// 8 bit transmission
    	TXIE=0;		// Enable Transmission Interrupt
    	TXEN=1;		// set bit TXIF to Enable Transmission
    	
    	TRISC6=0;	// TX output
    	TRISC7=1;	// RX intput
    	
    	// Flush RX Buffer
    	ser_tmp=RCREG;
    	ser_tmp=RCREG;
    	ser_tmp=RCREG;	
    }
    /*******************************************************************************
     * getch
     *
     * Read one byte from serial
     *
     * Returns : the byte received
     *******************************************************************************
     */
    
    unsigned char getch(void)
    {	while(!RCIF);
    	return (RCREG);
    }
    /*******************************************************************************
     * getchR
     *
     * Read one byte from serial with indication of reception error
     *
     * Returns : the byte received
     *******************************************************************************
     */
    
    unsigned char getchR(void)
    {
    	while (!(OERR || FERR || RCIF)) 
    	{
    		if (OERR) 
    		{
    			// overflow error
    			// disable_interrupt(GIE)?
    			CREN = 0;
    			ser_tmp = RCREG; // flush the rx buffer
    			ser_tmp = RCREG;
    			ser_tmp = RCREG;
    			CREN = 1;
    			// enable_interrupt(GIE)?
    		}
    		else if (FERR) 
    		{
    			// framing error
    			// disable_interrupt(GIE)?
    			ser_tmp = RCREG;
    			// enable_interrupt(GIE)?
    		}
    		else if (RCIF) 
    		{
    			// RCIF!
    			// disable_interrupt(GIE)?
    			ser_tmp = RCREG;
    			// enable_interrupt(GIE)?
    		}
    	}
    	return ser_tmp;
    }
    /*******************************************************************************
     * getch_nb
     *
     * non blockong Read one byte from serial
     *
     * Returns : the byte received or 0 if error
     *******************************************************************************
     */
    char getch_nb(void) 
    {
    	if (PIR1 & 32) {
    		ser_tmp = RCREG;
    		return ser_tmp;
    	} else {
    		return 0;
    	}
    }
    
    /*******************************************************************************
     * putch()
     * 
     * byte : the byte to send
     *
     * Write one byte to serial
     *******************************************************************************
     */
    
    void putch(char byte)
    {
    	while(!TXIF);
    	TXREG=byte;
    	//while(!TRMT);
    }
    
    /*******************************************************************************
     * put_string
     * 		s : a pointer on the string to send!
     *
     * Send string s to serial
     *******************************************************************************
     */
    void put_string(const unsigned char * text)
    {	char i = 0;
        while( text[i] !=0 )
            putch(text[i++]); 
    }
    
    /*******************************************************************************
    * envoi d'un octet au format hex
    ********************************************************************************
    */
    void tx_hex_byte(unsigned char val) 		
    {
       char c;
       c = conv_ascii((val>>4) & 0x0f);
       putch(c);
       c = conv_ascii(val&0x0f);
       putch(c);
    }
    /*******************************************************************************
    * envoi d'un octet au format decimal
    ********************************************************************************
    */
    void tx_dec_byte(unsigned char val) // displays byte in decimal
    {	unsigned char d;
       	char c;
       	d=val/100;
       	c=conv_ascii(d);
       	putch(c);
       
       	val=val%100;
       	d=val/10;
       	c=conv_ascii(d);
       	putch(c);   	
       
       	d=val % 10;
       	c=conv_ascii(d);
       	putch(c);
    }   
    /*******************************************************************************
    * conversion ascii
    ********************************************************************************
    */
    char conv_ascii(unsigned char val)	
    {
       char c;
       if (val < 10)
       {
         c=val+'0';
       }
       else
       {
         val=val-10;	   
         c=val + 'A';
       }
       return(c);
    }
    
    #endif

  15. #14
    invite067d8d6c

    Re : Pic18F2620 - usart - Rs232 - ascii

    Salut,

    Alors voici certaines choses que j'aimerai éclaircir.
    Peux-tu me donner la fréquence de ton quartz et la vitesse de communication de docklight (enfin de ton port COM) ??
    Lorsque tu envoies un ordre avec le pc, tu reçois le même ordre de la part de la carte??

    2ème chose. tu vas faire ceci:
    Sortir le case et le mettre dans une fonction avant le main()
    comme ceci

    Code:
    void control_moteur (char ordre)
    {
     switch (ordre)
     {
      case ......
      .......
     }
    }
    et dans le while(1) du main

    Code:
    while(1)
    {
     control_moteur(0x41);
     control_moteur(0x41);
     delay_ms(1000);
     control_moteur(0x53);
     delay_ms(1000);
    }
    Ceci devrait faire avancer un peu le robot puis le stopper, puis le refaire avancer ...

    @+

  16. #15
    invite960f35e5

    Re : Pic18F2620 - usart - Rs232 - ascii

    Citation Envoyé par Xtr£M Voir le message
    Alors voici certaines choses que j'aimerai éclaircir.
    Peux-tu me donner la fréquence de ton quartz et la vitesse de communication de docklight (enfin de ton port COM) ??
    Lorsque tu envoies un ordre avec le pc, tu reçois le même ordre de la part de la carte??
    - la fréquence du quartz est de 20 Mhz

    - la communication s est du 9600 bauds

    - oui quand j appuyais sur A , je voyais bien A revenir , peut importe la touche sa fonctionnait enfaite ...

    ps : mais la je suis un peu bloqué , je programmais avec une carte que j avais encore , sa fonctionnait et j ai fais une mauvaise manip , du coup ben voila ...
    j ai acheté un pickit2 pour pouvoir continué a programmé mais j arrive pas ...
    y a justement un sujet que j ai fais , si tu sais voir , qui sait , tu serais peut etre m aidé

    http://forums.futura-sciences.com/thread240411.html

  17. #16
    invite960f35e5

    Re : Pic18F2620 - usart - Rs232 - ascii

    voila nickel , mon pickit fonctionne donc je peux reprogrammé , v essayé ce que tu m as donné

  18. #17
    invite960f35e5

    Re : Pic18F2620 - usart - Rs232 - ascii

    voila donc j ai essayé comme ta dit ( je pense que j ai bien fais )

    enfaite sa fait bien le ptit demarrage et stop au depart ( tres court , normale ? )

    et apres sa allere de fonctionné , quand j appuie sur A , sa avance d un crant

    par contre : on dirait que peut importe la touche que j appuye , sa avance ...
    quand j appuie sur G ( pour gauche ) , les 2 tournes ...

    par contre , comment faire pour quand t appuye sur par exemple A , ben que sa avance tout le temp jusque quand je lache le doigt

    en tout cas en grand merci a toi pour ton aide

    voici le code :

    Code:
    #include <pic18.h>
    #include  <stdio.h> 
    #include <stdlib.h>
    #include "delay.h"
    #include "lcd.h"
    #include "usart.h"
    
    __CONFIG(1, HS&IESODIS&FCMDIS);
    __CONFIG(2, BORDIS&PWRTEN&WDTDIS );
    __CONFIG(3, PBANDIS);
    __CONFIG(4, LVPDIS&XINSTDIS&STVRDIS&LPT1DIS);
    __CONFIG(5, UNPROTECT);
    __CONFIG(6, WRTEN);
    
    #define S1 RA0
    #define S2 RA1
    #define S3 RA2
    #define S4 RA3
    
    #define OUTA RB3 
    #define OUTB RB2 
    #define OUTC RB1 
    #define OUTD RB0 
    
    
    #define OUTE RC0
    #define OUTF RC1
    #define OUTG RC2
    #define OUTH RC3
    
    int x=10;
    char ordre;
    
    void control_moteur (char ordre)
    {
    switch (ordre)
    {
    case 0x41:
    
    // avance : règles tes sorties pour avancer
    OUTA=1, OUTB=0, OUTC=0, OUTD=0;
    OUTE=1, OUTF=0, OUTG=0, OUTH=0;
    	
     delay_ms(x);
     
     OUTA=1, OUTB=0, OUTC=0, OUTD=1;
     OUTE=1, OUTF=0, OUTG=0, OUTH=1;
     
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=0, OUTD=1;
     OUTE=0, OUTF=0, OUTG=0, OUTH=1;
      
    
     delay_ms(x);
     
     OUTA=0, OUTB=1, OUTC=0, OUTD=1;
     OUTE=0, OUTF=1, OUTG=0, OUTH=1;
     
    
     delay_ms(x);
    
     OUTA=0, OUTB=1, OUTC=0, OUTD=0;
     OUTE=0, OUTF=1, OUTG=0, OUTH=0;
    	
     delay_ms(x);
     
     OUTA=0, OUTB=1, OUTC=1, OUTD=0;
     OUTE=0, OUTF=1, OUTG=1, OUTH=0;
     
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=1, OUTD=0;
     OUTE=0, OUTF=0, OUTG=1, OUTH=0;
      
    
     delay_ms(x);
     
     OUTA=1, OUTB=0, OUTC=1, OUTD=0;
     OUTE=1, OUTF=0, OUTG=1, OUTH=0;
     
    
     delay_ms(x);
    break;
    
    case 0x44:
    // droite : règles tes sorties pour tourner à droite
    OUTA=0, OUTB=0, OUTC=0, OUTD=0;
     OUTE=1, OUTF=0, OUTG=0, OUTH=0;
    	
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=0, OUTD=0;
     OUTE=1, OUTF=0, OUTG=0, OUTH=1;
     
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=0, OUTD=0;
     OUTE=0, OUTF=0, OUTG=0, OUTH=1;
      
    
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=0, OUTD=0;
     OUTE=0, OUTF=1, OUTG=0, OUTH=1;
     
    
     delay_ms(x);
    
     OUTA=0, OUTB=0, OUTC=0, OUTD=0;
     OUTE=0, OUTF=1, OUTG=0, OUTH=0;
    	
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=0, OUTD=0;
     OUTE=0, OUTF=1, OUTG=1, OUTH=0;
     
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=0, OUTD=0;
     OUTE=0, OUTF=0, OUTG=1, OUTH=0;
      
    
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=0, OUTD=0;
     OUTE=1, OUTF=0, OUTG=1, OUTH=0;
     
    
     delay_ms(x);
    break;
    
    case 0x47:
    // gauche : règles tes sorties pour tourner à gauche
    OUTA=1, OUTB=0, OUTC=0, OUTD=0;
     OUTE=0, OUTF=0, OUTG=0, OUTH=0;
    	
     delay_ms(x);
     
     OUTA=1, OUTB=0, OUTC=0, OUTD=1;
     OUTE=0, OUTF=0, OUTG=0, OUTH=0;
     
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=0, OUTD=1;
     OUTE=0, OUTF=0, OUTG=0, OUTH=0;
      
    
     delay_ms(x);
     
     OUTA=0, OUTB=1, OUTC=0, OUTD=1;
     OUTE=0, OUTF=0, OUTG=0, OUTH=0;
     
    
     delay_ms(x);
    
     OUTA=0, OUTB=1, OUTC=0, OUTD=0;
     OUTE=0, OUTF=0, OUTG=0, OUTH=0;
    	
     delay_ms(x);
     
     OUTA=0, OUTB=1, OUTC=1, OUTD=0;
     OUTE=0, OUTF=0, OUTG=0, OUTH=0;
     
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=1, OUTD=0;
     OUTE=0, OUTF=0, OUTG=0, OUTH=0;
      
    
     delay_ms(x);
     
     OUTA=1, OUTB=0, OUTC=1, OUTD=0;
     OUTE=0, OUTF=0, OUTG=0, OUTH=0;
     
    
     delay_ms(x);
    break;
    
    case 0x52:
    // recule : règles tes sorties pour reculer
    OUTA=1, OUTB=0, OUTC=1, OUTD=0;
     OUTE=1, OUTF=0, OUTG=1, OUTH=0;
    	
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=1, OUTD=0;
     OUTE=0, OUTF=0, OUTG=1, OUTH=0;
     
     delay_ms(x);
     
     OUTA=0, OUTB=1, OUTC=1, OUTD=0;
     OUTE=0, OUTF=1, OUTG=1, OUTH=0;
      
    
     delay_ms(x);
     
     OUTA=0, OUTB=1, OUTC=0, OUTD=0;
     OUTE=0, OUTF=1, OUTG=0, OUTH=0;
     
    
     delay_ms(x);
    
     OUTA=0, OUTB=1, OUTC=0, OUTD=1;
     OUTE=0, OUTF=1, OUTG=0, OUTH=1;
    	
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=0, OUTD=1;
     OUTE=0, OUTF=0, OUTG=0, OUTH=1;
     
     delay_ms(x);
     
     OUTA=1, OUTB=0, OUTC=0, OUTD=1;
     OUTE=1, OUTF=0, OUTG=0, OUTH=1;
      
    
     delay_ms(x);
     
     OUTA=1, OUTB=0, OUTC=0, OUTD=0;
     OUTE=1, OUTF=0, OUTG=0, OUTH=0;
     
    
     delay_ms(x);
    break;
    
    case 0x53:
    // stop : règles tes sorties pour ne plus bouger
    OUTA=0, OUTB=0, OUTC=0, OUTD=0;
    OUTE=0, OUTF=0, OUTG=0, OUTH=0;
    break;
    }
    }
    
    void main ()  
    {ADCON1=0x07;
     TRISA= 0b00000000;
     TRISB= 0b00000000;
     TRISC= 0b10000000;
    
    InitUSART (129);
    RC4=0;
    RC5=1;
    
    
    
    while (1)
    {
     control_moteur(0x41);
     control_moteur(0x41);
     delay_ms(1000);
     control_moteur(0x53);
     delay_ms(1000);
    
    // 1- on attend un caractère donc un ordre
    ordre = getch();
    
    // 2- on renvoie l'ordre que l'on vient de recevoir au pc
    putch(ordre);
    
    // 3- on traite l'ordre que l'on vient de recevoir!
    // je vais prendre 5 ordres! Ils sont en majuscules !! 
    // A (code 0x41) = avance
    // R (code 0x52) = recule
    // D (code 0x44) = droite
    // G (code 0x47) = gauche
    // S (code 0x53) = stop
    
    }
    }

  19. #18
    invite067d8d6c

    Re : Pic18F2620 - usart - Rs232 - ascii

    Re,

    Alors là je ne pense pas pourvoir t'aider plus que ça! En effet cela va dépendre du programme PC que tu utilises! Pour aller plus loin il va falloir commencer à coder de façon un peu plus sévère!
    Je pense qu'il va falloir que tu utilises la RS232 d'une façon différente!

    Par exemple, tant que tu n'as pas d'ordre sur la RS232 qui arrive, tu continues avec le dernier ordre reçu.
    Code:
    #include <pic18.h>
    #include  <stdio.h> 
    #include <stdlib.h>
    #include "delay.h"
    #include "lcd.h"
    #include "usart.h"
    
    __CONFIG(1, HS&IESODIS&FCMDIS);
    __CONFIG(2, BORDIS&PWRTEN&WDTDIS );
    __CONFIG(3, PBANDIS);
    __CONFIG(4, LVPDIS&XINSTDIS&STVRDIS&LPT1DIS);
    __CONFIG(5, UNPROTECT);
    __CONFIG(6, WRTEN);
    
    #define S1 RA0
    #define S2 RA1
    #define S3 RA2
    #define S4 RA3
    
    #define OUTA RB3 
    #define OUTB RB2 
    #define OUTC RB1 
    #define OUTD RB0 
    
    
    #define OUTE RC0
    #define OUTF RC1
    #define OUTG RC2
    #define OUTH RC3
    
    int x=10;
    char ordre;
    
    void control_moteur (char ordre)
    {
    switch (ordre)
    {
    case 0x41:
    
    // avance : règles tes sorties pour avancer
    OUTA=1, OUTB=0, OUTC=0, OUTD=0;
    OUTE=1, OUTF=0, OUTG=0, OUTH=0;
    	
     delay_ms(x);
     
     OUTA=1, OUTB=0, OUTC=0, OUTD=1;
     OUTE=1, OUTF=0, OUTG=0, OUTH=1;
     
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=0, OUTD=1;
     OUTE=0, OUTF=0, OUTG=0, OUTH=1;
      
    
     delay_ms(x);
     
     OUTA=0, OUTB=1, OUTC=0, OUTD=1;
     OUTE=0, OUTF=1, OUTG=0, OUTH=1;
     
    
     delay_ms(x);
    
     OUTA=0, OUTB=1, OUTC=0, OUTD=0;
     OUTE=0, OUTF=1, OUTG=0, OUTH=0;
    	
     delay_ms(x);
     
     OUTA=0, OUTB=1, OUTC=1, OUTD=0;
     OUTE=0, OUTF=1, OUTG=1, OUTH=0;
     
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=1, OUTD=0;
     OUTE=0, OUTF=0, OUTG=1, OUTH=0;
      
    
     delay_ms(x);
     
     OUTA=1, OUTB=0, OUTC=1, OUTD=0;
     OUTE=1, OUTF=0, OUTG=1, OUTH=0;
     
    
     delay_ms(x);
    break;
    
    case 0x44:
    // droite : règles tes sorties pour tourner à droite
    OUTA=0, OUTB=0, OUTC=0, OUTD=0;
     OUTE=1, OUTF=0, OUTG=0, OUTH=0;
    	
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=0, OUTD=0;
     OUTE=1, OUTF=0, OUTG=0, OUTH=1;
     
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=0, OUTD=0;
     OUTE=0, OUTF=0, OUTG=0, OUTH=1;
      
    
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=0, OUTD=0;
     OUTE=0, OUTF=1, OUTG=0, OUTH=1;
     
    
     delay_ms(x);
    
     OUTA=0, OUTB=0, OUTC=0, OUTD=0;
     OUTE=0, OUTF=1, OUTG=0, OUTH=0;
    	
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=0, OUTD=0;
     OUTE=0, OUTF=1, OUTG=1, OUTH=0;
     
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=0, OUTD=0;
     OUTE=0, OUTF=0, OUTG=1, OUTH=0;
      
    
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=0, OUTD=0;
     OUTE=1, OUTF=0, OUTG=1, OUTH=0;
     
    
     delay_ms(x);
    break;
    
    case 0x47:
    // gauche : règles tes sorties pour tourner à gauche
    OUTA=1, OUTB=0, OUTC=0, OUTD=0;
     OUTE=0, OUTF=0, OUTG=0, OUTH=0;
    	
     delay_ms(x);
     
     OUTA=1, OUTB=0, OUTC=0, OUTD=1;
     OUTE=0, OUTF=0, OUTG=0, OUTH=0;
     
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=0, OUTD=1;
     OUTE=0, OUTF=0, OUTG=0, OUTH=0;
      
    
     delay_ms(x);
     
     OUTA=0, OUTB=1, OUTC=0, OUTD=1;
     OUTE=0, OUTF=0, OUTG=0, OUTH=0;
     
    
     delay_ms(x);
    
     OUTA=0, OUTB=1, OUTC=0, OUTD=0;
     OUTE=0, OUTF=0, OUTG=0, OUTH=0;
    	
     delay_ms(x);
     
     OUTA=0, OUTB=1, OUTC=1, OUTD=0;
     OUTE=0, OUTF=0, OUTG=0, OUTH=0;
     
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=1, OUTD=0;
     OUTE=0, OUTF=0, OUTG=0, OUTH=0;
      
    
     delay_ms(x);
     
     OUTA=1, OUTB=0, OUTC=1, OUTD=0;
     OUTE=0, OUTF=0, OUTG=0, OUTH=0;
     
    
     delay_ms(x);
    break;
    
    case 0x52:
    // recule : règles tes sorties pour reculer
    OUTA=1, OUTB=0, OUTC=1, OUTD=0;
     OUTE=1, OUTF=0, OUTG=1, OUTH=0;
    	
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=1, OUTD=0;
     OUTE=0, OUTF=0, OUTG=1, OUTH=0;
     
     delay_ms(x);
     
     OUTA=0, OUTB=1, OUTC=1, OUTD=0;
     OUTE=0, OUTF=1, OUTG=1, OUTH=0;
      
    
     delay_ms(x);
     
     OUTA=0, OUTB=1, OUTC=0, OUTD=0;
     OUTE=0, OUTF=1, OUTG=0, OUTH=0;
     
    
     delay_ms(x);
    
     OUTA=0, OUTB=1, OUTC=0, OUTD=1;
     OUTE=0, OUTF=1, OUTG=0, OUTH=1;
    	
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=0, OUTD=1;
     OUTE=0, OUTF=0, OUTG=0, OUTH=1;
     
     delay_ms(x);
     
     OUTA=1, OUTB=0, OUTC=0, OUTD=1;
     OUTE=1, OUTF=0, OUTG=0, OUTH=1;
      
    
     delay_ms(x);
     
     OUTA=1, OUTB=0, OUTC=0, OUTD=0;
     OUTE=1, OUTF=0, OUTG=0, OUTH=0;
     
    
     delay_ms(x);
    break;
    
    case 0x53:
    // stop : règles tes sorties pour ne plus bouger
    OUTA=0, OUTB=0, OUTC=0, OUTD=0;
    OUTE=0, OUTF=0, OUTG=0, OUTH=0;
    break;
    }
    }
    
    void main ()  
    {
    char buffer_ordre;
    
     ADCON1=0x07;
     TRISA= 0b00000000;
     TRISB= 0b00000000;
     TRISC= 0b10000000;
    
    InitUSART (129);
    RC4=0;
    RC5=1;
    
    ordre = 0x53; // le robot est à l'arrêt
    
    while (1)
    {
    
    // 1- on essaie de lire un ordre
    buffer_ordre = getch_nb();
    // cette fonction va renvoyer soit l'ordre soit 0!
    
    if (buffer_ordre != 0)
    {
     ordre = buffer_ordre;
     putch(ordre);
    }
    
     control_moteur(ordre);
    }
    Voilà avec ça, ton système devrait commencer à être plus "fun"

    Bonne continuation

  20. #19
    invite960f35e5

    Re : Pic18F2620 - usart - Rs232 - ascii

    rah merci , c est nickel

    qu est ce que je suis heureux , s est incroyable , mon année est en jeu et la tu me sauves la vie j en suis très reconnaissant , chez pas comment te remercié pour le temps que tu m as consacré j y croyais plus ...

    enfin voila , pour la vitesse , s est nickel lol , y a rien de mieux

    par contre juste ptit problème , sa marche nickel mais PARFOIS , y a un probleme , quand je clique sur A ( donc sa avance ) parfois faut que j appuye genre 2,3 fois sur S pour stoppé ...

    a propos , je sais pas pk , sa renvoie pas la touche appuié ...
    y a t il moyen ou pas de genre quand j appuye sur A , il renvoie a l ecran de l ordi " le robot avance " ????
    pour S " le robot est stoppé " etc .

    voila apres sa serait nickel de chez nickel

    j attend ta reponse

  21. #20
    invite067d8d6c

    Re : Pic18F2620 - usart - Rs232 - ascii

    Re,

    Alors pour le premier problème, celui du stop qui n'est pas pris du premier coup il y a une solution mais je ne sais quel est ton niveau d'étude! Faut pas que ça fasse code qu'on t'as donné non plus.

    Pour le 2ème soucis celui de renvoyer une phrase c'est simple

    Code:
    while (1)
    {
    
    // 1- on essaie de lire un ordre
    buffer_ordre = getch_nb();
    // cette fonction va renvoyer soit l'ordre soit 0!
    
    if (buffer_ordre != 0)
    {
     ordre = buffer_ordre;
     switch(ordre)
     {
     case 0x41:
      put_string("le robot avance\0");
      break;
    
     case 0x44:
      put_string("le robot tourne a droite\0");
      break;
    
     case 0x47:
      put_string("le robot tourne a gauche\0");
      break;
    
     case 0x52:
      put_string("le robot recule\0");
      break;
    
     case 0x53:
      put_string("le robot est arrete\0");
      break;
     }
    }
    
     control_moteur(ordre);
    }
    Voilou!

  22. #21
    invite960f35e5

    Re : Pic18F2620 - usart - Rs232 - ascii

    oki merci

    a propos , pour le 1 er probleme , s est pas avec double while ???

    parce que je sais que y a aussi ce probleme causer par les bouton poussoir ou sa saute un passage

    si s est pas trop dur , tu peux tj me le faire et expliqué a coté a quoi sert chaque ligne

    comme ca tout sa sera nickel et fini

    parce que faudra que j explique aussi comment fonctionne mon programme donc si ta te dérange pas , m expliqué a quoi sert chaque ligne du programmage entier

  23. #22
    invite960f35e5

    Re : Pic18F2620 - usart - Rs232 - ascii

    ah oui , je voulais dire y a un ptit problème que j avais pas remarqué , les touches A , D ,G ,R fonctionne bien mais pour stoppé les moteurs , j ai l impression que peut importe la touche , sa se stop ... donc si j appuye sur Z , sa coupera aussi ...

    par contre un autre truc , j ai l impression que l information n arrive plus a l ordi ... chez pas si s est dans le code ou dans mon robot que y a un probleme ... serais tu m eclaircir

    merci

  24. #23
    invite960f35e5

    Re : Pic18F2620 - usart - Rs232 - ascii

    un ptit up

  25. #24
    invite067d8d6c

    Re : Pic18F2620 - usart - Rs232 - ascii

    Salut,

    Bon après un week-end bien mérité, me revoilà^^
    Alors concernant tes problèmes, j'ai pensé à plusieurs choses.
    1 - Ton état arrêt! As-tu des contraintes d'alimentation?? En effet quand tu est arrête, tu mets toutes les sorties à 0, donc je suppose que tu n'alimentes plus tes moteurs pas à pas, donc tu es en roue libre! Ne serait-il pas plus intéressant d'avoir un état roue libre et un état "freiné"??

    2 - Pour la réception, je te proposerai plutôt de travailler avec les interruptions du pic et c'est pour cela que je voulais connaitre ton niveau d'étude. Si tes profs voient que tu utilises des choses que tu n'as pas appris, il vont soit se dire que tu es hyper consciencieux, soit que tu as trouvé le code par magie.

    3 - Ton robot ne revoie plus l'ordre! Le problème vient peut-être de la façon dont est écrite la fonction put_string()! En effet, je n'avais pas fait attention, car tu dois lui donner un pointeur en entrée! Il faut donc créer des variables "const unsigned char" dans ton programme
    ex:
    Code:
    const unsigned char ordre_avance = "le robot avance\0";
    ....
    
    while (1)
    {
    
    // 1- on essaie de lire un ordre
    buffer_ordre = getch_nb();
    // cette fonction va renvoyer soit l'ordre soit 0!
    
    if (buffer_ordre != 0)
    {
     ordre = buffer_ordre;
     switch(ordre)
     {
     case 0x41:
      put_string(ordre_avance);
      break;
    ...
    Tu devrais avoir quelque chose comme ça!

    4 - Pour le problème de "stop" sur n'importe quel bouton il faut rajouter dans le switch un case default à la fin
    ex :
    Code:
    switch(ordre)
    {
     case 0x41: 
     .....
    
     case default:
      break;
    }
    Voilà pour le moment!
    @+

  26. #25
    invite960f35e5

    Re : Pic18F2620 - usart - Rs232 - ascii

    bonjour a toi te revoila

    donc voila , y a un probleme dans le code , je crois que y a des problemes dans le code :

    const unsigned char ordre_avancer = "le robot avance\0";
    const unsigned char ordre_droite = "le robot tourne a droite\0";
    const unsigned char ordre_gauche = "le robot tourne a gauche\0";
    const unsigned char ordre_reculer = "le robot recule\0";
    const unsigned char ordre_arreter = "le robot s'arrete\0";

    et le

    case default:
    break;

    voici l image :



    le illegal conversion et integer s est pour le const unsigned

    et le expression syntax s est pour le default

    voila le code , je pense que j ai mi au bonne endroit

    Code:
    #include <pic18.h>
    #include  <stdio.h> 
    #include <stdlib.h>
    #include "delay.h"
    #include "lcd.h"
    #include "usart.h"
    
    __CONFIG(1, HS&IESODIS&FCMDIS);
    __CONFIG(2, BORDIS&PWRTEN&WDTDIS );
    __CONFIG(3, PBANDIS);
    __CONFIG(4, LVPDIS&XINSTDIS&STVRDIS&LPT1DIS);
    __CONFIG(5, UNPROTECT);
    __CONFIG(6, WRTEN);
    
    #define S1 RA0
    #define S2 RA1
    #define S3 RA2
    #define S4 RA3
    
    #define OUTA RB3 
    #define OUTB RB2 
    #define OUTC RB1 
    #define OUTD RB0 
    
    
    #define OUTE RC0
    #define OUTF RC1
    #define OUTG RC2
    #define OUTH RC3
    
    int x=10;
    char ordre;
    
    const unsigned char ordre_avancer = "le robot avance\0";
    const unsigned char ordre_droite = "le robot tourne a droite\0";
    const unsigned char ordre_gauche = "le robot tourne a gauche\0";
    const unsigned char ordre_reculer = "le robot recule\0";
    const unsigned char ordre_arreter = "le robot s'arrete\0";
    
    void control_moteur (char ordre)
    {
    switch (ordre)
    {
    case 0x41:
    
    // avance : règles tes sorties pour avancer
    OUTA=1, OUTB=0, OUTC=0, OUTD=0;
    OUTE=1, OUTF=0, OUTG=0, OUTH=0;
    	
     delay_ms(x);
     
     OUTA=1, OUTB=0, OUTC=0, OUTD=1;
     OUTE=1, OUTF=0, OUTG=0, OUTH=1;
     
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=0, OUTD=1;
     OUTE=0, OUTF=0, OUTG=0, OUTH=1;
      
    
     delay_ms(x);
     
     OUTA=0, OUTB=1, OUTC=0, OUTD=1;
     OUTE=0, OUTF=1, OUTG=0, OUTH=1;
     
    
     delay_ms(x);
    
     OUTA=0, OUTB=1, OUTC=0, OUTD=0;
     OUTE=0, OUTF=1, OUTG=0, OUTH=0;
    	
     delay_ms(x);
     
     OUTA=0, OUTB=1, OUTC=1, OUTD=0;
     OUTE=0, OUTF=1, OUTG=1, OUTH=0;
     
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=1, OUTD=0;
     OUTE=0, OUTF=0, OUTG=1, OUTH=0;
      
    
     delay_ms(x);
     
     OUTA=1, OUTB=0, OUTC=1, OUTD=0;
     OUTE=1, OUTF=0, OUTG=1, OUTH=0;
     
    
     delay_ms(x);
    break;
    
    case 0x44:
    // droite : règles tes sorties pour tourner à droite
    OUTA=0, OUTB=0, OUTC=0, OUTD=0;
     OUTE=1, OUTF=0, OUTG=0, OUTH=0;
    	
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=0, OUTD=0;
     OUTE=1, OUTF=0, OUTG=0, OUTH=1;
     
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=0, OUTD=0;
     OUTE=0, OUTF=0, OUTG=0, OUTH=1;
      
    
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=0, OUTD=0;
     OUTE=0, OUTF=1, OUTG=0, OUTH=1;
     
    
     delay_ms(x);
    
     OUTA=0, OUTB=0, OUTC=0, OUTD=0;
     OUTE=0, OUTF=1, OUTG=0, OUTH=0;
    	
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=0, OUTD=0;
     OUTE=0, OUTF=1, OUTG=1, OUTH=0;
     
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=0, OUTD=0;
     OUTE=0, OUTF=0, OUTG=1, OUTH=0;
      
    
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=0, OUTD=0;
     OUTE=1, OUTF=0, OUTG=1, OUTH=0;
     
    
     delay_ms(x);
    break;
    
    case 0x47:
    // gauche : règles tes sorties pour tourner à gauche
    OUTA=1, OUTB=0, OUTC=0, OUTD=0;
     OUTE=0, OUTF=0, OUTG=0, OUTH=0;
    	
     delay_ms(x);
     
     OUTA=1, OUTB=0, OUTC=0, OUTD=1;
     OUTE=0, OUTF=0, OUTG=0, OUTH=0;
     
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=0, OUTD=1;
     OUTE=0, OUTF=0, OUTG=0, OUTH=0;
      
    
     delay_ms(x);
     
     OUTA=0, OUTB=1, OUTC=0, OUTD=1;
     OUTE=0, OUTF=0, OUTG=0, OUTH=0;
     
    
     delay_ms(x);
    
     OUTA=0, OUTB=1, OUTC=0, OUTD=0;
     OUTE=0, OUTF=0, OUTG=0, OUTH=0;
    	
     delay_ms(x);
     
     OUTA=0, OUTB=1, OUTC=1, OUTD=0;
     OUTE=0, OUTF=0, OUTG=0, OUTH=0;
     
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=1, OUTD=0;
     OUTE=0, OUTF=0, OUTG=0, OUTH=0;
      
    
     delay_ms(x);
     
     OUTA=1, OUTB=0, OUTC=1, OUTD=0;
     OUTE=0, OUTF=0, OUTG=0, OUTH=0;
     
    
     delay_ms(x);
    break;
    
    case 0x52:
    // recule : règles tes sorties pour reculer
    OUTA=1, OUTB=0, OUTC=1, OUTD=0;
     OUTE=1, OUTF=0, OUTG=1, OUTH=0;
    	
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=1, OUTD=0;
     OUTE=0, OUTF=0, OUTG=1, OUTH=0;
     
     delay_ms(x);
     
     OUTA=0, OUTB=1, OUTC=1, OUTD=0;
     OUTE=0, OUTF=1, OUTG=1, OUTH=0;
      
    
     delay_ms(x);
     
     OUTA=0, OUTB=1, OUTC=0, OUTD=0;
     OUTE=0, OUTF=1, OUTG=0, OUTH=0;
     
    
     delay_ms(x);
    
     OUTA=0, OUTB=1, OUTC=0, OUTD=1;
     OUTE=0, OUTF=1, OUTG=0, OUTH=1;
    	
     delay_ms(x);
     
     OUTA=0, OUTB=0, OUTC=0, OUTD=1;
     OUTE=0, OUTF=0, OUTG=0, OUTH=1;
     
     delay_ms(x);
     
     OUTA=1, OUTB=0, OUTC=0, OUTD=1;
     OUTE=1, OUTF=0, OUTG=0, OUTH=1;
      
    
     delay_ms(x);
     
     OUTA=1, OUTB=0, OUTC=0, OUTD=0;
     OUTE=1, OUTF=0, OUTG=0, OUTH=0;
     
    
     delay_ms(x);
    break;
    
    
    case 0x53:
    // stop : règles tes sorties pour ne plus bouger
    OUTA=0, OUTB=0, OUTC=0, OUTD=0;
    OUTE=0, OUTF=0, OUTG=0, OUTH=0;
    break;
    
    case default:
      break;
    
    }
    }
    
    void main ()  
    {
    char buffer_ordre;
    
     ADCON1=0x07;
     TRISA= 0b00000000;
     TRISB= 0b00000000;
     TRISC= 0b10000000;
    
    InitUSART (129);
    RC4=0;
    RC5=1;
    
    ordre = 0x53; // le robot est à l'arrêt
    
    
    while (1)
    {
    
    // 1- on essaie de lire un ordre
    buffer_ordre = getch_nb();
    // cette fonction va renvoyer soit l'ordre soit 0!
    
    if (buffer_ordre != 0)
    {
     ordre = buffer_ordre;
     switch(ordre)
     {
     case 0x41:
      put_string(ordre_avancer);
      break;
    
     case 0x44:
      put_string(ordre_droite);
      break;
    
     case 0x47:
      put_string(ordre_gauche);
      break;
    
     case 0x52:
      put_string(ordre_reculer);
      break;
    
     case 0x53:
      put_string(ordre_arreter);
      break;
    
     }
    }
    
     control_moteur(ordre);
    }}

  27. #26
    invite067d8d6c

    Re : Pic18F2620 - usart - Rs232 - ascii

    Oups,

    c'est pas une grosse erreur mais ce n'est pas case default mais default tout court

    Pour les warnings faut mettre ça:
    const unsigned char *ordre_avancer = "le robot avance\0";

    Bonne chance

  28. #27
    invite960f35e5

    Re : Pic18F2620 - usart - Rs232 - ascii

    voila j ai essayé ce que tu m as dit , j ai effectivement plus l erreur

    mais par contre , j ai tj le meme probleme , peut importe la touche , sa stop les moteurs

    et l information n arrive tj pas a l ordi je comprend pas parce que avant , sa marchait l autre fois ....

    ché pas si s est une erreur dans le code ou bien dans mon circuit pour renvoié l information ...

    mais tu parlais de interruption ect , peut etre que faut d office passé par la ??

    voila

  29. #28
    invite067d8d6c

    Re : Pic18F2620 - usart - Rs232 - ascii

    Exact encore une erreur bête de ma part!

    Voilà pour le problème de bouton qui arrête le robot!

    Code:
    while (1)
    {
    
    // 1- on essaie de lire un ordre
    buffer_ordre = getch_nb();
    // cette fonction va renvoyer soit l'ordre soit 0!
    
    if ((buffer_ordre == 0x41) || (buffer_ordre == 0x44) || (buffer_ordre == 0x47) || (buffer_ordre == 0x52) || (buffer_ordre == 0x53))
    {
     ordre = buffer_ordre;
     switch(ordre)
     {
     case 0x41:
      put_string(ordre_avancer);
      break;
    
     case 0x44:
      put_string(ordre_droite);
      break;
    
     case 0x47:
      put_string(ordre_gauche);
      break;
    
     case 0x52:
      put_string(ordre_reculer);
      break;
    
     case 0x53:
      put_string(ordre_arreter);
      break;
    
     }
    }
    }

  30. #29
    invite960f35e5

    Re : Pic18F2620 - usart - Rs232 - ascii

    ouais voila nickel pour l arret du robot

    par contre pour l envoie d information , comment je pourrais faire ???

    tu me parlais d interruption ect ??? ca sert a quoi ??? sa je comprend pas trop .... tu pourrais m eclairé

    a propos , ils savent bien que je serai aidé tant que j arrive a expliqué comment sa fonctionne

    enfin j aimerais des explications

    1 - Ton état arrêt! As-tu des contraintes d'alimentation?? En effet quand tu est arrête, tu mets toutes les sorties à 0, donc je suppose que tu n'alimentes plus tes moteurs pas à pas, donc tu es en roue libre! Ne serait-il pas plus intéressant d'avoir un état roue libre et un état "freiné"??

    2 - Pour la réception, je te proposerai plutôt de travailler avec les interruptions du pic et c'est pour cela que je voulais connaitre ton niveau d'étude. Si tes profs voient que tu utilises des choses que tu n'as pas appris, il vont soit se dire que tu es hyper consciencieux, soit que tu as trouvé le code par magie.

  31. #30
    invite067d8d6c

    Re : Pic18F2620 - usart - Rs232 - ascii

    Reuh,

    Bon alors ça avance c'est déjà ça!
    Pour l'envoie d'informations, j'ai des doutes sur la fonction que tu utilises, celle de UART.H. En fait, je ne suis pas sur qu'il renvoie la chaîne de caractères! Donc pour l'instant on mets de coté!

    Pour les "contraintes d'alimentation" , je pense que lorsque ton robot est dans la position arrêt! Tu dois pouvoir tourner les roues non?? Ou je me trompe ??

    Concernant les interruptions, en fait ça permet au pic d'arrêter ce qu'il est en train de faire pour recevoir l'ordre. Par exemple tu es en train d'avancer et tu reçoit un ordre! Alors le pic va directement lire l'ordre que tu envoies avec ton PC! Mais bon il faut que je me plonge vraiment dedans et ça va être plus dur de t'expliquer.

Page 1 sur 2 1 DernièreDernière

Discussions similaires

  1. Stéréogramme en ASCII
    Par invitee58f5773 dans le forum Logiciel - Software - Open Source
    Réponses: 0
    Dernier message: 02/06/2007, 11h00
  2. utilisation PIC18F2620
    Par invite9b9d0eb8 dans le forum Électronique
    Réponses: 0
    Dernier message: 22/11/2006, 09h07
  3. ascii to décimal
    Par invite3c59dc04 dans le forum Logiciel - Software - Open Source
    Réponses: 2
    Dernier message: 30/05/2006, 22h35
  4. [Pic18F2620]Configuration du Timer
    Par invitef0dd4a99 dans le forum Électronique
    Réponses: 0
    Dernier message: 03/05/2005, 20h00
  5. Caractère ASCII sur Trame RS232
    Par JP dans le forum Électronique
    Réponses: 6
    Dernier message: 04/09/2003, 01h38
Dans la rubrique Tech de Futura, découvrez nos comparatifs produits sur l'informatique et les technologies : imprimantes laser couleur, casques audio, chaises gamer...