Votre premier programme

Cette page vous emmène de rien du tout à un ordinateur qui pilote la redstone tout seul, un petit pas à la fois. Pas besoin de savoir programmer : chaque ligne est expliquée. Comptez une vingtaine de minutes, dans un monde créatif ou en survie une fois arrivé à l'âge des tubes à vide.

Au programme :

1. obtenir un ordinateur et son support de stockage,
2. le poser et le faire tourner, comme n'importe quelle machine Create,
3. ouvrir son terminal et lancer un programme tout fait,
4. écrire votre propre programme, ligne après ligne,
5. lui faire clignoter une lampe, puis le faire démarrer tout seul.

#1. Obtenir un ordinateur

Le premier ordinateur du mod est le Calculateur à tubes, à l'âge III (l'âge des tubes à vide). Chaque âge suivant en apporte un meilleur : plus rapide, avec plus de mémoire, un plus bel écran et plus de possibilités. Ils se programment tous de la même façon : tout ce qui est sur cette page marche sur chacun d'eux.

Âge	Ordinateur
III	Calculateur à tubes
IV	Ordinateur à transistors
V	Mini-ordinateur
VI	Micro-ordinateur et Microcontrôleur
VII	Ordinateur moderne

La page Les ordinateurs les compare en détail.

En survie, le Calculateur à tubes se fabrique sur un Établi mécanique : trois Modules logiques à tubes en haut, deux Plans de mémoire à tores autour d'un Boitier de laiton au milieu, deux Relais autour d'un Mécanisme de calcul en bas. JEI montre la recette et toutes les pièces. En créatif, prenez-en un dans l'onglet du mod.

Un ordinateur garde ses programmes sur un support de stockage, un objet que l'on met dedans. Le Calculateur à tubes lit un Paquet de cartes perforées : huit Cartes perforées vierges et une ficelle dans une table de craft (les Cartes perforées vierges viennent du papier coupé par une Scie mécanique, deux par feuille). Le paquet contient 4 Ko de programmes, largement de quoi commencer.

#2. Le poser et le faire tourner

Posez l'ordinateur : son écran est tourné vers vous. Comme toute machine Create, un ordinateur fonctionne à la rotation : amenez un arbre en rotation (le bloc « Rotor » de Create) à son dos, depuis n'importe quelle source (roue à eau, moulin, moteur à vapeur, ou un Moteur créatif en créatif). Le Microcontrôleur fait exception : il prend son arbre par le dessous.

La vitesse de rotation est la vitesse du processeur. Un ordinateur atteint sa pleine vitesse à 256 tr/min, la moitié à 128 tr/min, un huitième à 32 tr/min. Au-delà de 256 tr/min, rien de plus, et le sens de rotation ne compte pas. Un Calculateur à tubes à pleine vitesse exécute 400 instructions par seconde, c'est beaucoup pour les petits programmes de cette page ; mais à 8 tr/min (une roue à eau seule), il n'en exécute qu'environ 12 : tout prend du temps. Démultipliez si vous pouvez (une grande roue dentée qui entraîne une petite double la vitesse).

La vitesse coûte de la puissance, comme partout dans Create. Avec les réglages par défaut, le Calculateur à tubes demande 16 unités de stress (us) par tr/min : 512 us à 32 tr/min, 4 096 us à 256 tr/min. Les ordinateurs plus récents en demandent bien moins. Si le réseau est surmené, l'ordinateur se fige, exactement comme si rien ne tournait.

#3. Insérer le support

Tenez le Paquet de cartes perforées et faites un clic droit sur l'ordinateur : le paquet entre. Pour le ressortir, accroupi + clic droit à main vide. Vos fichiers restent sur le paquet : vous pouvez les emporter vers un autre ordinateur.

#4. Ouvrir le terminal

Clic droit sur l'ordinateur, à main vide. Le terminal s'ouvre et l'ordinateur vous accueille :

Brass OS 1.0
Tier 1 - 2048 cells
Tapez help pour commencer.
>

La première ligne est le nom du système, la deuxième indique le genre de processeur (Tier 1, c'est le Calculateur à tubes) et la taille de sa mémoire en cellules (cells). Le > est l'invite : l'ordinateur attend une commande. Tapez-en une, puis Entrée.

#5. Demander de l'aide

Tapez help :

> help
Commandes : help, examples, ls, cd, mkdi
r, cat, edit, run, rm, cp, mv, label, me
m, id, clear, brass, reboot, shutdown
Bibliothèques : display, fs, link, math,
 os, peripheral, rs, string, table, term
Débutant ? 'examples' donne des programm
es tout faits.
'edit <fichier>' écrit un programme ; ta
pez son nom pour le lancer.
'help <bibliothèque>' liste ses fonction
s (help rs).
Dossiers : mkdir, cd, 'edit <dossier>'.
import "lib" charge un autre fichier.

Les lignes trop longues continuent simplement sur la suivante : le papier fait 40 caractères de large. Les commandes sont les mots que l'invite comprend (elles sont toutes expliquées dans Le shell et l'éditeur). Les bibliothèques sont les boîtes à outils de vos programmes : rs pour la redstone, math pour les nombres, term pour l'écran...

Tapez maintenant examples. La commande liste des programmes tout faits, seulement ceux que cet ordinateur sait faire tourner :

> examples
hello - votre premier programme
blink - fait clignoter une lampe
counter - compte des impulsions
sequencer - un séquenceur à étapes
clock - l'heure, sur un moniteur
stock - surveille un coffre
speed - pilote un régulateur
traffic - un cycle de feu tricolore
buttons - panneau de boutons cliquables
8 de plus avec un ordinateur à transisto
rs+.
'examples <nom>' : copie sur le support

#6. Lancer un programme tout fait

Copiez le premier exemple sur votre paquet, puis lancez-le en tapant son nom :

> examples hello
Copié dans 'hello'. Lisez-le : edit hell
o   Lancez-le : hello
> hello
Comment t'appelles-tu ? Steve
Bonjour, Steve !
3...
2...
1...
Modifiez-moi : edit hello
>

Quand il demande votre nom, tapez-le puis Entrée. Bravo, vous venez de lancer un programme ! L'invite revient quand il se termine.

Tapez ls pour lister les fichiers du paquet : vous y verrez hello, et la place qui reste.

#7. Le lire dans l'éditeur

Tapez edit hello. L'éditeur s'ouvre, avec le programme en couleurs :

-- Votre premier programme. Lancez-le en tapant son nom : hello
-- print() écrit une ligne, read() attend ce que vous tapez.
write("Comment t'appelles-tu ? ")
local name = read()
print("Bonjour, " .. name .. " !")
for i = 3, 1, -1 do
  print(i .. "...")
  sleep(1)  -- attend une seconde
end
print("Modifiez-moi : edit hello")

Un programme est une liste d'instructions que l'ordinateur suit de haut en bas. Les lignes qui commencent par -- sont des commentaires : des notes pour les humains, que l'ordinateur ignore.

Changez quelque chose : remplacez "Bonjour, " par "Salut, ". Ensuite :

• Ctrl+S enregistre le fichier (la barre d'état affiche Enregistré),
• Échap revient au terminal (s'il reste des changements non enregistrés, il faut appuyer deux fois).

Tapez de nouveau hello : le programme tourne avec votre modification. C'est tout le cycle de la programmation : modifier, enregistrer, lancer, et on recommence.

#8. Arrêter un programme

Certains programmes ne s'arrêtent jamais d'eux-mêmes : un contrôleur d'usine doit tourner pour toujours. Pour arrêter le programme en cours, appuyez sur Ctrl+T dans le terminal, ou cliquez sur le bouton Stopper à côté de l'écran. L'écran s'efface et affiche Terminated (terminé), puis l'invite revient.

Essayez avec ce programme. Tapez edit toujours : l'éditeur s'ouvre sur un nouveau fichier vide. Tapez les lignes ci-dessous, enregistrez, quittez et lancez toujours :

local tour = 0
while true do
  tour = tour + 1
  print("Je tourne encore : " .. tour)
  sleep(1)
end

Il compte une fois par seconde, sans fin (while true do répète jusqu'à la fin des temps). Appuyez sur Ctrl+T pour l'arrêter.

#9. Écrire votre propre programme

À vous d'écrire. Tapez edit usine pour créer un nouveau fichier, et tapez-y chaque étape ci-dessous (en remplaçant le contenu précédent). Après chaque étape, enregistrez, quittez et lancez usine pour voir ce qu'il fait.

#Afficher du texte

print("Bonjour depuis mon usine !")
print("Toutes les machines sont prêtes.")

Bonjour depuis mon usine !
Toutes les machines sont prêtes.

print écrit une ligne à l'écran. Le texte entre guillemets est une chaîne : l'ordinateur l'affiche telle quelle.

#Retenir des valeurs dans des variables

local objet = "lingot de fer"
local nombre = 12
print("Stock : " .. nombre .. " x " .. objet)
nombre = nombre + 64
print("Après une livraison : " .. nombre)
print("Piles pleines : " .. nombre // 64)

Stock : 12 x lingot de fer
Après une livraison : 76
Piles pleines : 1

Une variable est un nom qui garde une valeur. local nombre = 12 crée la variable nombre avec la valeur 12 ; nombre = nombre + 64 la remplace par sa valeur plus 64. Les deux points .. collent des morceaux de texte entre eux (les nombres sont changés en texte au passage), et // divise en jetant le reste.

#Poser une question au joueur

read() attend que le joueur tape une ligne dans le terminal et appuie sur Entrée, et renvoie ce qui a été tapé. write fait comme print, sans passer à la ligne : la réponse se tape juste après la question.

write("Comment vous appelez-vous ? ")
local nom = read()
print("Bienvenue à l'usine, " .. nom .. " !")

> usine
Comment vous appelez-vous ? Steve
Bienvenue à l'usine, Steve !
>

#Prendre des décisions

if (si) n'exécute certaines lignes que quand une condition est vraie. Ici, tonumber transforme le texte tapé en nombre, ou donne nil (rien) quand le texte n'est pas un nombre :

write("Combien de lingots avez-vous ? ")
local nombre = tonumber(read())
if nombre == nil then
  print("Ce n'est pas un nombre.")
elseif nombre >= 64 then
  print("Assez pour une pile entière !")
else
  print("Il vous en manque " .. 64 - nombre .. ".")
end

> usine
Combien de lingots avez-vous ? 40
Il vous en manque 24.
> usine
Combien de lingots avez-vous ? beaucoup
Ce n'est pas un nombre.
>

Remarquez le end : il ferme le if. L'éditeur l'écrit pour vous quand vous appuyez sur Entrée après then.

#Répéter avec une boucle

Une boucle for répète des lignes un certain nombre de fois. sleep(1) met le programme en pause une seconde (attendre ne coûte aucune instruction) :

for i = 1, 5 do
  print("Plaque pressée : " .. i)
  sleep(1)
end
print("Terminé !")

Plaque pressée : 1
Plaque pressée : 2
Plaque pressée : 3
Plaque pressée : 4
Plaque pressée : 5
Terminé !

i compte de 1 à 5 : les lignes entre do et end s'exécutent cinq fois, avec i qui vaut 1, puis 2, et ainsi de suite.

#10. Agir sur le monde : une lampe qui clignote

Les programmes deviennent vraiment utiles quand ils agissent sur le monde. Un ordinateur envoie et lit de la redstone sur ses six faces : "front" (l'écran, l'avant), "back" (l'arrière), "left" (la gauche), "right" (la droite), "top" (le dessus) et "bottom" (le dessous). La gauche et la droite se comptent face à l'écran.

Posez une Lampe à redstone sur l'ordinateur. Puis edit clignote et tapez :

while true do
  rs.set("top", true)   -- lampe allumée
  sleep(0.5)
  rs.set("top", false)  -- lampe éteinte
  sleep(0.5)
end

Lancez clignote : la lampe clignote, une demi-seconde allumée, une demi-seconde éteinte. rs.set(face, true) envoie un signal plein (15) par une face, false le coupe. Appuyez sur Ctrl+T pour arrêter : un programme arrêté laisse ses sorties dans leur dernier état, la lampe peut donc rester allumée jusqu'à ce qu'un autre programme la change ou que l'ordinateur redémarre.

Maintenant, faites-le écouter. Posez un levier à gauche de l'ordinateur, et changez le programme pour que la lampe ne clignote que quand le levier est activé :

local allume = false
while true do
  if rs.get("left") > 0 then
    allume = not allume  -- bascule : true devient false, false devient true
  else
    allume = false
  end
  rs.set("top", allume)
  sleep(0.5)
end

rs.get("left") lit la puissance de redstone qui arrive par la gauche, de 0 (rien) à 15. C'est le début de la vraie automatisation : remplacez le levier par un capteur de Create, la lampe par un embrayage ou une porte, et l'ordinateur fait tourner une machine. La page Redstone va beaucoup plus loin.

#11. Démarrer tout seul : le fichier startup

Un ordinateur lance le fichier nommé **startup à chaque démarrage : quand il se met à tourner, quand vous appuyez sur Redémarrer (Ctrl+R), après Allumer**, et quand son chunk est rechargé (après un redémarrage du serveur, par exemple). Renommez votre clignoteur :

> mv clignote startup
> reboot

L'écran s'efface et la bannière revient, sans invite cette fois : startup tourne, et la lampe clignote toute seule.

Brass OS 1.0
Tier 1 - 2048 cells
Tapez help pour commencer.

Votre ordinateur est maintenant un vrai contrôleur : fermez le terminal et partez, il continue de travailler tant que son chunk est chargé et que son arbre tourne.

#Quand quelque chose ne va pas

Les messages d'erreur sont en anglais ; la page Messages d'erreur les explique un par un.

#Pour aller plus loin

• Les ordinateurs : les six ordinateurs, leur vitesse, leur mémoire, leurs écrans et leurs supports, et lequel choisir.
• Le shell et l'éditeur : toutes les commandes de l'invite et tous les raccourcis de l'éditeur.
• Les bases de Brass : le langage depuis le début (variables, nombres, texte), puis les structures de contrôle et les fonctions.
• Redstone et Évènements : réagir au monde sans gaspiller une seule instruction.
• Programmes intégrés : les programmes tout faits expliqués ligne à ligne, à commencer par blink et counter.
• Le livre de recettes : des projets complets comme une alarme de stock ou une porte à code.