delay microsecondes

[invitea5967f49]

Bonjour tous le monde,

Pour un projet mon prof ma passé des fonctions faites (qui viennent surement de microship) pour faire des delay en secondes et millisecondes.
Maintenant j'essaye de les adapter pour faire un delay en microsecondes, mais je n'y arrive pas...
Quelqu'un aurait-il des conseils?

Voici le .h :

#ifndef __DELAYS_H
#define __DELAYS_H

/* PIC18 cycle-count delay routines.
 *
 *   Functions:
 *		 Delay1TCY()
 *               Delay10TCY()  // 17Cxx only
 *               Delay10TCYx()
 *               Delay100TCYx()
 *               Delay1KTCYx()
 *               Delay10KTCYx()
 */

/* For definition of Nop() */
#include <p18cxxx.h>

/* Delay of exactly 1 Tcy */
#define Delay1TCY() Nop() 

#define PARAM_SCLASS auto

/* Delay of exactly 10 Tcy */
#define Delay10TCY() Delay10TCYx(1)

/* Delay10TCYx
 * Delay multiples of 10 Tcy
 * Passing 0 (zero) results in a delay of 2560 cycles.
 * The 18Cxxx version of this function supports the full range [0,255]
 * The 17Cxxx version supports [2,255] and 0.
 */
void Delay10TCYx(PARAM_SCLASS unsigned char);

/* Delay100TCYx
 * Delay multiples of 100 Tcy
 * Passing 0 (zero) results in a delay of 25,600 cycles.
 * The full range of [0,255] is supported.
 */
void Delay100TCYx(PARAM_SCLASS unsigned char);

/* Delay1KTCYx
 * Delay multiples of 1000 Tcy
 * Passing 0 (zero) results in a delay of 256,000 cycles.
 * The full range of [0,255] is supported.
 */
void Delay1KTCYx(PARAM_SCLASS unsigned char);

/* Delay10KTCYx
 * Delay multiples of 10,000 Tcy
 * Passing 0 (zero) results in a delay of 2,560,000 cycles.
 * The full range of [0,255] is supported.
 */
void Delay10KTCYx(PARAM_SCLASS unsigned char);

#endif

et le .c :

#include <stdio.h>
#include <stdlib.h>

#include <p18F24k22.h>
#include "delay.h"
#include "delays.h"
#include "fonction.h"
//#include "Variables.h"


/****************************************************************************/
/*  Wait for X Milliseconds                                                 */
/*  Function : DelayMs                                                      */
/*      Parameters                                                          */
/*          Input   :   Delay in Ms between 0 and 65535                     */
/*          Output  :   Nothing                                             */
/****************************************************************************/
void DelayMs(unsigned int cnt)
{
	//1000 cycles for one millisecond @4MHz
	while(cnt--)			
	{
		Delay1KTCYx(1);	//1000 cycles
	}
}

/****************************************************************************/
/*  Wait for X Seconds                                                      */
/*  Function : DelayS                                                       */
/*      Parameters                                                          */
/*          Input   :   Delay in S between 0 and 255                        */
/*          Output  :   Nothing                                             */
/****************************************************************************/
void DelayS(unsigned char cnt)		
{
	//1.000.000 cycles pour une seconde @4MHz
	while(cnt--)			
	{
		Delay10KTCYx(100);	//1,000,000 cycles
	}
}

Merci d'avance de votre aide
-----

[PIXEL]

des tempos en µseconde avec un tel µcont il ne faut pas y compter.

il faut passer à un circuit bien plus rapide ( donc bien plus cher)

[invitea5967f49]

j'utilise un pic18f24k22, ce n'est pas possible?

[PIXEL]

je laisse la parole aux Stradivarius des Pics , mais , de ma modeste expérience , passé la
milliseconde , faut plus y compter !

il te suffit de regarder combien prend une instruction sur ton PIC ,
c'est déjà largement supérieur à la µseconde.

[A voir en vidéo sur Futura]

[invitea5967f49]

Merci, je sais pas comment je vais faire alors

[PIXEL]

quel est le probléme précis ?

[invitea5967f49]

J'essaye de faire une télécommande avec une diode infrarouge et un tsop1138.
Celui-ci répond a une fréquence de 38khz
soit une période de 1/ 38000 = 26µs
les demi alternance font donc 13 µs

j'aimerai faire un code du genre :

emission = 1
delayµs(13)
emission = 0
delayµs(13)

[PIXEL]

fouille la toile avec " RC5 + PIC"

y'en a qui ont débroussaillé le sujet.

http://www.elektor.fr/magazines/2003...c5.66934.lynkx

[invite5c0d525e]

Sur les pic une instruction dure 4 cycles d'horloge donc à 4Mhz elle dure 1µs pile poil. Le 18f24k22 possede un oscillateur interne à 16MHz et peut pédaler jusqu'à 64Mhz donc un delai d'une µs c'est faisable.

Par contre je ne connais pas suffisament le c pour te bidouiller ton code.

[invitea5967f49]

Oui j'en ai déja entendu parlé, mais bon j'avais basé tout mon programme de cette façon, c'est vraiment dommage de n'avoir aucun moyen de faire des delays en µs

[invitea5967f49]

a merci gabuzo! voici une bonne nouvelle!

[invitea5967f49]

Personne n'a donc d'idées de comment améliorer mon code?

[eldudo]

Salut,

Imaginons que tu mettes un quartz de 20 MHz, dans ce cas là, une microseconde dure 5 cycles, donc une demi-période représente 13 *5 cycles =65 cycles.
Tu peux par exemple faire

emission = 1;
Delay10TCYx(1);
Delay10TCYx(1);
Delay10TCYx(1); // 60 cycles
Delay10TCYx(1);
Delay10TCYx(1);
Delay10TCYx(1);
rajouter des nop() pour arriver à la bonne durée si nécessaire en visualisant à l'oscillo
emission = 0
Delay10TCYx(1);
Delay10TCYx(1);
Delay10TCYx(1); // 60 cycles
Delay10TCYx(1);
Delay10TCYx(1);
Delay10TCYx(1);
rajouter des nop() en utilisant l'oscillo

C'est pas très joli, mais bon ça doit le faire !

Sans oscillo, le mieux serait de coder en assembleur ou d'ajouter du code en assembleur dans ton code en C .
A plus

[invitea5967f49]

ok merci, mais moi l'assembleur j'y connais vraiment rien.

[invitea5967f49]

Et si je met un quartz de 4Mhz, je peux mettre :
Delay1TCY() // 1 cycle

pour une durée de 1 µS?

[eldudo]

Oui, A 4MHz, nop() ( pareil que Delay1Tcy ) dure une 1 us .
Si tu n'as pas d'oscillo, il faudra que tu regardes le code en assembleur produit à partir de ton programme en C
et compter le nombre de cycles correspondant au bout de code qui doit durer 26 us .
Si tu dois faire régulièrement des tempos précises, il faut à mon avis que tu apprennes un minimum d'assembleur et c'est pas très compliqué en fait .
Au fait emission=0 et emission=1 prennent un certain temps, qu'il faut déduire de la période du signal pour trouver la durée des attentes.

[invitea5967f49]

D'accord, merci beaucoup

[eldudo]

De rien ,
Ciao !

[invitea5967f49]

Je peut écrire ceci comme code?

void DelayUs(unsigned char cnt)
{
	//1 cycles for one microsecond @4MHz
	while(cnt--)			
	{
		Nop();	//1 cycle
	}
}

mais ça ne marche pas j'ai l'impression

[invite0e5af214]

Hello,

Non tu ne peux pas faire ca.

ton while(cnt--) prend plusieurs instructions à chaque tour de boucle : en assembleur ton code donne quelque chose comme :

- Lire cnt dans la RAM
- Comparer la valeur lue à 0 et sortir de la boucle si ca vaut 0
- décrementer cnt
- Ecrire cnt dans la RAM
- nop
- Retourner au debut

CHACUNE des instructions ci-dessus prend 1us, donc ton délai est à peu près 6 fois trop long (Et ce que je te dis est FORTEMENT à la louche puisqu'on ne sait pas comment le compilateur va réellement traduire ce code)

Si tu veux mon avis, tu n'as AUCUNE chance de t'en sortir avec tes tempos pour des temps aussi cours.
Tu peux peut-etre regarder le module MSSP de ton PIC en mode SPI, en détournant un poil son utilisation tu pourrais envoyer des trames de 8 bits consécutifs automatiquement avec des périodes au cycle prêt.

Cyril

[jojo150393]

Salut !
j'étais dans la même galère que toi au niveau des delays en microseconde. La solution c'est simplement de mettre des Nop() autant de fois qu'il en faut. Si il en faut trop alors fait simplement compter une boucle.

[invitea5967f49]

C'est ce que j'ai fait, mis des nop d'affilé.
Une boucle prend des temps de cycle non?

[invitedb9b1ced]

Salut,

C'est un avis totalement personnel mais utiliser des délais pour faire un signal réctangulaire c'est risqué. Qu'est ce qui se passe s'il y a une interruption quelconque ?

Je ne saurais que trop te conseille d'user du module ECCP en PWM, il est adapté pour ce genre de chose.

A+