Le problème se pose dès que tu autorises 2 interruptions.
Si tu n'en as qu'une, c'est forcément celle que tu autorises et tu n'as pas besoin de tester les flags. Par contre, il faut obligatoirement mettre le flag à 0 avant de sortir de l'interruption.
D'accord. Vous avez raison.voir coque samsung galaxy note 4
Faut arrêter la moquette ...Envoyé par melisaaa89
D'accord. Vous avez raison.
Bonsoir,
Apres plusieurs recherches je n'ai pas trouvé de réponse clair a une question .
Voila ce que j'ai trouvé ? cela m'intrigue grandement . Comment travaillé alors avec des variables booleenes, si on veut se faire des flags qui peuvent prendre seulement deux valeurs, mais surtout les inversés facilement ?Il n’existe pas de type booléen en microC : la valeur entière 0 sera considérée comme
équivalente à la valeur faux et toute valeur différente de 0 équivalente à la valeur vrai.
On ne peut donc pas comparer un seul bit d'un variable ?
C'est en faisant des erreurs; que l'on apprend le mieux !!
Salut,
Le type booléen n'existe pas en C mais :
mikroC a déclaré des champs de bits ( exemple INTCON.GIE = x ) et tu peux utiliser variable = 0b10010101 (c'est pas ANSI C mais la plupart des compilos acceptent la notation binaire)
Et cela c'est pas un test d'une valeur binaire ???? (relis mon post précédent...)
Il faudra que tu crées des structures de champs de bits pour tes variables comme mikroC l'a fait pour les registres du PIC(je suppose que c'est dans le fichier header de mikroC...)Code:if ( (1 == INTCON.TMR0IF ) && (1 == INTCON.TMR0IE) )
Cela peut aussi se faire par des macros. Cela dépend du fabricant du compilateur...
a+
Dernière modification par RISC ; 11/09/2014 à 21h00.
Bonsoir RISC,
tu as une notification normalement !
J'ai pas trop compris ton psot precedent .
effectivement :
ici on test un bit d'un bytes . c'est ce que je voudrais faire !if ( (1 == INTCON.TMR0IF ) && (1 == INTCON.TMR0IE) )
Par exemple , j'appui sur un BP , ca inverse un bit , si je re-appui sa reinverse le bit( ou ca l'incremente ca revient au même).
ainsi avec une impulsion je garde un certain état .
Voici mon petit programme ; un compteur maintenant il compte la dixième de secondes . Quand j'appuie sur RB0 , je voudrais faire une pause du compteur , donc j'interdis l'interruption sur overflow, si je re-appui le compteur repart la ou il c'est arrété.
#include "Display_utils.h"
#define BP PORTB.F0
unsigned short h ; // Déclaration de la variable compteur
unsigned short i ; // Déclaration de la variable i centiéme de secondes : 0à255
unsigned short j ; // Declaration de la variable j seconde de secondes
unsigned short g ; // Declaration de la variable dizaine de seconde
unsigned short k ; // Declaration de la variable minutes
unsigned short pause ; // Declaration de la variable pause
void interrupt()
{
if ( (1 == INTCON.TMR0IF ) && (1 == INTCON.TMR0IE) ) // on regarde quel flag nous as fait rentrer dans l'interrupt
{
i++ ; // On incremente les dixiemes de secondes
TMR0H = 0x9E ; // On charge la valeur du timer0 au début
TMR0L = 0x58 ; // Pour repartir avec une base de 1 seconde
INTCON.TMR0IF = 0 ; // on ré-arme le flag d'interruption en le mettant a 0
}
}
void main(){
TRISA = 0 ; // Configure le port A en sortie
LATA = 0 ; // desactive tous les afficheurs
TRISB = 1 ; // Configure le port B en entrée
LATB = 0 ; // met tout à zéro
TRISD = 0 ; // Configure le port D en sortie
LATD = 0 ; // Efface tous les segments
//**************** configuration TIMER0 *******************
// ------ REGISTRE T0CON ( timer0 control) réglage du timer
T0CON = 0x82 ; // remplace toute la config du dessous
/*T0CON.TMR0ON = 1 ;// active ou non le timer0 .
T0CON.T08bit = 0 ;// Configure le TMR0 est 16 bit . en 8bit mettre 1
T0CON.T0CS = 0 ;// Timer0 Clock Select : choix de l'horloge interne=0 par le portA T0CKL=1
T0CON.T0SE = 0 ;// Timer0 Source Edge : à utilisé en cas de mode compteur
T0CON.PSA = 0 ;// Pre Scaler Assignement . non assigné=1 , assigné/activé =0
T0CON.F2 = 0 ;// Bit 0,1 et 2 pour choisir la valeur du préscaler
T0CON.F1 = 1 ;// Bit = 010 correspondant a un prescaler de 8
T0CON.F0 = 0 ;
*/
// ------ REGISTRE INTCON ( Interrupt control) réglage de l'interruption
INTCON = 0xA0 ; // remplace toute la config du dessous
/*INTCON.GIE = 1 ; // Global Interrupt ENABLE, On active toutes les interruptions
INTCON.PEIE = 0 ; // Peripheral Interrupt Enable ?????
INTCON.TMR0IE = 1 ; // timer0 overflow interrupt Enable : active l'interruption sur depassement si = 1
INTCON.INT0IE = 0 ; // Active l'interrption externe quand =1
INTCON.RBIE = 0 ; // ?????
INTCON.TMR0IF = 0 ; // Timer overflow Interrupt flag , mettre a 0 pour re-armement
INTCON.INT0IF = 0 ; // Extrenal interrupt flag
INTCON.RBIF = 0 ; // ?????
*/
TMR0H = 0x9E ;
TMR0L = 0x58 ;
g=0 ;
h=0 ;
i=0 ;
j=0 ;
k=0 ;
while(1) { // Boucle infinie on affiche les variables
if (i>9){ // si i STRICEMENT superieur à 9 donc à 10
i=0 ; // On remet i à 0
j++ ; // On incremente les secondes
if (j>9){ // Si les secondes sont STRICTEMENT superieur a 9 donc à 10
j=0 ; // On RaZ les secondes
g++ ; // On incremente les dizaines de secondes
if (g>5){ // si les dizaines de secondes sont STRICTEMENT superieur a 5 donc a 6
g=0 ; // On RaZ les dizaines de secondes
k++ ; // On incremente les minutes
if (k>9){ // Si les minutes sont STRICTEMENT superieur à 9
k=0 ; // On raz les minutes
}
}
}
}
LATD = mask(i) ; // On ramene la bonne valeur a l'afficheur
LATA = 1; // On active l'afficheur
delay_ms(5) ;
if (BP==1)
{
delay_ms(10) ;
pause = !pause ;
}
if (pause == 1)
{
INTCON.TMR0IE = 0 ; // dés-active l'interruption sur depassement si = 0
}
else
{
INTCON.TMR0IE = 1 ; // Active l'interruption sur depassement si = 1
}
LATD = mask(j) ;
LATA = 2 ;
delay_ms(5) ;
LATD = mask(g) ;
LATA = 4 ;
Delay_ms(5);
LATD = mask(k) ;
LATA = 8 ;
Delay_ms(5);
}
}
C'est en faisant des erreurs; que l'on apprend le mieux !!
Ouf , j'ai enfin réussis ; c'est vraiment ardu le C , sérieux ......
Bon, je pense qu'on ameliorer car quand la pause de 200ms comme antirebond n'est pas cool .
Mais bon j'avance .
Code:#include "Display_utils.h" #define BP PORTB.F0 struct { // création d'une structure de champs de bit flag1 : 1 ; // nom du premier bit } mastructure; // nom de ma variable unsigned short h ; // Déclaration de la variable compteur unsigned short i ; // Déclaration de la variable i centiéme de secondes : 0à255 unsigned short j ; // Declaration de la variable j seconde de secondes unsigned short g ; // Declaration de la variable dizaine de seconde unsigned short k ; // Declaration de la variable minutes void interrupt() { if ( (1 == INTCON.TMR0IF ) && (1 == INTCON.TMR0IE) ) // on regarde quel flag nous as fait rentrer dans l'interrupt { i++ ; // On incremente les dixiemes de secondes TMR0H = 0x9E ; // On charge la valeur du timer0 au début TMR0L = 0x58 ; // Pour repartir avec une base de 1 seconde INTCON.TMR0IF = 0 ; // on ré-arme le flag d'interruption en le mettant a 0 } } void main(){ ANSELB = 0; // Configure PORTB pins as digital ANSELC = 0; // Configure PORTC pins as digital TRISA = 0 ; // Configure le port A en sortie LATA = 0 ; // desactive tous les afficheurs TRISB = 1 ; // Configure le port B en entrée LATB = 0 ; // met tout à zéro TRISD = 0 ; // Configure le port D en sortie LATD = 0 ; // Efface tous les segments //**************** configuration TIMER0 ******************* // ------ REGISTRE T0CON ( timer0 control) réglage du timer T0CON = 0x82 ; // remplace toute la config du dessous // ------ REGISTRE INTCON ( Interrupt control) réglage de l'interruption INTCON = 0xA0 ; // remplace toute la config du dessous TMR0H = 0x9E ; TMR0L = 0x58 ; g=0 ; h=0 ; i=0 ; j=0 ; k=0 ; mastructure.flag1=0 ; // RaZ du bit while(1) { // Boucle infinie on affiche les variables if (i>9){ // si i STRICEMENT superieur à 9 donc à 10 i=0 ; // On remet i à 0 j++ ; // On incremente les secondes if (j>9){ // Si les secondes sont STRICTEMENT superieur a 9 donc à 10 j=0 ; // On RaZ les secondes g++ ; // On incremente les dizaines de secondes if (g>5){ // si les dizaines de secondes sont STRICTEMENT superieur a 5 donc a 6 g=0 ; // On RaZ les dizaines de secondes k++ ; // On incremente les minutes if (k>9){ // Si les minutes sont STRICTEMENT superieur à 9 k=0 ; // On raz les minutes } } } } LATD = mask(i) ; // On ramene la bonne valeur a l'afficheur LATA = 1; // On active l'afficheur delay_ms(5) ; LATD = mask(j) ; LATA = 2 ; delay_ms(5) ; LATD = mask(g) ; LATA = 4 ; Delay_ms(5); LATD = mask(k) ; LATA = 8 ; Delay_ms(5); if (BP==1) // Si appui sur le BP en RB0 { delay_ms(200) ; // anti rebond mastructure.flag1 = !mastructure.flag1 ; on iverse le flag creer sur une bit } if (mastructure.flag1== 1) // Si le flag est à 1 on desactive les interruptions { INTCON = 0x00 ; // dés-active l'interruption sur depassement si = 0 } else // Si le flag est à 0 on active les interruption { INTCON = 0xA0 ; // Active l'interruption sur depassement si = 1 } } }
C'est en faisant des erreurs; que l'on apprend le mieux !!
Bonjour à tous ,
Voici le compteur totalement finis . Plus aucun bug d'affichage , sur chaque pression ( front montant) soit le compteur s'arrete soit il redemarre ;
L'ecran reste parfaitement allumé tout le temps, quoi qu'il se passe !
Voila pour ceux qui ont le courage de regarder, et qui ont des idées pour l'ameliorer ou le simplifié car c'est une sacré usine a gaz pour obtenir un compteur finis .
Code:#include "Display_utils.h" #define BP PORTB.F0 struct { // création d'une structure de champs de bit flag1 : 1 ; // nom du premier bit } mastructure; // nom de ma variable unsigned short centieme ; // Déclaration de la variable i centiéme de secondes : 0à255 unsigned short seconde ; // Declaration de la variable j seconde de secondes unsigned short dizaine ; // Declaration de la variable dizaine de seconde unsigned short minute ; // Declaration de la variable minutes void interrupt() { if ( (1 == INTCON.TMR0IF ) && (1 == INTCON.TMR0IE) ) // on regarde quel flag nous as fait rentrer dans l'interrupt { centieme++ ; // On incremente les dixiemes de secondes TMR0H = 0x9E ; // On charge la valeur du timer0 au début TMR0L = 0x58 ; // Pour repartir avec une base de 1 seconde INTCON.TMR0IF = 0 ; // on ré-arme le flag d'interruption en le mettant a 0 } } void main(){ ANSELB = 0; // Configure PORTB pins as digital ANSELC = 0; // Configure PORTC pins as digital TRISA = 0 ; // Configure le port A en sortie LATA = 0 ; // desactive tous les afficheurs TRISB = 1 ; // Configure le port B en entrée LATB = 0 ; // met tout à zéro TRISD = 0 ; // Configure le port D en sortie LATD = 0 ; // Efface tous les segments //**************** configuration TIMER0 ******************* // ------ REGISTRE T0CON ( timer0 control) réglage du timer T0CON = 0x82 ; // remplace toute la config du dessous /*T0CON.TMR0ON = 1 ;// active ou non le timer0 . T0CON.T08bit = 0 ;// Configure le TMR0 est 16 bit . en 8bit mettre 1 T0CON.T0CS = 0 ;// Timer0 Clock Select : choix de l'horloge interne=0 par le portA T0CKL=1 T0CON.T0SE = 0 ;// Timer0 Source Edge : à utilisé en cas de mode compteur T0CON.PSA = 0 ;// Pre Scaler Assignement . non assigné=1 , assigné/activé =0 T0CON.F2 = 0 ;// Bit 0,1 et 2 pour choisir la valeur du préscaler T0CON.F1 = 1 ;// Bit = 010 correspondant a un prescaler de 8 T0CON.F0 = 0 ; */ // ------ REGISTRE INTCON ( Interrupt control) réglage de l'interruption INTCON = 0xA0 ; // remplace toute la config du dessous /*INTCON.GIE = 1 ; // Global Interrupt ENABLE, On active toutes les interruptions INTCON.PEIE = 0 ; // Peripheral Interrupt Enable ????? INTCON.TMR0IE = 1 ; // timer0 overflow interrupt Enable : active l'interruption sur depassement si = 1 INTCON.INT0IE = 0 ; // Active l'interrption externe quand =1 INTCON.RBIE = 0 ; // ????? INTCON.TMR0IF = 0 ; // Timer overflow Interrupt flag , mettre a 0 pour re-armement INTCON.INT0IF = 0 ; // Extrenal interrupt flag INTCON.RBIF = 0 ; // ????? */ TMR0H = 0x9E ; TMR0L = 0x58 ; centieme=0 ; seconde=0 ; dizaine=0 ; minute=0 ; mastructure.flag1=1 ; // mise à 1 du bit car au depart le compteur tourne tout seul while(1) { // Boucle infinie on affiche les variables if (centieme>9){ // si i STRICEMENT superieur à 9 donc à 10 centieme=0 ; // On remet i à 0 seconde++ ; // On incremente les secondes if (seconde>9){ // Si les secondes sont STRICTEMENT superieur a 9 donc à 10 seconde=0 ; // On RaZ les secondes dizaine++ ; // On incremente les dizaines de secondes if (dizaine>5){ // si les dizaines de secondes sont STRICTEMENT superieur a 5 donc a 6 dizaine=0 ; // On RaZ les dizaines de secondes minute++ ; // On incremente les minutes if (minute>9){ // Si les minutes sont STRICTEMENT superieur à 9 minute=0 ; // On raz les minutes } } } } LATD = mask(centieme) ; // On ramene la bonne valeur a l'afficheur LATA = 1; // On active l'afficheur delay_ms(5) ; LATD = mask(seconde) ; LATA = 2 ; delay_ms(5) ; LATD = mask(dizaine) ; LATA = 4 ; Delay_ms(5); LATD = mask(minute) ; LATA = 8 ; Delay_ms(5); if (BP==1 && mastructure.flag1== 1){ // Si appui sur le BP en RB0 et que le flag est à 1 donc le compteur tourne mastructure.flag1 = !mastructure.flag1 ; //on inverse le flag creer sur une bit INTCON = 0x00 ; // dés-active l'interruption sur depassement si = 0 , pour arreter le compteur while (BP==1) // tant que le BP est appuyé on affiche ce qui est figé sur l'ecran { LATD = mask(centieme) ; // On continue l'affichage pendant que le BP est appuyé LATA = 1; // Afin de ne pas faire de blanc pendant l'anti rebond delay_ms(5) ; LATD = mask(seconde) ; LATA = 2 ; delay_ms(5) ; LATD = mask(dizaine) ; LATA = 4 ; Delay_ms(5); LATD = mask(minute) ; LATA = 8 ; Delay_ms(5); } } if (BP==1 && mastructure.flag1== 0){ // Si appui sur le BP en RB0 et que le flag est à 0 donc le compteur est arreté INTCON = 0xA0 ; // Active l'interruption sur depassement si = 1 mastructure.flag1 = !mastructure.flag1 ; //on inverse le flag creer sur une bit while (BP==1) // tant que le BP est appuyé on affiche l'ecran qui tourne { if (centieme>9){ // si i STRICEMENT superieur à 9 donc à 10 centieme=0 ; // On remet i à 0 seconde++ ; // On incremente les secondes if (seconde>9){ // Si les secondes sont STRICTEMENT superieur a 9 donc à 10 seconde=0 ; // On RaZ les secondes dizaine++ ; // On incremente les dizaines de secondes if (dizaine>5){ // si les dizaines de secondes sont STRICTEMENT superieur a 5 donc a 6 dizaine=0 ; // On RaZ les dizaines de secondes minute++ ; // On incremente les minutes if (minute>9){ // Si les minutes sont STRICTEMENT superieur à 9 minute=0 ; // On raz les minutes } } } } LATD = mask(centieme) ; // On continue l'affichage pendant que le BP est appuyé LATA = 1; // Afin de ne pas faire de blanc pendant l'anti rebond delay_ms(5) ; LATD = mask(seconde) ; LATA = 2 ; delay_ms(5) ; LATD = mask(dizaine) ; LATA = 4 ; Delay_ms(5); LATD = mask(minute) ; LATA = 8 ; Delay_ms(5); } } } }
C'est en faisant des erreurs; que l'on apprend le mieux !!
Bonsoir ,
Je reviens encore avec une autre questions . je cherche de l'aide pour me mettre sur la voie .
Actuellement je m'initie au read ADC , avec les petits potars de la plaque easyPIc7 . le petit programme de test focntionne bien .
Quand je tourne mon potar , les led correspondant a la valeur binaire de celui s'allument .
Maintenant je souhaiterais affiché la valeur lus par le readadc sur les digits ;
Ma questions comment différencier les unités des dizaines et des centaines ?
ainsi je suppose quand tournant mon potar du debut à la fin de la course , la valeur affichée devrait etre de 0 à 255 .
Par avance merci
C'est en faisant des erreurs; que l'on apprend le mieux !!
Si tu convertis sur 8 bit, ce sera de 0 à 255.
initialisations des variables : centaines, dizaines, unités = 0
var est le résultat de la conversion A/N
while var > 100
inc centaines
centaines = centaines - 100
while var > 10
inc dizaines
dizaines = dizaine - 10
unités = var
centaines est la valeur à afficher sur le digit de gauche
dizaines est la valeur à afficher sur le digit du milieu
unités est la valeur à afficher sur le digit de droite
Attention, à la sortie de la routine ci-dessus, il faut convertir les valeurs en leurs équivalents pour 7 segments.
Faut toujours se relire ...
Je corrige les fautes dans la routine.
Ok merci bien .
je pense avoir saisi la subtilité ; allez zou, je vais essayer de faire ca .
C'est en faisant des erreurs; que l'on apprend le mieux !!
Pendant que tu essaies, je vais sous les draps, bonne nuit.
Comme tu as une conversion sur 10 bits, la valeur évolue 0 à 1023 (0 à 5V)
Bonjour,
Hummm..... conversion sur 10 bits !!!, ouf j'ai 4 digits , donc ca va le faire .
Mais déjà je n'arrive même pas a configurer le read_ADC .
dans l'exemple ils prennent AN2 donc il marque read_ADC (2) . Mais comme a chaque fois je change leur données pour m'entrainer et apprendre , moi je veux que ce soit RB0 l'entrée analogique . j'ai mis le switch qui va bien sur la carte pour activer RB0 avec le potar .
Mais je comprends pas quand ils marquent READ_Adc(2), il ne designe aucun PORT , seulement la PIN , y'a forcement une désignation de port quelques part .
Je vais essayer read_adc (PORTB.F0)
C'est en faisant des erreurs; que l'on apprend le mieux !!
MDR ,
J'ai un super gradateur de lumière, quand je tourne le portar, la LED en RB0 s'allume plus ou moins fort .
Je suis bien loin du but rechercher quand même .
Code:#include "mask_afficheur.h" unsigned short valeur; unsigned short centaines; unsigned short dizaines; unsigned short unites; void main() { ANSELA = 0; // Configure le PORTA en numérique TRISA = 0; // Met le PORTA en sortie ANSELB = 0x01 ; // Configure la broche RB0 en analogique TRISB = 0xff ; // Met le PORTB en entrée LATD = 0 ; // Met le PORTD en sortie do { valeur = ADC_Read(PORTB.F0); // Lis la valeur analogique sur RB0 et la place dans valeur while (valeur > 100) { centaines ++; valeur = valeur - 100 ; } LATD = mask(centaines) ; LATA = 4 ; delay_ms(5) ; } while(1); }
C'est en faisant des erreurs; que l'on apprend le mieux !!
Après une grosse matinée enfin . ca fonctionne j'affiche donc la valeur du read adc sur mes afficheurs
J'ai toutefois plusieurs questions :
-Il faut que je mette " #include <built_in.h> " pour il me semble comprendre la ligne : " LATD = hi(valeur) ; " qui je crois fais en sorte que les deux bit fort se retrouve sur D pour donner un résultat sur 10 bit . MAis je n'arrive pas a voir ce qu'il y a dans built_in.h ??? j'ai juste fais un copier collé betement .
-La valeur quand mon potar est max est de 963 , et non 1024 comme attendu , est ce dus a l'imprécision du potar ? car au debut il affiche bien1 , ca augmente nickel quand je le tourne et hop a fond, il indique 963 .
- Suis-je obligé de mettre la valeur sur le port C et D pour pouvoir les affichés ?
Code:#include "mask_afficheur.h" #include <built_in.h> unsigned int valeur; unsigned short milliers; unsigned short centaines; unsigned short dizaines; unsigned short unites; void main() { ANSELA = 0; // Configure le PORTA en numérique pour les afficheurs sur RA0...RA3 TRISA = 0; // Met le PORTA en sortie , toujours pour les afficheurs LATA = 0 ; // Desactive tous les afficheurs ANSELB = 0x01 ; // Configure la broche RB0 en analogique TRISB = 0xff ; // Met le PORTB en entrée LATB = 0 ; // efface le PORTB ANSELC = 0; // Configure le PORTC en numérique TRISC = 0x00 ; // Met le PORTC en sortie LATC = 0 ; // efface le PORTC ANSELD = 0; // Configure le PORTD en numérique TRISD = 0x00 ; // Met le PORTD en sortie LATD = 0 ; // efface le PORTD milliers = 0; // Mise à 0 de la variable centaines = 0; // Mise à 0 de la variable dizaines = 0; // Mise à 0 de la variable unites = 0; // Mise à 0 de la variable do { valeur = ADC_Read(12); // Lis la valeur analogique sur RB0 et la place dans valeur ( 12 regarder dans la DS page8) LATC = valeur ; LATD = hi(valeur) ; while (PORTD >= 1000) { milliers ++; PORTD = PORTD - 1000 ; } LATD = mask(milliers) ; LATA = 8 ; delay_ms(5) ; milliers = 0 ; while (valeur >= 100) { centaines ++; valeur = valeur - 100 ; } LATD = mask(centaines) ; LATA = 4 ; delay_ms(5) ; centaines = 0 ; while (valeur >= 10) { dizaines ++; valeur = valeur - 10 ; } LATD = mask(dizaines) ; LATA = 2 ; delay_ms(5) ; dizaines = 0 ; unites = valeur ; LATD = mask(unites) ; LATA = 1 ; delay_ms(5) ; } while(1); }
C'est en faisant des erreurs; que l'on apprend le mieux !!
Si tu veux RB0 comme entrée ana il te faut écrire READ_Adc(12) (voir datesheet page 291)
Le résultat de la conversion se trouvera dans les registres ADRESH et ADRESL
Resultat de la conversion = (ADRESH * 256) + ADRESL
Hello adipie,
Oui oui , c'est bien ce que j'ai marqué dans le programme , j'ai cherché un long moment .Si tu veux RB0 comme entrée ana il te faut écrire READ_Adc(12) (voir datesheet page 291)
hum.... la j'ai pas tout compris ! . je pourrais donc directement allé chercher le résultat dans ces adresses sans avoir a les retranscrire sur un port ?Le résultat de la conversion se trouvera dans les registres ADRESH et ADRESL
Resultat de la conversion = (ADRESH * 256) + ADRESL
Mais je me rends compte que ma question est bête , car comme je dois les affichés sur les afficheurs 7 segments , il faudra forcement que j'allume mes segments et donc que je mettre des sorties a 1 pour chaque segments !
C'est en faisant des erreurs; que l'on apprend le mieux !!
Affiche donc le résultat sur l'écran LCD pour commencer.
j'en ai pas lol . je n'ai que les afficheurs 7 segments pour le moment . Mais ca fonctionne bien .
C'est en faisant des erreurs; que l'on apprend le mieux !!
Alors tu envois le résultat sur Hyperterminal avect l'Uart.
Tu vas perdre beaucoup de temps avec les 7 segments.
Oulalalala !!! t u me complique beaucoup d'un coup lol .Alors tu envois le résultat sur Hyperterminal avect l'Uart.
L'UArt je crois que c'est un moyen de communication . et HyperTerminal il me semble un truc de Windows non ?
Ma plaque easypic7 est connecté par USB a l'ordi ?
C'est en faisant des erreurs; que l'on apprend le mieux !!
Regarde à la page 17 du manuel EasyPic le chapitre UART Via Usb, c'est très simple à utiliser.
Il te suffit d'un câble USB entre la carte EasyPic et un port Usb de ton PC pour afficher les valeurs en clair.
A la place de hyperterminal tu peux aussi utiliser RealTerm en téléchargement gratuit.
Effectivement ca m'as l'air très intéressant tout ca . je sais a quoi je vais passer ma soirée .
Car bizarrement j'ai pas trouve de simulateur permettant de visualiser simplement les variables ou l'état des pins de sorties . ceci pourrais peut etre palier à cela . ou alors j'ai mal cherché ca se peut aussi lol ;
C'est en faisant des erreurs; que l'on apprend le mieux !!
Encore plus simple et je n'y avais pas pensé, tu peux utiliser USART Terminal qui se trouve sous l'onglet Tools de MikroC.
Tu ouvre la fenêtre Com Port et tu relèves les ports disponibles.
Tu branche ta carte Easy Pic sur le PC et tu verra dans la fenêtre Com Port le nouveau port Com qui viens d'être crée.
C'est ce port que tu utilisera dans ton programme.
Ci-joint un exemple de programme en MikroBasic qui utilise l'UART pour afficher le résultat de la conversion analogique dans l'outil USART Terminal.
Quelqu'un aura-t-il une idée sur ce problème.
Je suis tranquillement entre d'essayer de faire une communication UART avec l'exemple donné . Tout va bien j'arrive a afficher, mon hello dans realterm ( merci adipie) .
Je commence a faire quelques modif pour tester . ca fonctionne encore .
De la je veux appuyer sur un BP pour afficher un texte et quand je relâche ca affiche un autre texte . Normalement pas trop compliqué ; Pfiou ca marche pas ;
J'ouvre un autre projet, appeler BP+led qui allume une led quand j'appui sur le BP, pour comparer . Je charge dans le PIC le programme et paf il reste sur le programme de USART .
Je ferme tout , je reouvre une autre programme avec mes afficheurs , impeccable ca fonctionne . je ferme je reouvre mon programme avec mon BP et ma led, et paf j'ai toujours le programme des afficheurs après avoir fais built +programme .
Bref je commence sérieusement a désesperer et a croire que je suis pas fais pour le C .
C'est en faisant des erreurs; que l'on apprend le mieux !!
Rien à voir avec le C, c'est un problème de manque de patience !
Poste le code qui ne fonctionne pas.
A la limite le code qui fonctionne pas , bon je peux m'en prendre qu'a moi ( quoi que ... lol) . mais le problème c'est que quand je charge un nouveau programme il reste sur l'ancien , c'est bizarre quand même !!! .
Bon je refais le code qui fonctionne pas ; et je te le post , car j'ai tellement essayé hier soir , que je sais plus ou j'en suis .
je le fais de suite , et je le post , si tu es encore la !! .
C'est en faisant des erreurs; que l'on apprend le mieux !!
