Convertir un UNSIGNED INT en deux UNSIGNED CHAR

Version imprimable

31/03/2013, 18h52
petitnul12

Convertir un UNSIGNED INT en deux UNSIGNED CHAR

Bonsoir,

Voila, je programme des µC PIC et pour paramétrer des registres j'ai l'habitude de les écrire sous cette forme:

TMR1H = 0xD8;
TMR1L = 0xF0;

Mais je souhaite créer une fonction pour paramétrer ces registres automatiquement, seulement je calcule la valeur de TMR1 en manipulant un UNSIGNED INT, et je ne voit pas trop comment découper ce nombre en deux pour le placer dans les deux registres H et L...

Vous avez des pistes ?
31/03/2013, 19h01
Metalman

Le unsigned char récupère le unsigned int, puis tu fais un >> ou << de 1 (si PIC en 16 bits) et le 2e unsigned char récupère la valeur...
Je n'ai pas fait des masses de décalages de bits, mais ce sont ces 2 opérateurs qu'il te faut ! :)

Ou tu magouilles une structure composée de 2 char avec les champs de bit, et tu cast ton unsigned int en cette structure pour accéder à chaque partie

La 2e méthode est plus "crade"... mais dans tous les cas : attention à l'endianness (big/little endian)
31/03/2013, 19h18
petitnul12

Je vais essayer de voir avec ces bestioles la, c'est un PIC 8 bits, mais je vais voir à ça ^^

Thank's !
31/03/2013, 19h34
petitnul12

En fait le UNSIGNED CHAR récupère les 8 bits les plus bas de l'INT ?
31/03/2013, 19h56
Metalman

Un char = 8 bits/1 octet... et "normalement" il récupère la valeur la plus basse oui...

Je ne sais pas si un unsigned char est nécessaire... le dernier bit est inutilisé "normalement"... ou il y une histoire de bit de contrôle dessus...
Bon... garde-le unsigned ok :P

EDIT : à tout hasard, es-tu sûr qu'un int est sur 16 bits sur ce PIC ?
31/03/2013, 20h08
Neckara

Bonjour,

Citation:

Envoyé par Metalman

Je ne sais pas si un unsigned char est nécessaire... le dernier bit est inutilisé "normalement"... ou il y une histoire de bit de contrôle dessus...

Dans un unsigned, il n'y a ni bit de contrôle, ni de bit inutilisés, tous les bits sont utilisés pour coder le nombre, un unsigned char peut donc contenir des valeurs entre 0 et 2^8 - 1 = 255.

cf FAQ.
31/03/2013, 20h23
petitnul12

J'avoue que la taille de l'entier je ne me suis pas demandé... Je vais voir à ca ^^
31/03/2013, 21h16
Metalman

Citation:

Envoyé par Neckara

Bonjour,

Dans un unsigned, il n'y a ni bit de contrôle, ni de bit inutilisés, tous les bits sont utilisés pour coder le nombre, un unsigned char peut donc contenir des valeurs entre 0 et 2^8 - 1 = 255.

cf FAQ.

Pour la signification du "unsigned" oui évidemment....

Mais pour le fait que cela soit un "char", je ne sais pas exactement comment cela se passe...
J'ai un souvenir que l'ASCII contient 127 caractères, et le dernier bit "servirait" à faire du contrôle... est-ce que les compilos/systèmes font cette distinction char <=> ASCII et modifient le dernier bit en fonction du caractère contenu ?... ou ignorent-ils la signification du caractère et laissent la valeur telle quelle ?
Je ne sais pas...
31/03/2013, 21h31
petitnul12

TMR1L = (unsigned char)(o->period);
TMR1H = ((unsigned char)(o->period))>>8;

J'ai tenter de faire ça, le TMR1L fonctionne bien (j'ai tester en forçant TMR1H), mais le TMR1H ne fonctionne pas, il ne veut pas prendre la bonne valeur.

Je vous tient au jus !
31/03/2013, 21h36
Neckara

Citation:

Envoyé par Metalman

Pour la signification du "unsigned" oui évidemment....

Mais pour le fait que cela soit un "char", je ne sais pas exactement comment cela se passe...
J'ai un souvenir que l'ASCII contient 127 caractères, et le dernier bit "servirait" à faire du contrôle... est-ce que les compilos/systèmes font cette distinction char <=> ASCII et modifient le dernier bit en fonction du caractère contenu ?... ou ignorent-ils la signification du caractère et laissent la valeur telle quelle ?
Je ne sais pas...

Il me semble qu'ils utilisent l'ASCII étendu.

Si on utilise que de l'ASCII, ils laissent le bit inutilisé ( pour permettre les comparaisons de caractères). Après, si on fait des échanges là on peut utiliser le 8ème bit comme bit de contrôle (mais ne pas oublier de remettre le 8ème bit à 0 une fois la vérification faite).
31/03/2013, 22h45
diogene

Citation:

Code:

TMR1H = ((unsigned char)(o->period))>>8;

ça doit faire 0.

Code:

TMR1H = (unsigned char)(o->period>>8);

Hummm cela ne fonctionne tjs pas, mais je ne saisis pas ou...
Voici le code complet:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
void o_clock_init(struct o_clock *o, unsigned int _freq, unsigned int _period)
{
    unsigned int reg;
 
    IPEN = 0;
    GIE = 1;
    PEIE = 1;
    TMR1IE = 1;
    TMR1IP = 0;
    T1CON = 0x01;
 
    reg = _period*_freq/1000000;
    o->period = 65536 - reg;
 
    TMR1L = (unsigned char)(o->period);
    TMR1H = (unsigned char)(o->period>>8);
    TMR1IF = 0;
}

TMR1L et TMR1H sont des registres de 8 bits.

01/04/2013, 05h49
moins1
Et que vaut reg qui sert à définir o->period?

Parce que ça fonctionne ce bout de code
Code:

1 2 TMR1L = (unsigned char)(o->period); TMR1H = (unsigned char)(o->period>>8);
Si j'ai par exemple 0xDEF3 dans o->period, j'obtiens 0xF3 dans TMR1L et 0xDE dans TMR1H.

8-)
01/04/2013, 12h00
Bktero

Sur quelle famille de PIC développes-tu et avec quel compilateur ?
01/04/2013, 16h22
petitnul12

Je suis sur un PIC18F458 (8 bits) et compilateur XC8 Lite.

Dans l'exemple de mon main, reg vaut 10000, ce qui fait un TMR1 à 0xD8F0

J'ai essayer en initialisant reg à 0; mais c'est tjs le même résultat. Je ne voit vraiment pas ou il bloque =(
01/04/2013, 16h49
Bktero
OK. Je voulais m'assurer de la taille d'un short int avec ce compiateur. Dans la documentation, c'est la section 5.4.2 Integer Data Types qui nous intéresse : un unsigned short (int) fait bien 16 bits.

Si dans ton main, tu fais un code comme suit et que tu vas en mode debug vérifier la valeur de chaque variable (avec les watches), les valeurs attendues sont-elles correctes ?
Code:

1 2 3 unsigned short int a = 0xFD13; unsigned char lsb = (unsigned char) (a & 0x00FF); unsigned char msb = (unsigned char) ((a >> 8) & 0x00FF);

Alors le morceau de code fonctionne dans le main sans soucis.

Après je me suis dit que la valeur de reg dépassait quelque fois la capacité d'un int alors je l'ai passé en double pour ensuite le caster, mais tjs rien..

Edit: Je vient de m'apercevoir que la variable period de ma structure clock vaut 0 après être passer dans le calcul.. Ca me semble bizzare =(
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 void o_clock_init(struct o_clock *o, unsigned int _freq, unsigned int _period) { o->ev = 0; double reg; reg = 0; IPEN = 0; GIE = 1; PEIE = 1; TMR1IE = 1; TMR1IP = 0; T1CON = 0x81; reg = (_period * _freq) / 1000000; o->period = 65536 - (unsigned int)reg; unsigned char lsb = (unsigned char) ((o->period) & 0x00FF); unsigned char msb = (unsigned char) (((o->period) >> 8) & 0x00FF); TMR1H = msb; TMR1L = lsb; TMR1IF = 0; }

01/04/2013, 19h38
crocodilex

Peut-on voir la structure o_clock ?
Que vaut _periode ? Que vaut _freq ?
01/04/2013, 19h57
crocodilex

D'après la datasheet, l'ordre d'écriture dans ces registres à une importance en fonction du bit RD16 du registre T1CON.
Il faut d'abord écrire le MSB puis le LSB.

Si tu ne veux pas te soucier de l'ordre, je pense qu'il faut mettre RD16 à 0 (donc T1CON=0x01)

Je teste ma fonction avec _freq = 10 000 000 et _period = 1000
Je les écris bien dans ce sens, mais même dans l'autre ça ne fonctionne pas.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#ifndef CLOCK_H
#define	CLOCK_H
 
#include <xc.h>
 
struct o_clock {
    unsigned int period; // Periode de l'horloge temps reel en µs
    unsigned char ev; //
};
 
void o_clock_init(struct o_clock *o, unsigned int _freq, unsigned int _period);
void o_clock_run(struct o_clock *o);
 
#endif	/* CLOCK_H */

01/04/2013, 20h27
petitnul12

Oups c'est une erreur, le registre T1CON doit bien être à 0x01 (en mode 2x8bits), et même en mode 16 bits ça ne fonctionne pas =(
01/04/2013, 21h06
crocodilex

Peux-tu vérifier la valeur de o->period avec ton debugger ?
01/04/2013, 21h12
petitnul12

Elle reste à zéro, mais je ne voit pas pourquoi =(
01/04/2013, 21h22
crocodilex

Par curiosité, peux-tu essayer ça :
o->period = 65535 - (unsigned int)reg;
01/04/2013, 21h35
petitnul12

Erreur de frappe ça ^^ Tjs le même problème =(
02/04/2013, 10h22
diogene
Code:

1 2 3 double reg; .... reg = (_period * _freq) / 1000000;
Le fait de mettre reg en double ne résoud rien, le calcul continue à être fait en entier et n'empêche pas le dépassement de capacité des int.
Seul le résultat sera mis en double, ce qui dans ce cas ne sert à rien.

Si on veut faire le calcul en double, il faut caster en double au moins l'une des deux valeurs _period ou _freq
02/04/2013, 11h45
petitnul12

Je saisis la subtilité ^^

Mais j'en suis tjs au même point, je ne voit tjs pas pourquoi.. Le problème vient bien du calcul, car si je force period à 55535 tout fonctionne bien.
02/04/2013, 12h50
diogene

Tu apportes des modifications au code, ça ne marche pas mais tu ne donnes pas le nouveau code que tu utilises.
On n'est pas devin.

Oups pardon ^^

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
void o_clock_init(struct o_clock *o, unsigned int _freq, unsigned int _period)
{
    o->ev = 0;
    double reg;
    reg = 0;
 
    IPEN = 0;
    GIE = 1;
    PEIE = 1;
    TMR1IE = 1;
    TMR1IP = 0;
    T1CON = 0x01;
 
    reg = ((double)_period *(double)_freq) / 1000000;
    o->period = 65535 - (unsigned int)reg;
 
    unsigned char lsb = (unsigned char) ((o->period) & 0x00FF);
    unsigned char msb = (unsigned char) (((o->period) >> 8) & 0x00FF);
    TMR1H = msb;
    TMR1L = lsb;
    TMR1IF = 0;
}

02/04/2013, 13h43
crocodilex

Peut-on voir le bout de code qui fait appel à cette fonction ?

Voici le main

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
void main(){
 
    unsigned int count;
    count = 0;
    ADCON1 = 0x00000110;
    ecu_init();
    o_clock_init(&clock,10000000,1000);
    TRISEbits.TRISE0 = 0;
 
    while(1){
        o_clock_run(&clock);
        if(clock.ev == 1)
        {
            count++;
            if(count == 500)
            {
                if(LATEbits.LATE0 == 1)
                {
                    PORTEbits.RE0 = 0;
                } else {
                    PORTEbits.RE0 = 1;
                }
                count = 0;
            }
        }
    }
}

et le o_clock_run

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
void o_clock_run(struct o_clock *o)
{
    if(o->ev == 1)
    {
        o->ev = 0;
    }
    if(TMR1IF==1)
    {
        o->ev = 1;
        unsigned char lsb = (unsigned char) ((o->period) & 0x00FF);
        unsigned char msb = (unsigned char) (((o->period) >> 8) & 0x00FF);
        TMR1H = msb;
        TMR1L = lsb;
        TMR1IF = 0;
    }
}

02/04/2013, 14h56
crocodilex

Où est déclaré clock et comment ?
Le plus simple est de mettre l'intégralité de ton code s'il n'est pas très gros.

Est-ce que tu utilises le debugger sur la cible ou avec un simulateur ?
Quelle est la valeur lue sur reg ?

Voici l'intégralité du main

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
#include <xc.h>
#include "clock.h"
#include "ecu.h"
 
struct o_clock  clock;
 
 
 
void main(){
 
    unsigned int count;
    count = 0;
    ADCON1 = 0x00000110;
    ecu_init();
    o_clock_init(&clock,10000000,1000);
    TRISEbits.TRISE0 = 0;
 
    while(1){
        o_clock_run(&clock);
        if(clock.ev == 1)
        {
            count++;
            if(count == 500)
            {
                if(LATEbits.LATE0 == 1)
                {
                    PORTEbits.RE0 = 0;
                } else {
                    PORTEbits.RE0 = 1;
                }
                count = 0;
            }
        }
    }
}

et le clock.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#ifndef CLOCK_H
#define	CLOCK_H
 
#include <xc.h>
 
struct o_clock {
    unsigned int period; // Periode de l'horloge temps reel en µs
    unsigned char ev; //
};
 
void o_clock_init(struct o_clock *o, unsigned int _freq, unsigned int _period);
void o_clock_run(struct o_clock *o);
 
#endif	/* CLOCK_H */

Je débug avec l'ICD3 sur cible, mais je ne l'ai pas à coté de moi en ce moment, je teste ce soir, mais o->period ne veut pas décoller de 0, et je ne comprend pas pourquoi.

Si à la place du calcul je met:

Code:

o->period = 55535;

et bien tout fonctionne, c'est vraiment au niveau du calcul que ça coince mais je ne comprend pas ou =(

03/04/2013, 19h11
petitnul12
Alors il y a vraiment un truc que je ne comprend plus ^^

Je met mon code suivant dans le main
Code:

1 2 3 unsigned long toto; toto = 0; toto = ((1000 * 10000000) / 1000000);
Et il trouve que toto = 1410

=/ Faut que je lui apprenne les maths je pense =)
03/04/2013, 20h23
Médinoc

Si un unsigned long fait 32 bits, alors c'est normal: 1,000 * 10,000,000 = 10,000,000,000 qui est supérieur à 4,294,967,295 (la plus grosse valeur non-signée qui tienne sur 32 bits).

10,000,000,000 modulo 4,294,967,296 donne 1,410,065,408 qui divisé par 1,000,000 donne 1,410.
03/04/2013, 20h42
petitnul12

Je me suis aperçu de ça après avoir poster le message, je restait borné sur mon 10000.

J'ai fait la division en premier, et tout ce passe bien =)

Thank's
03/04/2013, 22h09
crocodilex
Et je pense que Médinoc a trouvé la solution à ton problème.
La valeur de _freq ne tient pas dans un "unsigned int" puisque celui-ci fait 16 bits sur ton implémentation.
Code:

1 2 3 void o_clock_init(struct o_clock *o, unsigned int _freq, unsigned int _period); o_clock_init(&clock,10000000,1000);
Normalement, tu aurais dû t'en apercevoir puisque le compilateur doit te sortir un warning pour ce cas précis.

Fuseau horaire GMT +2. Il est actuellement 08h33.