PIC18 et langage C : j'ai un pb de débutant...

"Laurent CLAUDE"

============ Compilateur proche "C" classique :

Fonction RTC (par exemple lecture chip horloge I2C pcf 8583 )

void RtcGetClock (int& hr, int& min, int& sec) { hr = xx... (appel de la fonction lisant le chip ) min = xx... sec = xx... }

void main(){ ..../.... RtcGetClock (hh,mn,ss); printf( "\n\r%2X:%2X:%2X",hh,mn,ss); /*(cette fonction a simplement appelé dans hh,mn,ss la valeur pointée par &hr &min &sec */ .../... }

>

On Apr 16, 9:57 am, "maior=E9"

En g=E9n=E9ral, en C le passage par adresses se d=E9clare ainsi :

void RtcGetClock( int *hr, int *min, int *sec )

Et s'appelle ainsi :

int hr, min, sec; RtcGetClock( &hr, &min, &sec );

Le pr=E9fixe & signifie =AB adresse de la variable =BB (ce qui permet =E0 la fonction d'en modifier la valeur) et =E0 l'int=E9rieur de la fonction le pr=E9fixe * permet d'acc=E9der =E0 la valeur de la variable.

t,

Passage par r=E9f=E9rence. C'est du C++.

C'est quoi comme compilateur ?

--

-Stan

Hum ah bon ? Comment tu sais ce que va générer le compilateur dans ce cas?

Et a priori il n'a pas besoin d'optimiser pour le moment, s'il a des problèmes de performance, ce qu'il ne dit pas, ce n'est surement pas là. "Premature optimization is the root of all evil" ;-)

v.

C'est le nom donné par Atmel à sa série de µC, comme ATtiny2313 ou ATmega328 , etc ...

Contrairement aux PICs leur architecture est compatible avec GCC, ce qui est un gros point positif (pour moi en tous cas ;)). L'inconvénient est qu'il sont un poil plus chers (ça se joue en centimes) et moins populaires que les PICs en France donc un peu plus durs à trouver.

v.

Passage par référence. C'est du C++.

C'est quoi comme compilateur ? ============================== "Custom Computer Service" Pas tellement orienté objet car il n'y a pas de notion de classe mais simplement une utilisation des pointeurs.

vic a écrit :

Je confirme ! Je suis en train tenter de débugger un p'tit prog sur atmega328 sans outils adéquat (pas de programmateur avec jtag)... et c'est pas simple (pour moi, évidemment)

Franssoa

=3D=3D=3D=3D=3D=3D

Sans parler des aspects POO, il y a pas de choses tr=E8s utiles en C++, qui ont d'ailleurs =E9t=E9 introduites dans C99.

Mais je ne crois pas que les r=E9f=E9rences soient support=E9es en C99.

Je suis surpris qu'ils aient introduit les r=E9f=E9rences dans CCS. O=F9 trouve t-on la liste compl=E8te des features de ce compilo, je n' ai pas trouv=E9 sur leur site.

--

-Stan

"Stan" a écrit dans le message de news: snipped-for-privacy@r27g2000yqn.googlegroups.com...

Où trouve t-on la liste complète des features de ce compilo, je n' ai pas trouvé sur leur site. ===============

extrait: funct_a(int*x,int*y){ /*Traditional*/ if(*x!=5)

*y=*x+3; } funct_a(&a,&b); //........ funct_b(int&x,int&y){ /*Reference params*/ if(x!=5) y=x+3; } funct_b(a,b);

On Apr 15, 10:54 pm, Laurent CLAUDE

En C on peut d=E9finir des structures de donn=E9es h=E9t=E9rog=E8nes.

/* typage des =E9l=E9ments de la structure */

typedef struct { unsigned char heure, minute, seconde, jour, mois; unsigned int annee; } Struc_Example;

/* pour initialiser les valeurs depuis la fonction */

void GetData( Struc_Example *ptr ) { ptr->heure =3D 3; ptr->minute=3D 14; ptr->seconde =3D 15; /* etc ... */ }

/* appel de la fonction */

Struc_Example StrucTime; /* declaration */ GetData( &StrucTime ); /* appel */ printf( " %u \r\n", StrucExample.anee ); /* affiche */

/* On peut meme impl=E9menter une fonction acceptant */ /* un pointeur sur diff=E9rents types de donn=E9es ... */ /* en pr=E9voyant un element de la structure d=E9finissant son type */

void GetData( void *ptr );

On Apr 15, 10:54 pm, Laurent CLAUDE

En C on peut d=E9finir des structures de donn=E9es h=E9t=E9rog=E8nes.

/* typage des =E9l=E9ments de la structure */

typedef struct { unsigned char heure, minute, seconde, jour, mois; unsigned int annee; } Struc_Example;

/* pour initialiser les valeurs depuis la fonction */

void GetData( Struc_Example *ptr ) { ptr->heure =3D 3; ptr->minute=3D 14; ptr->seconde =3D 15; /* etc ... */ }

/* appel de la fonction */

Struc_Example StrucTime; /* declaration */ GetData( &StrucTime ); /* appel */ printf( " %u \r\n", StrucTime.annee ); /* affiche */

/* On peut meme impl=E9menter une fonction acceptant */ /* un pointeur sur diff=E9rents types de donn=E9es ... */ /* en pr=E9voyant un element de la structure d=E9finissant son type */

void GetData( void *ptr );

Oops, lire : il y a plein de choses

--

-Stan

Le 16/04/2010 13:40, vic a écrit :

En effet, les manques de performances se situent (encore) entre le siège et le clavier ;-)

Je vous remercient TOUS beaucoup d'avoir participé a ce sujet, j'ai appris beaucoup grave a votre aide, aujourd'hui j'en suis arrivé a résoudre mes premiers exercices en C, je suis très content car ça faisait longtemps que je reculais le moment de faire ce pas...

Mais ne vous inquiétez pas, je vais revenir rapidement avec de nouvelles questions basiques !!

Laurent

Le Fri, 16 Apr 2010 13:40:49 +0200, vic a écrit :

tu ne le sais pas tant que tu ne l'as pas fait compiler (merci M La Palice)

IL y a sans doute une option où le code assembleur généré est inclus dans le listing. De mon temps (...) le compilateur transformait le C en assembleur puis assemblait le résultat. Cette manière permet d'affiner le code dans les sections critiques.

Le plus efficace est toujours de passer ces sections en assembleur.

Maintenant même les PICS deviennent puissants cela aide.

Ah oui, Atmel, j'avais vu ça dans ma recherche de µC modernes. En gros, à part le prix quelles sont les vraies différences avec les PICs (bon je sais que si on met un amateur de 6800, une de 6502 rt un de 8080 dans la même pièce, chacun trouvera toujours le sien meilleur que les autres, mais bon, en étant en peu neutre) ? Je sais pas moi, en vitesse, gestion des IT, jeu d'instructions, interfaçage, programmabilité...?

--
LeLapin

s,

Ah, papy sait utiliser un moteur de recherche :o)

J'ai du travailler autant avec de l'Intel que du Motorola. Quand c'est pour des raisons professionnelles on n'a pas toujours le choix de l'uC. Objectivement, les archi Motorola sont mieux con=E7ues.

Pour certaines familles de PIC, la gestion des IT est tr=E8s moche. ( peut =EAtre est-elle mieux con=E7ue pour celles que je ne connait pas).

--

-Stan

J'ai personnellement une grosse préférence pour les AVR donc je ne suis pas hyper objectif, mais voici les différences des AVR par rapport aux PICs :

• Architecture :

- Pas de registre W, mais 32 registres généraux

- Pas de banque de mémoire à switcher à tout bout de champ. L'adressage peut se faire sur 16 bits.

- Pas d'espace mémoire séparé pour la pile.

- Compatible avec GCC

• Jeu d'instructions

- Plus complet, avec toute sorte d'instruction de branchements et d'adressage différent, mais plus long à apprendre (mais pourquoi utiliser l'assembleur quand on a GCC ;))

- Sur PIC on peut toujours calculer le moment d'exécution d'une interruption exactement. Sur AVR, il y a toujours une incertitude de +/-

1 cycle.

• Périphériques

- Pour les I/O, il y a 3 registres : direction, valeur écrite sur le port, et valeur réellement présente sur le port. Evite les erreurs du type "read-modify-write"

- Moins de périphériques que les PICs en ADC, USB, Ethernet, etc ...

• Vitesse

- Généralement plus rapides, la fréquence d'horloge est celle du quartz, sur les PICs elle est divisée par 4.

• Utilisabilité

- Moins de choix dans la gamme que pour les PICs. Pas forcément gênant pour un amateur mais en production ça peut obliger à prendre un modèle un peu plus cher que nécéssaire.

- Outils open-source, gratuits, multi-plateforme. IDE ou bien ligne de commande.

- Programmation série sous 5V au lieu de 12V.

v.

Il y a aussi une autre piste =E0 ne pas n=E9gliger : les ARM, par ex la s=E9rie des LPC 21xx de cher NXP. Le pb ( pour l'amateur ) c'est qu'il sont en boitier LQFP64, mais il existe des kits tr=E8s bon march=E9. On trouve des toolchains facilement ( GCC ou YAGARTO).

Sur les LPC, je trouve que les devices se g=E8rent tr=E8s simplement.

--

-Stan

vic, le 17/04/2010 a écrit :

[...]

Je vais peut-être écrire une connerie, mais il me semble que c'est un contre-argument. Toutes choses égales par ailleurs, le fait de tourner à une horloge divisée permet à priori un microcode qui tourne plus vite.

--
Pierre Maurette