Fonction C qui doit retourner un tableau de "bits"
Répondre à la discussion
Affichage des résultats 1 à 27 sur 27

Fonction C qui doit retourner un tableau de "bits"



  1. #1
    toubippc

    Fonction C qui doit retourner un tableau de "bits"


    ------

    Bonjour a tous,

    J ai écumer un peu le web .. mais je ne comprend pas les solutions, ou du moins je n arrive pas a les adaptés a mon code.
    C est simplement une variable décimale passer dans une fonction qui convertis en binaire et doit retourner un tableaux.
    D après ce que j ai lu et déjà réaliser, le tableaux est déclaré en char

    <mon code>
    Code:
    /*******************************
    PIC16F628
     -----------------------------
     Ce programme est destiné a envoyer des bits par infrarouge
     selon un nombre décimale
     Le nombre décimale est initialisé par le bouton presser (keypad)
     -----------------------------
     RA0-7 = interrupteur
     RB1 = Power LED
     RB2 = Temoin signal
     RB3 = PWM modulation alim LED IR
     RB5 = Envoie du signale
    ********************************/
    
    /************************************************
    ** Définition des variables *********************
    *************************************************/
    
    short int i,i2; // initialisation boucle
    long int dec,x; // initialisation de la variable "decimale" et "reste"
    char signal[25]; // initialisation tableau du SIGNAL
    /*************************************************
    ** FONCTION - convertion binaire => décimale *****
    *************************************************/
    char *binDec(long int dec)
    {
     char tab_bits[25]; // initialisation tableau BITS
      // après chaque division par deux,
      // quand "dec" est inferieur ou egal à 1, on arrete
      for(i2=0;dec <= 1; i2++)
      {
          x = dec%2;   // on reprend le reste de la division par 2
          dec /= 2;   // on divise le nombre par 2
          tab_bits[i2] = x;  // on incrémente la tableaux du "reste" 1/0
          return tab_bits ;
      }
    }
    
    void main() {
    // Initialisation *********
    // ************************
      // Initialisation de PWM ()
      PWM1_Init(38000);     // initialisation PWM 38000Hz
      PWM1_Start();         // démarrage de PWM
      PWM1_Set_Duty(128);   // Rapport cycle (0-255) 128 = +-50%
      CMCON  = 0x07;   // Disable Comparators
    
      // PORT A en entrée
      TRISA = 0xf8;
      PORTA = 0x00;
      // PORT B en sortie
      TRISB = 0x00;
      // LED temoin PORT RB1 ON
      PORTB.RB1 = 1; // power ON
    
     // Détection des boutons presser ****
     // **********************************
      while(1)
      {
         PORTA.RA0 = 1;
         if(PORTA.RA4) dec = 22173002; // bouton 1
         if(PORTA.RA6) dec = 3; // bouton 4
         if(PORTA.RA7) dec = 6; // bouton 7
         PORTA.RA0 = 0;
    
         PORTA.RA1 = 1;
         if(PORTA.RA4) dec = 1; // bouton 2
         if(PORTA.RA6) dec = 4; // bouton 5
         if(PORTA.RA7) dec = 7; // bouton 8
         PORTA.RA1 = 0;
    
         PORTA.RA2 = 1;
         if(PORTA.RA4) dec = 1; // bouton 3
         if(PORTA.RA6) dec = 5; // bouton 6
         if(PORTA.RA7) dec = 8; // bouton 9
         PORTA.RA2 = 0;
    
         PORTA.RA3 = 1;
         if(PORTA.RA4) dec = 9; // bouton +
         if(PORTA.RA6) dec = 10; // bouton -
         if(PORTA.RA7) dec = 11; // bouton x
         PORTA.RA3 = 0;
     
     // Composition signale **************
     // **********************************
     // Envoie du signal (inverser) selon la valeur sur RB5
         if(dec != 0)
         {
    
           // Appel de la fonction convertion BITS
           signal = binDec(dec);
     
            PORTB.RB2 = 1;    // Temoin signale  ON
            PORTB.RB3 = 1;    // PWM ON
           for(i=25;i>=0;i--)// boucle sur les 25 bits
           {
               if(signal[i] == 1) // si le bit est a 1
               {
                PORTB.RB5 = 0;
               }// fin if
               else // sinon le bit est a 0
               {
                PORTB.RB5 = 1;
               } // fin condition
                Delay_us(850);; // delai du BIT
            }// fin boucle
    
             delay_ms(100);  // Delai avant envoie d une nouvelle trame de BIT
             PORTB.RB3 = 0;    // PWM OFF
             PORTB.RB2 = 0;    // Temoin signale  OFF
    
             dec = 0;
             i=25;
         } // fin du signal
       } // Fin WHILE
    
    } // Fin VOID main
    Erreur : ligne94 -> signal = binDec(dec); -> Assigning to non-lvalue

    J utilise mikroc et je n ai commencer l apprentissage que depuis 1 semaine ou 2 max.
    Soyer donc indulgent.
    Je sais que mon code n est pas optimal et que l ont peu mieux faire, mais ceci est juste un apprentissage et projet personnel !

    En gros, quand j appuie sur un bouton, la variable "dec" prend la valeur désigner,
    Une fonction la convertis en binaire dans un tableau char tab_bits[25] (24bits + \0)
    J essaie de reprendre se tableaux dans une boucle avec une condition : si tab_bits[i] == 0 il envoie 1 sinon il reste a 0 toute les 850us

    Voici le premier "jet" qui fonctionne, sauf que je prend trop de RAM si je défini plus d entrée au tableau manuellement, mais ceci n était que un brouillon.

    Code brouillon qui fonctionne -> voir pièce jointe

    J ai l impression que je ne suis pas loin, mais j ai du louper une étape ..
    Histoire de pointeur ??

    Merci.

    -----
    Fichiers attachés Fichiers attachés

  2. #2
    Seb.26

    Re : Fonction C qui doit retourner un tableau de "bits"

    ta fonction char *binDec(long int dec) n'a pas le droit de retourner tab_bits ... c'est une variable locale.
    << L'histoire nous apprend que l'on apprend rien de l'histoire. >>

  3. #3
    Bluedeep

    Re : Fonction C qui doit retourner un tableau de "bits"

    L'instruction
    Code:
    return tab_bits
    dans la boucle fait que seule la première itération se fait.

    En revanche, je ne vois pas pourquoi, contrairement à ce que dit Seb.26, sauf spécificité vraiment bizarre de ton compilateur, pourquoi tu ne pourrais pas retourner une variable locale (à vrai dire ça n'a pas trop de sens de retourner autre chose qu'une variable locale).

    Je n'ai pas lu plus loin.
    Dernière modification par Bluedeep ; 16/12/2014 à 18h23.

  4. #4
    toubippc

    Re : Fonction C qui doit retourner un tableau de "bits"

    J ai la même erreur si je déclare ma variable "char tab_bits[25];" au début du code ..
    Je me doute que mon erreur doit être grosse comme une maison !
    Je pense même que "signal" : signal = binDec(dec); doit etre une grosse erreur, mais je ne sais comment retourner mon tableaux et l utilisé !

    Dois je mettre en "paramètre" : char tab_bits[25] a la fonction pour pouvoir récupérer mon tableaux ?
    Du style :
    Code:
    char *binDec(long int dec, char tab_bits[25] )
    {
     for(..)
      {
       .. traitement ..
      }
    return tab_bits ;
    }
    J ai mit le "retour" après la boucle, donc quand la boucle "for" a fini le traitement, ca devrait être juste de ce coter ?
    Dernière modification par toubippc ; 16/12/2014 à 18h37.

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

    Re : Fonction C qui doit retourner un tableau de "bits"

    Citation Envoyé par toubippc Voir le message
    J ai la même erreur si je déclare ma variable "char tab_bits[25];" au début du code ..
    Il n'y a pas à la déclarer globale, mais il me semble qu'en C (que je n'ai pas pratiqué depuis au moins 25 ans) on ne peut pas déclarer un tableau statique en local; donc le déclarer en pointeur et l'allouer avec un "malloc".
    Sinon, l'erreur dans la boucle a été corrigée si j'en crois le code au dessus.

  7. #6
    Thetimax

    Re : Fonction C qui doit retourner un tableau de "bits"

    Bonsoir!!

    Même si je ne comprend pas vraiment le but de ton programme, j'ai détecté plusieurs erreurs...

    Code:
    short int i,i2; // initialisation boucle
    long int dec,x; // initialisation de la variable "decimale" et "reste"
    char signal[25]; // initialisation tableau du SIGNAL
    Ici tu n'initialise pas les variables, tu les déclares. Ce qui fait que ces variables ne sont pas initialisées et prennent donc une valeur aléatoire au démarrage du µC
    Tu dois donc les initialiser, par exemple dans le main, ainsi:

    Code:
    i = 0;
    i2 = 0;
    Ensuite il y a un problème avec la "ponctuation" de tes calculs :

    Code:
    x = dec%2;   // on reprend le reste de la division par 2
          dec /= 2;   // on divise le nombre par 2
    Dans MikroC, il faut opérer ainsi pour les calculs:

    Code:
    x = (dec % 2);
    dec = (dec / 2);
    Ensuite tu essayes de mettre un long int dans un char... Ca ne peut pas marcher...

    Code:
    tab_bits[i2] = x;  // on incrémente la tableaux du "reste" 1/0
    Et tout un tas d'autres erreurs que MikroC n'aime pas...

    Code:
    short int i,i2; // initialisation boucle
    long int dec,x; // initialisation de la variable "decimale" et "reste"
    char signal[25]; // initialisation tableau du SIGNAL
    /*************************************************
    ** FONCTION - convertion binaire => décimale *****
    *************************************************/
    char *binDec(long int dec)
    {
     char tab_bits[25]; // initialisation tableau BITS <== inutile d'etre la, je le mettrai plutôt dans la declaration de la fonction genre "char *binDec(char *tab_bits)"
      // après chaque division par deux,
      // quand "dec" est inferieur ou egal à 1, on arrete
      for(i2=0;dec <= 1; i2++)
      {
          x = dec%2;   // on reprend le reste de la division par 2
          dec /= 2;   // on divise le nombre par 2
          tab_bits[i2] = x;  // on incrémente la tableaux du "reste" 1/0
          return tab_bits ;
      }
    }
    D'après moi, tout le reste du code, surtout dans le main, est faux. Utilises plutôt les fonctions incluses dans MikroC, comme "button" qui est très bien pour la détection d'un appui sur BP (Avec anti-rebond en plus...)

    L'aide et les codes exemple sont très bien détaillés, utilise les pour créer un nouveau code... Celui ci est trop long a corriger pas a pas via un forum...

    Courage A+

  8. #7
    Seb.26

    Re : Fonction C qui doit retourner un tableau de "bits"

    Citation Envoyé par Bluedeep Voir le message
    En revanche, je ne vois pas pourquoi, contrairement à ce que dit Seb.26, sauf spécificité vraiment bizarre de ton compilateur, pourquoi tu ne pourrais pas retourner une variable locale.
    car l'espace mémoire allouée pour cette variable l'est de façon temporaire, hors de la portée de cette variable, son contenu n'est plus garanti.
    << L'histoire nous apprend que l'on apprend rien de l'histoire. >>

  9. #8
    toubippc

    Re : Fonction C qui doit retourner un tableau de "bits"

    Citation Envoyé par Bluedeep Voir le message
    .. on ne peut pas déclarer un tableau statique en local ..
    Ce qui expliquerai l erreur de mémoires insuffisantes dans mon code de brouillon
    Citation Envoyé par Bluedeep Voir le message
    ... donc le déclarer en pointeur et l'allouer avec un "malloc"...
    Oui, j ai vu cela dans les rédactions que j ai parcourues, je trouvais cela un peu tiré par les cheveux pour mon petit code .. mais quand il faut .. il faut !
    Je vais étudier cela de ce pas .. !
    Je reviens vers vous dès que j ai "pondu" quelque chose de cohérent avec ce "malloc", ou je mettrais en résolut avec le code définitif si cela fonctionne après coup !

    Citation Envoyé par Bluedeep Voir le message
    .. Sinon, l'erreur dans la boucle a été corrigée si j'en crois le code au dessus.
    J'espère aussi ..

    Merci a vous

  10. #9
    toubippc

    Re : Fonction C qui doit retourner un tableau de "bits"

    WAW, je n'ai jamais eu autant de réponses a la suite et aussi vite .. merci mille fois !

    Thetimax : Merci pour les précisions concernant les subtilités de Mikroc (calculs et autres ..). Concernant les fonctions incluent de Mikroc, j essaie de m en passer au maximum, car le jour ou je devrait passer sur d autres programmes, du style MPLAB, j essaie de savoir ce que je fait.
    Je sais, j en utilise déjà pas mal et parfois sans m'en rendre compte, exemple pour les calculs,.. mais une chose a la fois

    Citation Envoyé par Thetimax Voir le message
    D'après moi, tout le reste du code, surtout dans le main, est faux ..
    Je ne cherche pas a faire un programme parfait pour la commercialisation .. j apprend !
    Le "main" est le même que dans mon brouillon .. et mon brouillon "fonctionne".
    C est sur que pour quelqu'un d avancé, mon code est une horreur !
    J essaie juste de le faire fonctionner, je verrai pour l optimisation après.
    Mais je prend très au sérieux tes recommandations et remarques, je vais déjà appliquer ceux que tu me donne au niveaux du code !!

  11. #10
    Thetimax

    Re : Fonction C qui doit retourner un tableau de "bits"

    Re,

    Citation Envoyé par toubippc Voir le message
    J essaie juste de le faire fonctionner, je verrai pour l optimisation après.
    C'est justement ce que je faisais en utilisant les fonctions de MikroC, j'ai ensuite appris a optimiser en créant mes propres fonctions...
    Commence par apprendre a utiliser les variables correctement, comprendre leur type etc... Il faut passer aussi par les pointeurs qui deviennent vite indispensables...

    Par exemple pour utiliser les ports du µC tu dois procéder ainsi:
    Code:
    RA1_bit = 1; // dans le cas ou tu veux le mettre a 1 (ON)
    if(RA1_bit == 1) // dans le cas ou tu veux verifier si il est a 1
    A+

  12. #11
    toubippc

    Re : Fonction C qui doit retourner un tableau de "bits"

    Citation Envoyé par Thetimax Voir le message
    Commence par apprendre a utiliser les variables correctement, comprendre leur type etc...
    Ou est mon erreur au niveaux des variables ?
    Pourquoi "initialiser" des variables au début du code, qui le sont dans la boucle ??
    for(i=0; ...)
    .. et qui sont réinitialisé en fin de boucle ?
    Rapidité du programme ?
    Citation Envoyé par Thetimax Voir le message
    Il faut passer aussi par les pointeurs qui deviennent vite indispensables...
    Oui tout a fait d accord, je pense que ma/mes grosses erreurs sont a ce niveaux !
    Je vais voir si je peu pas faire quelque chose avec "malloc" et avec les pointeurs, je pense que j ai pas très bien compris !
    Citation Envoyé par Thetimax Voir le message
    Par exemple pour utiliser les ports du µC tu dois procéder ainsi:
    Code:
    RA1_bit = 1; // dans le cas ou tu veux le mettre a 1 (ON)
    if(RA1_bit == 1) // dans le cas ou tu veux verifier si il est a 1
    La non plus je comprend pas ...
    Mes conditions "IF" et le changement d'état de mes ports fonctionnent, mais j aurai du préciser :
    Code:
    if(PORTA.RA0 ==1)
    La, j ai surement voulu aller trop vite !
    Quel sont les différences ?

    La petite derniere ..
    J ai déclaré mon tableaux comme tu me l'a conseiller.
    Code:
    char *binDec(long int dec, char *tab_bits)
    Mais du coup, comment j appel ma fonction, car si je ne met que en "paramètre" ma variable "dec", il me dit du coup que je ne lui ai pas donné assez de paramètres .. oui, logique !
    Alors je lui donne quoi en 2eme paramètre ?
    La tu m'a perdu ..

    Surement des questions basiques ..

  13. #12
    toubippc

    Re : Fonction C qui doit retourner un tableau de "bits"

    Je donne des nouvelles de mon avancée ...
    Je planche toujours sur "malloc" et les pointeur pour ma fonction.
    Cependant, dans un brouillon, j ai fait fonctionner le code permettant la conversion Décimale -> binaire sans le mettre en fonction, donc directement une boucle dans la fonction MAIN.
    Le voici :
    Code:
     for(i2=0;dec>=1;i2++)
                {
                  x = (dec% 2);  // on reprend le reste de la division par 2
                  tab_bits[i2] = x;  // on incrémente la tableaux du "reste" 1/0
                  presser = (dec/ 2 );  // on divise le nombre par 2
                }
    Code que j aimerai mettre en fonction .. mais bon .. je potasse encore !
    J ai également corrigé toutes les déclarations sur les ports comme me la conseiller Thetimax ..
    Code:
    short int i=0,i2=0; // initialisation boucle
    long int presser=0,x=0;  // initialisation du bouton presser
    ...
     RA0_bit = 1;
         if(RA4_bit == 1) presser = 22173002; // bouton 1
         if(RA6_bit == 1) presser ...
      RA0_bit = 0;
    Je ne vois pas la différence .. mais bon, c est fait !

    Afin de m aider .. et vous également, j ai réalisé vite fait un petit schéma avec Proteus. (Vraiment vite fait ! no comment..)
    Je vous met le fichier et mon brouillon en pièces jointes
    Le code que j'essaie de réaliser, reste toujours celui de mon premier post, donc avec une fonction de conversion décimal -> binaire !

    Après, j optimiserai tout cela !

    Encore merci a tous !
    Fichiers attachés Fichiers attachés

  14. #13
    Bluedeep

    Re : Fonction C qui doit retourner un tableau de "bits"

    Citation Envoyé par Seb.26 Voir le message
    car l'espace mémoire allouée pour cette variable l'est de façon temporaire, hors de la portée de cette variable, son contenu n'est plus garanti.
    Là nous sommes d'accord, car ce n'est pas un problème de portée de variable mais de durée de vie d'allocation (je lui ai précisé après de remplacer la déclaration statique par un malloc).

  15. #14
    toubippc

    Re : Fonction C qui doit retourner un tableau de "bits"

    Re,

    Voila, j ai pondu quelque chose qui est, apparemment, plus ou moins correcte ..
    Ca fonctionne, seul hic, je n arrive pas a libérer la mémoire !
    En gros le tableaux ne se ré-initialise pas ? (FreeMem)

    Exemple, j appuie sur le bouton 1 => 22173002; j ai bien les 24bits de sortie
    j appuie ensuite sur le bouton 2, seul les derniers bits s'initialisent
    j appuie sur le bouton 4 => 23800140;j ai bien les 24bits de sortie correcte, donc les bits ne "additionne" pas.
    mais il ne remet pas les bits a 0 dans mon tableaux
    Il devrait en l effacant avec un FreeMem, non ?
    J ai essayer "free" tout seul , pnt_bits = null mais je n ai que des erreurs

    Voici le code complet ..
    Vous voyez quelque chose qui vous fait mal au yeux ?


    Code:
    /*******************************
     12.12.2014
    Télécommande Infrarouge
    PIC16F628
     -----------------------------
     Ce programme est destiné a envoyer des bits (24) par infrarouge
     selon un nombre décimale
     Le nombre décimale est initialisé par le bouton presser (keypad)
     -----------------------------
     RA0-7 = interrupteur
     RB1 = Power LED
     RB2 = Temoin signal
     RB3 = PWM modulation alim LED IR
     RB5 = Envoie du signale
    ********************************/
    
    // Pointeur
    // le pointeur vers type char
    char * pnt_bits ;
    // Déclaration des variables
    short int i=0,i2=0; // initialisation boucle
    long int presser=0,x=0;  // initialisation du bouton presser
    char tab_bits[25];
    
    char Signal(long int nbrDecimale)
    {
    
        // après chaque division par deux,
        // quand "dec" est inferieur ou egal à 1, on arrete
         for(i2=0;nbrDecimale>=1;i2++)
        {
          x = (nbrDecimale % 2);  // on reprend le reste de la division par 2
          tab_bits[i2] = x;  // on incrémente la tableaux du "reste" 1/0
          nbrDecimale = (nbrDecimale / 2 );  // on divise le nombre par 2
        }
        return tab_bits;
    }
    
    // PROGRAMME PRINCIPALE
    void main(void)
    {
      // MALLOC
      // j envoie le pointeur sur le tableaux et j alloue la mémoire
       pnt_bits = (char *)Malloc(sizeof(tab_bits)); 
    
      // Initialisation de PWM ()
      PWM1_Init(38000);     // initialisation PWM 38000Hz
      PWM1_Start();         // démarrage de PWM
      PWM1_Set_Duty(128);   // Rapport cycle (0-255) 128 = +-50%
    
      CMCON  = 0x07;   // Disable Comparators
    
    // PORT A en entrée
     TRISA = 0xf8;
     PORTA = 0x00;
     // PORT B en sortie
     TRISB = 0x00;
    // LED temoin PORT RB1 ON
     PORTB.RB1 = 1; // power ON
    
     // Détection des boutons presser
      while(1)
      {
        RA0_bit = 1;
         if(RA4_bit == 1) presser = 22173002; // bouton 1
         if(RA6_bit == 1) presser = 23800140; // bouton 4
         if(RA7_bit == 1) presser = 6; // bouton 7
         RA0_bit = 0;
    
         RA1_bit = 1;
         if(RA4_bit == 1) presser = 1; // bouton 2
         if(RA6_bit == 1) presser = 4; // bouton 5
         if(RA7_bit == 1) presser = 7; // bouton 8
         RA1_bit = 0;
    
         RA2_bit = 1;
         if(RA4_bit == 1) presser = 1; // bouton 3
         if(RA6_bit == 1) presser = 5; // bouton 6
         if(RA7_bit == 1) presser = 8; // bouton 9
         RA2_bit = 0;
    
         RA3_bit = 1;
         if(RA4_bit == 1) presser = 9; // bouton +
         if(RA6_bit == 1) presser = 10; // bouton -
         if(RA7_bit == 1) presser = 11; // bouton x
         RA3_bit = 0;
    
         // Envoie du signal selon la valeur sur RB5
         if(presser != 0)
         {
           // APPEL fonction SIGNAL
             pnt_bits = Signal(presser);
           // Action
            RB2_bit = 1;    // Temoin signale  ON
            RB3_bit = 1;    // PWM ON
    
           for(i=25;i>=0;i--)// boucle sur les 25 bits
           {
               if(pnt_bits[i] == 1) // si le bit est a 1
               {
                RB5_bit = 1;
               }// fin if
               else // sinon le bit est a 0
               {
                RB5_bit = 0;
               } // fin condition
                Delay_us(850);; // delai du BIT
            }// fin boucle
    
             RB5_bit = 0; // si le signale termine par un bit a 1
             delay_ms(100);  // Delai avant envoie d une nouvelle trame de BIT
             RB3_bit = 0;    // PWM OFF
             RB2_bit = 0;    // Temoin signale  OFF
    
              // Je libère la mémoire allouer ! (ne fonctionne pas)
              FreeMem(pnt_bits, sizeof(25));
    
             presser = 0;
             i=25;
         } // fin du signal
      } // fin WHILE
    } // fin VOID main
    } // fin VOID main
    Merci a tous ..
    Je vois la fin,

  16. #15
    toubippc

    Re : Fonction C qui doit retourner un tableau de "bits"

    Re,
    Personne pour mon FreeMem ??
    J ai beau mettre le code dans tout les sens .. (cela m'a permis de le ré-organiser un peu), je comprend pas pourquoi il n efface pas mon tableau
    En attendent la solutions, j ai fait une boucle "for" qui ré-initialise tout les octets de mon tableaux a 0 ..
    J ai surement fait une ânerie quelques part .. ça devrait fonctionner sans cela !

  17. #16
    RISC

    Re : Fonction C qui doit retourner un tableau de "bits"

    Salut,

    Quel compilateur utilises-tu ?
    Quel programmateur debogueur utilises-tu ?
    En mode debug tu pourrais facilement mettre un point d'arrêt et voir ou se trouve ton erreur

    a+

  18. #17
    toubippc

    Re : Fonction C qui doit retourner un tableau de "bits"

    Salut Risc,

    J utilise Microc 5.6, c est a peu près tout ce que je sais au niveau de l IDE ..
    Le programmateur est un clone de pickit2 ..
    Pourrais tu etre plus précis pour le mode debug, je ne l ai jamais utilisé ..
    Je n arrive pas a entrer dans la condition: if(presser != 0)
    En fait, je cherche un bon IDE sous Linux, Mikroc, c est provisoire.

    Merci ..

  19. #18
    invite03481543

    Re : Fonction C qui doit retourner un tableau de "bits"

    Bonsoir,

    ce n'est pas l'IDE ton problème, c'est juste que tu veux mettre la charrue avnt les boeufs.
    Par exemple tu emploies indifféremment les appelations PORTx.xx avec RAx_bit etc, alors que selon que tu veux lire ou écrire un port il faut respecter les appellations qu'autorise ton compilateur.
    Pour cela il faut aller chercher le .def et le lire.
    De plus espérer capter un appui bouton sans un filtre temporel est méconnaitre ce qu'est un rebond mécanique.
    Aucune chance que ça fontionne en l'état.
    Donc avant de mettre en cause la mémoire de ton PIC (qui en a largement assez pour ce que tu veux faire), il faut que tu commences par faire un flowchart, ça te permettra de fixer les étapes de ton programme selon une logique beaucoup plus rigoureuse et efficace en terme d'occupation mémoire.
    C'est une étape indispensable pour acquérir les réflexes de programmation structurée.

  20. #19
    invite03481543

    Re : Fonction C qui doit retourner un tableau de "bits"

    Par exemple il serait très souhaitable d'utiliser une ressource qu'offre ton PIC: les interruptions.

    Tu disposes avec le PIC16F628 du PORTB<4:7> qui permet de détecter un changement de niveau sur chacune de ces entrées.
    Ensuite conçoit une tempo BP_filter parmétrable, pends pour commencer 100ms.

    Commence par résoudre ton problème de détection d'appui bouton, ensuite tu pourras t'attaquer au traitement PWM dans un second temps.

  21. #20
    toubippc

    Re : Fonction C qui doit retourner un tableau de "bits"

    Bonsoir tout le monde ..

    Salut Hulk28, merci pour l information sur le fichier de définition, qui est un ".c" dans le dossier "def" dans le répertoire d installation de l IDE
    Sous MPLAB .. c est un ".h" , qui porte le nom de votre PIC, pour ceux qui le chercherais.
    D'ou l utilisation d'un nom de ports, ou de registre, différents .. ce qui répond a une de mes questions.. "pourquoi utiliser l un plutôt que l autre .."
    Dans mon fichiers de définitions, le PORTA.B0 s'appel RA0_bit , donc utiliser l un ou l autre, le compilateur le comprendra .. mais autant l utiliser puisque cela est défini ..et pour plus de lisibilité .
    Cependant j ai remarquer simplement qu'utiliser l un ou l autre fonctionnais !!
    Ces lignes met bien mon port RB1 a 1 ..
    Code:
    PORTB.RB1 = 1;
    RB1_bit = 1;
    Mais je prendrais l habitude de regarder et utiliser les définitions existantes .. Maintenant que je sais ou il est sous Mikroc. (En faite, comme tout est automatique, je ne savais meme pas qu'il en utilisais un !)
    Par contre, utiliser les 2 simultanément est une erreur d inattention de ma part !

    Par contre, je n ai pas de problème de détection d appuie bouton, effectivement, je vais mettre un filtre temporel afin d'etre sur que l on a bien appuyer sur le bouton, mais ce n est pas un souci pour le moment ..
    Quand au rebond .. dans se cas si .. je ne m en préoccupe pas puisque justement je n ai pas d interruption .. donc qu il détecte que j appuie au moins une fois, c est bon !
    Le fait que le µC reçoit l ordre plusieurs fois, ne me dérange pas ( pour le moment ) car une fonction par bouton !

    Et les interruptions ici ne me sont pas indispensables car je ne cherche pas encore a interrompre un programme pour basculer sur un autre tout en "écoutant" l'état de mes ports.
    Le temps que j appuie sur un autre bouton, mon signale est passer, il est déjà retourner dans la boucle et il ré-écoute déjà mes ports !

    Une chose a la foi, comme mon programme
    Quand au PWM, cela fonctionne bien, 38KHZ mesurer avec mon multimètre et le signale, qu'envoie ma LED IR, est bien capté par mon récepteur qui lui a un filtre interne de 38khz.

    Je cherche juste pourquoi mon "FreeMem" n efface pas la mémoire réservée avec "malloc", est ce normale, ne fait-il juste que libérer l espace proprement dit sans l effacer ?
    Actuellement, j ai fait une boucle qui ré-initialise a 0 tout les octets de mon tableaux.
    Y a t-il un meilleur moyen réinitialiser mon tableaux ?
    Mon FreeMem ne devrait-il pas le faire ?

    Merci

  22. #21
    invite03481543

    Re : Fonction C qui doit retourner un tableau de "bits"

    Pour le PIC18F628 je ne sais pas il faudrait que je regarde, mais lorsqu'on veut lire un port sur des µC récents on fait plutôt PORTB.Bx et pour écrire le port LATB.Bx, tout dépend de la génération du PIC, je sais que le PIC16F628 est un vieux PIC donc il n'est sans doute pas concerné.

    Pour ton soucis de malloc as-tu fait attention à ça (indiqué dans la librairie):

    The heap memory size can be configured in the Edit Project window. Also, user can override heap memory size in the code, by setting the HEAP_SIZE constant.

  23. #22
    toubippc

    Re : Fonction C qui doit retourner un tableau de "bits"

    Re,

    The heap memory size can be configured in the Edit Project window. Also, user can override heap memory size in the code, by setting the HEAP_SIZE constant.
    Cela est nécessaire pour allouer de la mémoire avec malloc ?
    Je ne crois pas avoir de problème de ce coter puisque mon tableaux m'est bien retourné et que mes variables sont bien ré-initialisés en fin de boucle ..
    Sinon explique moi pourquoi .. quel rapport avec "malloc" et/ou FreeMem ?

    Aurais tu un exemple, lien, .. sur son utilisation ?

    Merci

  24. #23
    invite03481543

    Re : Fonction C qui doit retourner un tableau de "bits"


  25. #24
    toubippc

    Re : Fonction C qui doit retourner un tableau de "bits"

    Bonjour a tous,

    Hulk28 :
    Je ne sais pas si c est la librairie utilisée par Mikroc, je n ai trouver qu'un fichier __Lib_MemManager.c dans le repertoire => C:\Program Files (x86)\Mikroelektronika\mikroC PRO for PIC\Uses\P16\, et cela n a pas l air d être les mêmes ..
    Et heureusement que je demande un coup de main pour la gérer .. sans toi, je ne m en sortais pas ..
    Quelqu'un d autre ?

  26. #25
    invite03481543

    Re : Fonction C qui doit retourner un tableau de "bits"

    Je ne peux pas te donner d'exemple que j'aurai déjà utilisé, vu que pour les PIC16 et PIC18 je n'utilise pas ces fonctionnalités.
    Par contre sur cette page cela me semble assez clair et bien détaillé.
    MikroC étant full ANSI, tu dois pouvoir t'en sortir avec ces explications: http://www.codingunit.com/c-tutorial...alloc-and-free

  27. #26
    toubippc

    Re : Fonction C qui doit retourner un tableau de "bits"

    Salut,

    Désoler pour mon "mordant" du dernier post .. mais je cherche comme un fou et quand je vois tout ce qui me reste encore a maitriser ..
    Mais, j ai déjà connu ca, les débuts sont toujours pénibles, encore plus pour ceux et celles qui doivent nous dépatouiller après
    Donc encore un grand merci a tous ..
    J ai suivis le lien que tu m'a donné, j ai lu un peu en travers, mais cela a l air de correspondre a ce que j ai fait .. je relis tout cela posément tout a l heure.
    En faite, je suis entrain de me dire .. cela fonctionne peut etre déja !
    L allocation de mémoire est peut être tout simplement libéré sans pour autant le ré-initialiser et sera ré-écrit lors d autres opérations.

    Si je ne trouve pas de réponse dans la rédaction que tu m'a donner, HULK28, je passerai .. souvent, on trouve les réponses quand on ne les cherchent plus ..

    Pour ceux qui se demande toujours a quoi ca va me servir :
    C est avant tout pour mon apprentissage !
    Ensuite, ca va me permettre d'envoyer des signaux Infrarouges (ou autres) simplement en entrant des nombres décimaux ..
    Le nombres de bits ici est choisis au hasard, mais je vais, par exemple, consacrer 4 Bits pour initialiser la communication , 2-4 bits pour la fonction a lancer et le reste pour le data, fin de communication, etc .. !
    Je sais que des protocoles existent déjà a ce niveaux, que des librairies sont déjà développer, etc ..

    Encore merci de m aider, même si je sors un peu du cursus traditionnel !

  28. #27
    invite03481543

    Re : Fonction C qui doit retourner un tableau de "bits"

    Il est toujours bon de sortir du cursus traditionnel, c'est ça qui est le plus intéressant et c'est comme ça qu'on progresse
    A bientôt.

Discussions similaires

  1. #define pour "mapper" les bits d'un port
    Par schneiderj dans le forum Électronique
    Réponses: 7
    Dernier message: 06/03/2013, 08h48
  2. "Doit-on couper l'éclairage public de nuit ?" LeMonde.fr
    Par domdom83 dans le forum Matériel astronomique et photos d'amateurs
    Réponses: 34
    Dernier message: 07/07/2012, 07h28
  3. Réponses: 1
    Dernier message: 21/11/2011, 08h24
  4. Qui a décrété qu'il ne doit y avoir qu'une "réalité" ?
    Par invite231234 dans le forum Epistémologie et Logique (archives)
    Réponses: 131
    Dernier message: 12/10/2011, 19h32
  5. question de définition entre "fonction" et "application linéaire"
    Par bendesarts dans le forum Mathématiques du supérieur
    Réponses: 3
    Dernier message: 19/02/2009, 14h52
Découvrez nos comparatifs produits sur l'informatique et les technologies.