[atmega8] #clocks pour boucle, opération mathématique et variable

[adrien4607]

Bonjour (ou plutôt bonsoir ),
Je suis entrain de débuter dans l'AVR-C et j'ai besoin de savoir le nombre de coup de clocks (est-ce le bon nom ?) que doit faire un atmega8 pour faire une boucle, pour faire des opération mathématique (+, var++, -,var--, *, /) et pour assigner des variables.
J'ai été voir dans le datasheet, je n'ai surement pas été voir ou il faut (Instruction Set Summary) mais je suppose que cette information dois si trouver .

Sauriez-vous éclairer mais question qui sons surement un peut bête mais bon je fait mes premier pas dans se monde


Merci d’avance
-----

[adrien4607]

Corriger moi si je me trompe :

+ = ADD donc 1 coup de clock
- = SUB donc 1 coup de clock
1 coup de clock = 1 cycle

Le reste je sèche

[invite805ff73c]

Ah, pour une fois ça ne parle pas de PIC.

j'ai besoin de savoir

Pourquoi penses-tu avoir besoin de le savoir? Généralement quand on programme en C on s'en fiche, sauf cas particuliers d'optimisations.

Mais bon, je réponds quand même, si cela t'intéresse... Le fichier qu'il te faut: http://www.atmel.com/Images/doc0856.pdf

Corriger moi si je me trompe :

+ = ADD donc 1 coup de clock
- = SUB donc 1 coup de clock
1 coup de clock = 1 cycle

Correct, à condition que les deux opérands se trouvent déjà dans des registres et qu'il s'agit d'une op sur 8 bit uniquement. Autrement dit, si tu écris en C

 
uint8_t a,b,c;
//....
c=a+b;

le compilateur devra probablement déjà charger les valeurs de a et b depuis la RAM dans des registres, puis faire l'opération (le fameux ADD), puis sauvegarder le résultat dans la RAM. Donc plus d'un cycle!

pour faire une boucle,

Il n'existe pas d'instruction "boucle", donc le compilateur va décomposer en plusieurs instructions. Si on prends une boucle qui ne fait que compter jusqu'à p.ex. 250 on pourrais(!) se retrouver avec un truc du genre (mais le compilateur peut aussi faire completement autrement).

clr r16
debut:
inc r16
cpi r16,250
brne debut

Ah oui, quand j'entends un débutant parler du temps qu'il faut pour une boucle je m'attends au pire, alors je précise: Les temporisations se font soit avec un timer soit avec les fonctions delay_ms() ou semblables de la library standard. Toute boucle vide (qui ne fait que compter) sera en effet enlevé par le compilateur si on a activé les optimisations, d'autant plus que le temps dépendra de la version du compilateur! Donc à proscrire dans tout les cas!

pour faire des opération mathématique (+, var++, -,var--, *, /)

Sur 8 bit:
+ --> add
- --> sub (ou subi d'ailleurs)
var++ --> inc
var-- --> dec
* --> mul (attention, n'existe pas sur tout les AVR)
/ --> il n'y a pas de mnémonic pour cette opération, le compilateur doit décomposer en plusieurs mnémonics (une division c'est compliqué pour un µP!). Tu peux pour t'amuser écrire un petit programme test, le compiler et le passer à travers un déassembleur, tu verras...

et pour assigner des variables.

Dans le plus simple des cas ldi r16,42.

HTH

edit: Ah oui, j'allais oublier: Même si tu as l'intention de programmer en C faire un petit détours par la case assembleur est (à mon avis) une très bonne idée, cela te permettra de comprendre comment marche le µP pour mieux programmer en C et c'est aussi très utile pour débugger!

edit2

le nombre de coup de clocks (est-ce le bon nom ?)

le nombre de cycles (sur les AVR un cycle est égal à un coup d'horloge, sur les PIC je crois que ce n'est pas le cas, l'horloge est divisé à l'intérieur du composant).

[invite07d645db]

sur les PIC je crois que ce n'est pas le cas, l'horloge est divisé à l'intérieur du composant.

En effet, sur un PIC, la fréquence des instructions est quatre fois moindre que la fréquence de l'oscillateur.

[A voir en vidéo sur Futura]

[adrien4607]

Merci de vos réponse
Je cherchais ses info pour savoir comment (au niveau des temps) programmer une interface TWI ou I²C, mais je me suis rendu compte qu'il y avais déjà des registre près à l'emploi
Par compte j'ai beau lire dans la datasheet et chercher sur google, j'ai du mal à comprendre comment il fonctionne, niveau du protocole j'ai compris, par contre les registre qui gère le TWI ou I²C je galère .

Par exemple pour envoyé la condition de démarrage, dans la datasheet il est mit :

TWCR = (1<<TWINT)|(1<<TWSTA)|(1<<TWEN )

TWCR est le registre qui lance le TWI et la il est égale à : 0b00000001 décaler ver la gauche de TWINT OU 0b00000001 décaler ver la gauche de TWSTA OU 0b00000001 décaler ver la gauche de TWEN .

Je pense avoir compris que TWCR est le registre qui permet d’initialiser l'interface TWI, mais le reste, à part que c'est des Bits de TWCR je ne comprend pas, surtout que 0b00000001 est décaler par l'un de ces Bits qui sont égale à 0 ou à 1, donc TWCR est "égale" à l'un de ces Bits et ne peut être égale à 0b00000001 ou 0b00000010 ou 0b00000011

Je ne sais pas pour-quoi mais quelle-que chose me dis que je me trompe sur l’interprétation du code ...?

Ah, pour une fois ça ne parle pas de PIC.

Une petite question a ce sujet, pourquoi la majorité des personne se dirige vers les PIC de microchip ?
Personnellement, je trouve que Atmel est beaucoup plus intuitif et beaucoup moins couteux ( moins de 4€ frai de port compris pour un atmega8 + son programmateur USBASP)

[invite805ff73c]

mais je me suis rendu compte qu'il y avais déjà des registre près à l'emploi

Disons plutôt un module hardware configuré par des registres. Oui c'est presque pareil mais il faut être clair pour se comprendre...

Par compte j'ai beau lire dans la datasheet et chercher sur google, j'ai du mal à comprendre comment il fonctionne

Eh oui, quand on se retrouve avec 300 pages de doc il y a de quoi désesperer...

Je pense avoir compris que TWCR est le registre qui permet d’initialiser l'interface TWI, mais le reste, à part que c'est des Bits de TWCR je ne comprend pas, surtout que 0b00000001 est décaler par l'un de ces Bits qui sont égale à 0 ou à 1, donc TWCR est "égale" à l'un de ces Bits et ne peut être égale à 0b00000001 ou 0b00000010 ou 0b00000011

Heu... Ca moi je n'ai pas compris. Voyons cette instructions plus en détail:

TWCR = (1<<TWINT)|(1<<TWSTA)|(1<<TWEN )

TWINT, TWSTA et TWEN sont des constantes, prenons p.ex. 0, 2 et 3 (au pif, trop fainéant pour vérifier mais peu importe).
Que fait le compilateur? (Oui, le compilateur, parce que il n'y a que des constantes à droite du signe = donc toutes ces opérations le compilateur peut les faire à l'avance, inutile d'embêter le µP avec.) Alors que fait-il? Regardons le premier morceau:

 (1<<TWINT)

Un 1 décalé à gauche de TWINT, donc 0 positions.
Un 1

0b00000001

décalé à gauche de 0 positions

0b00000001

et voila notre première valeur. On garde en mémoire cette valeur et on en viens au deuxième morceau:

(1<<TWSTA)

Donc un 1

0b00000001

décalé à gauche de 2 positions

0b00000100

et voilà notre deuxième valeur.
Pour le troisième morceau tu l'auras compris, cela donne

0b00001000

Maintenant la suite: Le compilateur prends ces trois valeurs et fait un OU binaire(!):

0b00000001
0b00000010
0b00000100
------------------
0b00000111

Il faut donc écrire la valeur 0b00000111 dans le registre TWCR et c'est cela que va coder en mnémonics ASM le compilateur, du genre

ldi temp,0b00000111
out TWCR, temp

Voilà, j'espère que c'est plus clair. Pour le module I2C en soi faut que je lise la doc, je ne connais pas le truc par coeur. Patience svp.

Une petite question a ce sujet, pourquoi la majorité des personne se dirige vers les PIC de microchip ?

Ah, ça c'est le genre de questions qui peut déclencher de véritables guerres dans les forums... Il peut y avoir pleins de raisons de choisir une famille plutôt qu'une autre, disponibilité d'infos sur le net et dans les forums, personnes compétentes dans son entourage, boulot, clarté de la doc, disponibilité de compilateurs etc gratuits et ainsi de suite... Moi je préfère l'AVR au PIC, comme tu dis je trouve que c'est plus intuitif mais bon, question d'habitude (j'ai aussi eu l'occasion de bricoler un peu le PIC pendant mes études.)

question: Tu veux bien utiliser ton mega8 en maître ou alors en esclave? Si tu ne sais pas dis-moi avec quoi tu veux communiquer.

[invite805ff73c]

Bon, j'ai la doc du mega8 ouvert page 163. Je pars sur le principe que le µP est maître et qu'on veut écrire une donnée sur un esclave. J'écris au fur et à mesure que je lis la doc. Ce que j'écris est une version minimale SANS vérifications de TWSR et sans gestion d'erreurs! C'est juste pour comprendre le principe, à toi de l'améliorer (rajout gestion erreur, envoi plusieurs octets, interruptions etc).

Effectivement il y a plusieurs registres:
Bitrate donc choix de la vitesse --> TWBR . La formule se trouve page 170. Il n'y a pas de vitesse minimale et la vitesse maximale dépends de ou des esclave(s).
Control --> TWCR. Comme son nom l'indique, c'est avec celui-là qu'on donne des ordres au module.
Status -->TWSR. Bon, c'est clair... Mais attention! Les bits 0 à 1 servent pour le réglage de la fréquence de transmission.
Adress/Data Shift Register -->TWDR. C'est là qu'il faudra mettre les adresses/données qu'on veut envoyer.

Particularité chez les AVR: Pour effacer un drapeau d'interruption il faut écrire un 1 logique par dessus! Et oui il faut utiliser ce drapeau, même si on n'a pas activé les interruptions.

Le mode a utiliser: Master Transmitter Mode page 179 de la doc.

Prenons pas par pas par le début:
1. Remplir TWBR et TWSR0:1 avec les valeurs qui vont bien.
2. Activer le bazar et prendre contrôle des broches SDA et SCL: TWCR=(1<<TWEN);
Ok. Maintenant supposons que nous voulons envoyer la donnée DATA à l'esclave avec l'adresse ADDR. Comme je disais pas de gestion d'erreurs, je pars du principe que le bus est vide et que tout marche comme sur des roulettes...
3. Demander condition start: TWCR=(1<<TWEN)|(1<<TWSTA)|(1<< TWINT);
4. Attendre que cela soit fait: while(!(TWCR&(1<<TWINT)));
5. Ok, le module est en attente de l'adresse de l'esclave. Chargeons la: TWDR=ADDR;
6. et signalons au module que c'est fait en effacant le drapeau: TWCR=(1<<TWEN)|(1<<TWINT);
7. Attendre fin de transmission adresse: while(!(TWCR&(1<<TWINT)));
8. Ok, module en attente données. Charger: TWDR=DATA;
9. et signaler au module qu'il peut faire partir l'octet: TWCR=(1<<TWEN)|(1<<TWINT);
10. Attendre fin transmission données: while(!(TWCR&(1<<TWINT)));
11: Terminer la transmission: condition stop: TWCR=(1<<TWEN)|(1<<TWINT)|(1<< TWSTO);

et voilà le travail. Tu vois bien qu'à chaque accès de TWCR il faut penser à écrire un 1 à la position TWEN sous peine de désactiver le module si on oublie.

Comme je dis, exemple minimum, sans garantie... J'espère que ça peut aider à la prise en main du module. Si tu as des questions pose les (içi dans le fil, pas en MP). Bonne nuit...

Ah oui, quand on bricole l'I2C ça peut toujours servir: spécifications officielles: http://www.nxp.com/documents/user_manual/UM10204.pdf

[invite805ff73c]

Eh merde, 5 minutes c'est vraiment trop court (pour pouvoir modifier sa réponse).

J'avais une ancienne version de la doc sur le DD du coup les pages ne sont pas bonnes. A toi de voir, je ne peux plus le corriger. Doc à jour: http://www.atmel.com/Images/Atmel-24..._datasheet.pdf

[adrien4607]

Un grand merci pour vos explication et réponse

Oui, il est bien utiliser en Maitre.

et voilà le travail. Tu vois bien qu'à chaque accès de TWCR il faut penser à écrire un 1 à la position TWEN sous peine de désactiver le module si on oublie.

En faite si je comprend bien, TWINT, TWEN, ... ne sont pas égal au statut de leurs bit mais a leur position dans TWCR, ce qui donnerais :

0b00000001 << TWINT
<=> 0b00000001 << 7
= 0b10000000


Je pensais que tous les registre (d’ailleurs est-ce bien des registre ?) qui sont à l'intérieur du rectangle retournai la valeurs du bit

[invite805ff73c]

En faite si je comprend bien, TWINT, TWEN, ... ne sont pas égal au statut de leurs bit mais a leur position dans TWCR

Exactement. On peut aussi travailler avec les positions

TWCR=(1<<7);

mais c'est nettement moins lisible que

TWCR=(1<<TWINT);

. TWINT et Co. sont définis dans je ne sais quel fichier header avec des #define.

, ce qui donnerais :

0b00000001 << TWINT
<=> 0b00000001 << 7
= 0b10000000

Exactement.


.

Je pensais que tous les registre (d’ailleurs est-ce bien des registre ?) qui sont à l'intérieur du rectangle retournai la valeurs du bit

Non, le registre c'est le gros rectangle, à l'intérieur on ne trouve que des bits (et encore j'hésite de l'écrire, comme je disais en haut les TWINT etc sont simplement des constantes indiquant la position du bit dans le registre). Pour info, sur certains compilateurs PIC on a fait autrement et on peut écrire directement TWINT=1; mais cela n'est pas possible chez les AVR (du moins avec le compilateur GCC).

[adrien4607]

Ok, un grand merci pour cette éclaircissement et cette aide