Répondre à la discussion
Page 1 sur 2 1 DernièreDernière
Affichage des résultats 1 à 30 sur 41

ATSAMD21J18 - problème USART



  1. #1
    marcuccio19

    ATSAMD21J18 - problème USART


    ------

    Bonjour à tous, je suis débutant concernant la programmation de systèmes embarqués, je veux envoyer un chiffre via l'USART.

    J'utilise un ATSAMD21J18 et le convertisseur UART->USB est un UM232H

    enfaite je sais que le registre DATA ne doit être écrit que lorsque INTFLAG.DRE est mis à '1' mais j'ai déja essayé mais cela ne fonctionne pas dans mon programme.

    Si quelqu'un peut m'aider, ce serait très reconnaissant.

    voici mes codes :

    definitions.h :
    Code:
    #ifndef DEFINITIONS_H_
    #define DEFINITIONS_H_
    
    #define TXD_LED		PORT_PB08D_SERCOM4_PAD0
    #define RXD_LED		PORT_PB09D_SERCOM4_PAD1
    
    
    #endif /* DEFINITIONS_H_ */
    pin_config.c :
    Code:
    #include "sam.h"
    
    #include "definitions.h"
    
    void pin_config()
    {
    	REG_PORT_DIR1 |= TXD_LED; // configure TXD_LED comme une sortie
    	REG_PORT_OUT1 |= TXD_LED; // active la sortie
    	REG_PORT_PMUX1 |= PORT_PMUX_PMUXE_D; // sélectionne la fonction périphérique D pour les pins paires
    	//REG_PORT_PMUX1 |= PORT_PMUX_PMUXO_D; // sélectionne la fonction périphérique D pour les pins impaires
    	REG_PORT_PINCFG1 |= PORT_PINCFG_INEN; // 
    	REG_PORT_PINCFG1 |= PORT_PINCFG_PMUXEN; // La sélection du multiplexeur périphérique est activée et la fonction périphérique sélectionnée 
    	 										// contrôle la direction et la valeur de commande de sortie.
    }
    clock_config.c :
    Code:
    #include "sam.h"
    
    void clock_config()
    {
    	REG_SYSCTRL_XOSC |= SYSCTRL_XOSC_ENABLE; // active l'oscillateur
    	REG_SYSCTRL_XOSC |= SYSCTRL_XOSC_XTALEN; // mode oscillateur à quartz
    	REG_SYSCTRL_XOSC |= SYSCTRL_XOSC_RUNSTDBY;
    	REG_SYSCTRL_XOSC &= ~(SYSCTRL_XOSC_ONDEMAND); // oscillateur toujours en fonctionnement en mode veille et standby
    	REG_SYSCTRL_XOSC |= SYSCTRL_XOSC_AMPGC; // ajuste automatiquement le gain de l'oscillateur
    	
    	REG_GCLK_GENDIV = GCLK_GENDIV_ID(0x0) | GCLK_GENDIV_DIV(0x1);
    				// sélectionne GCLK_GEN0	// fGCLK0 = fXOSC / GENDIV.DIV
    											// fGCLK0 = 12*10^6 / 1 = 12MHz
    	while(GCLK->STATUS.bit.SYNCBUSY == 1); 	// attend que la synchronisation entre 
    											// les domaines d'horloge est complète									
    							
    	REG_GCLK_GENCTRL = GCLK_GENCTRL_ID(0x0) | GCLK_GENCTRL_SRC_XOSC | GCLK_GENCTRL_GENEN;  
    			// sélectionne ID GCLK_GEN0	// XOSC comme source d'horloge	// GCLK_GEN0 activé
    			
    	while(GCLK->STATUS.bit.SYNCBUSY == 1);	// attend que la synchronisation entre
    											// les domaines d'horloge est complète	
    					
    	
    	REG_GCLK_CLKCTRL = GCLK_CLKCTRL_ID_SERCOM4_CORE | GCLK_CLKCTRL_GEN_GCLK0 | GCLK_CLKCTRL_CLKEN;
    					// sélectionne l'ID SERCOM4		// sélectionne GCLK_GEN0	// active l'horloge générique
    					
    	 REG_PM_APBASEL |= PM_APBASEL_APBADIV_DIV1; // l'horloge APBA est divisée par 1
    	 REG_PM_APBAMASK |= PM_APBAMASK_SYSCTRL;	// L'horloge APBA pour SYSCTRL est activée.
    	 REG_PM_APBAMASK |= PM_APBAMASK_GCLK;	// L'horloge APBA pour GCLK est activée.
    	 REG_PM_APBAMASK |= PM_APBAMASK_PM;	// L'horloge APBA pour PM est activée.
    	 REG_PM_CPUSEL |= PM_CPUSEL_CPUDIV_DIV1;	// fCPU = fGCLK0 / 1
    												// fCPU = 12MHz
    												
    	 REG_PM_APBCSEL |= PM_APBCSEL_APBCDIV_DIV1; // fAPBC = fCPU = 12MHz	
    	 REG_PM_APBCMASK |= PM_APBCMASK_SERCOM4; // active le bus d'horloge SERCOM4		
    }
    usart_config.c :
    Code:
    #include "sam.h"
    
    void usart_config()
    {	
    	REG_SERCOM4_USART_CTRLA |= SERCOM_USART_CTRLA_MODE_USART_INT_CLK; // sélectionne une horloge interne
    	REG_SERCOM4_USART_CTRLA |= SERCOM_USART_CTRLA_CMODE; // choisis le mode synchrone
    	//REG_SERCOM4_USART_CTRLA |= SERCOM_USART_CTRLA_RXPO(0x1); // SERCOM_PAD[1] est utilisé pour la réception
    	REG_SERCOM4_USART_CTRLA |= SERCOM_USART_CTRLA_TXPO(0x0); // SERCOM_PAD[0] est utilisé pour la transmission
    	REG_SERCOM4_USART_CTRLA |= SERCOM_USART_CTRLA_RUNSTDBY;
    	
    	REG_SERCOM4_USART_CTRLB |= SERCOM_USART_CTRLB_CHSIZE(0x0); // choisis une taille de caractère : 8 bits 
    	while(SERCOM4->USART.SYNCBUSY.bit.CTRLB == 1); // attend la que synchro est complète 
    	REG_SERCOM4_USART_CTRLA |= SERCOM_USART_CTRLA_DORD; // le bit LSB est envoyé en premier
     
    	REG_SERCOM4_USART_CTRLA |= SERCOM_USART_CTRLA_FORM(0x0); // pas de bit de parité 
    	REG_SERCOM4_USART_CTRLB &= ~(SERCOM_USART_CTRLB_SBMODE); // 1 bit stop
    	while(SERCOM4->USART.SYNCBUSY.bit.CTRLB == 1);	// attend la que synchro est complète
    	
    	REG_SERCOM4_USART_BAUD |= SERCOM_USART_BAUD_BAUD(0x270);	// je veux une fBAUD = 9600
    																// fBAUD = FXOSC / 2*(BAUD + 1)
    																// donc BAUD = (FXOSC / 2*fBAUD) - 1
    																// BAUD = 624 <=> 0x270 en hexa
    										  
    	REG_SERCOM4_USART_CTRLB |= SERCOM_USART_CTRLB_TXEN; // active la transmission de données
    	while(SERCOM4->USART.SYNCBUSY.bit.CTRLB == 1);	// attend la que synchro est complète
    	//REG_SERCOM4_USART_CTRLB |= SERCOM_USART_CTRLB_RXEN;	// active la réception de données
    	//while(SERCOM4->USART.SYNCBUSY.bit.CTRLB == 1);	// attend la que synchro est complète
    	REG_SERCOM4_USART_CTRLA |= SERCOM_USART_CTRLA_ENABLE; // active le périphérique SERCOM4
    	while(SERCOM4->USART.SYNCBUSY.bit.ENABLE == 1);	// attend la que synchro est complète
    							  
    }
    usart_tx.c :
    Code:
    #include "sam.h"
    
    int usart_tx()
    {
    	if (SERCOM4->USART.INTFLAG.bit.DRE == 1) // si INTFLAG.DRE = 1, alors
    	{
    		REG_SERCOM4_USART_DATA |= 0x1; // écris "1" dans le registre DATA
    	}
    }
    main.c :
    Code:
    #include "sam.h"
    #include "definitions.h"
    #include "pin_config.h"
    #include "clock_config.h"
    #include "usart_config.h"
    #include "usart_tx.h"
    
    int main(void)
    {
    	pin_config();
    	clock_config();
    	usart_config();
    	usart_tx();
    	
    	while (1);
    	
    }

    -----
    Dernière modification par marcuccio19 ; 04/12/2020 à 20h33. Motif: explications supplémentaires

  2. Publicité
  3. #2
    marcuccio19

    Re : ATSAMD21J18 - problème USART

    j'ai oublié d'insérer les datasheets donc les voici :

    ATSAMD21J18 : https://ww1.microchip.com/downloads/...S40001882F.pdf

    UM232H : https://www.ftdichip.com/Support/Doc.../DS_UM232H.pdf

  4. #3
    Exotique

    Re : ATSAMD21J18 - problème USART

    Hello,
    je ne connais ton µC mais peux-tu préciser quel moyen tu utilises pour vérifier ta communication (Teraterm ou autre).
    Vérifie que la comm de ton PC est bien à 9600 bauds.
    Utilise un moyen de comm que tu sais déjà bien fonctionnel, ça évite de tourner en rond avec des problèmes matériels (câble, config, etc).

    Un chiffre doit être envoyé sous forme d'un caractère ASCII, avec généralement un caractère de fin d'envoi ou un délimiteur selon l'appli, détectable par le receveur.
    Je vois que tu ne l'envoies qu'une seule fois avec ensuite un while(1) qui fait tourner dans une boucle infinie, pour le moment utilise plutôt un envoi toutes les 100ms par exemple et vérifie bien si ta fonction d'envoi formate bien l'envoi de ton chiffre.
    Dernière modification par Exotique ; 05/12/2020 à 09h25.

  5. #4
    Exotique

    Re : ATSAMD21J18 - problème USART

    Essaye la fonction d'envoi sous cette forme:
    Code:
    int usart_tx()
    {
    	while(!(REG_SERCOM4_USART_INTFLAG & 1)) {}  /* attente que le bit du registre d'envoi de donnée soit vide*/
    	{
    		REG_SERCOM4_USART_DATA |= 0x1; // écris "1" dans le registre DATA
    	}
    }

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

    Re : ATSAMD21J18 - problème USART

    Et ajoute ça:
    Code:
    //usart_tx(); //mettre en commentaire cette ligne
    	
    	while (1)
                    {
                     usart_tx(); // envoi de la donnée sur l'UART
                     delay_ms(100); // voir selon ton compilateur comment se déclare une tempo de 100ms
                    }

  8. #6
    marcuccio19

    Re : ATSAMD21J18 - problème USART

    @Exotique :
    peux-tu préciser quel moyen tu utilises pour vérifier ta communication (Teraterm ou autre).
    J'utilise Realterm.

    je vais essayé ce que vous m'avez dit et je vous tiens au courant.

  9. Publicité
  10. #7
    marcuccio19

    Re : ATSAMD21J18 - problème USART

    voila j'ai modifié un peu mon code et maintenant j'ai réussi à envoyer quelque chose mais il m'affiche un caractère nul
    en mode ASCII :
    test_envoi.JPG

    en mode hexa :
    test_envoi_hexa.JPG

  11. #8
    Exotique

    Re : ATSAMD21J18 - problème USART

    Ca avance
    Tu peux reposter ton code?

  12. #9
    marcuccio19

    Re : ATSAMD21J18 - problème USART

    @Exotique : oui voilà, j'ai écrit seulement ceux que j'ai modifié

    pin_config.c :
    Code:
    #include "sam.h"
    
    #include "definitions.h"
    
    void pin_config()
    {
    	REG_PORT_DIR1 |= TXD_LED; // configure TXD_LED comme une sortie
    	REG_PORT_DIR1 &= ~(RXD_LED); // configure RXD_LED comme entrée
    	REG_PORT_OUT1 |= RXD_LED;
    	REG_PORT_PMUX1 |= PORT_PMUX_PMUXE_D; // sélectionne la fonction périphérique D pour les pins paires
    	REG_PORT_PMUX1 |= PORT_PMUX_PMUXO_D; // sélectionne la fonction périphérique D pour les pins impaires
    	REG_PORT_PINCFG1 |= PORT_PINCFG_PULLEN;
    	REG_PORT_PINCFG1 |= PORT_PINCFG_INEN;  
    	REG_PORT_PINCFG1 |= PORT_PINCFG_PMUXEN; // La sélection du multiplexeur périphérique est activée et la fonction périphérique sélectionnée 
    	 										// contrôle la direction et la valeur de commande de sortie.
    }
    clock_config.c :
    Code:
    #include "sam.h"
    
    void clock_config()
    {
    	REG_SYSCTRL_XOSC |= SYSCTRL_XOSC_ENABLE; // active l'oscillateur
    	REG_SYSCTRL_XOSC |= SYSCTRL_XOSC_XTALEN; // mode oscillateur à quartz
    	REG_SYSCTRL_XOSC |= SYSCTRL_XOSC_RUNSTDBY;
    	REG_SYSCTRL_XOSC &= ~(SYSCTRL_XOSC_ONDEMAND); // oscillateur toujours en fonctionnement en mode veille et standby
    	REG_SYSCTRL_XOSC |= SYSCTRL_XOSC_AMPGC; // ajuste automatiquement le gain de l'oscillateur
    	
    	REG_GCLK_GENDIV = GCLK_GENDIV_ID(0x0) | GCLK_GENDIV_DIV(0x1);
    				// sélectionne GCLK_GEN0	// fGCLK0 = fXOSC / GENDIV.DIV
    											// fGCLK0 = 12*10^6 / 1 = 12MHz
    	//while(GCLK->STATUS.bit.SYNCBUSY == 1); 	// attend que la synchronisation entre 
    											// les domaines d'horloge est complète									
    							
    	REG_GCLK_GENCTRL = GCLK_GENCTRL_ID(0x0) | GCLK_GENCTRL_SRC_XOSC | GCLK_GENCTRL_GENEN;  
    			// sélectionne ID GCLK_GEN0	// XOSC comme source d'horloge	// GCLK_GEN0 activé
    			
    	//while(GCLK->STATUS.bit.SYNCBUSY == 1);	// attend que la synchronisation entre
    											// les domaines d'horloge est complète	
    					
    	
    	REG_GCLK_CLKCTRL = GCLK_CLKCTRL_ID_SERCOM4_CORE | GCLK_CLKCTRL_GEN_GCLK0 | GCLK_CLKCTRL_CLKEN;
    					// sélectionne l'ID SERCOM4		// sélectionne GCLK_GEN0	// active l'horloge générique
    					
    	 REG_PM_APBASEL |= PM_APBASEL_APBADIV_DIV1; // l'horloge APBA est divisée par 1
    	 REG_PM_APBAMASK |= PM_APBAMASK_SYSCTRL;	// L'horloge APBA pour SYSCTRL est activée.
    	 REG_PM_APBAMASK |= PM_APBAMASK_GCLK;	// L'horloge APBA pour GCLK est activée.
    	 REG_PM_APBAMASK |= PM_APBAMASK_PM;	// L'horloge APBA pour PM est activée.
    	 REG_PM_CPUSEL |= PM_CPUSEL_CPUDIV_DIV1;	// fCPU = fGCLK0 / 1
    												// fCPU = 12MHz
    												
    	 REG_PM_APBCSEL |= PM_APBCSEL_APBCDIV_DIV1; // fAPBC = fCPU = 12MHz	
    	 REG_PM_APBCMASK |= PM_APBCMASK_SERCOM4; // active le bus d'horloge SERCOM4		
    }
    usart_config.c :
    Code:
    #include "sam.h"
    
    void usart_config()
    {	
    	REG_SERCOM4_USART_CTRLA |= SERCOM_USART_CTRLA_MODE_USART_INT_CLK; // sélectionne une horloge interne
    	REG_SERCOM4_USART_CTRLA &= ~(SERCOM_USART_CTRLA_CMODE); // choisis le mode asynchrone
    	REG_SERCOM4_USART_CTRLA |= SERCOM_USART_CTRLA_RXPO(0x1); // SERCOM_PAD[1] est utilisé pour la réception
    	REG_SERCOM4_USART_CTRLA |= SERCOM_USART_CTRLA_TXPO(0x0); // SERCOM_PAD[0] est utilisé pour la transmission
    	REG_SERCOM4_USART_CTRLA |= SERCOM_USART_CTRLA_RUNSTDBY;
    	
    	REG_SERCOM4_USART_CTRLB |= SERCOM_USART_CTRLB_CHSIZE(0x0); // choisis une taille de caractère : 8 bits 
    	//while(SERCOM4->USART.SYNCBUSY.bit.CTRLB == 1); // attend la que synchro est complète 
    	REG_SERCOM4_USART_CTRLA |= SERCOM_USART_CTRLA_DORD; // le bit LSB est envoyé en premier
     
    	REG_SERCOM4_USART_CTRLA |= SERCOM_USART_CTRLA_FORM(0x0); // pas de bit de parité 
    	REG_SERCOM4_USART_CTRLB &= ~(SERCOM_USART_CTRLB_SBMODE); // 1 bit stop
    	//while(SERCOM4->USART.SYNCBUSY.bit.CTRLB == 1);	// attend la que synchro est complète
    	
    	REG_SERCOM4_USART_CTRLA |= SERCOM_USART_CTRLA_SAMPR(0x0); // Suréchantillonnage 16x utilisant la génération arithmétique du baudrate
    	//REG_SERCOM4_USART_CTRLA |= SERCOM_USART_CTRLA_SAMPA(0x3); // ajuste l'échantillonement 
    	
    	REG_SERCOM4_USART_BAUD |= SERCOM_USART_BAUD_BAUD(0xFCB9);	// je veux une fBAUD = 9600
    																// fBAUD = FXOSC/16*(1-BAUD/65536)
    																// donc BAUD = 65536*(1-16*fBAUD/fXOSC)
    																// BAUD = 64697 <=> 0xFCB9 en hexa
    										  
    	REG_SERCOM4_USART_CTRLB |= SERCOM_USART_CTRLB_TXEN; // active la transmission de données
    	//while(SERCOM4->USART.SYNCBUSY.bit.CTRLB == 1);	// attend la que synchro est complète
    	REG_SERCOM4_USART_CTRLB |= SERCOM_USART_CTRLB_RXEN;	// active la réception de données
    	//while(SERCOM4->USART.SYNCBUSY.bit.CTRLB == 1);	// attend la que synchro est complète
    	REG_SERCOM4_USART_CTRLA |= SERCOM_USART_CTRLA_ENABLE; // active le périphérique SERCOM4
    	//while(SERCOM4->USART.SYNCBUSY.bit.ENABLE == 1);	// attend la que synchro est complète
    							  
    }
    usart_tx.c :
    Code:
    #include "sam.h"
    
    int usart_tx()
    {	
    		while(!(REG_SERCOM4_USART_INTFLAG & 1)) {}  /* attente que le bit du registre d'envoi de donnée soit vide*/
    		{
    			REG_SERCOM4_USART_DATA |= 0x1; // écris "1" dans le registre DATA
    		}
    }
    delay.c :
    Code:
    #include "sam.h"
    
    int n = 100000;
    
    void delay() // délai 1sec
    {
    	for (int i = 0; i < n; i++)
    	asm("nop");
    }
    main.c :
    Code:
    int main(void)
    {
    	pin_config();
    	clock_config();
    	usart_config();
    	
    	while(1)
    	{
    			usart_tx(); // envoi de la donnée sur l'UART
    			delay(); // délai 1sec
    		
    	}
    	
    }

  13. #10
    Exotique

    Re : ATSAMD21J18 - problème USART

    Il faut que tu écrives 48 et non pas 1.
    En ASCII c'est 48 (en base 10) qui vaut 1 ou 0x31 en hexa.

  14. #11
    marcuccio19

    Re : ATSAMD21J18 - problème USART

    Citation Envoyé par Exotique Voir le message
    Il faut que tu écrives 48 et non pas 1.
    En ASCII c'est 48 (en base 10) qui vaut 1 ou 0x31 en hexa.
    j'aimodifié sa valeur mais cela ne change rien,

  15. #12
    Exotique

    Re : ATSAMD21J18 - problème USART

    Tu as écrit quoi?
    Prends l'habitude de reposter ce que tu modifies pour être bien certain que l'on raisonne sur les mêmes données.

  16. Publicité
  17. #13
    Exotique

    Re : ATSAMD21J18 - problème USART

    Ca ne devrait normalement pas donner la même chose, vu que la data est différente.

  18. #14
    Exotique

    Re : ATSAMD21J18 - problème USART

    Citation Envoyé par Exotique Voir le message
    Il faut que tu écrives 48 et non pas 1.
    En ASCII c'est 48 (en base 10) qui vaut 1 ou 0x31 en hexa.
    J'ai écris une connerie c'est 49 en décimal!
    Si tu as écrit 48 c'est normal que tu aies 0... désolé.

  19. #15
    marcuccio19

    Re : ATSAMD21J18 - problème USART

    j'ai modifié comme cela :

    usart_tx.c :
    Code:
    #include "sam.h"
    
    int usart_tx()
    {	
    		while(!(REG_SERCOM4_USART_INTFLAG & 1)) {}  /* attente que le bit du registre d'envoi de donnée soit vide*/
    		{
    			REG_SERCOM4_USART_DATA |= 0x31; // écris "1" dans le registre DATA
    		}
    }

  20. #16
    Exotique

    Re : ATSAMD21J18 - problème USART

    Ok, et coté moniteur ça affiche quoi?
    Dernière modification par Exotique ; 05/12/2020 à 14h26.

  21. #17
    marcuccio19

    Re : ATSAMD21J18 - problème USART

    Citation Envoyé par Exotique Voir le message
    Ok, et coté moniteur ça affiche quoi?
    il m'affiche ça : Nom : test_envoi_ascii.JPG
Affichages : 76
Taille : 75,2 Ko

  22. #18
    Exotique

    Re : ATSAMD21J18 - problème USART

    Es-tu certain d'utiliser le bon USART et être connecté aux bonnes pins de ton µC selon cet USART?
    Es-tu bien certain également d'avoir configuré tes registres en mode asynchrone?

  23. Publicité
  24. #19
    marcuccio19

    Re : ATSAMD21J18 - problème USART

    Citation Envoyé par Exotique Voir le message
    Es-tu certain d'utiliser le bon USART et être connecté aux bonnes pins de ton µC selon cet USART?
    Es-tu bien certain également d'avoir configuré tes registres en mode asynchrone?
    oui normalement tout est correct

  25. #20
    Exotique

    Re : ATSAMD21J18 - problème USART

    Dans ce cas il faut vérifier le coté matériel.
    Un bout de schéma et le câble que tu utilises vers ton PC.
    J'espère que si tu entres sur un port USB tu as un adaptateur de niveaux entre ton µC et ton port USB.

  26. #21
    marcuccio19

    Re : ATSAMD21J18 - problème USART

    Citation Envoyé par Exotique Voir le message
    Dans ce cas il faut vérifier le coté matériel.
    Un bout de schéma et le câble que tu utilises vers ton PC.
    J'espère que si tu entres sur un port USB tu as un adaptateur de niveaux entre ton µC et ton port USB.
    j'ai fait les connexions comme spécifié dans la datasheet du UM232H sauf les pins CTS et RTS:
    Nom : connexion um232h.JPG
Affichages : 67
Taille : 61,7 Ko

  27. #22
    Exotique

    Re : ATSAMD21J18 - problème USART

    En principe quand tu envoies toutes les 100ms tu devrais apercevoir la led Tx du module FTDI clignoter, témoignant de l'envoi de l'octet.
    Est-ce le cas?

  28. #23
    marcuccio19

    Re : ATSAMD21J18 - problème USART

    Citation Envoyé par Exotique Voir le message
    En principe quand tu envoies toutes les 100ms tu devrais apercevoir la led Tx du module FTDI clignoter, témoignant de l'envoi de l'octet.
    Est-ce le cas?
    oui elle clignote quand j'envoie l'octet.

  29. #24
    marcuccio19

    Re : ATSAMD21J18 - problème USART

    le problème vient du code je pense mais je ne vois pas ce qui est mauvais dans ce que j'ai écrit.

  30. Publicité
  31. #25
    Exotique

    Re : ATSAMD21J18 - problème USART

    Soit ta base de temps en Bauds est mauvaise, soit tu as oublié quelque chose dans un registre.
    Vu la "qualité" de la doc je t'avoue avoir une sacré flemme à aller voir dedans...

  32. #26
    Exotique

    Re : ATSAMD21J18 - problème USART

    Citation Envoyé par marcuccio19 Voir le message
    oui elle clignote quand j'envoie l'octet.
    Tu parles de quelle led?
    Je vois dans ton code que tu as déclaré une led sur Tx.
    Moi je te parle de la led dans le module FTDI, on parle bien de la même?

  33. #27
    marcuccio19

    Re : ATSAMD21J18 - problème USART

    Citation Envoyé par Exotique Voir le message
    Tu parles de quelle led?
    Je vois dans ton code que tu as déclaré une led sur Tx.
    Moi je te parle de la led dans le module FTDI, on parle bien de la même?
    oui c'est celle là

  34. #28
    Exotique

    Re : ATSAMD21J18 - problème USART

    Citation Envoyé par marcuccio19 Voir le message
    j'ai modifié comme cela :

    usart_tx.c :
    Code:
    #include "sam.h"
    
    int usart_tx()
    {	
    		while(!(REG_SERCOM4_USART_INTFLAG & 1)) {}  /* attente que le bit du registre d'envoi de donnée soit vide*/
    		{
    			REG_SERCOM4_USART_DATA |= 0x31; // écris "1" dans le registre DATA
    		}
    }
    Peux-tu écrire plutôt ça:
    Code:
    int usart_tx()
    {	
    		while(!(REG_SERCOM4_USART_INTFLAG & 1)) {}  /* attente que le bit du registre d'envoi de donnée soit vide*/
    		{
    			REG_SERCOM4_USART_DATA = 0x31; // écris "1" dans le registre DATA
    		}
    }

  35. #29
    marcuccio19

    Re : ATSAMD21J18 - problème USART

    Citation Envoyé par Exotique Voir le message
    Peux-tu écrire plutôt ça:
    Code:
    int usart_tx()
    {	
    		while(!(REG_SERCOM4_USART_INTFLAG & 1)) {}  /* attente que le bit du registre d'envoi de donnée soit vide*/
    		{
    			REG_SERCOM4_USART_DATA = 0x31; // écris "1" dans le registre DATA
    		}
    }
    j'ai essayé mais cela n'a pas d'effet

  36. #30
    Exotique

    Re : ATSAMD21J18 - problème USART

    Je soupçonne un problème de synchronisation.

    Ta valeur pour fixer le baud-rate me semble bonne si j'en crois la doc, mais tu utilises la base de temps interne et je ne suis pas certain que ce soit judicieux pour un UART de prendre une telle fréquence interne.
    Peux-tu essayer avec par exemple 1MHz? Ce qui donnerait 0xEC57 avec s=8 si je ne me trompe pas.

Page 1 sur 2 1 DernièreDernière

Discussions similaires

  1. [Programmation] ATSAMD21J18 - non reconnue dans Atmel Studio
    Par marcuccio19 dans le forum Électronique
    Réponses: 7
    Dernier message: 20/11/2020, 11h50
  2. USART Rx problème
    Par amrouch dans le forum Électronique
    Réponses: 4
    Dernier message: 27/05/2012, 19h11
  3. probleme usart, pic16f627a
    Par damfle dans le forum Électronique
    Réponses: 29
    Dernier message: 12/01/2011, 17h36
  4. Probleme usart pic 18f4620
    Par betty77 dans le forum Électronique
    Réponses: 2
    Dernier message: 27/05/2010, 08h20
  5. Probleme USART PIC16F877
    Par amgab2003 dans le forum Électronique
    Réponses: 4
    Dernier message: 27/08/2009, 10h49
Découvrez nos comparatifs produits sur l'informatique et les technologies.