Le SR [fr]

Alors, petit point maintenant : comment trouvez-vous la dureté des cours ?

Svp, faites ce test : sur une échelle de 0 à 20 (0 étant ultra-simple et 20 hypra-difficile), à combien notez-vous la difficulté de ces tout premiers cours ?

Et bien sachez que le niveau de tous les suivants sera toujours aussi simple, vous pouvez peut-être rajouter 2 points à votre estimation... Vous contasterez par vous-même : le 68000 est très accessible pour la grande majorité des personnes...

Alors aujourd'hui, étudions le SR qui signifie Status Register en anglais. Il faut savoir que le SR fait un mot (donc 16 bits). Noté que l'octet composé des bits N° 0 à 7 est appelé le CCR pour Condition Code Register. Le CCR est automatiquement mis à jour par le CPU à chaque opération sur les registres de données et sur les accès mémoires que nous verrons la prochaine fois.

Les registres d'adresses ne sont pas concernées par le CCR, c'est une des différences entre les dx et ax dont je parlais dans un des articles précédents.

Il sert en fait à notifier un résultat particulier d'un calcul. Voici sa composition :

• bit N° 0 : Carry (C)
• bit N° 1 : oVerflow (V)
• bit N° 2 : Zero (Z)
• bit N° 3 : Negative (N)
• bit N° 4 : eXtend (X)
• bit N° 5 : inutilisé
• bit N° 6 : inutilisé
• bit N° 7 : inutilisé

• bit N° 8 : Interrupt priority mask (I0)
• bit N° 9 : Interrupt priority mask (I1)
• bit N° 10 : Interrupt priority mask (I2)
• bit N° 11 : inutilisé
• bit N° 12 : Master/interrupt state (M)
• bit N° 13 : Supervisor/user state (S)
• bit N° 14 : Trace enable (T0)
• bit N° 15 : Trace enable (T1)

Nous allons surtout expliquer le CCR dans ce cours, la suite pour un autre jour lorsque vous serez plus avancé...

Un exemple afin que vous compreniez mieux maintenant : lorsque nous bougeons une donnée immédiate dans un registre, le CPU "analyse" ce que vient d'être écrit dessus et modifie le CCR en fonction. Prenons donc :

move.l     #$00000000,d0

d0 va donc contenir zéro qui est un cas particulier parmi toutes les 4 294 967 296 possibilités qu'offre un long mot. Le CPU va donc mettre à 1 le bit N° 2 (Zero) du CCR.

 

Un autre exemple dans le même ordre d'idée :

move.w    #$8012,d0

$8012 = %1000 0000 0001 0010 = cas particulier aussi puisque nous avons bougé un mot (16 bits) qui a son bit N° 15 à 1. Nous avions vu que ce bit est spécial, car il indique le signe (-). Donc le CCR va avoir son bit N° 3 (Negative) à 1 ainsi que son bit N° 2 (Zero) à 0 puisque $8012 est différent de zéro.

Je vous invite bien sûr à vérifier ce que j'écris là par vous même avec AsmOne ! Prenons un registre d'adresse cette fois :

move.l    #$00000000,a0

n'a en rien modifié le CCR, comme vous le constatez sur cette photo :

Je vais vous montrer à quoi sert vraiment le CCR, mais avant un petit retour sur les adresses...
  

Move [fr]

Faisons connaissance maintenant avec l'instruction move (ou mnémonique, les deux mots décrivent la même chose). Traduite en français, elle signifie bouger. Elle sert donc tout simplement à déplacer des données d'un endroit à un autre.

Voyons son utilisation : comme bon nombre d'instructions, elle s'utilise de la façon suivante :

espace
tabulation move <forme de la source> tabulation <source>,<destination>
espace

Alors, plus de précisions :

• espace = ligne vide
• tabulation = toujours appliquer ici une tabulation (touche Tab sur votre clavier)
• <forme de la source> = soit .b, .w ou .l pour octet, mot ou long mot
• tabulation = encore ici une tabulation
• <source> = donnée que vous voulez transférer
• , = virgule
• <destination> = la donnée source atterrira alors ici

Prenons un exemple bien concret maintenant avec un cas particulier de move à valeur immédiate. Pour ceci, il faut utiliser # avant la source qui va signifier au CPU que vous voulez utiliser une donnée de votre choix juste après.

move.l    #$FFFFFFFF,d0

va donc écrire le long mot $FFFFFFFF dans le registre de données d0 :

Amusons-nous maintenant à bien comprendre tout ceci avec d'autres exemples aussi simple :

move.w    #$1111,d0

va donc bouger le mot $1111 dans d0. Seule la partie mot (c'est à dire les bits N° 0 à 15) va étre modifié dans la destination d0.

Ensuite, ce nouveau move :

move.b    #$55,d0

va donc bouger l'octet $55 dans d0. Seule la partie octet (c'est à dire les bits N° 0 à 7) va être modifié dans la destination d0.

Le résultat de ces trois instructions sera donc $FFFF1155 :

Je vous invite à découvrir par vous même le résultat de ces trois move consécutifs. Il suffit de prendre AsmOne (ou AsmPro comme sur les photos, qui est une version améliorée du premier) et de taper les trois mnémoniques dans l'éditeur.

Toujours bien mettre les tabulations aux bons endroits ainsi qu'un espace entre chaque instruction pour un maximum de clarté. Ensuite avec la souris, se rendre dans le débugger et tracer le petit programme avec la touche flèche bas. Tracer signifie que vous allez exécuter une à une les mnémoniques et voir en temps réel le résultat dans les registres.

Pour finir, bougeons tout le contenu du registre d0 dans d1 :

move.l    d0,d1

Ici sans # : pas de valeur immédiate en source mais juste d0. Notez que la source n'est jamais modifiée par le CPU : d0 restera bien d0. Seule d1 la destination sera modifiée :

Allez, un peu de pratique : à vous de jouer avec AsmOne !
   

Les adresses [fr]

La mémoire de nos Amiga est une sorte de long tube d'une largeur de 32 bits. Plus vous en avez, et plus le tube est long. Attention, il y a en fait deux types de mémoire :

1. La ram : peut être de la chipmem ou de la fastmem = le CPU peut lire et écrire dedans,
2. La rom : Kickstart ou drivers spécifiques, le CPU ne peut que lire son contenu.

Afin de localiser telles ou telles données en mémoire, il faut obligatoirement qu'elles soient indiquées au CPU.

C'est exactement comme dans le vie réelle : au 17 rue des Ivrognes près de Lyon, habite un certain Wodk. Enfin sauf que les adresses en informatique sont des nombres hexadécimaux comme précisés sur cette photo.

Petit retour sur les leçons précédentes, nous avions appris en théorie qu'un mot long (32 bits) est fait de 4 octets (8 bit) :

• 4 octets x 8 bits = 32 bits = un mot long

Ou alors qu'un mot long est fait de 2 mots :

• 2 mots x 16 bits = 32 bits = un mot long

Ou encore qu'un mot est fait de 2 octets :

• 2 octets x 8 bits = 16 bits = un mot

Et bien maintenant, vous en voyez sur cette photo "la représentation imagée" avec ce schéma de la structure mémorielle :

Alors, petite pause. Nous entrons dans le vif du sujet par un peu de théorie indispensable avant de débuter notre premier petit programme en assembleur. Rassurez-vous, tout va devenir plus clair avec un peu de pratique.

Chaque être humain est unique, certains vont comprendre en 5 minutes les leçons ici, alors que d'autres vont avoir besoin de beaucoup plus de temps : il n'y a aucune norme, chacun va a son rythme en fonction d'un tas de paramètres qui lui sont propres.

Vous avez ensuite besoin de "maturer" ces nouvelles informations, ou plutôt de les "relier" avec tout votre savoir actuel acquis au cours de votre vie. Patience, le temps fait son oeuvre. Revenez ici à l'établi de temps en temps afin d'ancrer à chaque fois un peu mieux tout ce nouveau savoir.


Pour continuer avec nos moutons, vous voyez que l'adresse $10000000 contient un long mot $10014880.

Prenez tout le temps nécessaire afin de bien comprendre qu'à l'adresse $10000000 se trouve une donnée qui est $10014880. Les adresses et les données sont deux choses différentes. Une adresse indique une donnée. Une adresse mémoire est une localisation, elle sert à trouver une donnée.

Avec cet exemple, il y a plusieurs lectures possibles :

• A l'adresse $10000000.l = il y a $10014880.l
• A l'adresse $10000000.b = il y a $10.b
• A l'adresse $10000001.b = il y a $01.b
• A l'adresse $10000002.b = il y a $48.b
• A l'adresse $10000004.w = il y a $48C0.w

Concernant l'article précédent, et bien vous pouvez mettre soit des adresses ou soit des données dans les registres dx ou ax. Leurs différences vont bientôt vous être expliqué, évitons de mettre la charrue avant les boeufs...

Pour finir, sachez que les 68k sont Big Endian, c'est à dire que les données sont disposées dans le sens de la lecture (de gauche à droite donc). A l'adresse $10000000, nous lisons $10014880 en BE alors qu'en Little Endian (LE) ce serait $80480110.
 

Les registres [fr]

Étudions maintenant certains registres.

Nous allons voir déjà les registres de données et les registres d'adresses.

Déjà, une donnée c'est un nombre : peu importe sa nature (entier ou à virgule), sa forme (octet, mot ou long mot) ou son signe.

Une adresse, et bien rendez-vous dans le prochain article qui lui sera entièrement consacré.

Alors, ces registres sont des petites mémoires tampons qui se trouvent dans le coeur du CPU. Le codeur peut lire et écrire dessus. Ils servent pour y faire des calculs comme une addition par exemple. Ils sont à la disposition du programmeur, vous faîtes ce que vous voulez avec. Le schéma de leur utilisation est bien souvent celui évoqué dans un précédent article : lire certaines données en mémoire pour les mettre donc dans nos fameux registres, y faire certains calculs, et balancer les résultats dans la mémoire graphique par exemple...

1) Les registres de données

L'ensemble des registres de données se note dx. Il y a huit registres, chacun d'une contenance de 32 bits en tout : d0, d1, d2, d3, d4, d5, d6 et d7. Ils peuvent contenir aussi des adresses.

2) Les registres d'adresses

L'ensemble des registres d'adresses se note ax. Il y a aussi huit registres, chacun d'une contenance de 32 bits : a0, a1, a2, a3, a4, a5, a6 et a7. Attention, a7 est spécial : c'est la pile, nous y reviendrons, et se note plutôt sp. Ils peuvent aussi contenir des données.
 

Il y a cependant quelques différences entre les registres dx et les ax que nous verrons plus tard, chaque chose en son temps...
  

Entier et flottant [fr]

Nous avons jusqu'ici uniquement parlé de nombres entiers (integer en anglais).

Suivant le nombre dont vous avez besoin, vous allez utiliser soit un octet, soit un mot ou soit un long mot. Votre nombre doit tenir dans les limites décrites dans le précédent article. Pour par exemple +124 875, vous prendrez un long mot... Ou pour +294, soit un mot ou un long mot...

Il existe aussi depuis le 68020 un coprocesseur appelé aussi FPU (68881 ou 68882) qui s'occupe lui des nombres à virgules (float en anglais).

Depuis le 68040, ce FPU externe a été inclus directos dans le CPU, ce qui était une bonne idée.

Donc, nous avons deux catégories de nombres à notre disposition :

1) les entiers

Ce sont des nombres sans virgule comme -7, +601, +520, -1040, +1203, -4004... Peu importe leur signe ou le fait qu'il soit octet, mot ou long mot...

2) les flottants

Eux ont donc une virgule, comme par exemple +3,1415 ou encore 1547,4587465... La FPU accepte aussi les entiers comme +10,0 !

Nous verrons la Fpu en dernier puisque l'essentiel de la programmation se fait avec les entiers. Vous pourrez faire des centaines voire des milliers de programmes Amiga en n'utilisant que la partie entière de nos CPUs préférés !

Tout est nombre dans nos ordinateurs : une image, un texte ou encore un mp3 sont des suites de nombres stockés sur un disque dur ou en mémoire fastram, tout simplement...

Lorsque vous retouchez une image par exemple, et bien vos changements modifient certains des nombres la constituant par d'autres...

Nous allons maintenant entrer dans le vif du sujet dans les prochains articles, les leçons assembleur commencent pour de vrai !

   

Les chiffres (II) [fr]

Voyons maintenant les limites des nombres .b, .w et .l : il y a déjà deux catégories, c'est à dire les nombres signés et non-signés (signed et unsigned en anglais). Avant de voir plus loin, il vous faut savoir que la position de chaque chiffre 0 ou 1 d'un nombre binaire est numérotée.

Prenons un exemple simple : le chiffre 7 tient sur un octet et s'écrit : %0000 0111

En partant de la gauche :

• 0 est à la position 7,
• 0 est à la position 6,
• 0 est à la position 5,
• 0 est à la position 4,
• 0 est à la position 3,
• 1 est à la position 2,
• 1 est à la position 1,
• 1 est à la position 0.

Le chiffre 7 peut aussi tenir sur un mot : %0000 0000 0000 0111

Dans ce cas, toujours en partant de la gauche :

• 0 est à la position 15,
• 0 est à la position 14,
• 0 est à la position 13,
• 0 est à la position 12,
• 0 est à la position 11,
• 0 est à la position 10,
• 0 est à la position 9,
• 0 est à la position 8,
• 0 est à la position 7,
• 0 est à la position 6,
• 0 est à la position 5,
• 0 est à la position 4,
• 0 est à la position 3,
• 1 est à la position 2,
• 1 est à la position 1,
• 1 est à la position 0.

Le chiffre 7 peut aussi tenir sur un long mot : %0000 0000 0000 0000 0000 0000 0000 0111

 Toujours en partant de la gauche :

• 0 est à la position 31,
• 0 est à la position 30,
• 0 est à la position 29,
• 0 est à la position 28,
• 0 est à la position 27,
• 0 est à la position 26,
• 0 est à la position 25,
• 0 est à la position 24,
• 0 est à la position 23,
• 0 est à la position 22,
• 0 est à la position 21,
• 0 est à la position 20,
• 0 est à la position 19,
• 0 est à la position 18,
• 0 est à la position 17,
• 0 est à la position 16,
• 0 est à la position 15,
• 0 est à la position 14,
• 0 est à la position 13,
• 0 est à la position 12,
• 0 est à la position 11,
• 0 est à la position 10,
• 0 est à la position 9,
• 0 est à la position 8,
• 0 est à la position 7,
• 0 est à la position 6,
• 0 est à la position 5,
• 0 est à la position 4,
• 0 est à la position 3,
• 1 est à la position 2,
• 1 est à la position 1,
• 1 est à la position 0.

 Revenons à nos moutons maintenant. Les octets, mots et long mots sont divisés en deux catégories :

1) Les signés

Ils contiennent un signe, qui peut donc être soit plus (+) ou soit moins (-). Pour signifier ceci au CPU, un bit spécial lui est consacré.

Pour un octet (byte ou .b) : bit n° 7

Pour un mot (word ou .w) : bit n° 15

Pour un long mot (long word ou .l) : bit n° 31

Pour avoir des nombres avec signe (-), il faut partir avec tous les bits à 1 et cette fois effectuer les décalages avec un 0 :

-1 = %1111 1111 = $FF
-2 = %1111 1110 = $FE
-3 = %1111 1101 = $FD
...

En reprenant notre chiffre 7 :

+7 = %0000 0111.b = $07

-7 = %1111 1001.b = $F9

+7 = %0000 0000 0000 0111.w = $0007

-7 = %1111 1111 1111 1001.w = $FFF9

+7 = %0000 0000 0000 0000 0000 0000 0000 0111.l = $00000007

-7 = %1111 1111 1111 1111 1111 1111 1111 1001.l = $FFFFFFF9

 
Donc, leurs limites sont :

Pour un .b (+) de :
0 à 127
%0000 0000 à %0111 1111
$00 à $7F

Pour un .w (+) de :
0 à 32 767
%0000 0000 0000 0000 à %0111 1111 1111 1111
$0000 à $7FFF

Pour un .l (+) de :
0 à 2 147 483 647
%0000 0000 0000 0000 0000 0000 0000 0000 à %0111 1111 1111 1111 1111 1111 1111 1111
$00000000 à $7FFFFFFF

Pour un .b (-) de :
-128 à -1
%1000 0000 à %1111 1111
$80 à $FF

Pour un .w (-) de :
-32 768 à -1
%1000 0000 0000 0000 à %1111 1111 1111 1111
$8000 à $FFFF

Pour un .l (-) de :
-2 147 483 648 à -1
%1000 0000 0000 0000 0000 0000 0000 0000 à %1111 1111 1111 1111 1111 1111 1111 1111
$80000000 à $FFFFFFFF

  

2) Les non-signés

Eux sont toujours plus (+) et n'ont donc aucun bit de distinction.

Leurs limites sont donc :

Pour un .b (+) de :
0 à 255
%0000 0000 à %1111 1111
$00 à $FF

Pour un .w (+) de :
0 à 65 535
%0000 0000 0000 0000 à %1111 1111 1111 1111
$0000 à $FFFF

Pour un .l (+) de :
0 à 4 294 967 295
%0000 0000 0000 0000 0000 0000 0000 0000 à %1111 1111 1111 1111 1111 1111 1111 1111
$00000000 à $FFFFFFFF

Bref, tout ceci est la base de l'assembleur : à connaitre sur le bout des doigts !
   

Les chiffres (I) [fr]

Les nombres sont l'essence même des CPUs. Ils ne savent faire que trois choses :

1. Lire des nombres (de la fastram par exemple),
2. Faire des calculs avec,
3. Écrire ces nombres.

Nous utilisons tous quotidiennement le mode "décimal" (base 10 car 10 nombres sont utilisés à savoir le 0, 1, 2, 3, 4, 5, 6, 7, 8 et le 9) sans aucun sigle distinctif.

Le bit est l'unité fondamentale en informatique : tout est construit à partir cette brique. Il peut être soit à 1 ou soit à 0. Il n'a donc que deux possibilités, d'où l'appellation "binaire" (base 2 car 2 nombres sont utilisés, le 0 et le 1). Le sigle utilisé pour distinguer un nombre binaire est %.

Tout est nombre avec tous les CPUs du monde entier : en effet, ils ne comprennent QUE les nombres binaires, et rien d'autre ! Les autres bases (comme la base 16, voir plus loin) vont simplifier la lecture et la compréhension pour les humains.

Ensuite, voici l'appellation d'un groupe de bits :

• un nombre formé de 8 bits = 1 octet (ou byte en anglais avec pour abréviation .b)
• un nombre formé de 16 bits = 1 mot (ou word en anglais avec pour abréviation .w)
• un nombre formé de 32 bits = 1 long mot (ou long word en anglais avec pour abréviation .l)

Donc 8 chiffres consécutifs précédés du sigle % indiquent un octet binaire. Comptons maintenant jusqu'à 18 en binaire :

• %0000 0000 = 0
• %0000 0001 = 1

Stop : nous avons utilisé tous les chiffres disponibles en binaire. Il suffit alors de décalé d'un cran vers la gauche en le mettant à 1 et de remettre à 0 le cran droit :

• %0000 0010 = 2
• %0000 0011 = 3

Ajout de 1 sur un nouveau cran et remise à 0 des autres :

• %0000 0100 = 4
• %0000 0101 = 5
• %0000 0110 = 6
• %0000 0111 = 7

... et ainsi de suite...

• %0000 1000 = 8
• %0000 1001 = 9
• %0000 1010 = 10
• %0000 1011 = 11
• %0000 1100 = 12
• %0000 1101 = 13
• %0000 1110 = 14
• %0000 1111 = 15
• %0001 0000 = 16
• %0001 0001 = 17
• %0001 0010 = 18...

Une autre base est très utilisée en informatique : "l'hexadécimal" (base 16 car 16 nombres et lettres sont utilisés comme le 0, 1, 2, 3, 4, 5, 6, 7, 8 ,9, A, B, C, D, E et le F). Le sigle $ (parfois aussi noté 0x ou 0h) signifie hexadécimal. C'est exactement le même principe qu'avec le binaire avec les décalages :

• %0000 0000 = 0 = $00
• %0000 0001 = 1 = $01
• %0000 0010 = 2 = $02
• %0000 0011 = 3 = $03
• %0000 0100 = 4 = $04
• %0000 0101 = 5 = $05
• %0000 0110 = 6 = $06
• %0000 0111 = 7 = $07
• %0000 1000 = 8 = $08
• %0000 1001 = 9 = $09
• %0000 1010 = 10 = $0A
• %0000 1011 = 11 = $0B
• %0000 1100 = 12 = $0C
• %0000 1101 = 13 = $0D
• %0000 1110 = 14 = $0E
• %0000 1111 = 15 = $0F

Stop : tous les chiffres et lettres de la base 16 sont utilisés. Cran à gauche additionné de 1 et mise à 0 pour l'autre :

• %0001 0000 = 16 = $10
• %0001 0001 = 17 = $11
• %0001 0010 = 18 = $12...

Tout ceci est à apprendre par coeur et être compris sur le bout des doigts !

  

Preparation [eng]

These are the essential preparations to start your learning in right conditions :

• Buy a special notebook for your lessons. Write in big letters "Asm 68k" on the first page. This notebook will serve you constantly at the beginning to write down your notes and even after when you'll be seasoned. Indeed it's faster and useful to scribble memos with a pen than in a text file saved on your hard drive
• Cygnus Editor (Ced) = A very well made text editor, the best to write the sources of your programs
• Asm One = An assembler and also a step by step debugger, very useful to see and test what your chained mnemonics really do. It also contain a sources editor but less practical compared to Ced. A very interesting memory viewer is also available.
• Phxass = Command line assembler which will be installed in C: and used only with the CLI. To use most of the time with Ced to compile your sources
• The 3.9 RKM = These are the official documentations which detail all the Kickstart funtions
• A guide describing all the of 68k mnemonics = Downloadable from Aminet
• Optional = A calculator which offer binary/decimal/hexadecimal conversions which sometime may be useful.

You are now fully ready to start !

(translated by Squaley)

     

Préparation [fr]

Voici les préparatifs indispensables afin de commencer votre apprentissage dans de bonnes conditions :

• Achetez un cahier spécial pour vos leçons. Notez en gros caractères Asm 68k sur la page de garde. Ce cahier vous servira constamment pour prendre des notes au début, et même ensuite lorsque vous serez aguerri. C'est en effet bien plus pratique et rapide de griffonner des mémos avec un crayon plutôt que dans un fichier texte sauvegardé sur disque dur,

• Cygnus Editor (Ced) = traitement de texte ultra bien fait, un must pour écrire les sources de vos programmes,

• Asm One = assembleur et surtout débugger pas à pas, très utile pour voir et tester ce que réalisent vraiment les mnémoniques que vous alignez les une après les autres. Il possède aussi un éditeur de sources, mais peu pratique comparé à Ced. Un viewer de mémoire très intéressant est aussi disponible,

• Phxass = assembleur en ligne de commande que vous installerez dans C: et n'utiliserez qu'avec le Cli. S'utilisera avec Ced la plupart du temps pour assembler vos sources,

• Les RKM 3.9 = ce sont les documentations officielles qui précisent l'utilisation de toutes les fonctions du Kickstart,

• Un guide décrivant toutes les mnémoniques du 68k  = downloadable depuis Aminet,

• Facultatif : une calculatrice proposant les conversions binaire/décimal/hexadécimal bien pratique parfois.

  
Voilà, vous êtes fin prêt pour commencer les leçons maintenant !
    

Preconceived ideas [eng]

Before starting, you need to clear your mind and get back to zero with your prejudices about coding in general and particular about assembler.

This time you need to start by reprogramming yourself with positive ideas and  with constructive beliefs which will help you to progress in the good direction.

68k assembly is really simple, It's your prejudices and non-positive ideas which block you in this domain. The good thing is to repeat in a loud and clear voice in present tense some positive phrases which go in the right way :

• "68k assembly is very simple",
• "Thousand of people knows how to code in assembly, so do I",
• "I code in 68k assembly with ease"...

   
Take your time to assimilate these phrases and persuade yourself that assembler is available for everyone, whatever your study level or social position... Repeating these phrases during 20 minutes a day during some months is  a good idea...

In fact, you need to own two essential qualities to know how to code : to be logic and to have a good memory.

For logic, everybody seems to have one. For the memory here's some tips and important advices to improve all of your cerebral potential and also your general health : 

• Bach flowers : these are elixirs made from different flowers which will help you to calm your mind, helping for a better concentration.
• Becoming vegetarian of course : meat, fish, and dairy products are very virulent poisons for the human body as also for the mental. By eating only fruits and vegetables you'll get a better wellness in general, you'll be less sick and you'll have far more clear and performant thoughts. The greatest genius were vegetarians because they knew those benefits allow them to make their brain works better...
• Drink good quality water. There's a lot of filters you can plug on tap,  there's also filtered water fountain that you can find everywhere on internet...
• Only eat bio food : run away from supermarkets because they propose goods full of chemical products and additives, the whole is grown with pesticides and may block your cognitive faculties...
• Some plants can have powerful positive effects like the Ginkgo Biloba, spirulina, royal jelly. The human body is a "whole" other organs helps you think and not only the head...
• Colon hydrotherapy for "purify" your bowels : some call the belly, the second brain...
• Do some sports, at least 2 hours a week...

 
These very pedagogical courses, I hope, will explain you step by step all the necessary bases to understand how 68k are working and then allow you make your own programs by yourself !

They will go straight to the point without unnecessary and boring explanations : you will have all  the essential package to program, alone, this wonderful processor which is the 68k !

(translated by Squaley)

     

Idées reçues [fr]

Avant de commencer, il vous faut faire table rase dans votre mental, et tout remettre à zéro quant à vos préjugés sur la programmation en général et l'assembleur en particulier.

Vous devez donc débuter par vous reprogrammer vous-même, avec des idées positives cette fois, des croyances constructives qui vous feront avancer dans la bonne direction.

L'assembleur 68k est vraiment simple, ce sont déjà vos idées préconçues non-positives qui vous empêchaient de progresser dans ce domaine. Le bon truc déjà serait de répéter à haute et ferme voix au présent de l'indicatif des phrases positives qui vont dans le bon sens :

• "L'assembleur 68k est très simple",
• "Des milliers de personnes arrivent à programmer en assembleur, j'y arrive donc aussi",
• "Je programme en assembleur 68k avec facilité"...

Prenez donc quelques temps pour bien assimiler ces phrases et bien vous persuader que l'assembleur est à la portée de tous, quelque soit votre niveau d'étude ou votre position sociale... Les répéter pendant 20 minutes tous les jours pendant quelques mois est une très bonne idée...

En fait, il faut posséder deux qualités essentielles pour savoir programmer : être logique et disposer d'une bonne mémoire.

Pour la logique, à priori tout le monde l'est. Pour la mémoire, voici quelques astuces et conseils importants pour améliorer l'ensemble de votre potentiel cérébral ainsi que votre santé générale :

• Les Fleurs de Bach : ce sont des élixirs de différentes fleurs qui vont vous aider à calmer votre mental, favorisant ainsi une meilleure concentration déjà.
• Devenir végétarien bien sûr : la viande, le poisson, les produits laitiers sont des poisons très virulents pour le corps humain ainsi que pour le mental. En ne mangeant que des fruits et des légumes, vous obtiendrez un plus grand bien être général, tomberez beaucoup moins malade, et aurez des pensées bien plus claires et performantes. Tous les grands génies étaient végétariens, car ils connaissaient ces avantages leur ayant permis de faire déjà mieux fonctionner leur cerveau...
• Boire une eau de bonne qualité. Il existe de nombreux filtres à poser sur les robinets, ainsi que des fontaines filtrantes trouvables un peu partout sur le Web...
• Ne manger que bio : les supermarchés sont à fuir, car proposant des produits remplis de chimie et d'additifs le tout cultivé aux pesticides qui bloquent vos facultés cognitives...
• Certaines plantes peuvent avoir des effets positifs très puissants comme le Ginko Biloba, la Spiruline, et la Gelée Royale. L'organisme humain est un "tout", le reste des organes vous servent aussi à penser, pas qu'uniquement la tête...
• Les hydrothérapies du colon afin de le "purifier" : certains appel le ventre le deuxième cerveau...
• Faire un peu de sport, au moins 2 heures par semaines minimum...

Ces cours très pédagogiques je l'espère vous expliqueront pas à pas toutes les bases nécessaires afin de comprendre le fonctionnement des 68k, pour ensuite vous permettre de réaliser vos programmes à vous, et par vous-même !

Ils iront droit au but, sans explications inutiles et ennuyeuses : vous aurez tout le bagage indispensable pour pouvoir ensuite programmer seul ce fabuleux processeur qu'est le 68k !
 

What is asm ? [eng]

Machine code is like french or chinese, it's the only language understood by the CPU. The assembler is a bridge between this one and us the humans. Indeed, asm is understandable by man with the use of numbers and letters (called mnemonic, adressing mode, registers...) which once assembled is converted in machine code, that is to say a sequence of 0 and 1.

Other programming languages exist like basic, C or even fortran : those are coupled with a compiler which converts eg. C in machine code so that the CPU will understand the program you have written and then execute it.

Several assemblers exist, just as there is many languages on this earth. Each CPU understand his own machine code : eg. Amiga NG with PPC doesn't understand 68k... So you must use an interpreter (which is a program like any other) which will convert 68k code into PPC one... WinUAE which a lot of you know on PC, contains an interpreter converting this time 68k in x86...

We have a huge opportunity with our 68k, since his language is very simple compared to other assemblers. You will note that its learning is exactly as a spoken language : beginnings are somewhat confusing, you need to get used with novelty, and then step by step with lessons everything get simpler... until immediate comprehension when courses and lessons are over and well assimilate.

In fact, you will have to understand the CPU, that is to say "see" how it works : in a way be at his place...don't worry, it's quite possible, hundreds of thousands of people all computer mixed arrived, so you'll get there too !

Plus, today with internet, exchanges are very fast and simple : sending a e-mail with a question can bring a flash answer to a incomprehension and then you'll continue to evolve et learn without being stuck for days and months on something unclear...

That's not all : not only the 68000+ is simple, but also our operating system too. Indeed, the kickstart contain more than a thousand of functions well defined which allows to simply code any games, demos or utilities...

In short, all the conditions are right for you finally launch in assembly programming, which, you'll see, will be passionating, I am sure !

With these very pedagogical courses, you'll become a real boss in assembly programming because the good habits and the right methods will be learned since the beginning ! Plus, having myself years of daily programming (oh là là, what a passion my friends !) in this language, I am aware of what is essential to know, and then all the useless (and there's a lot) will be spared...

The 68000+ being imperfect, there's for example many functions which I've never used. All the unnecessary is abandoned here : this blog is mainly for beginners to learn good and strong bases. Personally, I started from scratch with this language, I owned some rudiments in basic and that's all. My learning has been very and so much long, but with my experience, I'll thrust you faster in the upper echelons of the 68k assembly programming.

Next, once your level in this domain well developed, you may explore by yourself all the hidden recess of the 68000+ : the main goal here is to help you make your first steps in the best available conditions so you can be on your own...

I suppose myself a good pedagog : however if some parts seem unclear, let your questions in the commentary and I will correct the article for more clarity...

Good read and good learning !

Cosmos

  

(translated by Squaley)

     

Qu’est-ce que l’asm ? [fr]

Le langage machine est comme le français ou le chinois, un langage qui est la seule et unique langue compréhensible par le CPU. L'assembleur est un pont entre celui-ci et nous les humains. En effet, l'asm est compréhensible par l'homme avec l'utilisation de chiffres et de lettres (appelés mnémoniques, modes d'adressage, registres...) qui une fois assemblés sera convertit en langage machine, c'est à dire en une suite de 0 et de 1.

Il existe d'autres langages de programmation comme le basic, le C ou encore même le fortan : ceux-ci sont accompagnés d'un compilateur qui va convertir par exemple le C en assembleur afin que le CPU puisse comprendre le programme que vous avez écrit et ainsi l'exécuter.

Il existe plusieurs assembleurs, tout comme il existe de nombreuses langues sur cette Terre. Chaque CPU ne comprend que son propre langage : les Amiga NG avec leur PPC ne comprennent pas le 68k par exemple... Il faut alors utiliser un interpréteur (qui est un programme comme n'importe quel autre) qui va convertir le langage du 68k dans celui du PPC... WinUAE que beaucoup connaissent sur PC, contient un interpréteur convertissant cette fois le 68k en x86...

Nous avons une chance énorme avec nos 68k, puisque son langage est très simple comparativement à d'autres assembleurs. Vous noterez que son apprentissage est exactement comme celui d'une langue parlée : les débuts sont quelque peu déroutants, il faut s'habituer à la nouveauté, et ensuite tout devient simple au fur et à mesure des leçons... Jusqu'à la compréhension immédiate lorsque les cours et les exercices sont terminés et bien assimilés.

En fait, il va falloir comprendre le CPU, c'est à dire "voir" comment il fonctionne : vous mettre à sa place en quelque sorte... Rassurez-vous, c'est tout fait possible, des centaines de milliers de personnes tout ordinateurs confondus y sont bien arrivés, donc vous y arriverez aussi !

De plus, avec Internet aujourd'hui, les échanges sont très rapides et très simples : envoyer un e-mail avec une question peut donner une réponse quasi-éclair à une incompréhension et vous pourrez ainsi continuer à évoluer et à apprendre sans rester coincé des jours ou des mois sur un truc que vous ne trouviez pas clair...

Ce n'est pas tout : non seulement le 68000+ est simple, mais en plus notre système d'exploitation l'est également. En effet, le Kickstart contient plus d'un millier de fonctions bien définies qui permettent de programmer simplement n'importe quels jeux, démos ou utilitaires...

Bref, toutes les conditions sont réunies pour vous lancer enfin dans la programmation assembleur, qui, vous le constaterez, vous passionnera j'en suis certain !

Avec ces cours très pédagogiques, vous deviendrez un vrai crack en assembleur puisque les bonnes habitudes et les bonnes méthodes vous seront enseignées dés le tout début ! De plus, ayant à mon actif des années de programmation quasi-quotidienne (rha là là, quelle passion mes amis alors !) dans ce langage, je sais très bien ce qui est indispensable à savoir, et ainsi tout l'inutile (et il y en a un paquet) vous sera épargné...

Le 68000+ étant imparfait, il existe par exemple bon nombres d'instructions que je n'ai jamais utilisées. Tout le superflu est donc abandonné ici : ce blog est surtout destiné aux débutants afin de vous enseigner de bonnes et solides bases. Personnellement, j'ai débuté de zéro dans ce langage, je n'avais que quelques rudiments de basic et c'est tout. Mon apprentissage a été très et trop long, mais grâce à mon expérience, je vous propulserai bien plus vite dans les hautes sphères de la programmation assembleur 68k !

Par contre ensuite, une fois votre niveau dans ce domaine bien développé, vous pourrez par vous même explorer bien sûr tous les recoins du 68000+ : le principal but est surtout ici de vous mettre le pied à l'étrier dans les meilleures conditions possibles afin que vous puissiez alors vous débrouiller tout seul...

Je me suppose bon pédagogue : si toutefois certains passages vous semblent peu clairs, laissez vos interrogations en commentaires et je rectifierai l'article pour plus de clarté...

Bonne lecture et bon apprentissage !

Cosmos