42 réponses à ce sujet

[Sugi]

Bon je viens de regarder la datasheet, le timer 0 est sur 8 bit, le timer1 sur 16bit...

Mais de se j'ai lu sur les timer, ils ont tous une fonction particulière. Le 0 est un compteur sur 8 bit
(sa devrais m'aider malgrès les 8 bits) le 1 est un comparateur et peu être utilisé pour le mode capture
et enfin le 2 sert à la gestion du PWM.

J'ai une question par rapport à sa, puis-je utiliser le timer1 comme compteur même s'il ne sert pas
à sa au départ ?

si tu n'as pas compris mes astuces, je pourrais t'ecrires ca en pseudo-code (pas de code, ca dépend de trop de choses, et je suis pas là pour faire le boulot des autres ...).
Je n'est pas l'habitude de demander de faire le boulot à ma place, mais si tu peu me faire un exemple
en C sous CCS je ne dit pas non .

En tout cas merci d'être venu nous éclairés.

[Sugi]

Bonsoir bonsoir,

Suite à ton poste Otatiaro, j'ai fait quelques recherche sur le timer0 et j'ai trouver de quoi faire une
base de temps, voici la formule que j'ai trouver:

delais=(256 - PRC) x 4 x PRD x 1/FH

avec : - delais le temps voulu en sec
- PRC la valeur a chargé dans le registre de comptage du timer
- PRD la valeur du prediviseur
- FH la frequence de l'horloge en hertz

Je connais le delais que je veux et la fréquence de mon horloge, le PRD est a adapter selon les résultat,
il me faut donc le PRC. En remanipulant la formule on a:

PRC= 256 - (delais / (4 x PRD / 20000000)

(corriger moi si je me trompe...)

Donc en admettant que je veuille une base de temp de 1 sec et en mettant un prediviseur de 16 (le max
je crois non ?) j'obtiens un PRC de -312244 et pour 5 sec j'obtiens -1562244.
Le PRC s'utilise dans la fonction set_timer0(PRC), c'est elle qui permet de faire une base de temps...

Ma question est: est il possible de mettre un PRC non seulement négatif, mais aussi long ? sur un timer de
8 bit sa va être limite je crois bien.

Merci d'avance

edit: je viens de faire les calculs en admettant que je ne puisse pas mettre de négatif ni zero, le plus
grand temps que je pourrais avoir avec un PRC de 1 serait 816µs. On est encore loin de la seconde

Allez je vais me coucher il se fait tard...

Modifié par Sugi, 30 octobre 2006 - 01:50 .

[Fabarbuck]

Alors... dans le désordre: meme si le microcontroleur est 8 bits, il peut, en se prenant la tete, compter sur 16 et a priori 32 bits. Il fait des tas d'opérations, c'est tout... le compilateur se débrouille pour insérer ce qu'il faut poru que ca se passe bien, c'est tout.

Pour le timer... bah... je n'ai pas lu le cours de bigonoff mais je pense qu'il en parle... grossierement, c'est un périphérique que tu peux configurer pour qu'il compte tout seul dans son coin, pendant que le pic fait autre chose, et quand il a assez compté ou qu'il se produit un truc correspondant à ce que tu lui as demandé, pouf, il fait signe au pic qui peut 'changer' ce qu'il est en train de faire, et donc exécuter un bout de programme que tu as prévu pour ce cas. en gros:

- je configure le timer, pour qu'il me fasse signe dans x us.
- je continue d'exécuter le programme courant, pour pas perdre mon temps pendant ces x us.
- au bout de x us, une interruption timer est levée. La fonction 'timer's interrupt handler' (gestion de l'interruption timer) est exécutée.

Pour ton délai... ben déja 800 us ca peut etre pas mal.Ta fonction timer's interrupt handler peut etre du style:

int timer_high = 0;
VALUE=5000/0,8; /* je fais pas le calcul de tete, je te laisse faire */

interrupt_handler()
if(++timer_high==VALUE) (
timer_high = 0
ca_fait_5_sec();
)

Du coup... tous les 800 us, tu incrémente timer_high et tu teste si tu l'as assez incrémenté. Quand c'est le cas, tu le remets à 0, et tu lances la fonction qui va bien.
Bon... ce code est loin d'etre super bien fait, mais l'idée générale, c'est ca.

[Sugi]

Bojour,

Perso je n'est pas lu le cour de bigonoff non plus, tout simplement parce que je garde
un mauvais souvenir de l'assembleur (en particulier le 68000...).

Bref, se matin je me suis interessé au timer1 vu qu'il est sur 16bit. En 8 bit on ne peu
pas depasser le nombre 256 je crois, sur 16 bit sa doit être 65535 si j'ai bien compris.
Alors j'ai refait le même calcul et je suis arriver à une valeur max de 0.2 sec et des poussiere.
Sa risque d'être plus rapide avec se timer la non ?

Par contre je ne connais pas interrupt_handler et donc je ne comprend pas bien ton programme .
C'est du C de microchip ? Je travail sous CCS moi.

Tu peu m'aider encore un peu s'il te plait ?

Merci d'avance.

[Otatiaro]

Bojour,

Perso je n'est pas lu le cour de bigonoff non plus, tout simplement parce que je garde
un mauvais souvenir de l'assembleur (en particulier le 68000...).

Bref, se matin je me suis interessé au timer1 vu qu'il est sur 16bit. En 8 bit on ne peu
pas depasser le nombre 256 je crois, sur 16 bit sa doit être 65535 si j'ai bien compris.
Alors j'ai refait le même calcul et je suis arriver à une valeur max de 0.2 sec et des poussiere.
Sa risque d'être plus rapide avec se timer la non ?

Par contre je ne connais pas interrupt_handler et donc je ne comprend pas bien ton programme .
C'est du C de microchip ? Je travail sous CCS moi.

Tu peu m'aider encore un peu s'il te plait ?

Merci d'avance.

Salut,

alors dans un premier temps, il est difficile de comparer l'assembleur 68000 et l'assembleur PIC, tout simplement parce qu'un 68000 est un CISC alors qu'un PIC (comme un AVR) est un RISC.

grooso-modo ca veut dire que dans un 68000, t'as plusieurs centaines d'instructions, des dizaines de registres, et chaque instruction prend un nombre de cycles d'horloge différent. Dans un PIC, tu as 35 instructions (plus ou moins, ca dépend des familles), UN SEUL registre (W, pour Work, le registre de travail), et chaque instruction (sauf les branchements, dans certains cas) ne prennent qu'un cycle d'horloge pour s'executer.

Bilan l'assembleur PIC est de loin plus simple que l'assembleur 68000, de loin ... et je ne peux que te conseiller de lire les cours de bigo, même si tu comptes faire du C par la suite, le langage assembleur est le langage de plus bas niveau, c'est celui qui t'en apprendra le plus sur le fonctionnement du microcontroleur.

Voilà pour le sermont sur l'asm

Maintenant pour le timer, fabarbuck et moi t'avont donné une solution pour "étendre" un timer 8 bit sur quasiement n'importe quel nombre de bit, et arriver jusqu'a la seconde.

Le "interrupt_handler" c'est ce que le controleur fait quand ton timer gueule parce qu'il à fini de compter (c'est une simple fonction, il suffit de dire à ton compilo qu'en cas d'interruption, il vient à cet endroit, et une fois cette fonction terminée, il revient à ce qu'il faisait avant).

++

si tu n'as pas compris mes astuces, je pourrais t'ecrires ca en pseudo-code (pas de code, ca dépend de trop de choses, et je suis pas là pour faire le boulot des autres ...).
Je n'est pas l'habitude de demander de faire le boulot à ma place, mais si tu peu me faire un exemple
en C sous CCS je ne dit pas non .

Salut,

juste en passant, le pseudo-code, c'est un "pseudo-langage" qui permet de décrire des algorithmes de facon simple, et ce n'est en aucun cas du C, un petit exemple :


variable entière blabla

début
blabla = 0;
tant que blabla < 10
blabla ++;
fin tant que
si blabla != 10 alors cool sinon pas cool
fin


Ca se traduit très bien en C par exemple, mais y'a des adaptations à faire ... et là c'est ton boulot d'adapter les algos pour ton usage spécifique.

++

[EDIT] une boulette se trouve dans le pseudo-code, saurez vous la retrouver ?

[Sugi]

variable entière blabla // tu declare un variable entiere appeler blabla

début //debut du prog
blabla = 0; //tu initialise blabla a 0
tant que blabla < 10 //tant que blabla est inferieur a 10
blabla ++; //tu l'incremente
fin tant que
si blabla != 10 alors cool sinon pas cool // sa n'a pas lieu d'être puisque blabla serra forcement =10 a la fin non ?
fin

Ensuite le pseudo code Fabarbuck:

int timer_high = 0; //déclaration variable entière timer_high initialisée à 0
VALUE=5000/0,8; //constante value initialisée à 6250
//à partir de la je comprend pas vraiment
interrupt_handler() //c'est le nom de la fonction ??
if(++timer_high==VALUE) //si timer_high incrementé = value
timer_high = 0 //on initialise timer_high a 0
ca_fait_5_sec(); // ??
)

Tu peu m'eclairer un peu plus ?

[Sugi]

Bon ben je croyais avoir trouver le truc, mais non sa ne fonctionne pas,
voila se que j'ai fais (en C du compilo CCS):

#include <16F877A.h>
#use delay (clock=20000000)
#fuses HS, NOWDT, NOPROTECT, NOPUT, NOBROWNOUT, NOLVP
#int_TIMER0 // obliger pour le timer0
int temps;	//ma variable

void timer0_av() // la fonction
{
   set_timer0(6); // interruption tout les 0,8ms
   if(temps++ == 6250) //la suite comme Fabarbuck
   {
	  temps=0;
	  output_high(pin_B5);//marche avant robot
	  delay_us(2000);
	  output_low(pin_B5);
	  delay_ms(16);
	  output_high(pin_B4);
	  delay_us(1000);
	  output_low(pin_B4);
	  delay_ms(18);
   }
}

void main()
{
   setup_timer_0(RTCC_INTERNAL | RTCC_DIV_16); //obliger pour le timer0
   enable_interrupts(INT_TIMER0);
   enable_interrupts(GLOBAL);
   timer0_av(); // ma fonction
}

Mon robot avance indefiniment, je ne vois pas du tout ou est l'erreur...

[Fabarbuck]

Plusieurs trucs dont je ne suis pas sur:
- un int déclaré dans ton compilo sera sur 8 bits..? est ce qu'il ne faudrait pas lui dire gentilment que tu veux une variable sur un nombre de bits suffisant pour atteindre la valeur 6000 et des brouettes?
- la fonction delay_us n'utilise pas de timer? (si oui, il risque d'y avoir conflit)
- tu fais quoi exactement en changeant l'état des pins..? pourquoi tu utilises des delays dans ta procédure d'interruption..?
- je ne vois pas de boucle infinie... ton programme s'exécute donc surement une fois et une seule, et pouf, terminé. les pattes du uc doivent rester dans leur dernier etat, et plus changer.
- j'ai pas l'impression que tu t'y sois pris correctement pour écrire ton interrupt handler du timer overflow..?
-> regarde la doc de ton compilo pour savoir comment lui expliquer que telle ou telle fonction doit etre le handler pour l'interrupt overflow du timer que tu as choisi. L'idée des interruptions, c'est que lorsqu'elle est déclenchée, le uC arrete ce qu'il est en train de faire, exécute le interrupt handler que tu lui as spécifié (une fonction...), et quand il a fini, il reprend là ou il en était.

[Sugi]

- un int déclaré dans ton compilo sera sur 8 bits..?
Oui j'ai verifier, dans CCS un int est sur 8 bit

- la fonction delay_us n'utilise pas de timer?
non elle a juste besoin du #use delay...

- tu fais quoi exactement en changeant l'état des pins..?
Ben c'est pour faire bouger les servos

- je ne vois pas de boucle infinie...
Pas besoin si je veu seulement le faire rouler 5 sec ?

- j'ai pas l'impression que tu t'y sois pris correctement pour écrire ton interrupt handler du timer overflow..?
Y'a plusieurs mots que j'ai du mal a comprendre la.
Sinon oui c'est comme sa qu'est decrit le timer0 en mode compteur

-> regarde la doc de ton compilo pour savoir comment lui expliquer
C'est justement la que j'ai regardé.

[Fabarbuck]

- un int déclaré dans ton compilo sera sur 8 bits..?
Oui j'ai verifier, dans CCS un int est sur 8 bit
et converti en binaire, sur 8 bits, ca fait combien, 6000 et des brouettes..? :roll:
Ce qui se passe si le compilo est stupide, c'est que disons que 6000+brouettes, ca se code en 11000101011 ; ta variable sur 8 bit sera tronquée à 00101011, soit... 1+2+8+32=43. Au lieu de 0,8ms*6000_et_des_brouettes, tu vas faire le truc dans ton if au bout de 0,8ms*43 !!!





- la fonction delay_us n'utilise pas de timer?
non elle a juste besoin du #use delay...
le fait qu'il faille mettre la directive #use ne veut pas forcément dire qu'elle n'utilise pas de timer, si..? cela dit, je veux bien penser qu'il ne faut pas de timer pour cette fonction... c'était juste un clin d'oeil pour te dire de te 'méfier' des librairies que tu utilises sans savoir forcément quel usage elles font des ressources matérielles.

- tu fais quoi exactement en changeant l'état des pins..?
Ben c'est pour faire bouger les servos
La, j'ai pas trop compris ce que tu veux faire, du coup ! Si j'examine les délais pour chaque broche:
sur B5:
etat initial: 1
attente 2ms
mise à 0

sur B4:
etat initial indefini (je suppose 0 au reset)
attente de 18ms
mise à 1
attente 1ms
mise à 0
attente 18ms

Le petit soucis, c'est que tu n'envoies des impulsions... qu'une seule fois en 5 secondes...! (enfin, si le reste du code est correct). donc... tes servos vont potentiellement meme pas voir passer l'impulsion !


- je ne vois pas de boucle infinie...
Pas besoin si je veu seulement le faire rouler 5 sec ?
pas faux

- j'ai pas l'impression que tu t'y sois pris correctement pour écrire ton interrupt handler du timer overflow..?
Y'a plusieurs mots que j'ai du mal a comprendre la.
Sinon oui c'est comme sa qu'est decrit le timer0 en mode compteur
quels mots? interrupt handler, c'est le gestionnaire(la fonction, ou routine) d'interruption (j'ai mis le mot en anglais pour que tu puisses voir ca dans la datasheet et doc du compilo ). timer overflow, c'est l'interruption de base d'un timer ; tu définis sa vitesse de comptage par le biais du prescaler (diviseur de la fréquence prise en entrée du timer comme référence), et ensuite, il s'incrémente à chaque top horloge (potentiellement divisée) et quand il a atteint le max (donc... overflow, ou débordement: tu stockes 11111111 et tu ajoutes 1... tu as 0, ce qui est incorrect, tu devrais avoir 100000000, impossible sur 8bits, donc débordement...)

Un dernier truc... tu désactive les interruptions à la fin de ton programme...? si non, le timer tournera indéfiniment (je pense), et il y a fort a parier que du coup, ta routine de gestion de l'interruption du timer soit appelée à l'infini...

Au final, en pseudo code, je ferais plutot un truc du genre:

int tempo_high1 (init à 0)
int tempo_high2 (idem)

MAIN:
initialisation du uC (sorties pour les servos activées en sortie, init à 0).
initialisation du timer
boolean yabuboulo = true;
for(ever & yaduboulo)
début impulsion servo1
début impulsion servo2
delay quivabien1 (temps haut commun: 1ms)
fin impulsion servo1
delay quivabien2 (temps ou 1 est bas et l'autre haut: 1ms)
fin impulsion servo2
delay quivabien3 (temps mort commun: 18ms)
fin du forever

/* tu remarques que là, ton robot va avancer à fond tout le temps....*/

TIMER0_ovf_handler
/* le gestionnaire de l'interruption débordement timer0 */
/* meme tambouille que précédement ou presque */
if (++tempo_high1 == 255)
tempo_high2 +=1;
if (tempo_high2 == 6000_et_des_brouettes / 255 /* celle la tu la fera pour moi */ )
/* ca fait 5 secondes que le timer est lancé !!! on tue tout... */
yaduboulo = false;
desactive timer (il sert plus a rien....)


Comme tu le vois, plutot que de demander au compilo de me pondre 500 instructions en asm pour gérer un entier suffisament grand pour stocker 6000, je me débrouille en scindant moi meme 'intelligement' ma variable en deux. C'est une possibilité... je t'invite cependant à utiliser une bonne taille de variable pour ton précédent int (par exemple 16 bits) et à REGARDER LE CODE PONDU PAR LE COMPILATEUR. c'est tres chiant à faire, mais tu devrais voir un peu ce que ca donne, quand on laisse faire les machines... (et pourtant, mon métier est d'apprendre aux compilo à mieux automatiser des trucs... :roll: )

[Sugi]

et converti en binaire, sur 8 bits, ca fait combien, 6000 et des brouettes..? :roll:
Ok sa j'ai compris

c'était juste un clin d'oeil pour te dire de te 'méfier'
Oui je m'en suis rendu compte que j'avais dit une connerie après

La, j'ai pas trop compris ce que tu veux faire, du coup
voila comment je le vois:
sur B5:
etat haut
pendant 2 ms
passage etat bas
pendant 16 ms

sur B4:
idem mais les delay change

Sa correspond au impulsion à envoyer au servo non ?

int tempo_high1 (init à 0) //ok
int tempo_high2 (idem) //non il me le faut sur 16bit donc int16 tempo_high2 ?

MAIN:
initialisation du uC (sorties pour les servos activées en sortie, init à 0). //ok
initialisation du timer //ok
boolean yabuboulo = true; //je vois pas du tout mais je vais chercher
for(ever & yaduboulo) // forever = for(temp=0;temp<yaduboulo;temp++) ?
début impulsion servo1
début impulsion servo2
delay quivabien1 (temps haut commun: 1ms) //impossible mes servo sont inverser, l'un va en avant l'autre en arriere pour aller tout droit
fin impulsion servo1
delay quivabien2 (temps ou 1 est bas et l'autre haut: 1ms)
fin impulsion servo2
delay quivabien3 (temps mort commun: 18ms)
fin du forever

/* tu remarques que là, ton robot va avancer à fond tout le temps....*/

TIMER0_ovf_handler
/* le gestionnaire de l'interruption débordement timer0 */ //je pense savoir
/* meme tambouille que précédement ou presque */ //la suite que javais mit
if (++tempo_high1 == 255)
tempo_high2 +=1; //tempo_high2=tempo_high2+1 ? cet operateur est decrit comme sa dans mon compilo donc c'est pareille que tempo_high2++
if (tempo_high2 == 6000_et_des_brouettes / 255 /* celle la tu la fera pour moi tongue.gif */ )
/* ca fait 5 secondes que le timer est lancé !!! on tue tout... */
yaduboulo = false;
desactive timer (il sert plus a rien....)

Le reste c'est simplement 2 if imbriqué, puis une desactivation du timer.

Modifié par Sugi, 30 octobre 2006 - 10:22 .

[Fabarbuck]

Ca va devenir le b$rdel ce post (si ca l'est pas déja !)


Sa correspond au impulsion à envoyer au servo non ?
oui, mais là tu les envoies l'une apres l'autre et donc tous les délais se cumulent. Si la fréquence des impulsions est trop basse, ton servo fera des à coups.


int tempo_high2 (idem) //non il me le faut sur 16bit donc int16 tempo_high2 ?
pourquoi ca? justement, tu fais une sorte de variable sur 16bits grace à deux variables 8bits... refais les calculsde valeur max, tu verras que ca tient dans 8 bits cette fois.


boolean yabuboulo = true; //je vois pas du tout mais je vais chercher
ben... tu peux le déclarer int, ca change pas grand chose. C'est juste pour faire une condition qui soit vraie quand le robot doit avancer, et fausse quand il doit s'arreter.


for(ever & yaduboulo) // forever = for(temp=0;temp<yaduboulo;temp++) ?
non, plutot for(;yaduboulot;). Le but est de boucler à l'infini tant que yaduboulot est vrai. Une boucle while peut faire l'affaire aussi, peu importe (sauf si tu sais le code produit dans l'un et l'autre cas... c'est un test de ton compilo à faire ! fais un programme avec juste ce bout de code, en version avec un for et en version avec un while... vois ce que ca donne (dou l'utilité de lire l'asm...), et à l'avenir, tu sauras ce qu'il vaut mieux écrire.

//impossible mes servo sont inverser, l'un va en avant l'autre en arriere pour aller tout droit
Et alors? Si les 2 impulsions sont générées en meme temps... les deux débutent en meme temps, pendant 1ms les deux signaux sont à 1, puis un passe à 0, l'autre reste à 1 encore 1ms et passe aussi à 0. Tu generes ainsi deux impulsions quivontbien, non?


tempo_high2=tempo_high2+1 ? cet operateur est decrit comme sa dans mon compilo donc c'est pareille que tempo_high2++
sémantiquement, oui. Après... à toi de voir ce qu'en fait ton compilateur !
(-> du point de vue du sens, c'est à peu pres identique... sauf peut etre coté ordre des opérations, mais c'est de la sodomie de dyptère ici ; encore une fois c'est pour te montrer une facon différente de l'écrire, et pour t'encourager à faire des petits tests avec l'une ou l'autre manière, pour savoir ce qui va donner le meilleur truc avec ton compilo, au cas ou ca donne pas le meme résultat... et c'est pas impossible...)


Le reste c'est simplement 2 if imbriqué, puis une desactivation du timer.
A peu de choses près, oui. Remarque aussi que on met yaduboulot à false... le but étant que lors de l'exécution de l'interrupt handler quivabien, tu fais en sorte qu'il n'y ait plus d'autre interruption timer, et que le programme principal (le main) sorte de la boucle for/while qui fait avancer indéfiniment le robot. A la limite, couper les interruptions n'est pas nécessaire, parce qu'une fois que yaduboulot est passé à faux et que le main a dépassé la boucle 'infinie', l'interruption ne va plus changer quoi que ce soit aux sorties et donc aux servos.

[Sugi]

Oui c'est le b$rdel comme tu dit, sa doit bien faire 4 jour qu'on est dessus et j'ai toujours pas compris
completement le probleme, sa commence à m'enervé et toi aussi j'imagine.

Je comprend le principe tu timer, mais la façon de le mettre en oeuvre non.

En plus maintenant tu me dit que ma façon de faire avancer mes servo est mauvaise, alors
que quand je met mon bout de programme dans une boucle infinie ben il avance...

Je vais plus avoir un cheveux sur le crane à la fin des vacances moi

[Fabarbuck]

Je reprends:
- si tes servos avancaient, je suppose que ca vient de la troncature de la variable qui fait 6000_et_des_brouettes ; la fréquence de tes crénaux devait etre faible, mais ce n'est pas forcément un soucis
- s'il avancait à l'infini, c'est surement parce qu'une fois l'interruption activée, elle tourne à l'infini, meme si ton programme est terminé. Comme c'est là que les servos sont activés, ils le sont à l'infini
- pour ce qui est du timer, il faut déja comprendre:
* comment un processeur dans un uC exécute ton programme
* ce qu'est une interruption, et comment le uC la traite
Pour ca, je suppose que les cours de bigonoff sont une aide précieuse et plus détaillée que nos réponses ici. Comprendre l'assembleur est aussi une aide très utile, parce que le niveau de représentation de ce qu'il se passe est tres proche du fonctionnement réel de la machine, que tu dois comprendre pour saisir ce qu'il se passe vraiment.

Ca ne m'énerve pas, et si tu as des questions, faut pas hésiter à les poser, meme si tu les as déja posées 5 fois, si à chaque fois tu reformules, précises, ben ca va finir par aboutir
Faut pas croire que c'est des notions triviales... c'est à la portée de 'tout le monde' ou presque... presque, parce qu'il faut quand meme faire un sacré effort pour rentrer suffisament dedans pour capter !

[Sugi]

Bah pour quelqu'un qui est dans le metier ou qui fait se genre d'étude la, oui sa doit
paraitre plutôt facile. Mais pour moi, la honnetement je sature...
Sa fait 4 jours que j'essaye de comprendre, et donc 4 jours que le robot n'a pas avancer.

Pour se qui est de l'assembleur, j'en est une sainte horreur, c'est un language à mes yeux
qui ne ressemble à rien (comprendre sa na pas vraiment de structure), qui est proche de
la machine certe mais vraiment très loin de l'homme...

J'ai essayer de lire le cour de bigo (c'est pour dire que je ne suis pas borné, j'ai essayer au moins),
mais rien que de voir des mov_machin, des add_truc et des sub_chose sa me bloque...
Pourtant je sait à quoi correspond ces commandes, mais je me dit que deja avec un language
evolué je comprend pas un timer alors avec des mov_machin à perte de vue j'imagine même pas le carnage.

Je relache un peu l'effort pour le moment parce que comme dit plus haut, je sature. Se qui ne veux pas
dire que je laisse tomber bien sur.

Modifié par Sugi, 31 octobre 2006 - 02:02 .

[Fabarbuck]

Ben... les pros comme tu dis, en ont chié au moment d'apprendre
Remarque que je n'ai pas dit que c'était simple. Il faut juste ne pas mettre la charrue avant les boeufs ! Et prendre du temps pour capter le truc. Si tu parvenais à tout comprendre en 4 jours, honnetement, tu pourrais aller dans une école ingé spécialisée dans le domaine, et rire au nez des profs et des éleves... parce que ce serait une performance les ridiculisant

Ce que je veux dire par 'l'assembleur est intéressant d'un point de vue pedagogique', ce n'est pas de te faire écrire tous tes progs en asm... loin de là... moi meme, j'aime pas trop (et puis quand on fait des compilateurs, c'est un aveu d'échec de s'en passer à 100% ). Ce que je veux dire, c'est que si tu veux vraiment comprendre à fond, il faut étudier la chose à fond, et ca, ca passe aussi par une réflexion sur ce qui se passe dans le uC.

- que devient mon programme écrit en C?
- que passe il quand je met le uC sous tension?
- et la us d'après? et les suivantes?
- comment les choses se déroulent? en quoi changer mon programme va changer ce déroulement?

C'est une liste non exhaustive... mais si tu ne sais pas ce qu'est un Program Counter, des registres, l'alu, le registre de status, la table des vecteurs d'interruptions, les mécanismes de jump conditionnels ou non... etc, ben... je te conseille vivement de te renseigner, progressivement, sur ces aspects. Parce que quand tu sais ce qu'il se passe dans le bide de ta bécane, tu as plus de chance d'influer dessus dans le sens que tu veux

Cela dit... C'est les vacances, alors... bah profite en pour faire de la meca (un truc pas sérieux, quoi ) ou te reposer les neurones (en faisant de la meca? )

[Sugi]

- que devient mon programme écrit en C?
En fait je viens de regarder, et mon compilo ne me fournis pas de fichier asm...
J'ai un tas de fichier avec des extentions que je ne connais pas, un fichier C et un fichier hex.

- que devient mon programme écrit en C?
- que passe il quand je met le uC sous tension?
- et la us d'après? et les suivantes?
- comment les choses se déroulent? en quoi changer mon programme va changer ce déroulement?
Interessant à savoir, c'est sur. Cela dit tu t'est un peu embrouiller sur ta dernière question

mais si tu ne sais pas ce qu'est un Program Counter, des registres, l'alu, le registre de status, la table des vecteurs d'interruptions, les mécanismes de jump conditionnels ou non... etc, ben...
Euh la par contre je suis pret à parié qu'une bonne partie des gens qui ont fait un robot ici ne savent pas de quoi tu parle. Mais bon je connais deja les registre, c'est un bon debut ?

bah profite en pour faire de la meca (un truc pas sérieux, quoi)
J'ai passer un BAC genie meca, et je suis dans un lycée qui pourrais me faire un super chassis
alu, du moment que je leur donne un plan au norme. En attendant la méca du robot est déja faite,
une plaque de bois percé, des fixations pour les servos et une roue folle.

La je voudrais seulement que se foutu robot roule

[Fabarbuck]

J'ai un tas de fichier avec des extentions que je ne connais pas, un fichier C et un fichier hex.
En théorie, un hex est assez proche de l'asm sans les commentaires, non? Tu es sur que tu peux pas configurer le compilo pour qu'il sorte des fichiers intermédiaires lisibles..? je ne connais pas ton soft, donc je ne peux pas t'aider plus... mais c'est toujours un truc marant à faire de lire l'asm généré par ton compilo...

Interessant à savoir, c'est sur. Cela dit tu t'est un peu embrouiller sur ta dernière question
Comment ca..? j'ai pas été clair, peut etre... ce que je voulais dire, c'est l'impact du coding style sur les performances et le déroulement précis de l'exécution de ton application

Euh la par contre je suis pret à parié qu'une bonne partie des gens qui ont fait un robot ici ne savent pas de quoi tu parle. Mais bon je connais deja les registre, c'est un bon debut ?
Une bonne partie... peut etre, meme si j'en suis vraiment pas sur ! N'empeche que je pense que si tu veux vraiment maitriser le truc, c'est important de comprendre les mécanismes mis en oeuvre, et ce qu'il se passe dans le bide du uC. Bon, moi, c'est mon taff (et ca me passionne !) donc... je fais des robots pour bidouiller ca, et pas l'inverse.... N'empeche, si tu prends le temps d'apprendre ca, je suis sur que tu programmes bien mieux, et que tu n'as plus autant de soucis pour arriver à faire ce que tu veux.


bah profite en pour faire de la meca (un truc pas sérieux, quoi)
Je charriais, biensur Je suis une quiche en méca, et ca me gave. Si je trouve un truc en cours du soir genre 'usinage' & co, je vais finir par m'inscrire

[Sugi]

En théorie, un hex est assez proche de l'asm sans les commentaires, non?
Euh... tu n'a jamais ouvert un fichier hexa ?
En fait c une suite de chiffre entre 0 et 9 et de lettre entre A et F, mais tu dois le saoir je pense.
Je vais voir se que je peu faire avec se compilo

en quoi changer mon programme va changer ce déroulement?
Je voulais parlé de cette phrase, j'ai eu du mal à comprendre
mais c'est bon

je fais des robots pour bidouiller ca, et pas l'inverse....
moi se serrait plutôt l'inverse

N'empeche, si tu prends le temps d'apprendre ca, je suis sur que tu programmes bien mieux
Je n'en doute pas une seconde

Si je trouve un truc en cours du soir genre 'usinage' & co
J'en est jamais entendu parler. La meca c'est interessant mais sa devient vite
compliqué au niveau calcul...

[JEF]

En fait c une suite de chiffre entre 0 et 9 et de lettre entre A et F, mais tu dois le saoir je pense.

ah, enfin un truc que je sais: ce sont des valeur en hexadecimal...ecrit "0x.." et une valeur en hexa, ton compilo devrai reconnaitre ça.