PIC récéption HF problème... prog en C

[invite1feace2e]

Bonjour,
pour un projet avec un pote on cherche à réaliser un transmission par HF (module aurel, 3k de bande passante).

Actuellement:
- émission avec un 16f628
- réception avec un 16f877: affichage sur un LCD

Notre problème est que la réception ne fonctionne pas correctement.
Nous utilisons les fonctions de CCS.

voir en PJ la source svp.

Pourquoi il ne fonctionne pas? ce qui nous étonne, c'est que la réception par interruption fonctionne deux fois (deux passages de boucle) puis plus d'interruption du tout (alors que le programme tourne toujours dans la boucle principale!!).
L'émission c'est un mot en continue.
En faite, lors des deux passages dans l'interruption, on recoit un caractère à chaque fois, qui n'a rien avoir avec ceux envoyé (d'ou le doute sur la synchronisation).

pour remettre en forme notre signal issu du récepteur, nous avons ajouter un trigger, est ce que celui ci perturberais notre réception, en modifiant les temps haut et bas de la durée d'un bit?

Merci de votre intérêt.
-----

[invitef86a6203]

tu interdit ton int dans l'int elle meme

disable_interrupts(INT_RDA);

Et tu l'autorise tout les 2600 ms tout delay additionné.
Y a de quoi en raté un maximum

D'ailleurs dans l'int on est déja en interruption disable.
Cette ligne semble superflue.

Il ya une erreur de logique, à cogiter ...

[invitef86a6203]

Non, elle est en commentaire (//).

Pas dans le main,
mais dans #INT_RDA il y en a un aussi mais pas de comments

Par contre lorsque ton prog tombe dans while(1) il ne fait plus rien

Hè !
C'est un Do {} while(1)
pas
un While {}

[invite5637435c]

Pas dans le main,
mais dans #INT_RDA il y en a un aussi mais pas de comments


Hè !
C'est un Do {} while(1)
pas
un While {}

Oui tu as raison, d'ailleurs j'ai carrément supprimé mon post, y avait rien de bon du tout.
désolé...

[A voir en vidéo sur Futura]

[invite5637435c]

tu interdit ton int dans l'int elle meme

Par contre ça n'est pas génant, tu es déjà dans l'interruption donc tu exécutes les instructions jusqu'au bout et si une autre interruption survient elle ne sera pas prise en compte.

Et tu l'autorise tout les 2600 ms tout delay additionné.
Y a de quoi en raté un maximum

Là je suis d'accord avec toi, les timmings sont vraiment demesurés.

[invitef86a6203]

disable_interrupts(INT_RDA);

Tu crois que ça c'est un nettoyage de flag ?
ça ressemble plus à un "Clear int" !

Je connais pas son compilateur ...

[invitef86a6203]

Si effectivement le compilo ne gère pas le flag, avec la déclaration en pragma "#" il faut alors l'effacer.
Il y a peut être une confusion entre 2 ordres.

[invitef86a6203]

If you want to stop the application from processing interrupts, you can disable the interrupts using disable_interrupts CCS macro. You can either disable a specific interrupt or all interrupts using the GLOBAL define.

http://mdubuc.freeshell.org/Robotics/Tips.html

C'est bien un CLI donc l'erreur est juste lol
Dans leur exemple pas de nettoyage de flag , j'en déduit ,le compilo doit le faire.

[invite5637435c]

Oui, moi aussi je n'utilise pas ce compilo et je trouve que leurs explications ne sont pas très claires...

Je ne vois pas comment on peut annuler une routine d'interruption lorsqu'on est déjà dedans, à moins que le CLI soit lui même une interruption plus prioritaire encore sur ce type de compilo, mais j'en doute un peu.

Je regarderai ça demain car comme je suis passablement grippé, je n'ai pas vraiment les idées claires.
@+

[invitef86a6203]

Je regarderai ça demain car comme je suis passablement grippé, je n'ai pas vraiment les idées claires.

ah , je me disais aussi , il a pas la forme aujourd'hui.
bon rétablissement

[invite1feace2e]

Bonjour,
merci pour vos réponses.
Effectivement, au début on s'est dit que tant qu'à faire, c'est plus simple d'utiliser les fonctions toutes faites de CCS.
Après on à quand même eu un doute pour la remise du flag pour "l'acquitement" de l'interruption.
Il semblerait que le registre se vide en le lisant.
On va essayer de baisser le flag à la main, on sera sur comme ca

Le disable/enable vient du faite qu'on emet en continue, donc les interruptions arriveraient trop souvent, non?
Du coup pour garder la main dans le main, on disable l'interrupt.
On perd des données, mais par la suite un bon protocole nous évitera cet inconvénient. Du moment qu'on récupère les bon caractères.

Pour les tempos, on va les enlever de l' IT.
Résultat cette aprèm

Merci

[invite1feace2e]

Quelques nouvelles, l'acquittement de l'intteruptions se fait automatiquement avec les fonctions. Si on veut le faire manuellement, il faut rajouter no_clear derriere #int_rda.

On a supprimé toutes les tempo, on a diminué la vitesse de transfert à 1200 baud.

On dirait que les interruptions se "désactivent" après 2 passages dans la fonction d'interruptions.

On a remis à jour les pieces jointes.

Si quelqu'un a une idée...

Merci à tous

[invitef86a6203]

Les fichiers sont en cours de validation...

Peut on mettre un procedure LCD dans l'int ?
Cela me semble pas très "clean".
Il est préférable de mettre un flag dans l'int et afficher dans le main en poolant le flag.

Personnellement j'aurais pas osé faire ça !

[invite1feace2e]

pour répondre en attendant la validation, il n'y a plus de procédure dans l'it. Celle ci a été réduite au strict nécéssaire.

#INT_RDA                
void RecepIT(void)
{
	disable_interrupts(INT_RDA);
	cVar = getch();
	it = 1;
}

au faite, ca veut dire quoi "poolant le flag"??

merci

[invite5637435c]

Ca y est, je viens de valider.

ah , je me disais aussi , il a pas la forme aujourd'hui.
bon rétablissement

berci!

[invite1feace2e]

un nouvelle essai:

on a enlever le disable et enable du programme mais on fait toujours que 2 passage dans l'interruptions.

C'est bizarre, on voit vraiment pas d'ou ca peut venir...

[invitef86a6203]

au faite, ca veut dire quoi "poolant le flag"??

C'est ce que tu fait avec la variable IT qui sert de flag.

PlaceCurseur(LCD_L2, 13);
AfficheCarLCD(cVar);

Tu ecrit toujours à la meme place normal ?

cVar = getch();
reçois une lettre seulement.

Il faut bufferiser et attendre la fin du message !

Buffer[ptr] = getch();
if Buffer[ptr]=13 then IT=1; /* 13d = 0x0d = fin de message */
ptr++;

[invite1feace2e]

en faite, on a essayer de recupérer dans un tableau (ou buffer?) et afficher une fois plein. Mais cette ne fonctionne pas. En effet, on recois toujours que 2 caractères.

 string[it] = cVar;
		if(it == 15)
		{
		it = 0;
		strcpy(stringdef, string);
		AfficheTabLCD(stringdef, 16, LCD_L2, 0);
		}
		AfficheTabLCD(string, it, LCD_L2, 0);

Du coup, on affiche tout le temps les différentes valeurs du tableau. On a remis le code en pièce jointe d'ou est issu ce code.

Mais on reçois toujours que 2 caractères (seulement 2 interruptions ) et ce sont pas les bons...

merci, on reviens demain matin!! (l'IUT ferme...)

[invite1feace2e]

Bonjour,
Quelqu'un a déjà utilisé la liaison série??
En fait, pour s'affranchir des problèmes HF on passe par fil en attendant.
Le problème, c'est qu'on recoit de temps en temps plusieurs caractères, et d'autres fois, seulement deux puis plus rien.

Problème de tempos?

Notre problème viendrai donc de l'emission...

[invite1feace2e]

Bonjour,
c'est encore nous.
Depuis le temps, on a pas beaucoup avancé.

L'émission est simplifiée :

#include "16F628A.h"
#use delay(clock = 20000000)
#use RS232(baud =9600 , xmit = PIN_B2, rcv = PIN_B1)

void main(void)
{
	do
	{
	puts("BONJOUR");
    delay_ms(1000);
	}while(1);
}

Ce coté là fonctionne (l'oscillo en est témoin )

pour ce qui est de la réception, c'est une autre histoire.
On travail toujours en liaison série par fils.
Même alime pour les deux pic.

la source du programme sur le 877:

#include "16F877-DM2.h"
#include <string.h>
#include "AfficheurLCD.h"

#define LED		RB7

#fuses HS,NOWDT,NOPROTECT,NOPUT,NOBROWNOUT				// Pour la config d' icprog		
#use delay(clock = 20000000)							// Quartz de 20 Mhz
#use RS232(baud =9600, xmit = PIN_C6, rcv = PIN_C7)

char string[16] = {'0'};
int8 it = 0;

#INT_RDA              // pas de no_clear => acquitement automatique
void RecepIT(void)
{
char cVar;
	cVar = RCREG;
	it ++;
	if(it >= 15)
    	it = 0;
	string[it] = cVar;	
}

void InitPIC(void);


/*__________________________________________________________________________________________*/
void main(void)
{   
	InitPIC();   // InitPIC, initLCD test LED et LCD.

	enable_interrupts(GLOBAL);
	enable_interrupts(INT_RDA);
	delay_ms(100);

	do{	
		PlaceCurseur(LCD_L1, 0);
		AfficheCarLCD(string[it]); 
		AfficheTabLCD(string, 16, LCD_L2, 0);	
		LED = !LED;
	}while(1);
}


/*________________________________________________________________________*/
void InitPIC(void)
{     // ------------- 1 => entrée ; 0 => sortie -------------- \\
    TRISA = 0b00000000;          // RA1-RA3 -> E, R/W, RS du LCD en sortie
    TRISB = 0b01111111;          // RB7 -> Led rouge, RB6-RB0 -> Interrupteurs
    TRISC = 0b10000000;          // RC7 -> Emission HF, RC6 -> Reception HF
    TRISD = 0b00000000;          // Data bus line LCD

    setup_adc(ADC_OFF);				// pas de CAN sur PORTA : RA3-RA2-RA1
	disable_interrupts(GLOBAL);

	InitLCD();
	delay_ms(100);
	PlaceCurseur(LCD_L1, 0);
	AfficheChaineLCD("Telecommande");
	PlaceCurseur(LCD_L2, 0);
	AfficheChaineLCD("Interactive");
	LED = 1; delay_ms(100);
	LED = 0; delay_ms(250);
	LED = 1; delay_ms(100);
	LED = 0; delay_ms(250);
	LED = 1; delay_ms(100);
	LED = 0;
	delay_ms(1000);
	LcdWriteCmd(LCD_CLEAR);
}

alors en fait, on a encore besoin de votre aide, parce qu'on ne voit pas ce qui ne fonctionne pas:

On active les interruptions seulement (et juste) avant la boucle while. Le problème c'est que lorsque l'on alimente l'emetteur après (dans la boucle) On recoit bien ce qu'on a envoyé. Lorsque l'ont alimente avant (tous en meme temps), plus d'interruption après deux lectures du registre.

Lorsque le programme tourne (emetteur alimenté dans la boucle) on affiche sur le LCD (ligne 2) "#BONJOUR##BON#" en boucle.
les "#" sont en fait le bit de start et de stop ajouté par le PIC.
Lorsque le programme tourne (emetteur alimenté avant la boucle) on affiche sur le LCD (ligne 2)
"0BO########" (0 étant la premiere case initialisé à 0)
Dans ce cas, les "#" sont des caractères qui n'ont rien à faire là... ce que c'est? hum, un carré noir :s

C'est bizarre. Voyez-vous d'ou ça peut venir?

Merci de votre aide