12F629 14µs

[invite96073554]

Bonjour

Voilà j'ai un programme (fait sous Flowcode V3) qui doit me sortir un état haut de 14µs puis état bas de 14µs tout sa 30 fois avec une pause de 9ms après les 30 fois pour recommencé, or je n'arrive pas à utilisé delay_us.

Je sait bien qu'une boucle prend du temps a s'exécuter, mais comment je pourrais avoir mes 14µs ?

voilà le code C

//************************************************************************************
//**  
//**  File name:     F:\2eme phase\PIC12F629_2eme_phase.c
//**  Generated by:  Flowcode v3.4.7.48
//**  Date:          Thursday, March 26, 2009 12:12:05
//**  Licence:       ** User
//**  Registered to: *************
//**  
//**  
//**     PAS À USAGE COMMERCIAL
//**  
//**  http://www.matrixmultimedia.com
//************************************************************************************


#define MX_PIC

//Définir pour microcontrôleur
#define P12F629
#define MX_EE
#define MX_EE_TYPE1
#define MX_EE_SIZE 128

//Fonctions
#include <system.h>
#pragma CLOCK_FREQ 4000000

//Configuration de données
#pragma DATA 0x2007, 0xf95

//Fonctions internes
#include "C:\Program Files\Matrix Multimedia\Flowcode V3\FCD\internals.h"

//Déclarations de fonction Macro


//Déclarations de Variable
char FCV_DURE;

char FCLV_LOOP1;


//Définitions supplémentaires


//Implémentations Macro

//Installation supplémentaire


void main()
{
    
    //Initialisation
    cmcon = 0x07;


    //Code d'initialisation d'Interruption
    option_reg = 0xC0;


    //Boucle
    //Boucle: Tant que1
    while (1)
    {
        //Boucle
        //Boucle: Boucle 30 fois
        for (FCLV_LOOP1=0; FCLV_LOOP1<30; FCLV_LOOP1++)
        {
            //Sortie
            //Sortie: 1 -> A2
            trisio = trisio & 0xfb;
            if (1)
                gpio = (gpio & 0xfb) | 0x04;
            else
                gpio = gpio & 0xfb;


            //Code C
            //Code C:
            {
            delay_us(14);
            }



            //Sortie
            //Sortie: 0 -> A2
            trisio = trisio & 0xfb;
            if (0)
                gpio = (gpio & 0xfb) | 0x04;
            else
                gpio = gpio & 0xfb;


            //Code C
            //Code C:
            {
            delay_us(14);
            }



        }


        //Pause
        //Pause: 9 ms
        delay_ms(9);


    }


    mainendloop: goto mainendloop;
}

void interrupt(void)
{
}

Quand je test je trouve 35µs à l'état haut et 45µs à l'état bas.
-----

[alainav1]

bonjour,
si tu ne mets pas de delay tu aura le temps minimum
si le delais mini est inferieur à celui que tu souhaites
tu ajustes avec un delay x (x a definir par des essais puisque tu sais mesurer le resultat )c'est une propsition car calculer le temps pris par les instructions du C je ne sait pas faire .
cordialement
Alain

[invite96073554]

{
delay_us(14);
}

Bah mon delay_us est bien mis, c'est 14 µs.

J'avais réussi à avoir se que je veux avec :

asm
{
nop
nop
nop
nop
nop
nop
}

Mais bon je trouve que c'est pas super propres comme code.

Euh delay x c'est a dire (c'est en quel unité ?)

[alainav1]

bonjour,
je veux dire que si les temps sont trés courts il faudrait calculer les temps d'instruction des fonction en C (boucle ...)
quand je dis delay x cela signifie que tu fais des essais avec la fonction
delay_us(x ) (X en microsecondes ) et par tatonnement tu trouves la valeur de X qui correspond à ton besion .
c'est ce que tu as fais avec de nop .
c'est pas elegant mais ça marche !
que vouloir de plus ?
cordialement
Alain

[A voir en vidéo sur Futura]

[invite96073554]

bah le problème c'est que je suis descendu jusqu'à 1 pour delay mais j'ai toujours une valeur au dessus de 14us :s

[Gérard]

Pour cette durée, il vaut mieux écrire en asm en comptant les instructions.

[invite96073554]

ah bon bah tant pis, je voulais faire sa bien ^^ tant pis, de toute manière dans la version finale de l'algorigrame, il met impossible d'avoir un état bas de 14µs, le PIC n'est pas assez rapide ><

[alainav1]

bonjour,
je programme en basic quand je suis pas a quelques dizaines de µS pret mais en dessous seul des boucles avec des nop ( en assembleur ) permettent d' ajuster des temps trés courts.
le basic (ou le C ..) sont facile a programmer mais il me parait aussi indispensable de programmer en assembleur pour des cas specifiques .
l'assembleur s'intègre souvent facilement dans les langages évoluer .
Les cours de bigonoff on donc encore beaucoup d'avenir !
cordialement
Alain